From 8d28f676c5b76bac272efcfaae9c6eb2fa153a62 Mon Sep 17 00:00:00 2001 From: Johnosezele Date: Fri, 6 Mar 2026 04:57:41 +0100 Subject: [PATCH 1/6] scaffold initial architecture for bdk-dart flutter reference app --- bdk_demo/README.md | 84 +- bdk_demo/lib/app/app.dart | 25 + bdk_demo/lib/app/bootstrap.dart | 24 + .../lib/core/constants/app_constants.dart | 39 + bdk_demo/lib/core/logging/app_logger.dart | 36 + bdk_demo/lib/core/router/app_router.dart | 106 + bdk_demo/lib/core/theme/app_colors.dart | 20 + bdk_demo/lib/core/theme/app_theme.dart | 50 + bdk_demo/lib/core/utils/clipboard_util.dart | 23 + bdk_demo/lib/core/utils/formatters.dart | 48 + .../shared/widgets/neutral_button.dart | 40 + .../shared/widgets/placeholder_page.dart | 32 + .../shared/widgets/secondary_app_bar.dart | 22 + .../wallet_setup/wallet_choice_page.dart | 126 + bdk_demo/lib/main.dart | 127 +- bdk_demo/lib/models/currency_unit.dart | 14 + bdk_demo/lib/models/tx_details.dart | 27 + bdk_demo/lib/models/wallet_record.dart | 112 + .../lib/providers/blockchain_providers.dart | 16 + .../lib/providers/connectivity_provider.dart | 15 + .../lib/providers/settings_providers.dart | 38 + bdk_demo/lib/providers/wallet_providers.dart | 25 + bdk_demo/lib/services/blockchain_service.dart | 5 + bdk_demo/lib/services/storage_service.dart | 75 + bdk_demo/lib/services/wallet_service.dart | 4 + bdk_demo/pubspec.yaml | 23 +- bdk_demo/test/widget_test.dart | 28 +- lib/bdk.dart | 3862 ++++++++--------- 28 files changed, 2948 insertions(+), 2098 deletions(-) create mode 100644 bdk_demo/lib/app/app.dart create mode 100644 bdk_demo/lib/app/bootstrap.dart create mode 100644 bdk_demo/lib/core/constants/app_constants.dart create mode 100644 bdk_demo/lib/core/logging/app_logger.dart create mode 100644 bdk_demo/lib/core/router/app_router.dart create mode 100644 bdk_demo/lib/core/theme/app_colors.dart create mode 100644 bdk_demo/lib/core/theme/app_theme.dart create mode 100644 bdk_demo/lib/core/utils/clipboard_util.dart create mode 100644 bdk_demo/lib/core/utils/formatters.dart create mode 100644 bdk_demo/lib/features/shared/widgets/neutral_button.dart create mode 100644 bdk_demo/lib/features/shared/widgets/placeholder_page.dart create mode 100644 bdk_demo/lib/features/shared/widgets/secondary_app_bar.dart create mode 100644 bdk_demo/lib/features/wallet_setup/wallet_choice_page.dart create mode 100644 bdk_demo/lib/models/currency_unit.dart create mode 100644 bdk_demo/lib/models/tx_details.dart create mode 100644 bdk_demo/lib/models/wallet_record.dart create mode 100644 bdk_demo/lib/providers/blockchain_providers.dart create mode 100644 bdk_demo/lib/providers/connectivity_provider.dart create mode 100644 bdk_demo/lib/providers/settings_providers.dart create mode 100644 bdk_demo/lib/providers/wallet_providers.dart create mode 100644 bdk_demo/lib/services/blockchain_service.dart create mode 100644 bdk_demo/lib/services/storage_service.dart create mode 100644 bdk_demo/lib/services/wallet_service.dart diff --git a/bdk_demo/README.md b/bdk_demo/README.md index ce25e86..859fdfa 100644 --- a/bdk_demo/README.md +++ b/bdk_demo/README.md @@ -1,16 +1,82 @@ -# bdk_demo +# BDK-Dart Wallet (Flutter) -A new Flutter project. +The _BDK-Dart Wallet_ is a wallet built as a reference app for the [bitcoindevkit](https://github.com/bitcoindevkit) on Flutter using [bdk-dart](https://github.com/bitcoindevkit/bdk-dart). This repository is not intended to produce a production-ready wallet, the app only works on Signet, Testnet 3, and Regtest. + +The demo app is built with the following goals in mind: +1. Be a reference application for the `bdk_dart` API on Flutter (iOS & Android). +2. Showcase the core features of the bitcoindevkit library: wallet creation, recovery, Esplora/Electrum sync, send, receive, and transaction history. +3. Demonstrate a clean, testable Flutter architecture using Riverpod and GoRouter. + +## Features + +| Feature | Status | +|---|---| +| Create wallet (P2WPKH / P2TR) | - | +| Recover wallet (phrase / descriptor) | - | +| Multi-wallet support | - | +| Esplora sync (Regtest) | - | +| Electrum sync (Testnet / Signet) | - | +| Wallet balance (BTC / sats toggle) | - | +| Receive (address generation + QR) | - | +| Send (single recipient + fee rate) | - | +| Transaction history | - | +| Transaction detail | - | +| Recovery data viewer | - | +| Theme toggle (light / dark) | - | +| In-app log viewer | - | + +## Architecture + +Clean Architecture + Riverpod: + +``` +lib/ +├── app/ # App shell (MaterialApp, bootstrap) +├── core/ # Theme, router, constants, logging, utils +├── models/ # WalletRecord, TxDetails, CurrencyUnit +├── services/ # WalletService, BlockchainService, StorageService +├── providers/ # Riverpod providers (wallet, blockchain, settings) +└── features/ # Feature pages and widgets +``` + +**Note:** +- **State management:** Riverpod +- **Navigation:** GoRouter +- **Domain objects:** Uses `bdk_dart` types directly +- **Secure storage:** `flutter_secure_storage` for mnemonics and descriptors +- **BDK threading:** `Isolate.run()` for heavy sync operations ## Getting Started -This project is a starting point for a Flutter application. +```bash +# Clone and navigate to the demo app +cd bdk_demo + +# Install dependencies +flutter pub get + +# Run on a connected device or emulator +flutter run +``` + +> **Note:** This app depends on `bdk_dart` via a local path (`../`). Make sure the parent `bdk-dart` repository is set up and the native Rust build toolchain is available. See the [bdk-dart README](../README.md) for build prerequisites. + +## Supported Networks + +| Network | Blockchain Client | Default Endpoint | +|---|---|---| +| Signet | Electrum | `ssl://mempool.space:60602` | +| Testnet 3 | Electrum | `ssl://electrum.blockstream.info:60002` | +| Regtest | Esplora | `http://localhost:3002` | + + +## Address Types -A few resources to get you started if this is your first Flutter project: +| Type | Standard | Default | +|---|---|---| +| P2TR (Taproot) | BIP-86 | - | +| P2WPKH (Native SegWit) | BIP-84 | - | -- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab) -- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook) +## License -For help getting started with Flutter development, view the -[online documentation](https://docs.flutter.dev/), which offers tutorials, -samples, guidance on mobile development, and a full API reference. +See [LICENSE](../LICENSE). diff --git a/bdk_demo/lib/app/app.dart b/bdk_demo/lib/app/app.dart new file mode 100644 index 0000000..487b3b6 --- /dev/null +++ b/bdk_demo/lib/app/app.dart @@ -0,0 +1,25 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; + +import '../core/router/app_router.dart'; +import '../core/theme/app_theme.dart'; +import '../providers/settings_providers.dart'; + +class App extends ConsumerWidget { + const App({super.key}); + + @override + Widget build(BuildContext context, WidgetRef ref) { + final themeMode = ref.watch(themeModeProvider); + final router = createRouter(); + + return MaterialApp.router( + title: 'BDK-Dart Wallet', + debugShowCheckedModeBanner: false, + theme: AppTheme.light, + darkTheme: AppTheme.dark, + themeMode: themeMode, + routerConfig: router, + ); + } +} diff --git a/bdk_demo/lib/app/bootstrap.dart b/bdk_demo/lib/app/bootstrap.dart new file mode 100644 index 0000000..56fe6b3 --- /dev/null +++ b/bdk_demo/lib/app/bootstrap.dart @@ -0,0 +1,24 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import '../core/logging/app_logger.dart'; +import '../providers/settings_providers.dart'; +import '../services/storage_service.dart'; +import 'app.dart'; + +Future bootstrap() async { + WidgetsFlutterBinding.ensureInitialized(); + + final prefs = await SharedPreferences.getInstance(); + final storageService = StorageService(prefs: prefs); + + AppLogger.instance.info('BDK-Dart Wallet app started'); + + runApp( + ProviderScope( + overrides: [storageServiceProvider.overrideWithValue(storageService)], + child: const App(), + ), + ); +} diff --git a/bdk_demo/lib/core/constants/app_constants.dart b/bdk_demo/lib/core/constants/app_constants.dart new file mode 100644 index 0000000..a1c67ab --- /dev/null +++ b/bdk_demo/lib/core/constants/app_constants.dart @@ -0,0 +1,39 @@ +import 'package:bdk_demo/models/wallet_record.dart'; + +abstract final class AppConstants { + static const appVersion = '0.1.0'; + + static const walletLookahead = 25; + + static const fullScanStopGap = 25; + + static const syncParallelRequests = 4; + + static const maxRecipients = 4; + + static const maxLogEntries = 5000; +} + +enum ClientType { esplora, electrum } + +class EndpointConfig { + final ClientType clientType; + final String url; + + const EndpointConfig({required this.clientType, required this.url}); +} + +const Map defaultEndpoints = { + WalletNetwork.signet: EndpointConfig( + clientType: ClientType.electrum, + url: 'ssl://mempool.space:60602', + ), + WalletNetwork.testnet: EndpointConfig( + clientType: ClientType.electrum, + url: 'ssl://electrum.blockstream.info:60002', + ), + WalletNetwork.regtest: EndpointConfig( + clientType: ClientType.esplora, + url: 'http://localhost:3002', + ), +}; diff --git a/bdk_demo/lib/core/logging/app_logger.dart b/bdk_demo/lib/core/logging/app_logger.dart new file mode 100644 index 0000000..6ea821b --- /dev/null +++ b/bdk_demo/lib/core/logging/app_logger.dart @@ -0,0 +1,36 @@ +import 'dart:collection'; + +import 'package:bdk_demo/core/constants/app_constants.dart'; + +enum LogLevel { info, warn, error } + +class AppLogger { + AppLogger._(); + + static final AppLogger instance = AppLogger._(); + + final _entries = Queue(); + + int get maxEntries => AppConstants.maxLogEntries; + + void log(LogLevel level, String message) { + final timestamp = DateTime.now().toIso8601String(); + final label = switch (level) { + LogLevel.info => 'INFO', + LogLevel.warn => 'WARN', + LogLevel.error => 'ERROR', + }; + _entries.addFirst('$timestamp [$label] $message'); + while (_entries.length > maxEntries) { + _entries.removeLast(); + } + } + + void info(String message) => log(LogLevel.info, message); + void warn(String message) => log(LogLevel.warn, message); + void error(String message) => log(LogLevel.error, message); + + List getLogs() => _entries.toList(); + + void clear() => _entries.clear(); +} diff --git a/bdk_demo/lib/core/router/app_router.dart b/bdk_demo/lib/core/router/app_router.dart new file mode 100644 index 0000000..5d8d4fa --- /dev/null +++ b/bdk_demo/lib/core/router/app_router.dart @@ -0,0 +1,106 @@ +import 'package:go_router/go_router.dart'; +import 'package:bdk_demo/features/shared/widgets/placeholder_page.dart'; +import 'package:bdk_demo/features/wallet_setup/wallet_choice_page.dart'; + +abstract final class AppRoutes { + static const walletChoice = '/'; + static const activeWallets = '/active-wallets'; + static const createWallet = '/create-wallet'; + static const recoverWallet = '/recover-wallet'; + static const home = '/home'; + static const receive = '/receive'; + static const send = '/send'; + static const transactionHistory = '/transactions'; + static const transactionDetail = '/transactions/:txid'; + static const settings = '/settings'; + static const about = '/about'; + static const theme = '/theme'; + static const logs = '/logs'; + static const recoveryData = '/recovery-data'; +} + +GoRouter createRouter() => GoRouter( + initialLocation: AppRoutes.walletChoice, + routes: [ + GoRoute( + path: AppRoutes.walletChoice, + name: 'walletChoice', + builder: (context, state) => const WalletChoicePage(), + ), + GoRoute( + path: AppRoutes.activeWallets, + name: 'activeWallets', + builder: (context, state) => + const PlaceholderPage(title: 'Active Wallets'), + ), + GoRoute( + path: AppRoutes.createWallet, + name: 'createWallet', + builder: (context, state) => + const PlaceholderPage(title: 'Create Wallet'), + ), + GoRoute( + path: AppRoutes.recoverWallet, + name: 'recoverWallet', + builder: (context, state) => + const PlaceholderPage(title: 'Recover Wallet'), + ), + + GoRoute( + path: AppRoutes.home, + name: 'home', + builder: (context, state) => const PlaceholderPage(title: 'Home'), + ), + GoRoute( + path: AppRoutes.receive, + name: 'receive', + builder: (context, state) => const PlaceholderPage(title: 'Receive'), + ), + GoRoute( + path: AppRoutes.send, + name: 'send', + builder: (context, state) => const PlaceholderPage(title: 'Send'), + ), + GoRoute( + path: AppRoutes.transactionHistory, + name: 'transactionHistory', + builder: (context, state) => + const PlaceholderPage(title: 'Transaction History'), + ), + GoRoute( + path: AppRoutes.transactionDetail, + name: 'transactionDetail', + builder: (context, state) { + final txid = state.pathParameters['txid'] ?? ''; + return PlaceholderPage(title: 'Transaction $txid'); + }, + ), + + GoRoute( + path: AppRoutes.settings, + name: 'settings', + builder: (context, state) => const PlaceholderPage(title: 'Settings'), + ), + GoRoute( + path: AppRoutes.about, + name: 'about', + builder: (context, state) => const PlaceholderPage(title: 'About'), + ), + GoRoute( + path: AppRoutes.theme, + name: 'theme', + builder: (context, state) => const PlaceholderPage(title: 'Theme'), + ), + GoRoute( + path: AppRoutes.logs, + name: 'logs', + builder: (context, state) => const PlaceholderPage(title: 'Logs'), + ), + GoRoute( + path: AppRoutes.recoveryData, + name: 'recoveryData', + builder: (context, state) => + const PlaceholderPage(title: 'Recovery Data'), + ), + ], +); diff --git a/bdk_demo/lib/core/theme/app_colors.dart b/bdk_demo/lib/core/theme/app_colors.dart new file mode 100644 index 0000000..0bf4a31 --- /dev/null +++ b/bdk_demo/lib/core/theme/app_colors.dart @@ -0,0 +1,20 @@ +import 'package:flutter/material.dart'; + +abstract final class AppColors { + static const dayGlowPrimary = Color(0xFFF7931A); + static const dayGlowOnPrimary = Colors.white; + static const dayGlowBackground = Color(0xFFFAFAFA); + static const dayGlowSurface = Colors.white; + static const dayGlowHistoryAccent = Color(0xFFF5A623); + + static const nightGlowPrimary = Color(0xFFF7931A); + static const nightGlowOnPrimary = Colors.white; + static const nightGlowBackground = Color(0xFF121212); + static const nightGlowSurface = Color(0xFF1E1E1E); + static const nightGlowSubtle = Color(0xFF2A2A2A); + + static const pendingOrange = Color(0xFFF5A623); + static const confirmedGreen = Color(0xFF8FD998); + static const offlineRed = Color(0xFFE76F51); + static const errorRed = Color(0xFFCF6679); +} diff --git a/bdk_demo/lib/core/theme/app_theme.dart b/bdk_demo/lib/core/theme/app_theme.dart new file mode 100644 index 0000000..a044b8c --- /dev/null +++ b/bdk_demo/lib/core/theme/app_theme.dart @@ -0,0 +1,50 @@ +import 'package:flutter/material.dart'; +import 'package:google_fonts/google_fonts.dart'; + +import 'app_colors.dart'; + +abstract final class AppTheme { + static ThemeData get light => ThemeData( + useMaterial3: true, + brightness: Brightness.light, + colorScheme: ColorScheme.fromSeed( + seedColor: AppColors.dayGlowPrimary, + brightness: Brightness.light, + surface: AppColors.dayGlowSurface, + ), + scaffoldBackgroundColor: AppColors.dayGlowBackground, + textTheme: GoogleFonts.interTextTheme(ThemeData.light().textTheme), + appBarTheme: const AppBarTheme(centerTitle: true, elevation: 0), + cardTheme: CardThemeData( + elevation: 0, + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(16), + side: BorderSide(color: Colors.grey.shade200), + ), + ), + snackBarTheme: const SnackBarThemeData(behavior: SnackBarBehavior.floating), + ); + + static ThemeData get dark => ThemeData( + useMaterial3: true, + brightness: Brightness.dark, + colorScheme: ColorScheme.fromSeed( + seedColor: AppColors.nightGlowPrimary, + brightness: Brightness.dark, + surface: AppColors.nightGlowSurface, + ), + scaffoldBackgroundColor: AppColors.nightGlowBackground, + textTheme: GoogleFonts.interTextTheme(ThemeData.dark().textTheme), + appBarTheme: const AppBarTheme(centerTitle: true, elevation: 0), + cardTheme: CardThemeData( + elevation: 0, + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(16), + side: BorderSide(color: Colors.grey.shade800), + ), + ), + snackBarTheme: const SnackBarThemeData(behavior: SnackBarBehavior.floating), + ); + + static TextStyle get monoStyle => GoogleFonts.sourceCodePro(); +} diff --git a/bdk_demo/lib/core/utils/clipboard_util.dart b/bdk_demo/lib/core/utils/clipboard_util.dart new file mode 100644 index 0000000..378cfb8 --- /dev/null +++ b/bdk_demo/lib/core/utils/clipboard_util.dart @@ -0,0 +1,23 @@ +import 'package:flutter/services.dart'; +import 'package:flutter/material.dart'; + +abstract final class ClipboardUtil { + static Future copyAndNotify( + BuildContext context, + String text, { + String message = 'Copied to clipboard', + }) async { + await Clipboard.setData(ClipboardData(text: text)); + if (context.mounted) { + ScaffoldMessenger.of(context) + ..hideCurrentSnackBar() + ..showSnackBar( + SnackBar( + content: Text(message), + duration: const Duration(seconds: 2), + behavior: SnackBarBehavior.floating, + ), + ); + } + } +} diff --git a/bdk_demo/lib/core/utils/formatters.dart b/bdk_demo/lib/core/utils/formatters.dart new file mode 100644 index 0000000..f99fdf0 --- /dev/null +++ b/bdk_demo/lib/core/utils/formatters.dart @@ -0,0 +1,48 @@ +import 'package:bdk_demo/models/currency_unit.dart'; + +abstract final class Formatters { + static String formatBalance(int satoshis, CurrencyUnit unit) => + switch (unit) { + CurrencyUnit.bitcoin => (satoshis / 100000000).toStringAsFixed(8), + CurrencyUnit.satoshi => '$satoshis sat', + }; + + static String formatAddress(String address) => + address.splitByLength(4).join(' '); + + static String formatTimestamp(int unixSeconds) { + final dt = DateTime.fromMillisecondsSinceEpoch(unixSeconds * 1000); + final months = [ + 'January', + 'February', + 'March', + 'April', + 'May', + 'June', + 'July', + 'August', + 'September', + 'October', + 'November', + 'December', + ]; + final month = months[dt.month - 1]; + final hour = dt.hour.toString().padLeft(2, '0'); + final minute = dt.minute.toString().padLeft(2, '0'); + return '$month ${dt.day} ${dt.year} $hour:$minute'; + } + + static String abbreviateTxid(String txid) => txid.length > 16 + ? '${txid.substring(0, 8)}...${txid.substring(txid.length - 8)}' + : txid; +} + +extension StringChunking on String { + List splitByLength(int size) { + final chunks = []; + for (var i = 0; i < length; i += size) { + chunks.add(substring(i, i + size > length ? length : i + size)); + } + return chunks; + } +} diff --git a/bdk_demo/lib/features/shared/widgets/neutral_button.dart b/bdk_demo/lib/features/shared/widgets/neutral_button.dart new file mode 100644 index 0000000..390dca3 --- /dev/null +++ b/bdk_demo/lib/features/shared/widgets/neutral_button.dart @@ -0,0 +1,40 @@ +import 'package:flutter/material.dart'; + +class NeutralButton extends StatelessWidget { + final String label; + final VoidCallback? onPressed; + final IconData? icon; + + const NeutralButton({ + super.key, + required this.label, + required this.onPressed, + this.icon, + }); + + @override + Widget build(BuildContext context) { + return SizedBox( + width: double.infinity, + child: OutlinedButton( + onPressed: onPressed, + style: OutlinedButton.styleFrom( + padding: const EdgeInsets.symmetric(vertical: 16), + shape: RoundedRectangleBorder( + borderRadius: BorderRadius.circular(12), + ), + ), + child: Row( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + if (icon != null) ...[ + Icon(icon, size: 20), + const SizedBox(width: 8), + ], + Text(label, style: const TextStyle(fontSize: 16)), + ], + ), + ), + ); + } +} diff --git a/bdk_demo/lib/features/shared/widgets/placeholder_page.dart b/bdk_demo/lib/features/shared/widgets/placeholder_page.dart new file mode 100644 index 0000000..233462d --- /dev/null +++ b/bdk_demo/lib/features/shared/widgets/placeholder_page.dart @@ -0,0 +1,32 @@ +import 'package:flutter/material.dart'; + +import 'package:bdk_demo/features/shared/widgets/secondary_app_bar.dart'; + +/// Temporary placeholder page for routes not yet implemented. +class PlaceholderPage extends StatelessWidget { + final String title; + + const PlaceholderPage({super.key, required this.title}); + + @override + Widget build(BuildContext context) { + return Scaffold( + appBar: SecondaryAppBar(title: title), + body: Center( + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Icon(Icons.construction, size: 64, color: Colors.grey.shade400), + const SizedBox(height: 16), + Text( + title, + style: const TextStyle(fontSize: 20, fontWeight: FontWeight.w600), + ), + const SizedBox(height: 8), + Text('Coming soon', style: TextStyle(color: Colors.grey.shade500)), + ], + ), + ), + ); + } +} diff --git a/bdk_demo/lib/features/shared/widgets/secondary_app_bar.dart b/bdk_demo/lib/features/shared/widgets/secondary_app_bar.dart new file mode 100644 index 0000000..6ac8e0d --- /dev/null +++ b/bdk_demo/lib/features/shared/widgets/secondary_app_bar.dart @@ -0,0 +1,22 @@ +import 'package:flutter/material.dart'; + +class SecondaryAppBar extends StatelessWidget implements PreferredSizeWidget { + final String title; + + const SecondaryAppBar({super.key, required this.title}); + + @override + Widget build(BuildContext context) { + return AppBar( + leading: IconButton( + icon: const Icon(Icons.arrow_back), + onPressed: () => Navigator.of(context).maybePop(), + ), + title: Text(title), + centerTitle: true, + ); + } + + @override + Size get preferredSize => const Size.fromHeight(kToolbarHeight); +} diff --git a/bdk_demo/lib/features/wallet_setup/wallet_choice_page.dart b/bdk_demo/lib/features/wallet_setup/wallet_choice_page.dart new file mode 100644 index 0000000..9bac63c --- /dev/null +++ b/bdk_demo/lib/features/wallet_setup/wallet_choice_page.dart @@ -0,0 +1,126 @@ +import 'package:flutter/material.dart'; +import 'package:go_router/go_router.dart'; +import 'package:bdk_demo/core/router/app_router.dart'; + +class WalletChoicePage extends StatelessWidget { + const WalletChoicePage({super.key}); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Scaffold( + body: SafeArea( + child: Center( + child: Padding( + padding: const EdgeInsets.symmetric(horizontal: 32), + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Container( + width: 80, + height: 80, + decoration: BoxDecoration( + shape: BoxShape.circle, + color: theme.colorScheme.primaryContainer, + ), + child: Center( + child: Text( + '₿', + style: TextStyle( + fontSize: 40, + fontWeight: FontWeight.bold, + color: theme.colorScheme.primary, + ), + ), + ), + ), + const SizedBox(height: 48), + + _ChoiceCard( + icon: Icons.account_balance_wallet, + title: 'Use an Active Wallet', + subtitle: 'Load a previously created wallet', + onTap: () => context.push(AppRoutes.activeWallets), + ), + const SizedBox(height: 16), + _ChoiceCard( + icon: Icons.add_circle_outline, + title: 'Create a New Wallet', + subtitle: 'Generate a new wallet with a fresh mnemonic', + onTap: () => context.push(AppRoutes.createWallet), + ), + const SizedBox(height: 16), + _ChoiceCard( + icon: Icons.restore, + title: 'Recover an Existing Wallet', + subtitle: 'Restore from recovery phrase or descriptor', + onTap: () => context.push(AppRoutes.recoverWallet), + ), + ], + ), + ), + ), + ), + ); + } +} + +class _ChoiceCard extends StatelessWidget { + final IconData icon; + final String title; + final String subtitle; + final VoidCallback onTap; + + const _ChoiceCard({ + required this.icon, + required this.title, + required this.subtitle, + required this.onTap, + }); + + @override + Widget build(BuildContext context) { + final theme = Theme.of(context); + + return Card( + child: InkWell( + onTap: onTap, + borderRadius: BorderRadius.circular(16), + child: Padding( + padding: const EdgeInsets.all(20), + child: Row( + children: [ + Icon(icon, size: 36, color: theme.colorScheme.primary), + const SizedBox(width: 16), + Expanded( + child: Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text( + title, + style: theme.textTheme.titleMedium?.copyWith( + fontWeight: FontWeight.w600, + ), + ), + const SizedBox(height: 4), + Text( + subtitle, + style: theme.textTheme.bodySmall?.copyWith( + color: theme.colorScheme.onSurface.withAlpha(153), + ), + ), + ], + ), + ), + Icon( + Icons.chevron_right, + color: theme.colorScheme.onSurface.withAlpha(102), + ), + ], + ), + ), + ), + ); + } +} diff --git a/bdk_demo/lib/main.dart b/bdk_demo/lib/main.dart index 8c72951..c562b9d 100644 --- a/bdk_demo/lib/main.dart +++ b/bdk_demo/lib/main.dart @@ -1,126 +1,3 @@ -import 'package:bdk_dart/bdk.dart' as bdk; -import 'package:flutter/material.dart'; +import 'app/bootstrap.dart'; -void main() { - runApp(const MyApp()); -} - -class MyApp extends StatelessWidget { - const MyApp({super.key}); - - @override - Widget build(BuildContext context) { - return MaterialApp( - title: 'BDK Dart Demo', - theme: ThemeData( - colorScheme: ColorScheme.fromSeed(seedColor: Colors.orange), - useMaterial3: true, - ), - home: const MyHomePage(title: 'BDK Dart Proof of Concept'), - ); - } -} - -class MyHomePage extends StatefulWidget { - const MyHomePage({super.key, required this.title}); - final String title; - - @override - State createState() => _MyHomePageState(); -} - -class _MyHomePageState extends State { - String? _networkName; - String? _descriptorSnippet; - String? _error; - - void _showSignetNetwork() { - try { - final network = bdk.Network.testnet; - final descriptor = bdk.Descriptor( - descriptor: - 'wpkh(tprv8ZgxMBicQKsPf2qfrEygW6fdYseJDDrVnDv26PH5BHdvSuG6ecCbHqLVof9yZcMoM31z9ur3tTYbSnr1WBqbGX97CbXcmp5H6qeMpyvx35B/' - '84h/1h/0h/0/*)', - network: network, - ); - - setState(() { - _networkName = network.name; - _descriptorSnippet = descriptor.toString().substring(0, 32); - _error = null; - }); - } catch (e) { - setState(() { - _error = e.toString(); - _networkName = null; - _descriptorSnippet = null; - }); - } - } - - @override - Widget build(BuildContext context) { - return Scaffold( - appBar: AppBar( - backgroundColor: Theme.of(context).colorScheme.inversePrimary, - title: Text(widget.title), - ), - body: Center( - child: Column( - mainAxisAlignment: MainAxisAlignment.center, - children: [ - Icon( - _error != null - ? Icons.error_outline - : _networkName != null - ? Icons.check_circle - : Icons.network_check, - size: 80, - color: _error != null - ? Colors.red - : _networkName != null - ? Colors.green - : Colors.grey, - ), - const SizedBox(height: 20), - const Text('BDK bindings status', style: TextStyle(fontSize: 20)), - if (_networkName != null) ...[ - Text( - 'Network: $_networkName', - style: Theme.of(context).textTheme.headlineMedium?.copyWith( - color: Colors.orange, - fontWeight: FontWeight.bold, - ), - ), - if (_descriptorSnippet != null) - Padding( - padding: const EdgeInsets.only(top: 12), - child: Text( - 'Descriptor sample: $_descriptorSnippet…', - style: const TextStyle(fontFamily: 'monospace'), - ), - ), - ] else if (_error != null) ...[ - Padding( - padding: const EdgeInsets.symmetric(horizontal: 24), - child: Text( - _error!, - style: const TextStyle(color: Colors.red), - textAlign: TextAlign.center, - ), - ), - ] else ...[ - const Text('Press the button to load bindings'), - ], - ], - ), - ), - floatingActionButton: FloatingActionButton.extended( - onPressed: _showSignetNetwork, - backgroundColor: Colors.orange, - icon: const Icon(Icons.play_circle_fill), - label: const Text('Load Dart binding'), - ), - ); - } -} +void main() => bootstrap(); diff --git a/bdk_demo/lib/models/currency_unit.dart b/bdk_demo/lib/models/currency_unit.dart new file mode 100644 index 0000000..8c2daee --- /dev/null +++ b/bdk_demo/lib/models/currency_unit.dart @@ -0,0 +1,14 @@ +enum CurrencyUnit { + bitcoin, + satoshi; + + String get label => switch (this) { + CurrencyUnit.bitcoin => 'BTC', + CurrencyUnit.satoshi => 'sat', + }; + + CurrencyUnit get toggled => switch (this) { + CurrencyUnit.bitcoin => CurrencyUnit.satoshi, + CurrencyUnit.satoshi => CurrencyUnit.bitcoin, + }; +} diff --git a/bdk_demo/lib/models/tx_details.dart b/bdk_demo/lib/models/tx_details.dart new file mode 100644 index 0000000..a55820e --- /dev/null +++ b/bdk_demo/lib/models/tx_details.dart @@ -0,0 +1,27 @@ +class TxDetails { + final String txid; + final int sent; + final int received; + final int fee; + final double? feeRate; + final bool pending; + final int? blockHeight; + final DateTime? confirmationTime; + + const TxDetails({ + required this.txid, + required this.sent, + required this.received, + this.fee = 0, + this.feeRate, + this.pending = true, + this.blockHeight, + this.confirmationTime, + }); + + int get netAmount => received - sent; + + String get shortTxid => txid.length > 16 + ? '${txid.substring(0, 8)}...${txid.substring(txid.length - 8)}' + : txid; +} diff --git a/bdk_demo/lib/models/wallet_record.dart b/bdk_demo/lib/models/wallet_record.dart new file mode 100644 index 0000000..2c2a798 --- /dev/null +++ b/bdk_demo/lib/models/wallet_record.dart @@ -0,0 +1,112 @@ +import 'dart:convert'; + +enum WalletNetwork { + signet, + testnet, + regtest; + + String get displayName => switch (this) { + WalletNetwork.signet => 'Signet', + WalletNetwork.testnet => 'Testnet 3', + WalletNetwork.regtest => 'Regtest', + }; +} + +enum ScriptType { + p2wpkh, + p2tr, + unknown; + + String get displayName => switch (this) { + ScriptType.p2wpkh => 'P2WPKH (Native SegWit)', + ScriptType.p2tr => 'P2TR (Taproot)', + ScriptType.unknown => 'Unknown', + }; + + String get shortName => switch (this) { + ScriptType.p2wpkh => 'P2WPKH', + ScriptType.p2tr => 'P2TR', + ScriptType.unknown => 'Unknown', + }; +} + +class WalletRecord { + final String id; + final String name; + final WalletNetwork network; + final ScriptType scriptType; + final bool fullScanCompleted; + + const WalletRecord({ + required this.id, + required this.name, + required this.network, + required this.scriptType, + this.fullScanCompleted = false, + }); + + WalletRecord copyWith({ + String? id, + String? name, + WalletNetwork? network, + ScriptType? scriptType, + bool? fullScanCompleted, + }) { + return WalletRecord( + id: id ?? this.id, + name: name ?? this.name, + network: network ?? this.network, + scriptType: scriptType ?? this.scriptType, + fullScanCompleted: fullScanCompleted ?? this.fullScanCompleted, + ); + } + + Map toJson() => { + 'id': id, + 'name': name, + 'network': network.name, + 'scriptType': scriptType.name, + 'fullScanCompleted': fullScanCompleted, + }; + + factory WalletRecord.fromJson(Map json) => WalletRecord( + id: json['id'] as String, + name: json['name'] as String, + network: WalletNetwork.values.byName(json['network'] as String), + scriptType: ScriptType.values.byName(json['scriptType'] as String), + fullScanCompleted: json['fullScanCompleted'] as bool? ?? false, + ); + + static String encodeList(List records) => + jsonEncode(records.map((r) => r.toJson()).toList()); + + static List decodeList(String encoded) => + (jsonDecode(encoded) as List) + .cast>() + .map(WalletRecord.fromJson) + .toList(); +} + +class WalletSecrets { + final String descriptor; + final String changeDescriptor; + final String recoveryPhrase; + + const WalletSecrets({ + required this.descriptor, + required this.changeDescriptor, + this.recoveryPhrase = '', + }); + + Map toJson() => { + 'descriptor': descriptor, + 'changeDescriptor': changeDescriptor, + 'recoveryPhrase': recoveryPhrase, + }; + + factory WalletSecrets.fromJson(Map json) => WalletSecrets( + descriptor: json['descriptor'] as String, + changeDescriptor: json['changeDescriptor'] as String, + recoveryPhrase: json['recoveryPhrase'] as String? ?? '', + ); +} diff --git a/bdk_demo/lib/providers/blockchain_providers.dart b/bdk_demo/lib/providers/blockchain_providers.dart new file mode 100644 index 0000000..3e046ec --- /dev/null +++ b/bdk_demo/lib/providers/blockchain_providers.dart @@ -0,0 +1,16 @@ +import 'package:flutter_riverpod/flutter_riverpod.dart'; + +enum SyncStatus { idle, syncing, synced, error } + +final syncStatusProvider = NotifierProvider( + SyncStatusNotifier.new, +); + +class SyncStatusNotifier extends Notifier { + @override + SyncStatus build() => SyncStatus.idle; + + void set(SyncStatus status) => state = status; +} + +// TODO: Add blockchainServiceProvider, esploraClientProvider, etc. diff --git a/bdk_demo/lib/providers/connectivity_provider.dart b/bdk_demo/lib/providers/connectivity_provider.dart new file mode 100644 index 0000000..0fbe6aa --- /dev/null +++ b/bdk_demo/lib/providers/connectivity_provider.dart @@ -0,0 +1,15 @@ +import 'package:connectivity_plus/connectivity_plus.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; + +final connectivityProvider = StreamProvider>((ref) { + return Connectivity().onConnectivityChanged; +}); + +final isOnlineProvider = Provider((ref) { + final connectivity = ref.watch(connectivityProvider); + return connectivity.when( + data: (results) => results.any((r) => r != ConnectivityResult.none), + loading: () => true, + error: (_, __) => false, + ); +}); diff --git a/bdk_demo/lib/providers/settings_providers.dart b/bdk_demo/lib/providers/settings_providers.dart new file mode 100644 index 0000000..b207ee8 --- /dev/null +++ b/bdk_demo/lib/providers/settings_providers.dart @@ -0,0 +1,38 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import '../services/storage_service.dart'; + +final storageServiceProvider = Provider((ref) { + throw UnimplementedError( + 'storageServiceProvider must be overridden with a ProviderScope override ' + 'after SharedPreferences is initialized in bootstrap().', + ); +}); + +final themeModeProvider = NotifierProvider( + ThemeModeNotifier.new, +); + +class ThemeModeNotifier extends Notifier { + @override + ThemeMode build() { + final storage = ref.watch(storageServiceProvider); + return storage.getDarkTheme() ? ThemeMode.dark : ThemeMode.light; + } + + void toggle() { + final isDark = state == ThemeMode.dark; + state = isDark ? ThemeMode.light : ThemeMode.dark; + ref.read(storageServiceProvider).setDarkTheme(!isDark); + } + + void setThemeMode(ThemeMode mode) { + state = mode; + ref.read(storageServiceProvider).setDarkTheme(mode == ThemeMode.dark); + } +} + +final introDoneProvider = Provider((ref) { + final storage = ref.watch(storageServiceProvider); + return storage.getIntroDone(); +}); diff --git a/bdk_demo/lib/providers/wallet_providers.dart b/bdk_demo/lib/providers/wallet_providers.dart new file mode 100644 index 0000000..55ece5f --- /dev/null +++ b/bdk_demo/lib/providers/wallet_providers.dart @@ -0,0 +1,25 @@ +import 'package:flutter_riverpod/flutter_riverpod.dart'; + +import '../models/wallet_record.dart'; +import 'settings_providers.dart'; + +final activeWalletRecordProvider = + NotifierProvider( + ActiveWalletRecordNotifier.new, + ); + +class ActiveWalletRecordNotifier extends Notifier { + @override + WalletRecord? build() => null; + + void set(WalletRecord record) => state = record; + void clear() => state = null; +} + +final walletRecordsProvider = Provider>((ref) { + final storage = ref.watch(storageServiceProvider); + return storage.getWalletRecords(); +}); + +// TODO: Add activeWalletProvider. +// TODO: Add balanceProvider, syncStateProvider. diff --git a/bdk_demo/lib/services/blockchain_service.dart b/bdk_demo/lib/services/blockchain_service.dart new file mode 100644 index 0000000..aeb8bb9 --- /dev/null +++ b/bdk_demo/lib/services/blockchain_service.dart @@ -0,0 +1,5 @@ +class BlockchainService { + // TODO: Implement Esplora/Electrum client creation. + // TODO: Implement sync/fullScan with fullScanCompleted logic. + // TODO: Implement broadcast and fee estimation. +} diff --git a/bdk_demo/lib/services/storage_service.dart b/bdk_demo/lib/services/storage_service.dart new file mode 100644 index 0000000..927964e --- /dev/null +++ b/bdk_demo/lib/services/storage_service.dart @@ -0,0 +1,75 @@ +import 'dart:convert'; +import 'package:flutter_secure_storage/flutter_secure_storage.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import '../models/wallet_record.dart'; + +abstract final class _PrefKeys { + static const introDone = 'intro_done'; + static const darkTheme = 'dark_theme'; + static const walletRecords = 'wallet_records'; +} + +abstract final class _SecureKeys { + static String secrets(String walletId) => 'wallet_secrets_$walletId'; +} + +class StorageService { + final SharedPreferences _prefs; + final FlutterSecureStorage _secure; + + StorageService({ + required SharedPreferences prefs, + FlutterSecureStorage? secure, + }) : _prefs = prefs, + _secure = secure ?? const FlutterSecureStorage(); + + bool getIntroDone() => _prefs.getBool(_PrefKeys.introDone) ?? false; + + Future setIntroDone() => _prefs.setBool(_PrefKeys.introDone, true); + + bool getDarkTheme() => _prefs.getBool(_PrefKeys.darkTheme) ?? false; + + Future setDarkTheme(bool isDark) => + _prefs.setBool(_PrefKeys.darkTheme, isDark); + + List getWalletRecords() { + final encoded = _prefs.getString(_PrefKeys.walletRecords); + if (encoded == null) return []; + return WalletRecord.decodeList(encoded); + } + + Future addWalletRecord( + WalletRecord record, + WalletSecrets secrets, + ) async { + final records = getWalletRecords(); + records.add(record); + await _prefs.setString( + _PrefKeys.walletRecords, + WalletRecord.encodeList(records), + ); + await _secure.write( + key: _SecureKeys.secrets(record.id), + value: jsonEncode(secrets.toJson()), + ); + } + + Future getSecrets(String walletId) async { + final encoded = await _secure.read(key: _SecureKeys.secrets(walletId)); + if (encoded == null) return null; + return WalletSecrets.fromJson(jsonDecode(encoded) as Map); + } + + Future setFullScanCompleted(String walletId) async { + final records = getWalletRecords(); + final updated = records.map((r) { + if (r.id == walletId) return r.copyWith(fullScanCompleted: true); + return r; + }).toList(); + await _prefs.setString( + _PrefKeys.walletRecords, + WalletRecord.encodeList(updated), + ); + } +} diff --git a/bdk_demo/lib/services/wallet_service.dart b/bdk_demo/lib/services/wallet_service.dart new file mode 100644 index 0000000..5f7b79e --- /dev/null +++ b/bdk_demo/lib/services/wallet_service.dart @@ -0,0 +1,4 @@ +class WalletService { + // TODO: Implement wallet creation, recovery, and loading. + // TODO: Implement sync/fullScan integration. +} diff --git a/bdk_demo/pubspec.yaml b/bdk_demo/pubspec.yaml index f631c13..f5a8cb1 100644 --- a/bdk_demo/pubspec.yaml +++ b/bdk_demo/pubspec.yaml @@ -33,19 +33,26 @@ dependencies: bdk_dart: path: ../ - # The following adds the Cupertino Icons font to your application. - # Use with the CupertinoIcons class for iOS style icons. + flutter_riverpod: ^3.2.1 + + go_router: ^17.1.0 + + pretty_qr_code: ^3.6.0 + + shared_preferences: ^2.3.4 + flutter_secure_storage: ^10.0.0 + + connectivity_plus: ^7.0.0 + + google_fonts: ^8.0.2 + + uuid: ^4.5.3 + intl: ^0.20.2 cupertino_icons: ^1.0.8 dev_dependencies: flutter_test: sdk: flutter - - # The "flutter_lints" package below contains a set of recommended lints to - # encourage good coding practices. The lint set provided by the package is - # activated in the `analysis_options.yaml` file located at the root of your - # package. See that file for information about deactivating specific lint - # rules and activating additional ones. flutter_lints: ^5.0.0 # For information on the generic Dart part of this file, see the diff --git a/bdk_demo/test/widget_test.dart b/bdk_demo/test/widget_test.dart index b2a716f..7871a40 100644 --- a/bdk_demo/test/widget_test.dart +++ b/bdk_demo/test/widget_test.dart @@ -1,30 +1,8 @@ -import 'package:flutter/material.dart'; import 'package:flutter_test/flutter_test.dart'; -import 'package:bdk_demo/main.dart'; - void main() { - testWidgets('BDK bindings demo test', (WidgetTester tester) async { - // Build our app and trigger a frame. - await tester.pumpWidget(const MyApp()); - - // Verify initial state shows the prompt message. - expect(find.text('Press the button to load bindings'), findsOneWidget); - expect(find.text('BDK bindings status'), findsOneWidget); - expect(find.byIcon(Icons.network_check), findsOneWidget); - - // Verify the button exists. - expect(find.text('Load Dart binding'), findsOneWidget); - expect(find.byIcon(Icons.play_circle_fill), findsOneWidget); - - // Tap the 'Load Dart binding' button and trigger a frame. - await tester.tap(find.byType(FloatingActionButton)); - await tester.pump(); - - // Verify that the network and descriptor are displayed. - expect(find.textContaining('Network:'), findsOneWidget); - expect(find.textContaining('testnet'), findsOneWidget); - expect(find.textContaining('Descriptor sample:'), findsOneWidget); - expect(find.byIcon(Icons.check_circle), findsOneWidget); + testWidgets('App scaffold builds', (WidgetTester tester) async { + // TODO: Implement widget tests + expect(true, isTrue); }); } diff --git a/lib/bdk.dart b/lib/bdk.dart index 737d3d9..2c2ad92 100644 --- a/lib/bdk.dart +++ b/lib/bdk.dart @@ -24964,30 +24964,28 @@ Uint8List createUint8ListFromInt(int value) { return uint8List; } -class FfiConverterSequenceAddressInfo { - static List lift(RustBuffer buf) { - return FfiConverterSequenceAddressInfo.read(buf.asUint8List()).value; +class FfiConverterSequenceConflict { + static List lift(RustBuffer buf) { + return FfiConverterSequenceConflict.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterAddressInfo.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = FfiConverterConflict.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterAddressInfo.write( + offset += FfiConverterConflict.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -24995,113 +24993,63 @@ class FfiConverterSequenceAddressInfo { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterAddressInfo.allocationSize(l)) + .map((l) => FfiConverterConflict.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalMerkleProof { - static MerkleProof? lift(RustBuffer buf) { - return FfiConverterOptionalMerkleProof.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = FfiConverterMerkleProof.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); - } - - static int allocationSize([MerkleProof? value]) { - if (value == null) { - return 1; - } - return FfiConverterMerkleProof.allocationSize(value) + 1; - } - - static RustBuffer lower(MerkleProof? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalMerkleProof.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalMerkleProof.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); - } - - static int write(MerkleProof? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterMerkleProof.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; - } -} - -class FfiConverterOptionalSequenceUint8List { - static List? lift(RustBuffer buf) { - return FfiConverterOptionalSequenceUint8List.read(buf.asUint8List()).value; +class FfiConverterOptionalSignOptions { + static SignOptions? lift(RustBuffer buf) { + return FfiConverterOptionalSignOptions.read(buf.asUint8List()).value; } - static LiftRetVal?> read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterSequenceUint8List.read( + final result = FfiConverterSignOptions.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal?>(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([List? value]) { + static int allocationSize([SignOptions? value]) { if (value == null) { return 1; } - return FfiConverterSequenceUint8List.allocationSize(value) + 1; + return FfiConverterSignOptions.allocationSize(value) + 1; } - static RustBuffer lower(List? value) { + static RustBuffer lower(SignOptions? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalSequenceUint8List.allocationSize(value); + final length = FfiConverterOptionalSignOptions.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalSequenceUint8List.write(value, buf); + FfiConverterOptionalSignOptions.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(List? value, Uint8List buf) { + static int write(SignOptions? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterSequenceUint8List.write( + return FfiConverterSignOptions.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -25159,169 +25107,210 @@ class FfiConverterOptionalChangeSet { } } -class FfiConverterSequenceConflict { - static List lift(RustBuffer buf) { - return FfiConverterSequenceConflict.read(buf.asUint8List()).value; +class FfiConverterMapStringToTapKeyOrigin { + static Map lift(RustBuffer buf) { + return FfiConverterMapStringToTapKeyOrigin.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterConflict.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterTapKeyOrigin.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterConflict.write( - value[i], + for (final entry in value.entries) { + offset += FfiConverterString.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterTapKeyOrigin.write( + entry.value, Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterConflict.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterString.allocationSize(e.key) + + FfiConverterTapKeyOrigin.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUInt8 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt8.read(buf.asUint8List()).value; +class FfiConverterMapSequenceUInt32ToSequenceCondition { + static Map, List> lift(RustBuffer buf) { + return FfiConverterMapSequenceUInt32ToSequenceCondition.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal, List>> read(Uint8List buf) { + final map = , List>{}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterSequenceUInt32.read( + Uint8List.view(buf.buffer, offset), + ); + offset += k.bytesRead; + final v = FfiConverterSequenceCondition.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - final result = FfiConverterUInt8.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([int? value]) { - if (value == null) { - return 1; + static int write(Map, List> value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterSequenceUInt32.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterSequenceCondition.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterUInt8.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(int? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalUInt8.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt8.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(Map, List> value) { + return value.entries + .map( + (e) => + FfiConverterSequenceUInt32.allocationSize(e.key) + + FfiConverterSequenceCondition.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(int? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterUInt8.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(Map, List> value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterBool { - static bool lift(int value) { - return value == 1; - } - - static int lower(bool value) { - return value ? 1 : 0; +class FfiConverterMapTxidToUInt64 { + static Map lift(RustBuffer buf) { + return FfiConverterMapTxidToUInt64.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(FfiConverterBool.lift(buf.first), 1); + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = Txid.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; + } + return LiftRetVal(map, offset - buf.offsetInBytes); } - static RustBuffer lowerIntoRustBuffer(bool value) { - return toRustBuffer(Uint8List.fromList([FfiConverterBool.lower(value)])); + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += Txid.write(entry.key, Uint8List.view(buf.buffer, offset)); + offset += FfiConverterUInt64.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; } - static int allocationSize([bool value = false]) { - return 1; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + Txid.allocationSize(e.key) + + FfiConverterUInt64.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(bool value, Uint8List buf) { - buf.setAll(0, [value ? 1 : 0]); - return allocationSize(); + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterOptionalInt64 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalInt64.read(buf.asUint8List()).value; +class FfiConverterOptionalHeaderNotification { + static HeaderNotification? lift(RustBuffer buf) { + return FfiConverterOptionalHeaderNotification.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterInt64.read( + final result = FfiConverterHeaderNotification.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int? value]) { + static int allocationSize([HeaderNotification? value]) { if (value == null) { return 1; } - return FfiConverterInt64.allocationSize(value) + 1; + return FfiConverterHeaderNotification.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(HeaderNotification? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalInt64.allocationSize(value); + final length = FfiConverterOptionalHeaderNotification.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalInt64.write(value, buf); + FfiConverterOptionalHeaderNotification.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(HeaderNotification? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterInt64.write( + return FfiConverterHeaderNotification.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -25329,28 +25318,28 @@ class FfiConverterOptionalInt64 { } } -class FfiConverterSequencePeer { - static List lift(RustBuffer buf) { - return FfiConverterSequencePeer.read(buf.asUint8List()).value; +class FfiConverterSequenceTxIn { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTxIn.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterPeer.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterTxIn.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterPeer.write( + offset += FfiConverterTxIn.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -25358,354 +25347,302 @@ class FfiConverterSequencePeer { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterPeer.allocationSize(l)) + .map((l) => FfiConverterTxIn.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapStringToKeySource { - static Map lift(RustBuffer buf) { - return FfiConverterMapStringToKeySource.read(buf.asUint8List()).value; +class FfiConverterOptionalBool { + static bool? lift(RustBuffer buf) { + return FfiConverterOptionalBool.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterKeySource.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterBool.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterString.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterKeySource.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([bool? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterBool.allocationSize(value) + 1; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterKeySource.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lower(bool? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalBool.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalBool.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(bool? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterBool.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceIpAddress { - static List lift(RustBuffer buf) { - return FfiConverterSequenceIpAddress.read(buf.asUint8List()).value; +class FfiConverterOptionalAmount { + static Amount? lift(RustBuffer buf) { + return FfiConverterOptionalAmount.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = IpAddress.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final result = Amount.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += IpAddress.write(value[i], Uint8List.view(buf.buffer, offset)); + static int allocationSize([Amount? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return Amount.allocationSize(value) + 1; } - static int allocationSize(List value) { - return value - .map((l) => IpAddress.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static RustBuffer lower(Amount? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalAmount.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalAmount.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(Amount? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return Amount.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceTransaction { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTransaction.read(buf.asUint8List()).value; +class FfiConverterInt64 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt64(0), 8); } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = Transaction.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + static int lower(int value) { + if (value < -9223372036854775808 || value > 9223372036854775807) { + throw ArgumentError("Value out of range for i64: " + value.toString()); } - return LiftRetVal(res, offset - buf.offsetInBytes); + return value; } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += Transaction.write(value[i], Uint8List.view(buf.buffer, offset)); - } - return offset - buf.offsetInBytes; + static int allocationSize([int value = 0]) { + return 8; } - static int allocationSize(List value) { - return value - .map((l) => Transaction.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, lower(value)); + return 8; } +} - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceTxOut { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTxOut.read(buf.asUint8List()).value; +class FfiConverterString { + static String lift(RustBuffer buf) { + return utf8.decoder.convert(buf.asUint8List()); } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); + static RustBuffer lower(String value) { + return toRustBuffer(Utf8Encoder().convert(value)); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterTxOut.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; + static LiftRetVal read(Uint8List buf) { + final end = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0) + 4; + return LiftRetVal(utf8.decoder.convert(buf, 4, end), end); } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterTxOut.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize([String value = ""]) { + return utf8.encoder.convert(value).length + 4; } - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(String value, Uint8List buf) { + final list = utf8.encoder.convert(value); + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, list.length); + buf.setAll(4, list); + return list.length + 4; } } -class FfiConverterMapUInt32ToSequenceCondition { - static Map> lift(RustBuffer buf) { - return FfiConverterMapUInt32ToSequenceCondition.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalDouble32 { + static double? lift(RustBuffer buf) { + return FfiConverterOptionalDouble32.read(buf.asUint8List()).value; } - static LiftRetVal>> read(Uint8List buf) { - final map = >{}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterSequenceCondition.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterDouble32.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map> value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterUInt32.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterSequenceCondition.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([double? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterDouble32.allocationSize(value) + 1; } - static int allocationSize(Map> value) { - return value.entries - .map( - (e) => - FfiConverterUInt32.allocationSize(e.key) + - FfiConverterSequenceCondition.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lower(double? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalDouble32.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalDouble32.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(Map> value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(double? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterDouble32.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterMapStringToSequenceUInt64 { - static Map> lift(RustBuffer buf) { - return FfiConverterMapStringToSequenceUInt64.read(buf.asUint8List()).value; +class FfiConverterSequenceLeafNode { + static List lift(RustBuffer buf) { + return FfiConverterSequenceLeafNode.read(buf.asUint8List()).value; } - static LiftRetVal>> read(Uint8List buf) { - final map = >{}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterSequenceUInt64.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; + final ret = LeafNode.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map> value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterString.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterSequenceUInt64.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + for (var i = 0; i < value.length; i++) { + offset += LeafNode.write(value[i], Uint8List.view(buf.buffer, offset)); } return offset - buf.offsetInBytes; } - static int allocationSize(Map> value) { - return value.entries - .map( - (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterSequenceUInt64.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize(List value) { + return value + .map((l) => LeafNode.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Map> value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalSequencePsbtFinalizeException { - static List? lift(RustBuffer buf) { - return FfiConverterOptionalSequencePsbtFinalizeException.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalUint8List { + static Uint8List? lift(RustBuffer buf) { + return FfiConverterOptionalUint8List.read(buf.asUint8List()).value; } - static LiftRetVal?> read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterSequencePsbtFinalizeException.read( + final result = FfiConverterUint8List.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal?>( - result.value, - result.bytesRead + 1, - ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([List? value]) { + static int allocationSize([Uint8List? value]) { if (value == null) { return 1; } - return FfiConverterSequencePsbtFinalizeException.allocationSize(value) + 1; + return FfiConverterUint8List.allocationSize(value) + 1; } - static RustBuffer lower(List? value) { + static RustBuffer lower(Uint8List? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = - FfiConverterOptionalSequencePsbtFinalizeException.allocationSize(value); + final length = FfiConverterOptionalUint8List.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalSequencePsbtFinalizeException.write(value, buf); + FfiConverterOptionalUint8List.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(List? value, Uint8List buf) { + static int write(Uint8List? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterSequencePsbtFinalizeException.write( + return FfiConverterUint8List.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -25713,157 +25650,98 @@ class FfiConverterOptionalSequencePsbtFinalizeException { } } -class FfiConverterSequencePsbtFinalizeException { - static List lift(RustBuffer buf) { - return FfiConverterSequencePsbtFinalizeException.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalScript { + static Script? lift(RustBuffer buf) { + return FfiConverterOptionalScript.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterPsbtFinalizeException.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final result = Script.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterPsbtFinalizeException.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([Script? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return Script.allocationSize(value) + 1; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterPsbtFinalizeException.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterMapProprietaryKeyToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapProprietaryKeyToUint8List.read( - buf.asUint8List(), - ).value; - } - - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterProprietaryKey.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + static RustBuffer lower(Script? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final length = FfiConverterOptionalScript.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalScript.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterProprietaryKey.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUint8List.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int write(Script? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; } - return offset - buf.offsetInBytes; - } - - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterProprietaryKey.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); - } - - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + buf[0] = 1; + return Script.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterString { - static String lift(RustBuffer buf) { - return utf8.decoder.convert(buf.asUint8List()); - } - - static RustBuffer lower(String value) { - return toRustBuffer(Utf8Encoder().convert(value)); - } - - static LiftRetVal read(Uint8List buf) { - final end = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0) + 4; - return LiftRetVal(utf8.decoder.convert(buf, 4, end), end); +class FfiConverterDouble32 { + static double lift(double value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal( + buf.buffer.asByteData(buf.offsetInBytes).getFloat32(0), + 4, + ); } - static int allocationSize([String value = ""]) { - return utf8.encoder.convert(value).length + 4; + static double lower(double value) => value; + static int allocationSize([double value = 0]) { + return 4; } - static int write(String value, Uint8List buf) { - final list = utf8.encoder.convert(value); - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, list.length); - buf.setAll(4, list); - return list.length + 4; + static int write(double value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setFloat32(0, value); + return FfiConverterDouble32.allocationSize(); } } -class FfiConverterSequenceTxIn { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTxIn.read(buf.asUint8List()).value; +class FfiConverterSequencePkOrF { + static List lift(RustBuffer buf) { + return FfiConverterSequencePkOrF.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterTxIn.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterPkOrF.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterTxIn.write( + offset += FfiConverterPkOrF.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -25871,14 +25749,14 @@ class FfiConverterSequenceTxIn { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterTxIn.allocationSize(l)) + .map((l) => FfiConverterPkOrF.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); @@ -25930,134 +25808,134 @@ class FfiConverterSequenceLocalOutput { } } -class FfiConverterUInt8 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint8(0), 1); +class FfiConverterOptionalOutputStatus { + static OutputStatus? lift(RustBuffer buf) { + return FfiConverterOptionalOutputStatus.read(buf.asUint8List()).value; } - static int lower(int value) { - if (value < 0 || value > 255) { - throw ArgumentError("Value out of range for u8: " + value.toString()); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return value; + final result = FfiConverterOutputStatus.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int value = 0]) { - return 1; + static int allocationSize([OutputStatus? value]) { + if (value == null) { + return 1; + } + return FfiConverterOutputStatus.allocationSize(value) + 1; } - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint8(0, lower(value)); - return 1; + static RustBuffer lower(OutputStatus? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalOutputStatus.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalOutputStatus.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); + } + + static int write(OutputStatus? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterOutputStatus.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceCondition { - static List lift(RustBuffer buf) { - return FfiConverterSequenceCondition.read(buf.asUint8List()).value; +class FfiConverterMapUInt32ToSequenceCondition { + static Map> lift(RustBuffer buf) { + return FfiConverterMapUInt32ToSequenceCondition.read( + buf.asUint8List(), + ).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal>> read(Uint8List buf) { + final map = >{}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterCondition.read( + final k = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterSequenceCondition.read( Uint8List.view(buf.buffer, offset), ); - offset += ret.bytesRead; - res.add(ret.value); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map> value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterCondition.write( - value[i], + for (final entry in value.entries) { + offset += FfiConverterUInt32.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterSequenceCondition.write( + entry.value, Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterCondition.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map> value) { + return value.entries + .map( + (e) => + FfiConverterUInt32.allocationSize(e.key) + + FfiConverterSequenceCondition.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map> value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequencePolicy { - static List lift(RustBuffer buf) { - return FfiConverterSequencePolicy.read(buf.asUint8List()).value; +class FfiConverterSequenceTxOut { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTxOut.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = Policy.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += Policy.write(value[i], Uint8List.view(buf.buffer, offset)); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value.map((l) => Policy.allocationSize(l)).fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceTx { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTx.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterTx.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterTx.write( + offset += FfiConverterTxOut.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -26065,166 +25943,126 @@ class FfiConverterSequenceTx { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterTx.allocationSize(l)) + .map((l) => FfiConverterTxOut.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceScriptAmount { - static List lift(RustBuffer buf) { - return FfiConverterSequenceScriptAmount.read(buf.asUint8List()).value; +class FfiConverterSequenceDescriptor { + static List lift(RustBuffer buf) { + return FfiConverterSequenceDescriptor.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterScriptAmount.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = Descriptor.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterScriptAmount.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + offset += Descriptor.write(value[i], Uint8List.view(buf.buffer, offset)); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterScriptAmount.allocationSize(l)) + .map((l) => Descriptor.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapSequenceUInt32ToSequenceCondition { - static Map, List> lift(RustBuffer buf) { - return FfiConverterMapSequenceUInt32ToSequenceCondition.read( - buf.asUint8List(), - ).value; - } - - static LiftRetVal, List>> read(Uint8List buf) { - final map = , List>{}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterSequenceUInt32.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterSequenceCondition.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; - } - return LiftRetVal(map, offset - buf.offsetInBytes); +class FfiConverterUInt16 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint16(0), 2); } - static int write(Map, List> value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterSequenceUInt32.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterSequenceCondition.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int lower(int value) { + if (value < 0 || value > 65535) { + throw ArgumentError("Value out of range for u16: " + value.toString()); } - return offset - buf.offsetInBytes; + return value; } - static int allocationSize(Map, List> value) { - return value.entries - .map( - (e) => - FfiConverterSequenceUInt32.allocationSize(e.key) + - FfiConverterSequenceCondition.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize([int value = 0]) { + return 2; } - static RustBuffer lower(Map, List> value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint16(0, lower(value)); + return 2; } } -class FfiConverterOptionalTxDetails { - static TxDetails? lift(RustBuffer buf) { - return FfiConverterOptionalTxDetails.read(buf.asUint8List()).value; +class FfiConverterOptionalBlock { + static Block? lift(RustBuffer buf) { + return FfiConverterOptionalBlock.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTxDetails.read( + final result = FfiConverterBlock.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TxDetails? value]) { + static int allocationSize([Block? value]) { if (value == null) { return 1; } - return FfiConverterTxDetails.allocationSize(value) + 1; + return FfiConverterBlock.allocationSize(value) + 1; } - static RustBuffer lower(TxDetails? value) { + static RustBuffer lower(Block? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxDetails.allocationSize(value); + final length = FfiConverterOptionalBlock.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxDetails.write(value, buf); + FfiConverterOptionalBlock.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TxDetails? value, Uint8List buf) { + static int write(Block? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTxDetails.write( + return FfiConverterBlock.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26232,92 +26070,49 @@ class FfiConverterOptionalTxDetails { } } -class FfiConverterSequenceAnchor { - static List lift(RustBuffer buf) { - return FfiConverterSequenceAnchor.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterAnchor.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterAnchor.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value - .map((l) => FfiConverterAnchor.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterOptionalHeaderNotification { - static HeaderNotification? lift(RustBuffer buf) { - return FfiConverterOptionalHeaderNotification.read(buf.asUint8List()).value; +class FfiConverterOptionalString { + static String? lift(RustBuffer buf) { + return FfiConverterOptionalString.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterHeaderNotification.read( + final result = FfiConverterString.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([HeaderNotification? value]) { + static int allocationSize([String? value]) { if (value == null) { return 1; } - return FfiConverterHeaderNotification.allocationSize(value) + 1; + return FfiConverterString.allocationSize(value) + 1; } - static RustBuffer lower(HeaderNotification? value) { + static RustBuffer lower(String? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalHeaderNotification.allocationSize(value); + final length = FfiConverterOptionalString.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalHeaderNotification.write(value, buf); + FfiConverterOptionalString.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(HeaderNotification? value, Uint8List buf) { + static int write(String? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterHeaderNotification.write( + return FfiConverterString.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26325,86 +26120,90 @@ class FfiConverterOptionalHeaderNotification { } } -class FfiConverterOptionalLockTime { - static LockTime? lift(RustBuffer buf) { - return FfiConverterOptionalLockTime.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = FfiConverterLockTime.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); +class FfiConverterMapHashableOutPointToTxOut { + static Map lift(RustBuffer buf) { + return FfiConverterMapHashableOutPointToTxOut.read(buf.asUint8List()).value; } - static int allocationSize([LockTime? value]) { - if (value == null) { - return 1; + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = HashableOutPoint.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - return FfiConverterLockTime.allocationSize(value) + 1; + return LiftRetVal(map, offset - buf.offsetInBytes); } - static RustBuffer lower(LockTime? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += HashableOutPoint.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterTxOut.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - final length = FfiConverterOptionalLockTime.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalLockTime.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + return offset - buf.offsetInBytes; } - static int write(LockTime? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterLockTime.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + HashableOutPoint.allocationSize(e.key) + + FfiConverterTxOut.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); + } + + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterMapStringToTapKeyOrigin { - static Map lift(RustBuffer buf) { - return FfiConverterMapStringToTapKeyOrigin.read(buf.asUint8List()).value; +class FfiConverterMapProprietaryKeyToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapProprietaryKeyToUint8List.read( + buf.asUint8List(), + ).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterTapKeyOrigin.read( + final k = FfiConverterProprietaryKey.read( Uint8List.view(buf.buffer, offset), ); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += FfiConverterString.write( + offset += FfiConverterProprietaryKey.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterTapKeyOrigin.write( + offset += FfiConverterUint8List.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -26412,106 +26211,109 @@ class FfiConverterMapStringToTapKeyOrigin { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map value) { return value.entries .map( (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterTapKeyOrigin.allocationSize(e.value), + FfiConverterProprietaryKey.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterDouble64 { - static double lift(double value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal( - buf.buffer.asByteData(buf.offsetInBytes).getFloat64(0), - 8, - ); - } - - static double lower(double value) => value; - static int allocationSize([double value = 0]) { - return 8; +class FfiConverterSequenceUInt32 { + static List lift(RustBuffer buf) { + return FfiConverterSequenceUInt32.read(buf.asUint8List()).value; } - static int write(double value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setFloat64(0, value); - return FfiConverterDouble64.allocationSize(); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); } -} -class FfiConverterDouble32 { - static double lift(double value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal( - buf.buffer.asByteData(buf.offsetInBytes).getFloat32(0), - 4, - ); + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterUInt32.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; } - static double lower(double value) => value; - static int allocationSize([double value = 0]) { - return 4; + static int allocationSize(List value) { + return value + .map((l) => FfiConverterUInt32.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static int write(double value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setFloat32(0, value); - return FfiConverterDouble32.allocationSize(); + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterOptionalUint8List { - static Uint8List? lift(RustBuffer buf) { - return FfiConverterOptionalUint8List.read(buf.asUint8List()).value; +class FfiConverterOptionalTx { + static Tx? lift(RustBuffer buf) { + return FfiConverterOptionalTx.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUint8List.read( + final result = FfiConverterTx.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Uint8List? value]) { + static int allocationSize([Tx? value]) { if (value == null) { return 1; } - return FfiConverterUint8List.allocationSize(value) + 1; + return FfiConverterTx.allocationSize(value) + 1; } - static RustBuffer lower(Uint8List? value) { + static RustBuffer lower(Tx? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUint8List.allocationSize(value); + final length = FfiConverterOptionalTx.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUint8List.write(value, buf); + FfiConverterOptionalTx.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Uint8List? value, Uint8List buf) { + static int write(Tx? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUint8List.write( + return FfiConverterTx.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26519,49 +26321,87 @@ class FfiConverterOptionalUint8List { } } -class FfiConverterOptionalBool { - static bool? lift(RustBuffer buf) { - return FfiConverterOptionalBool.read(buf.asUint8List()).value; +class FfiConverterSequencePolicy { + static List lift(RustBuffer buf) { + return FfiConverterSequencePolicy.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = Policy.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += Policy.write(value[i], Uint8List.view(buf.buffer, offset)); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value.map((l) => Policy.allocationSize(l)).fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterOptionalTxDetails { + static TxDetails? lift(RustBuffer buf) { + return FfiConverterOptionalTxDetails.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterBool.read( + final result = FfiConverterTxDetails.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([bool? value]) { + static int allocationSize([TxDetails? value]) { if (value == null) { return 1; } - return FfiConverterBool.allocationSize(value) + 1; + return FfiConverterTxDetails.allocationSize(value) + 1; } - static RustBuffer lower(bool? value) { + static RustBuffer lower(TxDetails? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalBool.allocationSize(value); + final length = FfiConverterOptionalTxDetails.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalBool.write(value, buf); + FfiConverterOptionalTxDetails.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(bool? value, Uint8List buf) { + static int write(TxDetails? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterBool.write( + return FfiConverterTxDetails.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26569,30 +26409,28 @@ class FfiConverterOptionalBool { } } -class FfiConverterSequenceUint8List { - static List lift(RustBuffer buf) { - return FfiConverterSequenceUint8List.read(buf.asUint8List()).value; +class FfiConverterSequenceString { + static List lift(RustBuffer buf) { + return FfiConverterSequenceString.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterUint8List.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterUint8List.write( + offset += FfiConverterString.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -26600,63 +26438,83 @@ class FfiConverterSequenceUint8List { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterUint8List.allocationSize(l)) + .map((l) => FfiConverterString.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalTx { - static Tx? lift(RustBuffer buf) { - return FfiConverterOptionalTx.read(buf.asUint8List()).value; +class FfiConverterDouble64 { + static double lift(double value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal( + buf.buffer.asByteData(buf.offsetInBytes).getFloat64(0), + 8, + ); } - static LiftRetVal read(Uint8List buf) { + static double lower(double value) => value; + static int allocationSize([double value = 0]) { + return 8; + } + + static int write(double value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setFloat64(0, value); + return FfiConverterDouble64.allocationSize(); + } +} + +class FfiConverterOptionalTxOut { + static TxOut? lift(RustBuffer buf) { + return FfiConverterOptionalTxOut.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTx.read( + final result = FfiConverterTxOut.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Tx? value]) { + static int allocationSize([TxOut? value]) { if (value == null) { return 1; } - return FfiConverterTx.allocationSize(value) + 1; + return FfiConverterTxOut.allocationSize(value) + 1; } - static RustBuffer lower(Tx? value) { + static RustBuffer lower(TxOut? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTx.allocationSize(value); + final length = FfiConverterOptionalTxOut.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTx.write(value, buf); + FfiConverterOptionalTxOut.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Tx? value, Uint8List buf) { + static int write(TxOut? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTx.write( + return FfiConverterTxOut.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26664,49 +26522,277 @@ class FfiConverterOptionalTx { } } -class FfiConverterOptionalBlock { - static Block? lift(RustBuffer buf) { - return FfiConverterOptionalBlock.read(buf.asUint8List()).value; +class FfiConverterSequenceCondition { + static List lift(RustBuffer buf) { + return FfiConverterSequenceCondition.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterCondition.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterCondition.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterCondition.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceOutput { + static List lift(RustBuffer buf) { + return FfiConverterSequenceOutput.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterOutput.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterOutput.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterOutput.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceScriptAmount { + static List lift(RustBuffer buf) { + return FfiConverterSequenceScriptAmount.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterScriptAmount.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterScriptAmount.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterScriptAmount.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterMapKeyToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapKeyToUint8List.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterKey.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; + } + return LiftRetVal(map, offset - buf.offsetInBytes); + } + + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterKey.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterUint8List.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterKey.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); + } + + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceInput { + static List lift(RustBuffer buf) { + return FfiConverterSequenceInput.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterInput.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterInput.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterInput.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterOptionalUInt64 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalUInt64.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterBlock.read( + final result = FfiConverterUInt64.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Block? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return FfiConverterBlock.allocationSize(value) + 1; + return FfiConverterUInt64.allocationSize(value) + 1; } - static RustBuffer lower(Block? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalBlock.allocationSize(value); + final length = FfiConverterOptionalUInt64.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalBlock.write(value, buf); + FfiConverterOptionalUInt64.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Block? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterBlock.write( + return FfiConverterUInt64.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26714,132 +26800,118 @@ class FfiConverterOptionalBlock { } } -class FfiConverterMapStringToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapStringToUint8List.read(buf.asUint8List()).value; +class FfiConverterSequenceWalletEvent { + static List lift(RustBuffer buf) { + return FfiConverterSequenceWalletEvent.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + final ret = FfiConverterWalletEvent.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterString.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUint8List.write( - entry.value, + for (var i = 0; i < value.length; i++) { + offset += FfiConverterWalletEvent.write( + value[i], Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterWalletEvent.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Map value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalString { - static String? lift(RustBuffer buf) { - return FfiConverterOptionalString.read(buf.asUint8List()).value; +class FfiConverterSequenceUint8List { + static List lift(RustBuffer buf) { + return FfiConverterSequenceUint8List.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterUint8List.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); } - final result = FfiConverterString.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int allocationSize([String? value]) { - if (value == null) { - return 1; + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterUint8List.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterString.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(String? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalString.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalString.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterUint8List.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static int write(String? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterString.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterSequenceEvictedTx { - static List lift(RustBuffer buf) { - return FfiConverterSequenceEvictedTx.read(buf.asUint8List()).value; +class FfiConverterSequenceAnchor { + static List lift(RustBuffer buf) { + return FfiConverterSequenceAnchor.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterEvictedTx.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = FfiConverterAnchor.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterEvictedTx.write( + offset += FfiConverterAnchor.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -26847,52 +26919,50 @@ class FfiConverterSequenceEvictedTx { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterEvictedTx.allocationSize(l)) + .map((l) => FfiConverterAnchor.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapTapScriptSigKeyToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapTapScriptSigKeyToUint8List.read( - buf.asUint8List(), - ).value; +class FfiConverterMapStringToSequenceUInt64 { + static Map> lift(RustBuffer buf) { + return FfiConverterMapStringToSequenceUInt64.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal>> read(Uint8List buf) { + final map = >{}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterTapScriptSigKey.read( + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterSequenceUInt64.read( Uint8List.view(buf.buffer, offset), ); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map> value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += FfiConverterTapScriptSigKey.write( + offset += FfiConverterString.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterUint8List.write( + offset += FfiConverterSequenceUInt64.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -26900,114 +26970,66 @@ class FfiConverterMapTapScriptSigKeyToUint8List { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map> value) { return value.entries .map( (e) => - FfiConverterTapScriptSigKey.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), + FfiConverterString.allocationSize(e.key) + + FfiConverterSequenceUInt64.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map> value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalTxid { - static Txid? lift(RustBuffer buf) { - return FfiConverterOptionalTxid.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = Txid.read(Uint8List.view(buf.buffer, buf.offsetInBytes + 1)); - return LiftRetVal(result.value, result.bytesRead + 1); - } - - static int allocationSize([Txid? value]) { - if (value == null) { - return 1; - } - return Txid.allocationSize(value) + 1; - } - - static RustBuffer lower(Txid? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalTxid.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalTxid.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); - } - - static int write(Txid? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return Txid.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; - } -} - -class FfiConverterOptionalKeychainAndIndex { - static KeychainAndIndex? lift(RustBuffer buf) { - return FfiConverterOptionalKeychainAndIndex.read(buf.asUint8List()).value; +class FfiConverterOptionalCanonicalTx { + static CanonicalTx? lift(RustBuffer buf) { + return FfiConverterOptionalCanonicalTx.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterKeychainAndIndex.read( + final result = FfiConverterCanonicalTx.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([KeychainAndIndex? value]) { + static int allocationSize([CanonicalTx? value]) { if (value == null) { return 1; } - return FfiConverterKeychainAndIndex.allocationSize(value) + 1; + return FfiConverterCanonicalTx.allocationSize(value) + 1; } - static RustBuffer lower(KeychainAndIndex? value) { + static RustBuffer lower(CanonicalTx? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalKeychainAndIndex.allocationSize(value); + final length = FfiConverterOptionalCanonicalTx.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalKeychainAndIndex.write(value, buf); + FfiConverterOptionalCanonicalTx.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(KeychainAndIndex? value, Uint8List buf) { + static int write(CanonicalTx? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterKeychainAndIndex.write( + return FfiConverterCanonicalTx.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27015,49 +27037,49 @@ class FfiConverterOptionalKeychainAndIndex { } } -class FfiConverterOptionalSignOptions { - static SignOptions? lift(RustBuffer buf) { - return FfiConverterOptionalSignOptions.read(buf.asUint8List()).value; +class FfiConverterOptionalTapTree { + static TapTree? lift(RustBuffer buf) { + return FfiConverterOptionalTapTree.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterSignOptions.read( + final result = TapTree.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([SignOptions? value]) { + static int allocationSize([TapTree? value]) { if (value == null) { return 1; } - return FfiConverterSignOptions.allocationSize(value) + 1; + return TapTree.allocationSize(value) + 1; } - static RustBuffer lower(SignOptions? value) { + static RustBuffer lower(TapTree? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalSignOptions.allocationSize(value); + final length = FfiConverterOptionalTapTree.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalSignOptions.write(value, buf); + FfiConverterOptionalTapTree.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(SignOptions? value, Uint8List buf) { + static int write(TapTree? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterSignOptions.write( + return TapTree.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27065,34 +27087,34 @@ class FfiConverterOptionalSignOptions { } } -class FfiConverterMapHashableOutPointToTxOut { - static Map lift(RustBuffer buf) { - return FfiConverterMapHashableOutPointToTxOut.read(buf.asUint8List()).value; +class FfiConverterMapDescriptorIdToUInt32 { + static Map lift(RustBuffer buf) { + return FfiConverterMapDescriptorIdToUInt32.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = HashableOutPoint.read(Uint8List.view(buf.buffer, offset)); + final k = DescriptorId.read(Uint8List.view(buf.buffer, offset)); offset += k.bytesRead; - final v = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); + final v = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += HashableOutPoint.write( + offset += DescriptorId.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterTxOut.write( + offset += FfiConverterUInt32.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -27100,66 +27122,66 @@ class FfiConverterMapHashableOutPointToTxOut { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map value) { return value.entries .map( (e) => - HashableOutPoint.allocationSize(e.key) + - FfiConverterTxOut.allocationSize(e.value), + DescriptorId.allocationSize(e.key) + + FfiConverterUInt32.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalTxStatus { - static TxStatus? lift(RustBuffer buf) { - return FfiConverterOptionalTxStatus.read(buf.asUint8List()).value; +class FfiConverterOptionalKeychainAndIndex { + static KeychainAndIndex? lift(RustBuffer buf) { + return FfiConverterOptionalKeychainAndIndex.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTxStatus.read( + final result = FfiConverterKeychainAndIndex.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TxStatus? value]) { + static int allocationSize([KeychainAndIndex? value]) { if (value == null) { return 1; } - return FfiConverterTxStatus.allocationSize(value) + 1; + return FfiConverterKeychainAndIndex.allocationSize(value) + 1; } - static RustBuffer lower(TxStatus? value) { + static RustBuffer lower(KeychainAndIndex? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxStatus.allocationSize(value); + final length = FfiConverterOptionalKeychainAndIndex.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxStatus.write(value, buf); + FfiConverterOptionalKeychainAndIndex.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TxStatus? value, Uint8List buf) { + static int write(KeychainAndIndex? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTxStatus.write( + return FfiConverterKeychainAndIndex.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27167,30 +27189,28 @@ class FfiConverterOptionalTxStatus { } } -class FfiConverterSequenceChainChange { - static List lift(RustBuffer buf) { - return FfiConverterSequenceChainChange.read(buf.asUint8List()).value; +class FfiConverterSequenceOutPoint { + static List lift(RustBuffer buf) { + return FfiConverterSequenceOutPoint.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterChainChange.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = FfiConverterOutPoint.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterChainChange.write( + offset += FfiConverterOutPoint.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -27198,120 +27218,63 @@ class FfiConverterSequenceChainChange { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterChainChange.allocationSize(l)) + .map((l) => FfiConverterOutPoint.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalConfirmationBlockTime { - static ConfirmationBlockTime? lift(RustBuffer buf) { - return FfiConverterOptionalConfirmationBlockTime.read( - buf.asUint8List(), - ).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = FfiConverterConfirmationBlockTime.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal( - result.value, - result.bytesRead + 1, - ); - } - - static int allocationSize([ConfirmationBlockTime? value]) { - if (value == null) { - return 1; - } - return FfiConverterConfirmationBlockTime.allocationSize(value) + 1; - } - - static RustBuffer lower(ConfirmationBlockTime? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalConfirmationBlockTime.allocationSize( - value, - ); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalConfirmationBlockTime.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); - } - - static int write(ConfirmationBlockTime? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterConfirmationBlockTime.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; - } -} - -class FfiConverterOptionalCanonicalTx { - static CanonicalTx? lift(RustBuffer buf) { - return FfiConverterOptionalCanonicalTx.read(buf.asUint8List()).value; +class FfiConverterOptionalLocalOutput { + static LocalOutput? lift(RustBuffer buf) { + return FfiConverterOptionalLocalOutput.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterCanonicalTx.read( + final result = FfiConverterLocalOutput.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([CanonicalTx? value]) { + static int allocationSize([LocalOutput? value]) { if (value == null) { return 1; } - return FfiConverterCanonicalTx.allocationSize(value) + 1; + return FfiConverterLocalOutput.allocationSize(value) + 1; } - static RustBuffer lower(CanonicalTx? value) { + static RustBuffer lower(LocalOutput? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalCanonicalTx.allocationSize(value); + final length = FfiConverterOptionalLocalOutput.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalCanonicalTx.write(value, buf); + FfiConverterOptionalLocalOutput.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(CanonicalTx? value, Uint8List buf) { + static int write(LocalOutput? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterCanonicalTx.write( + return FfiConverterLocalOutput.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27319,173 +27282,147 @@ class FfiConverterOptionalCanonicalTx { } } -class FfiConverterMapDescriptorIdToUInt32 { - static Map lift(RustBuffer buf) { - return FfiConverterMapDescriptorIdToUInt32.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = DescriptorId.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; - } - return LiftRetVal(map, offset - buf.offsetInBytes); +class FfiConverterUInt64 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint64(0), 8); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += DescriptorId.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUInt32.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int lower(int value) { + if (value < 0) { + throw ArgumentError("Value out of range for u64: " + value.toString()); } - return offset - buf.offsetInBytes; + return value; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - DescriptorId.allocationSize(e.key) + - FfiConverterUInt32.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize([int value = 0]) { + return 8; } - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint64(0, lower(value)); + return 8; } } -class FfiConverterSequenceUInt64 { - static List lift(RustBuffer buf) { - return FfiConverterSequenceUInt64.read(buf.asUint8List()).value; +class FfiConverterSequenceIpAddress { + static List lift(RustBuffer buf) { + return FfiConverterSequenceIpAddress.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); + final ret = IpAddress.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterUInt64.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + offset += IpAddress.write(value[i], Uint8List.view(buf.buffer, offset)); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterUInt64.allocationSize(l)) + .map((l) => IpAddress.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalOutputStatus { - static OutputStatus? lift(RustBuffer buf) { - return FfiConverterOptionalOutputStatus.read(buf.asUint8List()).value; +class FfiConverterMapTapScriptSigKeyToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapTapScriptSigKeyToUint8List.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterTapScriptSigKey.read( + Uint8List.view(buf.buffer, offset), + ); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - final result = FfiConverterOutputStatus.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([OutputStatus? value]) { - if (value == null) { - return 1; + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterTapScriptSigKey.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterUint8List.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterOutputStatus.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(OutputStatus? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalOutputStatus.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalOutputStatus.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterTapScriptSigKey.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(OutputStatus? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterOutputStatus.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterSequenceInput { - static List lift(RustBuffer buf) { - return FfiConverterSequenceInput.read(buf.asUint8List()).value; +class FfiConverterSequenceTx { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTx.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterInput.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterTx.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterInput.write( + offset += FfiConverterTx.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -27493,106 +27430,103 @@ class FfiConverterSequenceInput { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterInput.allocationSize(l)) + .map((l) => FfiConverterTx.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceOutPoint { - static List lift(RustBuffer buf) { - return FfiConverterSequenceOutPoint.read(buf.asUint8List()).value; +class FfiConverterSequenceTransaction { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTransaction.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterOutPoint.read(Uint8List.view(buf.buffer, offset)); + final ret = Transaction.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterOutPoint.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + offset += Transaction.write(value[i], Uint8List.view(buf.buffer, offset)); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterOutPoint.allocationSize(l)) + .map((l) => Transaction.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalDescriptor { - static Descriptor? lift(RustBuffer buf) { - return FfiConverterOptionalDescriptor.read(buf.asUint8List()).value; +class FfiConverterOptionalSequenceUint8List { + static List? lift(RustBuffer buf) { + return FfiConverterOptionalSequenceUint8List.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal?> read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Descriptor.read( + final result = FfiConverterSequenceUint8List.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal?>(result.value, result.bytesRead + 1); } - static int allocationSize([Descriptor? value]) { + static int allocationSize([List? value]) { if (value == null) { return 1; } - return Descriptor.allocationSize(value) + 1; + return FfiConverterSequenceUint8List.allocationSize(value) + 1; } - static RustBuffer lower(Descriptor? value) { + static RustBuffer lower(List? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalDescriptor.allocationSize(value); + final length = FfiConverterOptionalSequenceUint8List.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalDescriptor.write(value, buf); + FfiConverterOptionalSequenceUint8List.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Descriptor? value, Uint8List buf) { + static int write(List? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Descriptor.write( + return FfiConverterSequenceUint8List.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27600,146 +27534,124 @@ class FfiConverterOptionalDescriptor { } } -class FfiConverterMapTxidToUInt64 { - static Map lift(RustBuffer buf) { - return FfiConverterMapTxidToUInt64.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = Txid.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; - } - return LiftRetVal(map, offset - buf.offsetInBytes); - } - - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += Txid.write(entry.key, Uint8List.view(buf.buffer, offset)); - offset += FfiConverterUInt64.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - Txid.allocationSize(e.key) + - FfiConverterUInt64.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); - } - - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceTxid { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTxid.read(buf.asUint8List()).value; +class FfiConverterOptionalLockTime { + static LockTime? lift(RustBuffer buf) { + return FfiConverterOptionalLockTime.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = Txid.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final result = FfiConverterLockTime.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += Txid.write(value[i], Uint8List.view(buf.buffer, offset)); + static int allocationSize([LockTime? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterLockTime.allocationSize(value) + 1; } - static int allocationSize(List value) { - return value.map((l) => Txid.allocationSize(l)).fold(0, (a, b) => a + b) + - 4; + static RustBuffer lower(LockTime? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalLockTime.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalLockTime.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(LockTime? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterLockTime.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceString { - static List lift(RustBuffer buf) { - return FfiConverterSequenceString.read(buf.asUint8List()).value; +class FfiConverterMapControlBlockToTapScriptEntry { + static Map lift(RustBuffer buf) { + return FfiConverterMapControlBlockToTapScriptEntry.read( + buf.asUint8List(), + ).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterControlBlock.read( + Uint8List.view(buf.buffer, offset), + ); + offset += k.bytesRead; + final v = FfiConverterTapScriptEntry.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterString.write( - value[i], + for (final entry in value.entries) { + offset += FfiConverterControlBlock.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterTapScriptEntry.write( + entry.value, Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterString.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterControlBlock.allocationSize(e.key) + + FfiConverterTapScriptEntry.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUInt32 { +class FfiConverterOptionalUInt16 { static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt32.read(buf.asUint8List()).value; + return FfiConverterOptionalUInt16.read(buf.asUint8List()).value; } static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt32.read( + final result = FfiConverterUInt16.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); return LiftRetVal(result.value, result.bytesRead + 1); @@ -27749,17 +27661,17 @@ class FfiConverterOptionalUInt32 { if (value == null) { return 1; } - return FfiConverterUInt32.allocationSize(value) + 1; + return FfiConverterUInt16.allocationSize(value) + 1; } static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt32.allocationSize(value); + final length = FfiConverterOptionalUInt16.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt32.write(value, buf); + FfiConverterOptionalUInt16.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; @@ -27772,7 +27684,7 @@ class FfiConverterOptionalUInt32 { return 1; } buf[0] = 1; - return FfiConverterUInt32.write( + return FfiConverterUInt16.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27780,49 +27692,49 @@ class FfiConverterOptionalUInt32 { } } -class FfiConverterOptionalTransaction { - static Transaction? lift(RustBuffer buf) { - return FfiConverterOptionalTransaction.read(buf.asUint8List()).value; +class FfiConverterOptionalInt64 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalInt64.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Transaction.read( + final result = FfiConverterInt64.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Transaction? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return Transaction.allocationSize(value) + 1; + return FfiConverterInt64.allocationSize(value) + 1; } - static RustBuffer lower(Transaction? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTransaction.allocationSize(value); + final length = FfiConverterOptionalInt64.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTransaction.write(value, buf); + FfiConverterOptionalInt64.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Transaction? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Transaction.write( + return FfiConverterInt64.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27830,72 +27742,56 @@ class FfiConverterOptionalTransaction { } } -class FfiConverterInt32 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt32(0), 4); - } - - static int lower(int value) { - if (value < -2147483648 || value > 2147483647) { - throw ArgumentError("Value out of range for i32: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 4; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, lower(value)); - return 4; - } -} - -class FfiConverterOptionalTxOut { - static TxOut? lift(RustBuffer buf) { - return FfiConverterOptionalTxOut.read(buf.asUint8List()).value; +class FfiConverterOptionalConfirmationBlockTime { + static ConfirmationBlockTime? lift(RustBuffer buf) { + return FfiConverterOptionalConfirmationBlockTime.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTxOut.read( + final result = FfiConverterConfirmationBlockTime.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal( + result.value, + result.bytesRead + 1, + ); } - static int allocationSize([TxOut? value]) { + static int allocationSize([ConfirmationBlockTime? value]) { if (value == null) { return 1; } - return FfiConverterTxOut.allocationSize(value) + 1; + return FfiConverterConfirmationBlockTime.allocationSize(value) + 1; } - static RustBuffer lower(TxOut? value) { + static RustBuffer lower(ConfirmationBlockTime? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxOut.allocationSize(value); + final length = FfiConverterOptionalConfirmationBlockTime.allocationSize( + value, + ); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxOut.write(value, buf); + FfiConverterOptionalConfirmationBlockTime.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TxOut? value, Uint8List buf) { + static int write(ConfirmationBlockTime? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTxOut.write( + return FfiConverterConfirmationBlockTime.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27903,137 +27799,134 @@ class FfiConverterOptionalTxOut { } } -class FfiConverterMapControlBlockToTapScriptEntry { - static Map lift(RustBuffer buf) { - return FfiConverterMapControlBlockToTapScriptEntry.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalNetwork { + static Network? lift(RustBuffer buf) { + return FfiConverterOptionalNetwork.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterControlBlock.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterTapScriptEntry.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterNetwork.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterControlBlock.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterTapScriptEntry.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([Network? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterNetwork.allocationSize(value) + 1; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterControlBlock.allocationSize(e.key) + - FfiConverterTapScriptEntry.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lower(Network? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalNetwork.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalNetwork.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(Network? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterNetwork.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceCanonicalTx { - static List lift(RustBuffer buf) { - return FfiConverterSequenceCanonicalTx.read(buf.asUint8List()).value; +class FfiConverterOptionalBlockHash { + static BlockHash? lift(RustBuffer buf) { + return FfiConverterOptionalBlockHash.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterCanonicalTx.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final result = BlockHash.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterCanonicalTx.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([BlockHash? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return BlockHash.allocationSize(value) + 1; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterCanonicalTx.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static RustBuffer lower(BlockHash? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalBlockHash.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalBlockHash.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(BlockHash? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return BlockHash.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterMapUInt16ToDouble64 { - static Map lift(RustBuffer buf) { - return FfiConverterMapUInt16ToDouble64.read(buf.asUint8List()).value; +class FfiConverterMapStringToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapStringToUint8List.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterUInt16.read(Uint8List.view(buf.buffer, offset)); + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); offset += k.bytesRead; - final v = FfiConverterDouble64.read(Uint8List.view(buf.buffer, offset)); + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += FfiConverterUInt16.write( + offset += FfiConverterString.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterDouble64.write( + offset += FfiConverterUint8List.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -28041,89 +27934,66 @@ class FfiConverterMapUInt16ToDouble64 { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map value) { return value.entries .map( (e) => - FfiConverterUInt16.allocationSize(e.key) + - FfiConverterDouble64.allocationSize(e.value), + FfiConverterString.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterUInt16 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint16(0), 2); - } - - static int lower(int value) { - if (value < 0 || value > 65535) { - throw ArgumentError("Value out of range for u16: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 2; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint16(0, lower(value)); - return 2; - } -} - -class FfiConverterOptionalTapTree { - static TapTree? lift(RustBuffer buf) { - return FfiConverterOptionalTapTree.read(buf.asUint8List()).value; +class FfiConverterOptionalUInt32 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalUInt32.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = TapTree.read( + final result = FfiConverterUInt32.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TapTree? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return TapTree.allocationSize(value) + 1; + return FfiConverterUInt32.allocationSize(value) + 1; } - static RustBuffer lower(TapTree? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTapTree.allocationSize(value); + final length = FfiConverterOptionalUInt32.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTapTree.write(value, buf); + FfiConverterOptionalUInt32.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TapTree? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return TapTree.write( + return FfiConverterUInt32.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28131,51 +28001,30 @@ class FfiConverterOptionalTapTree { } } -class FfiConverterInt64 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt64(0), 8); - } - - static int lower(int value) { - if (value < -9223372036854775808 || value > 9223372036854775807) { - throw ArgumentError("Value out of range for i64: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 8; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, lower(value)); - return 8; - } -} - -class FfiConverterSequencePkOrF { - static List lift(RustBuffer buf) { - return FfiConverterSequencePkOrF.read(buf.asUint8List()).value; +class FfiConverterSequenceChainChange { + static List lift(RustBuffer buf) { + return FfiConverterSequenceChainChange.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterPkOrF.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterChainChange.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterPkOrF.write( + offset += FfiConverterChainChange.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -28183,94 +28032,89 @@ class FfiConverterSequencePkOrF { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterPkOrF.allocationSize(l)) + .map((l) => FfiConverterChainChange.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapKeyToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapKeyToUint8List.read(buf.asUint8List()).value; +class FfiConverterSequenceEvictedTx { + static List lift(RustBuffer buf) { + return FfiConverterSequenceEvictedTx.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterKey.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + final ret = FfiConverterEvictedTx.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterKey.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUint8List.write( - entry.value, + for (var i = 0; i < value.length; i++) { + offset += FfiConverterEvictedTx.write( + value[i], Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterKey.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterEvictedTx.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Map value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceOutput { - static List lift(RustBuffer buf) { - return FfiConverterSequenceOutput.read(buf.asUint8List()).value; +class FfiConverterSequenceAddressInfo { + static List lift(RustBuffer buf) { + return FfiConverterSequenceAddressInfo.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterOutput.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterAddressInfo.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterOutput.write( + offset += FfiConverterAddressInfo.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -28278,86 +28122,61 @@ class FfiConverterSequenceOutput { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterOutput.allocationSize(l)) + .map((l) => FfiConverterAddressInfo.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterUInt32 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint32(0), 4); - } - - static int lower(int value) { - if (value < 0 || value > 4294967295) { - throw ArgumentError("Value out of range for u32: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 4; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint32(0, lower(value)); - return 4; - } -} - -class FfiConverterOptionalPolicy { - static Policy? lift(RustBuffer buf) { - return FfiConverterOptionalPolicy.read(buf.asUint8List()).value; +class FfiConverterOptionalTxid { + static Txid? lift(RustBuffer buf) { + return FfiConverterOptionalTxid.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Policy.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + final result = Txid.read(Uint8List.view(buf.buffer, buf.offsetInBytes + 1)); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Policy? value]) { + static int allocationSize([Txid? value]) { if (value == null) { return 1; } - return Policy.allocationSize(value) + 1; + return Txid.allocationSize(value) + 1; } - static RustBuffer lower(Policy? value) { + static RustBuffer lower(Txid? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalPolicy.allocationSize(value); + final length = FfiConverterOptionalTxid.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalPolicy.write(value, buf); + FfiConverterOptionalTxid.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Policy? value, Uint8List buf) { + static int write(Txid? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Policy.write( + return Txid.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28365,49 +28184,49 @@ class FfiConverterOptionalPolicy { } } -class FfiConverterOptionalBlockHash { - static BlockHash? lift(RustBuffer buf) { - return FfiConverterOptionalBlockHash.read(buf.asUint8List()).value; +class FfiConverterOptionalTransaction { + static Transaction? lift(RustBuffer buf) { + return FfiConverterOptionalTransaction.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = BlockHash.read( + final result = Transaction.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([BlockHash? value]) { + static int allocationSize([Transaction? value]) { if (value == null) { return 1; } - return BlockHash.allocationSize(value) + 1; + return Transaction.allocationSize(value) + 1; } - static RustBuffer lower(BlockHash? value) { + static RustBuffer lower(Transaction? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalBlockHash.allocationSize(value); + final length = FfiConverterOptionalTransaction.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalBlockHash.write(value, buf); + FfiConverterOptionalTransaction.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(BlockHash? value, Uint8List buf) { + static int write(Transaction? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return BlockHash.write( + return Transaction.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28415,115 +28234,49 @@ class FfiConverterOptionalBlockHash { } } -class FfiConverterSequenceUInt32 { - static List lift(RustBuffer buf) { - return FfiConverterSequenceUInt32.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterUInt32.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value - .map((l) => FfiConverterUInt32.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterUInt64 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint64(0), 8); - } - - static int lower(int value) { - if (value < 0) { - throw ArgumentError("Value out of range for u64: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 8; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint64(0, lower(value)); - return 8; - } -} - -class FfiConverterOptionalNetwork { - static Network? lift(RustBuffer buf) { - return FfiConverterOptionalNetwork.read(buf.asUint8List()).value; +class FfiConverterOptionalMerkleProof { + static MerkleProof? lift(RustBuffer buf) { + return FfiConverterOptionalMerkleProof.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterNetwork.read( + final result = FfiConverterMerkleProof.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Network? value]) { + static int allocationSize([MerkleProof? value]) { if (value == null) { return 1; } - return FfiConverterNetwork.allocationSize(value) + 1; + return FfiConverterMerkleProof.allocationSize(value) + 1; } - static RustBuffer lower(Network? value) { + static RustBuffer lower(MerkleProof? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalNetwork.allocationSize(value); + final length = FfiConverterOptionalMerkleProof.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalNetwork.write(value, buf); + FfiConverterOptionalMerkleProof.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Network? value, Uint8List buf) { + static int write(MerkleProof? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterNetwork.write( + return FfiConverterMerkleProof.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28531,40 +28284,83 @@ class FfiConverterOptionalNetwork { } } -class FfiConverterSequenceLeafNode { - static List lift(RustBuffer buf) { - return FfiConverterSequenceLeafNode.read(buf.asUint8List()).value; +class FfiConverterUint8List { + static Uint8List lift(RustBuffer value) { + return FfiConverterUint8List.read(value.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal read(Uint8List buf) { + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + final bytes = Uint8List.view(buf.buffer, buf.offsetInBytes + 4, length); + return LiftRetVal(bytes, length + 4); + } + + static RustBuffer lower(Uint8List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } + + static int allocationSize([Uint8List? value]) { + if (value == null) { + return 4; + } + return 4 + value.length; + } + + static int write(Uint8List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + buf.setRange(4, 4 + value.length, value); + return 4 + value.length; + } +} + +class FfiConverterMapStringToKeySource { + static Map lift(RustBuffer buf) { + return FfiConverterMapStringToKeySource.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = LeafNode.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterKeySource.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += LeafNode.write(value[i], Uint8List.view(buf.buffer, offset)); + for (final entry in value.entries) { + offset += FfiConverterString.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterKeySource.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => LeafNode.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterString.allocationSize(e.key) + + FfiConverterKeySource.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); @@ -28616,30 +28412,28 @@ class FfiConverterSequenceUnconfirmedTx { } } -class FfiConverterSequenceWalletEvent { - static List lift(RustBuffer buf) { - return FfiConverterSequenceWalletEvent.read(buf.asUint8List()).value; +class FfiConverterSequencePeer { + static List lift(RustBuffer buf) { + return FfiConverterSequencePeer.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterWalletEvent.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = FfiConverterPeer.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterWalletEvent.write( + offset += FfiConverterPeer.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -28647,63 +28441,63 @@ class FfiConverterSequenceWalletEvent { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterWalletEvent.allocationSize(l)) + .map((l) => FfiConverterPeer.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalLocalOutput { - static LocalOutput? lift(RustBuffer buf) { - return FfiConverterOptionalLocalOutput.read(buf.asUint8List()).value; +class FfiConverterOptionalUInt8 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalUInt8.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterLocalOutput.read( + final result = FfiConverterUInt8.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([LocalOutput? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return FfiConverterLocalOutput.allocationSize(value) + 1; + return FfiConverterUInt8.allocationSize(value) + 1; } - static RustBuffer lower(LocalOutput? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalLocalOutput.allocationSize(value); + final length = FfiConverterOptionalUInt8.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalLocalOutput.write(value, buf); + FfiConverterOptionalUInt8.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(LocalOutput? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterLocalOutput.write( + return FfiConverterUInt8.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28711,80 +28505,258 @@ class FfiConverterOptionalLocalOutput { } } -class FfiConverterUint8List { - static Uint8List lift(RustBuffer value) { - return FfiConverterUint8List.read(value.asUint8List()).value; +class FfiConverterUInt8 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint8(0), 1); + } + + static int lower(int value) { + if (value < 0 || value > 255) { + throw ArgumentError("Value out of range for u8: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 1; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint8(0, lower(value)); + return 1; + } +} + +class FfiConverterMapUInt16ToDouble64 { + static Map lift(RustBuffer buf) { + return FfiConverterMapUInt16ToDouble64.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterUInt16.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterDouble64.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; + } + return LiftRetVal(map, offset - buf.offsetInBytes); + } + + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterUInt16.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterDouble64.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterUInt16.allocationSize(e.key) + + FfiConverterDouble64.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); + } + + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterUInt32 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint32(0), 4); + } + + static int lower(int value) { + if (value < 0 || value > 4294967295) { + throw ArgumentError("Value out of range for u32: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 4; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint32(0, lower(value)); + return 4; + } +} + +class FfiConverterInt32 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt32(0), 4); + } + + static int lower(int value) { + if (value < -2147483648 || value > 2147483647) { + throw ArgumentError("Value out of range for i32: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 4; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, lower(value)); + return 4; + } +} + +class FfiConverterSequenceUInt64 { + static List lift(RustBuffer buf) { + return FfiConverterSequenceUInt64.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterUInt64.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterUInt64.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceCanonicalTx { + static List lift(RustBuffer buf) { + return FfiConverterSequenceCanonicalTx.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterCanonicalTx.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterCanonicalTx.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; } - static LiftRetVal read(Uint8List buf) { - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - final bytes = Uint8List.view(buf.buffer, buf.offsetInBytes + 4, length); - return LiftRetVal(bytes, length + 4); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterCanonicalTx.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Uint8List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } - - static int allocationSize([Uint8List? value]) { - if (value == null) { - return 4; - } - return 4 + value.length; - } - - static int write(Uint8List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - buf.setRange(4, 4 + value.length, value); - return 4 + value.length; - } } -class FfiConverterOptionalAmount { - static Amount? lift(RustBuffer buf) { - return FfiConverterOptionalAmount.read(buf.asUint8List()).value; +class FfiConverterOptionalPolicy { + static Policy? lift(RustBuffer buf) { + return FfiConverterOptionalPolicy.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Amount.read( + final result = Policy.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Amount? value]) { + static int allocationSize([Policy? value]) { if (value == null) { return 1; } - return Amount.allocationSize(value) + 1; + return Policy.allocationSize(value) + 1; } - static RustBuffer lower(Amount? value) { + static RustBuffer lower(Policy? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalAmount.allocationSize(value); + final length = FfiConverterOptionalPolicy.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalAmount.write(value, buf); + FfiConverterOptionalPolicy.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Amount? value, Uint8List buf) { + static int write(Policy? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Amount.write( + return Policy.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28792,89 +28764,114 @@ class FfiConverterOptionalAmount { } } -class FfiConverterSequenceDescriptor { - static List lift(RustBuffer buf) { - return FfiConverterSequenceDescriptor.read(buf.asUint8List()).value; +class FfiConverterSequenceTxid { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTxid.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = Descriptor.read(Uint8List.view(buf.buffer, offset)); + final ret = Txid.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += Descriptor.write(value[i], Uint8List.view(buf.buffer, offset)); + offset += Txid.write(value[i], Uint8List.view(buf.buffer, offset)); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => Descriptor.allocationSize(l)) - .fold(0, (a, b) => a + b) + + static int allocationSize(List value) { + return value.map((l) => Txid.allocationSize(l)).fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUInt16 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt16.read(buf.asUint8List()).value; +class FfiConverterBool { + static bool lift(int value) { + return value == 1; } - static LiftRetVal read(Uint8List buf) { + static int lower(bool value) { + return value ? 1 : 0; + } + + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(FfiConverterBool.lift(buf.first), 1); + } + + static RustBuffer lowerIntoRustBuffer(bool value) { + return toRustBuffer(Uint8List.fromList([FfiConverterBool.lower(value)])); + } + + static int allocationSize([bool value = false]) { + return 1; + } + + static int write(bool value, Uint8List buf) { + buf.setAll(0, [value ? 1 : 0]); + return allocationSize(); + } +} + +class FfiConverterOptionalDescriptor { + static Descriptor? lift(RustBuffer buf) { + return FfiConverterOptionalDescriptor.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt16.read( + final result = Descriptor.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int? value]) { + static int allocationSize([Descriptor? value]) { if (value == null) { return 1; } - return FfiConverterUInt16.allocationSize(value) + 1; + return Descriptor.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(Descriptor? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt16.allocationSize(value); + final length = FfiConverterOptionalDescriptor.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt16.write(value, buf); + FfiConverterOptionalDescriptor.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(Descriptor? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUInt16.write( + return Descriptor.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28882,49 +28879,55 @@ class FfiConverterOptionalUInt16 { } } -class FfiConverterOptionalUInt64 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt64.read(buf.asUint8List()).value; +class FfiConverterOptionalSequencePsbtFinalizeException { + static List? lift(RustBuffer buf) { + return FfiConverterOptionalSequencePsbtFinalizeException.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal?> read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt64.read( + final result = FfiConverterSequencePsbtFinalizeException.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal?>( + result.value, + result.bytesRead + 1, + ); } - static int allocationSize([int? value]) { + static int allocationSize([List? value]) { if (value == null) { return 1; } - return FfiConverterUInt64.allocationSize(value) + 1; + return FfiConverterSequencePsbtFinalizeException.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(List? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt64.allocationSize(value); + final length = + FfiConverterOptionalSequencePsbtFinalizeException.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt64.write(value, buf); + FfiConverterOptionalSequencePsbtFinalizeException.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(List? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUInt64.write( + return FfiConverterSequencePsbtFinalizeException.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28932,99 +28935,96 @@ class FfiConverterOptionalUInt64 { } } -class FfiConverterOptionalScript { - static Script? lift(RustBuffer buf) { - return FfiConverterOptionalScript.read(buf.asUint8List()).value; +class FfiConverterSequencePsbtFinalizeException { + static List lift(RustBuffer buf) { + return FfiConverterSequencePsbtFinalizeException.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterPsbtFinalizeException.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); } - final result = Script.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int allocationSize([Script? value]) { - if (value == null) { - return 1; + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterPsbtFinalizeException.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); } - return Script.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(Script? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalScript.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalScript.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterPsbtFinalizeException.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static int write(Script? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return Script.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterOptionalDouble32 { - static double? lift(RustBuffer buf) { - return FfiConverterOptionalDouble32.read(buf.asUint8List()).value; +class FfiConverterOptionalTxStatus { + static TxStatus? lift(RustBuffer buf) { + return FfiConverterOptionalTxStatus.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterDouble32.read( + final result = FfiConverterTxStatus.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([double? value]) { + static int allocationSize([TxStatus? value]) { if (value == null) { return 1; } - return FfiConverterDouble32.allocationSize(value) + 1; + return FfiConverterTxStatus.allocationSize(value) + 1; } - static RustBuffer lower(double? value) { + static RustBuffer lower(TxStatus? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalDouble32.allocationSize(value); + final length = FfiConverterOptionalTxStatus.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalDouble32.write(value, buf); + FfiConverterOptionalTxStatus.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(double? value, Uint8List buf) { + static int write(TxStatus? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterDouble32.write( + return FfiConverterTxStatus.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + From dd48ec725ddb6bcf4da8d499073f7374c8727632 Mon Sep 17 00:00:00 2001 From: Johnosezele Date: Fri, 13 Mar 2026 14:52:55 +0100 Subject: [PATCH 2/6] Restore bdk.dart from main --- lib/bdk.dart | 3872 +++++++++++++++++++++++++------------------------- 1 file changed, 1936 insertions(+), 1936 deletions(-) diff --git a/lib/bdk.dart b/lib/bdk.dart index 2c2ad92..737d3d9 100644 --- a/lib/bdk.dart +++ b/lib/bdk.dart @@ -24964,28 +24964,30 @@ Uint8List createUint8ListFromInt(int value) { return uint8List; } -class FfiConverterSequenceConflict { - static List lift(RustBuffer buf) { - return FfiConverterSequenceConflict.read(buf.asUint8List()).value; +class FfiConverterSequenceAddressInfo { + static List lift(RustBuffer buf) { + return FfiConverterSequenceAddressInfo.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterConflict.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterAddressInfo.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterConflict.write( + offset += FfiConverterAddressInfo.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -24993,63 +24995,113 @@ class FfiConverterSequenceConflict { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterConflict.allocationSize(l)) + .map((l) => FfiConverterAddressInfo.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalSignOptions { - static SignOptions? lift(RustBuffer buf) { - return FfiConverterOptionalSignOptions.read(buf.asUint8List()).value; +class FfiConverterOptionalMerkleProof { + static MerkleProof? lift(RustBuffer buf) { + return FfiConverterOptionalMerkleProof.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterSignOptions.read( + final result = FfiConverterMerkleProof.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([SignOptions? value]) { + static int allocationSize([MerkleProof? value]) { if (value == null) { return 1; } - return FfiConverterSignOptions.allocationSize(value) + 1; + return FfiConverterMerkleProof.allocationSize(value) + 1; } - static RustBuffer lower(SignOptions? value) { + static RustBuffer lower(MerkleProof? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalSignOptions.allocationSize(value); + final length = FfiConverterOptionalMerkleProof.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalSignOptions.write(value, buf); + FfiConverterOptionalMerkleProof.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(SignOptions? value, Uint8List buf) { + static int write(MerkleProof? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterSignOptions.write( + return FfiConverterMerkleProof.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; + } +} + +class FfiConverterOptionalSequenceUint8List { + static List? lift(RustBuffer buf) { + return FfiConverterOptionalSequenceUint8List.read(buf.asUint8List()).value; + } + + static LiftRetVal?> read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); + } + final result = FfiConverterSequenceUint8List.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal?>(result.value, result.bytesRead + 1); + } + + static int allocationSize([List? value]) { + if (value == null) { + return 1; + } + return FfiConverterSequenceUint8List.allocationSize(value) + 1; + } + + static RustBuffer lower(List? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalSequenceUint8List.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalSequenceUint8List.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); + } + + static int write(List? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterSequenceUint8List.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -25107,210 +25159,169 @@ class FfiConverterOptionalChangeSet { } } -class FfiConverterMapStringToTapKeyOrigin { - static Map lift(RustBuffer buf) { - return FfiConverterMapStringToTapKeyOrigin.read(buf.asUint8List()).value; +class FfiConverterSequenceConflict { + static List lift(RustBuffer buf) { + return FfiConverterSequenceConflict.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterTapKeyOrigin.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; + final ret = FfiConverterConflict.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterString.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterTapKeyOrigin.write( - entry.value, + for (var i = 0; i < value.length; i++) { + offset += FfiConverterConflict.write( + value[i], Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterTapKeyOrigin.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterConflict.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Map value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapSequenceUInt32ToSequenceCondition { - static Map, List> lift(RustBuffer buf) { - return FfiConverterMapSequenceUInt32ToSequenceCondition.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalUInt8 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalUInt8.read(buf.asUint8List()).value; } - static LiftRetVal, List>> read(Uint8List buf) { - final map = , List>{}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterSequenceUInt32.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterSequenceCondition.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterUInt8.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map, List> value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterSequenceUInt32.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterSequenceCondition.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([int? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterUInt8.allocationSize(value) + 1; } - static int allocationSize(Map, List> value) { - return value.entries - .map( - (e) => - FfiConverterSequenceUInt32.allocationSize(e.key) + - FfiConverterSequenceCondition.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lower(int? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalUInt8.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalUInt8.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(Map, List> value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(int? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterUInt8.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterMapTxidToUInt64 { - static Map lift(RustBuffer buf) { - return FfiConverterMapTxidToUInt64.read(buf.asUint8List()).value; +class FfiConverterBool { + static bool lift(int value) { + return value == 1; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = Txid.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; - } - return LiftRetVal(map, offset - buf.offsetInBytes); + static int lower(bool value) { + return value ? 1 : 0; } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += Txid.write(entry.key, Uint8List.view(buf.buffer, offset)); - offset += FfiConverterUInt64.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(FfiConverterBool.lift(buf.first), 1); } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - Txid.allocationSize(e.key) + - FfiConverterUInt64.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lowerIntoRustBuffer(bool value) { + return toRustBuffer(Uint8List.fromList([FfiConverterBool.lower(value)])); } - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int allocationSize([bool value = false]) { + return 1; + } + + static int write(bool value, Uint8List buf) { + buf.setAll(0, [value ? 1 : 0]); + return allocationSize(); } } -class FfiConverterOptionalHeaderNotification { - static HeaderNotification? lift(RustBuffer buf) { - return FfiConverterOptionalHeaderNotification.read(buf.asUint8List()).value; +class FfiConverterOptionalInt64 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalInt64.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterHeaderNotification.read( + final result = FfiConverterInt64.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([HeaderNotification? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return FfiConverterHeaderNotification.allocationSize(value) + 1; + return FfiConverterInt64.allocationSize(value) + 1; } - static RustBuffer lower(HeaderNotification? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalHeaderNotification.allocationSize(value); + final length = FfiConverterOptionalInt64.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalHeaderNotification.write(value, buf); + FfiConverterOptionalInt64.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(HeaderNotification? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterHeaderNotification.write( + return FfiConverterInt64.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -25318,28 +25329,28 @@ class FfiConverterOptionalHeaderNotification { } } -class FfiConverterSequenceTxIn { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTxIn.read(buf.asUint8List()).value; +class FfiConverterSequencePeer { + static List lift(RustBuffer buf) { + return FfiConverterSequencePeer.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterTxIn.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterPeer.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterTxIn.write( + offset += FfiConverterPeer.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -25347,302 +25358,354 @@ class FfiConverterSequenceTxIn { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterTxIn.allocationSize(l)) + .map((l) => FfiConverterPeer.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalBool { - static bool? lift(RustBuffer buf) { - return FfiConverterOptionalBool.read(buf.asUint8List()).value; +class FfiConverterMapStringToKeySource { + static Map lift(RustBuffer buf) { + return FfiConverterMapStringToKeySource.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterKeySource.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - final result = FfiConverterBool.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([bool? value]) { - if (value == null) { - return 1; + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterString.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterKeySource.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterBool.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(bool? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalBool.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalBool.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterString.allocationSize(e.key) + + FfiConverterKeySource.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(bool? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterBool.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterOptionalAmount { - static Amount? lift(RustBuffer buf) { - return FfiConverterOptionalAmount.read(buf.asUint8List()).value; +class FfiConverterSequenceIpAddress { + static List lift(RustBuffer buf) { + return FfiConverterSequenceIpAddress.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = IpAddress.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - final result = Amount.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int allocationSize([Amount? value]) { - if (value == null) { - return 1; + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += IpAddress.write(value[i], Uint8List.view(buf.buffer, offset)); } - return Amount.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(Amount? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalAmount.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalAmount.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(List value) { + return value + .map((l) => IpAddress.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static int write(Amount? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return Amount.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterInt64 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt64(0), 8); +class FfiConverterSequenceTransaction { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTransaction.read(buf.asUint8List()).value; } - static int lower(int value) { - if (value < -9223372036854775808 || value > 9223372036854775807) { - throw ArgumentError("Value out of range for i64: " + value.toString()); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = Transaction.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - return value; + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int allocationSize([int value = 0]) { - return 8; + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += Transaction.write(value[i], Uint8List.view(buf.buffer, offset)); + } + return offset - buf.offsetInBytes; } - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, lower(value)); - return 8; + static int allocationSize(List value) { + return value + .map((l) => Transaction.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } -} -class FfiConverterString { - static String lift(RustBuffer buf) { - return utf8.decoder.convert(buf.asUint8List()); + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } +} - static RustBuffer lower(String value) { - return toRustBuffer(Utf8Encoder().convert(value)); +class FfiConverterSequenceTxOut { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTxOut.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - final end = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0) + 4; - return LiftRetVal(utf8.decoder.convert(buf, 4, end), end); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int allocationSize([String value = ""]) { - return utf8.encoder.convert(value).length + 4; + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterTxOut.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; } - static int write(String value, Uint8List buf) { - final list = utf8.encoder.convert(value); - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, list.length); - buf.setAll(4, list); - return list.length + 4; + static int allocationSize(List value) { + return value + .map((l) => FfiConverterTxOut.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterOptionalDouble32 { - static double? lift(RustBuffer buf) { - return FfiConverterOptionalDouble32.read(buf.asUint8List()).value; +class FfiConverterMapUInt32ToSequenceCondition { + static Map> lift(RustBuffer buf) { + return FfiConverterMapUInt32ToSequenceCondition.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal>> read(Uint8List buf) { + final map = >{}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterSequenceCondition.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - final result = FfiConverterDouble32.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([double? value]) { - if (value == null) { - return 1; + static int write(Map> value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterUInt32.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterSequenceCondition.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterDouble32.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(double? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalDouble32.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalDouble32.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(Map> value) { + return value.entries + .map( + (e) => + FfiConverterUInt32.allocationSize(e.key) + + FfiConverterSequenceCondition.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(double? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterDouble32.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(Map> value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterSequenceLeafNode { - static List lift(RustBuffer buf) { - return FfiConverterSequenceLeafNode.read(buf.asUint8List()).value; +class FfiConverterMapStringToSequenceUInt64 { + static Map> lift(RustBuffer buf) { + return FfiConverterMapStringToSequenceUInt64.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal>> read(Uint8List buf) { + final map = >{}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = LeafNode.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterSequenceUInt64.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map> value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += LeafNode.write(value[i], Uint8List.view(buf.buffer, offset)); + for (final entry in value.entries) { + offset += FfiConverterString.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterSequenceUInt64.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => LeafNode.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map> value) { + return value.entries + .map( + (e) => + FfiConverterString.allocationSize(e.key) + + FfiConverterSequenceUInt64.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map> value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUint8List { - static Uint8List? lift(RustBuffer buf) { - return FfiConverterOptionalUint8List.read(buf.asUint8List()).value; +class FfiConverterOptionalSequencePsbtFinalizeException { + static List? lift(RustBuffer buf) { + return FfiConverterOptionalSequencePsbtFinalizeException.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal?> read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUint8List.read( + final result = FfiConverterSequencePsbtFinalizeException.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal?>( + result.value, + result.bytesRead + 1, + ); } - static int allocationSize([Uint8List? value]) { + static int allocationSize([List? value]) { if (value == null) { return 1; } - return FfiConverterUint8List.allocationSize(value) + 1; + return FfiConverterSequencePsbtFinalizeException.allocationSize(value) + 1; } - static RustBuffer lower(Uint8List? value) { + static RustBuffer lower(List? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUint8List.allocationSize(value); + final length = + FfiConverterOptionalSequencePsbtFinalizeException.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUint8List.write(value, buf); + FfiConverterOptionalSequencePsbtFinalizeException.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Uint8List? value, Uint8List buf) { + static int write(List? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUint8List.write( + return FfiConverterSequencePsbtFinalizeException.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -25650,98 +25713,157 @@ class FfiConverterOptionalUint8List { } } -class FfiConverterOptionalScript { - static Script? lift(RustBuffer buf) { - return FfiConverterOptionalScript.read(buf.asUint8List()).value; +class FfiConverterSequencePsbtFinalizeException { + static List lift(RustBuffer buf) { + return FfiConverterSequencePsbtFinalizeException.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterPsbtFinalizeException.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); } - final result = Script.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterPsbtFinalizeException.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterPsbtFinalizeException.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterMapProprietaryKeyToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapProprietaryKeyToUint8List.read( + buf.asUint8List(), + ).value; + } + + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterProprietaryKey.read( + Uint8List.view(buf.buffer, offset), + ); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; + } + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([Script? value]) { - if (value == null) { - return 1; + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterProprietaryKey.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterUint8List.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return Script.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(Script? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalScript.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalScript.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterProprietaryKey.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(Script? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return Script.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterDouble32 { - static double lift(double value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal( - buf.buffer.asByteData(buf.offsetInBytes).getFloat32(0), - 4, - ); +class FfiConverterString { + static String lift(RustBuffer buf) { + return utf8.decoder.convert(buf.asUint8List()); } - static double lower(double value) => value; - static int allocationSize([double value = 0]) { - return 4; + static RustBuffer lower(String value) { + return toRustBuffer(Utf8Encoder().convert(value)); } - static int write(double value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setFloat32(0, value); - return FfiConverterDouble32.allocationSize(); + static LiftRetVal read(Uint8List buf) { + final end = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0) + 4; + return LiftRetVal(utf8.decoder.convert(buf, 4, end), end); + } + + static int allocationSize([String value = ""]) { + return utf8.encoder.convert(value).length + 4; + } + + static int write(String value, Uint8List buf) { + final list = utf8.encoder.convert(value); + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, list.length); + buf.setAll(4, list); + return list.length + 4; } } -class FfiConverterSequencePkOrF { - static List lift(RustBuffer buf) { - return FfiConverterSequencePkOrF.read(buf.asUint8List()).value; +class FfiConverterSequenceTxIn { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTxIn.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterPkOrF.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterTxIn.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterPkOrF.write( + offset += FfiConverterTxIn.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -25749,14 +25871,14 @@ class FfiConverterSequencePkOrF { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterPkOrF.allocationSize(l)) + .map((l) => FfiConverterTxIn.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); @@ -25808,134 +25930,134 @@ class FfiConverterSequenceLocalOutput { } } -class FfiConverterOptionalOutputStatus { - static OutputStatus? lift(RustBuffer buf) { - return FfiConverterOptionalOutputStatus.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = FfiConverterOutputStatus.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); +class FfiConverterUInt8 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint8(0), 1); } - static int allocationSize([OutputStatus? value]) { - if (value == null) { - return 1; + static int lower(int value) { + if (value < 0 || value > 255) { + throw ArgumentError("Value out of range for u8: " + value.toString()); } - return FfiConverterOutputStatus.allocationSize(value) + 1; + return value; } - static RustBuffer lower(OutputStatus? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalOutputStatus.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalOutputStatus.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize([int value = 0]) { + return 1; } - static int write(OutputStatus? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterOutputStatus.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint8(0, lower(value)); + return 1; } } -class FfiConverterMapUInt32ToSequenceCondition { - static Map> lift(RustBuffer buf) { - return FfiConverterMapUInt32ToSequenceCondition.read( - buf.asUint8List(), - ).value; +class FfiConverterSequenceCondition { + static List lift(RustBuffer buf) { + return FfiConverterSequenceCondition.read(buf.asUint8List()).value; } - static LiftRetVal>> read(Uint8List buf) { - final map = >{}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterSequenceCondition.read( + final ret = FfiConverterCondition.read( Uint8List.view(buf.buffer, offset), ); - offset += v.bytesRead; - map[k.value] = v.value; + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map> value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterUInt32.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterSequenceCondition.write( - entry.value, + for (var i = 0; i < value.length; i++) { + offset += FfiConverterCondition.write( + value[i], Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(Map> value) { - return value.entries - .map( - (e) => - FfiConverterUInt32.allocationSize(e.key) + - FfiConverterSequenceCondition.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterCondition.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Map> value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceTxOut { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTxOut.read(buf.asUint8List()).value; +class FfiConverterSequencePolicy { + static List lift(RustBuffer buf) { + return FfiConverterSequencePolicy.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = Policy.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += Policy.write(value[i], Uint8List.view(buf.buffer, offset)); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value.map((l) => Policy.allocationSize(l)).fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceTx { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTx.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterTx.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterTxOut.write( + offset += FfiConverterTx.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -25943,211 +26065,99 @@ class FfiConverterSequenceTxOut { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterTxOut.allocationSize(l)) + .map((l) => FfiConverterTx.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceDescriptor { - static List lift(RustBuffer buf) { - return FfiConverterSequenceDescriptor.read(buf.asUint8List()).value; +class FfiConverterSequenceScriptAmount { + static List lift(RustBuffer buf) { + return FfiConverterSequenceScriptAmount.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = Descriptor.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterScriptAmount.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += Descriptor.write(value[i], Uint8List.view(buf.buffer, offset)); + offset += FfiConverterScriptAmount.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => Descriptor.allocationSize(l)) + .map((l) => FfiConverterScriptAmount.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterUInt16 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint16(0), 2); - } - - static int lower(int value) { - if (value < 0 || value > 65535) { - throw ArgumentError("Value out of range for u16: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 2; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint16(0, lower(value)); - return 2; - } -} - -class FfiConverterOptionalBlock { - static Block? lift(RustBuffer buf) { - return FfiConverterOptionalBlock.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = FfiConverterBlock.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); - } - - static int allocationSize([Block? value]) { - if (value == null) { - return 1; - } - return FfiConverterBlock.allocationSize(value) + 1; - } - - static RustBuffer lower(Block? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalBlock.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalBlock.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); - } - - static int write(Block? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterBlock.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; - } -} - -class FfiConverterOptionalString { - static String? lift(RustBuffer buf) { - return FfiConverterOptionalString.read(buf.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); - } - final result = FfiConverterString.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); - } - - static int allocationSize([String? value]) { - if (value == null) { - return 1; - } - return FfiConverterString.allocationSize(value) + 1; - } - - static RustBuffer lower(String? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalString.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalString.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); - } - - static int write(String? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterString.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; - } -} - -class FfiConverterMapHashableOutPointToTxOut { - static Map lift(RustBuffer buf) { - return FfiConverterMapHashableOutPointToTxOut.read(buf.asUint8List()).value; +class FfiConverterMapSequenceUInt32ToSequenceCondition { + static Map, List> lift(RustBuffer buf) { + return FfiConverterMapSequenceUInt32ToSequenceCondition.read( + buf.asUint8List(), + ).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal, List>> read(Uint8List buf) { + final map = , List>{}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = HashableOutPoint.read(Uint8List.view(buf.buffer, offset)); + final k = FfiConverterSequenceUInt32.read( + Uint8List.view(buf.buffer, offset), + ); offset += k.bytesRead; - final v = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); + final v = FfiConverterSequenceCondition.read( + Uint8List.view(buf.buffer, offset), + ); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map, List> value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += HashableOutPoint.write( + offset += FfiConverterSequenceUInt32.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterTxOut.write( + offset += FfiConverterSequenceCondition.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -26155,101 +26165,95 @@ class FfiConverterMapHashableOutPointToTxOut { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map, List> value) { return value.entries .map( (e) => - HashableOutPoint.allocationSize(e.key) + - FfiConverterTxOut.allocationSize(e.value), + FfiConverterSequenceUInt32.allocationSize(e.key) + + FfiConverterSequenceCondition.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map, List> value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapProprietaryKeyToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapProprietaryKeyToUint8List.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalTxDetails { + static TxDetails? lift(RustBuffer buf) { + return FfiConverterOptionalTxDetails.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterProprietaryKey.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterTxDetails.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterProprietaryKey.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUint8List.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([TxDetails? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterTxDetails.allocationSize(value) + 1; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterProprietaryKey.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lower(TxDetails? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalTxDetails.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalTxDetails.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(TxDetails? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterTxDetails.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceUInt32 { - static List lift(RustBuffer buf) { - return FfiConverterSequenceUInt32.read(buf.asUint8List()).value; +class FfiConverterSequenceAnchor { + static List lift(RustBuffer buf) { + return FfiConverterSequenceAnchor.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterAnchor.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterUInt32.write( + offset += FfiConverterAnchor.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -26257,63 +26261,63 @@ class FfiConverterSequenceUInt32 { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterUInt32.allocationSize(l)) + .map((l) => FfiConverterAnchor.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalTx { - static Tx? lift(RustBuffer buf) { - return FfiConverterOptionalTx.read(buf.asUint8List()).value; +class FfiConverterOptionalHeaderNotification { + static HeaderNotification? lift(RustBuffer buf) { + return FfiConverterOptionalHeaderNotification.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTx.read( + final result = FfiConverterHeaderNotification.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Tx? value]) { + static int allocationSize([HeaderNotification? value]) { if (value == null) { return 1; } - return FfiConverterTx.allocationSize(value) + 1; + return FfiConverterHeaderNotification.allocationSize(value) + 1; } - static RustBuffer lower(Tx? value) { + static RustBuffer lower(HeaderNotification? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTx.allocationSize(value); + final length = FfiConverterOptionalHeaderNotification.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTx.write(value, buf); + FfiConverterOptionalHeaderNotification.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Tx? value, Uint8List buf) { + static int write(HeaderNotification? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTx.write( + return FfiConverterHeaderNotification.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26321,87 +26325,49 @@ class FfiConverterOptionalTx { } } -class FfiConverterSequencePolicy { - static List lift(RustBuffer buf) { - return FfiConverterSequencePolicy.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = Policy.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += Policy.write(value[i], Uint8List.view(buf.buffer, offset)); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value.map((l) => Policy.allocationSize(l)).fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterOptionalTxDetails { - static TxDetails? lift(RustBuffer buf) { - return FfiConverterOptionalTxDetails.read(buf.asUint8List()).value; +class FfiConverterOptionalLockTime { + static LockTime? lift(RustBuffer buf) { + return FfiConverterOptionalLockTime.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTxDetails.read( + final result = FfiConverterLockTime.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TxDetails? value]) { + static int allocationSize([LockTime? value]) { if (value == null) { return 1; } - return FfiConverterTxDetails.allocationSize(value) + 1; + return FfiConverterLockTime.allocationSize(value) + 1; } - static RustBuffer lower(TxDetails? value) { + static RustBuffer lower(LockTime? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxDetails.allocationSize(value); + final length = FfiConverterOptionalLockTime.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxDetails.write(value, buf); + FfiConverterOptionalLockTime.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TxDetails? value, Uint8List buf) { + static int write(LockTime? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTxDetails.write( + return FfiConverterLockTime.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26409,43 +26375,54 @@ class FfiConverterOptionalTxDetails { } } -class FfiConverterSequenceString { - static List lift(RustBuffer buf) { - return FfiConverterSequenceString.read(buf.asUint8List()).value; +class FfiConverterMapStringToTapKeyOrigin { + static Map lift(RustBuffer buf) { + return FfiConverterMapStringToTapKeyOrigin.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterTapKeyOrigin.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { + for (final entry in value.entries) { offset += FfiConverterString.write( - value[i], + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterTapKeyOrigin.write( + entry.value, Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterString.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterString.allocationSize(e.key) + + FfiConverterTapKeyOrigin.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); @@ -26472,49 +26449,119 @@ class FfiConverterDouble64 { } } -class FfiConverterOptionalTxOut { - static TxOut? lift(RustBuffer buf) { - return FfiConverterOptionalTxOut.read(buf.asUint8List()).value; +class FfiConverterDouble32 { + static double lift(double value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal( + buf.buffer.asByteData(buf.offsetInBytes).getFloat32(0), + 4, + ); + } + + static double lower(double value) => value; + static int allocationSize([double value = 0]) { + return 4; + } + + static int write(double value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setFloat32(0, value); + return FfiConverterDouble32.allocationSize(); + } +} + +class FfiConverterOptionalUint8List { + static Uint8List? lift(RustBuffer buf) { + return FfiConverterOptionalUint8List.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); + } + final result = FfiConverterUint8List.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); + } + + static int allocationSize([Uint8List? value]) { + if (value == null) { + return 1; + } + return FfiConverterUint8List.allocationSize(value) + 1; + } + + static RustBuffer lower(Uint8List? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalUint8List.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalUint8List.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); + } + + static int write(Uint8List? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterUint8List.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; + } +} + +class FfiConverterOptionalBool { + static bool? lift(RustBuffer buf) { + return FfiConverterOptionalBool.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTxOut.read( + final result = FfiConverterBool.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TxOut? value]) { + static int allocationSize([bool? value]) { if (value == null) { return 1; } - return FfiConverterTxOut.allocationSize(value) + 1; + return FfiConverterBool.allocationSize(value) + 1; } - static RustBuffer lower(TxOut? value) { + static RustBuffer lower(bool? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxOut.allocationSize(value); + final length = FfiConverterOptionalBool.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxOut.write(value, buf); + FfiConverterOptionalBool.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TxOut? value, Uint8List buf) { + static int write(bool? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTxOut.write( + return FfiConverterBool.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26522,105 +26569,17 @@ class FfiConverterOptionalTxOut { } } -class FfiConverterSequenceCondition { - static List lift(RustBuffer buf) { - return FfiConverterSequenceCondition.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterCondition.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterCondition.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value - .map((l) => FfiConverterCondition.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceOutput { - static List lift(RustBuffer buf) { - return FfiConverterSequenceOutput.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterOutput.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterOutput.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value - .map((l) => FfiConverterOutput.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceScriptAmount { - static List lift(RustBuffer buf) { - return FfiConverterSequenceScriptAmount.read(buf.asUint8List()).value; +class FfiConverterSequenceUint8List { + static List lift(RustBuffer buf) { + return FfiConverterSequenceUint8List.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterScriptAmount.read( + final ret = FfiConverterUint8List.read( Uint8List.view(buf.buffer, offset), ); offset += ret.bytesRead; @@ -26629,11 +26588,11 @@ class FfiConverterSequenceScriptAmount { return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterScriptAmount.write( + offset += FfiConverterUint8List.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -26641,158 +26600,113 @@ class FfiConverterSequenceScriptAmount { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterScriptAmount.allocationSize(l)) + .map((l) => FfiConverterUint8List.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapKeyToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapKeyToUint8List.read(buf.asUint8List()).value; +class FfiConverterOptionalTx { + static Tx? lift(RustBuffer buf) { + return FfiConverterOptionalTx.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterKey.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterTx.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterKey.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUint8List.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([Tx? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; - } - - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterKey.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); - } - - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceInput { - static List lift(RustBuffer buf) { - return FfiConverterSequenceInput.read(buf.asUint8List()).value; + return FfiConverterTx.allocationSize(value) + 1; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterInput.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); + static RustBuffer lower(Tx? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final length = FfiConverterOptionalTx.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalTx.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterInput.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + static int write(Tx? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value - .map((l) => FfiConverterInput.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + buf[0] = 1; + return FfiConverterTx.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterOptionalUInt64 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt64.read(buf.asUint8List()).value; +class FfiConverterOptionalBlock { + static Block? lift(RustBuffer buf) { + return FfiConverterOptionalBlock.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt64.read( + final result = FfiConverterBlock.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int? value]) { + static int allocationSize([Block? value]) { if (value == null) { return 1; } - return FfiConverterUInt64.allocationSize(value) + 1; + return FfiConverterBlock.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(Block? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt64.allocationSize(value); + final length = FfiConverterOptionalBlock.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt64.write(value, buf); + FfiConverterOptionalBlock.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(Block? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUInt64.write( + return FfiConverterBlock.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -26800,118 +26714,132 @@ class FfiConverterOptionalUInt64 { } } -class FfiConverterSequenceWalletEvent { - static List lift(RustBuffer buf) { - return FfiConverterSequenceWalletEvent.read(buf.asUint8List()).value; +class FfiConverterMapStringToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapStringToUint8List.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterWalletEvent.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterWalletEvent.write( - value[i], + for (final entry in value.entries) { + offset += FfiConverterString.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterUint8List.write( + entry.value, Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterWalletEvent.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterString.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceUint8List { - static List lift(RustBuffer buf) { - return FfiConverterSequenceUint8List.read(buf.asUint8List()).value; +class FfiConverterOptionalString { + static String? lift(RustBuffer buf) { + return FfiConverterOptionalString.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterUint8List.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final result = FfiConverterString.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterUint8List.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([String? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterString.allocationSize(value) + 1; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterUint8List.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static RustBuffer lower(String? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalString.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalString.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(String? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterString.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceAnchor { - static List lift(RustBuffer buf) { - return FfiConverterSequenceAnchor.read(buf.asUint8List()).value; +class FfiConverterSequenceEvictedTx { + static List lift(RustBuffer buf) { + return FfiConverterSequenceEvictedTx.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterAnchor.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterEvictedTx.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterAnchor.write( + offset += FfiConverterEvictedTx.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -26919,50 +26847,52 @@ class FfiConverterSequenceAnchor { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterAnchor.allocationSize(l)) + .map((l) => FfiConverterEvictedTx.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapStringToSequenceUInt64 { - static Map> lift(RustBuffer buf) { - return FfiConverterMapStringToSequenceUInt64.read(buf.asUint8List()).value; +class FfiConverterMapTapScriptSigKeyToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapTapScriptSigKeyToUint8List.read( + buf.asUint8List(), + ).value; } - static LiftRetVal>> read(Uint8List buf) { - final map = >{}; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterSequenceUInt64.read( + final k = FfiConverterTapScriptSigKey.read( Uint8List.view(buf.buffer, offset), ); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map> value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += FfiConverterString.write( + offset += FfiConverterTapScriptSigKey.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterSequenceUInt64.write( + offset += FfiConverterUint8List.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -26970,66 +26900,114 @@ class FfiConverterMapStringToSequenceUInt64 { return offset - buf.offsetInBytes; } - static int allocationSize(Map> value) { + static int allocationSize(Map value) { return value.entries .map( (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterSequenceUInt64.allocationSize(e.value), + FfiConverterTapScriptSigKey.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map> value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalCanonicalTx { - static CanonicalTx? lift(RustBuffer buf) { - return FfiConverterOptionalCanonicalTx.read(buf.asUint8List()).value; +class FfiConverterOptionalTxid { + static Txid? lift(RustBuffer buf) { + return FfiConverterOptionalTxid.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterCanonicalTx.read( + final result = Txid.read(Uint8List.view(buf.buffer, buf.offsetInBytes + 1)); + return LiftRetVal(result.value, result.bytesRead + 1); + } + + static int allocationSize([Txid? value]) { + if (value == null) { + return 1; + } + return Txid.allocationSize(value) + 1; + } + + static RustBuffer lower(Txid? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalTxid.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalTxid.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); + } + + static int write(Txid? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return Txid.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; + } +} + +class FfiConverterOptionalKeychainAndIndex { + static KeychainAndIndex? lift(RustBuffer buf) { + return FfiConverterOptionalKeychainAndIndex.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); + } + final result = FfiConverterKeychainAndIndex.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([CanonicalTx? value]) { + static int allocationSize([KeychainAndIndex? value]) { if (value == null) { return 1; } - return FfiConverterCanonicalTx.allocationSize(value) + 1; + return FfiConverterKeychainAndIndex.allocationSize(value) + 1; } - static RustBuffer lower(CanonicalTx? value) { + static RustBuffer lower(KeychainAndIndex? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalCanonicalTx.allocationSize(value); + final length = FfiConverterOptionalKeychainAndIndex.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalCanonicalTx.write(value, buf); + FfiConverterOptionalKeychainAndIndex.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(CanonicalTx? value, Uint8List buf) { + static int write(KeychainAndIndex? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterCanonicalTx.write( + return FfiConverterKeychainAndIndex.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27037,49 +27015,49 @@ class FfiConverterOptionalCanonicalTx { } } -class FfiConverterOptionalTapTree { - static TapTree? lift(RustBuffer buf) { - return FfiConverterOptionalTapTree.read(buf.asUint8List()).value; +class FfiConverterOptionalSignOptions { + static SignOptions? lift(RustBuffer buf) { + return FfiConverterOptionalSignOptions.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = TapTree.read( + final result = FfiConverterSignOptions.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TapTree? value]) { + static int allocationSize([SignOptions? value]) { if (value == null) { return 1; } - return TapTree.allocationSize(value) + 1; + return FfiConverterSignOptions.allocationSize(value) + 1; } - static RustBuffer lower(TapTree? value) { + static RustBuffer lower(SignOptions? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTapTree.allocationSize(value); + final length = FfiConverterOptionalSignOptions.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTapTree.write(value, buf); + FfiConverterOptionalSignOptions.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TapTree? value, Uint8List buf) { + static int write(SignOptions? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return TapTree.write( + return FfiConverterSignOptions.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27087,34 +27065,34 @@ class FfiConverterOptionalTapTree { } } -class FfiConverterMapDescriptorIdToUInt32 { - static Map lift(RustBuffer buf) { - return FfiConverterMapDescriptorIdToUInt32.read(buf.asUint8List()).value; +class FfiConverterMapHashableOutPointToTxOut { + static Map lift(RustBuffer buf) { + return FfiConverterMapHashableOutPointToTxOut.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = DescriptorId.read(Uint8List.view(buf.buffer, offset)); + final k = HashableOutPoint.read(Uint8List.view(buf.buffer, offset)); offset += k.bytesRead; - final v = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + final v = FfiConverterTxOut.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += DescriptorId.write( + offset += HashableOutPoint.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterUInt32.write( + offset += FfiConverterTxOut.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -27122,66 +27100,66 @@ class FfiConverterMapDescriptorIdToUInt32 { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map value) { return value.entries .map( (e) => - DescriptorId.allocationSize(e.key) + - FfiConverterUInt32.allocationSize(e.value), + HashableOutPoint.allocationSize(e.key) + + FfiConverterTxOut.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalKeychainAndIndex { - static KeychainAndIndex? lift(RustBuffer buf) { - return FfiConverterOptionalKeychainAndIndex.read(buf.asUint8List()).value; +class FfiConverterOptionalTxStatus { + static TxStatus? lift(RustBuffer buf) { + return FfiConverterOptionalTxStatus.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterKeychainAndIndex.read( + final result = FfiConverterTxStatus.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([KeychainAndIndex? value]) { + static int allocationSize([TxStatus? value]) { if (value == null) { return 1; } - return FfiConverterKeychainAndIndex.allocationSize(value) + 1; + return FfiConverterTxStatus.allocationSize(value) + 1; } - static RustBuffer lower(KeychainAndIndex? value) { + static RustBuffer lower(TxStatus? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalKeychainAndIndex.allocationSize(value); + final length = FfiConverterOptionalTxStatus.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalKeychainAndIndex.write(value, buf); + FfiConverterOptionalTxStatus.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(KeychainAndIndex? value, Uint8List buf) { + static int write(TxStatus? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterKeychainAndIndex.write( + return FfiConverterTxStatus.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27189,28 +27167,30 @@ class FfiConverterOptionalKeychainAndIndex { } } -class FfiConverterSequenceOutPoint { - static List lift(RustBuffer buf) { - return FfiConverterSequenceOutPoint.read(buf.asUint8List()).value; +class FfiConverterSequenceChainChange { + static List lift(RustBuffer buf) { + return FfiConverterSequenceChainChange.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterOutPoint.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterChainChange.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterOutPoint.write( + offset += FfiConverterChainChange.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -27218,63 +27198,70 @@ class FfiConverterSequenceOutPoint { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterOutPoint.allocationSize(l)) + .map((l) => FfiConverterChainChange.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalLocalOutput { - static LocalOutput? lift(RustBuffer buf) { - return FfiConverterOptionalLocalOutput.read(buf.asUint8List()).value; +class FfiConverterOptionalConfirmationBlockTime { + static ConfirmationBlockTime? lift(RustBuffer buf) { + return FfiConverterOptionalConfirmationBlockTime.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterLocalOutput.read( + final result = FfiConverterConfirmationBlockTime.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal( + result.value, + result.bytesRead + 1, + ); } - static int allocationSize([LocalOutput? value]) { + static int allocationSize([ConfirmationBlockTime? value]) { if (value == null) { return 1; } - return FfiConverterLocalOutput.allocationSize(value) + 1; + return FfiConverterConfirmationBlockTime.allocationSize(value) + 1; } - static RustBuffer lower(LocalOutput? value) { + static RustBuffer lower(ConfirmationBlockTime? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalLocalOutput.allocationSize(value); + final length = FfiConverterOptionalConfirmationBlockTime.allocationSize( + value, + ); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalLocalOutput.write(value, buf); + FfiConverterOptionalConfirmationBlockTime.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(LocalOutput? value, Uint8List buf) { + static int write(ConfirmationBlockTime? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterLocalOutput.write( + return FfiConverterConfirmationBlockTime.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27282,147 +27269,223 @@ class FfiConverterOptionalLocalOutput { } } -class FfiConverterUInt64 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint64(0), 8); +class FfiConverterOptionalCanonicalTx { + static CanonicalTx? lift(RustBuffer buf) { + return FfiConverterOptionalCanonicalTx.read(buf.asUint8List()).value; } - static int lower(int value) { - if (value < 0) { - throw ArgumentError("Value out of range for u64: " + value.toString()); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return value; + final result = FfiConverterCanonicalTx.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int value = 0]) { - return 8; + static int allocationSize([CanonicalTx? value]) { + if (value == null) { + return 1; + } + return FfiConverterCanonicalTx.allocationSize(value) + 1; } - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint64(0, lower(value)); - return 8; + static RustBuffer lower(CanonicalTx? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalCanonicalTx.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalCanonicalTx.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); + } + + static int write(CanonicalTx? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterCanonicalTx.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceIpAddress { - static List lift(RustBuffer buf) { - return FfiConverterSequenceIpAddress.read(buf.asUint8List()).value; +class FfiConverterMapDescriptorIdToUInt32 { + static Map lift(RustBuffer buf) { + return FfiConverterMapDescriptorIdToUInt32.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = DescriptorId.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; + } + return LiftRetVal(map, offset - buf.offsetInBytes); + } + + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += DescriptorId.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterUInt32.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + DescriptorId.allocationSize(e.key) + + FfiConverterUInt32.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); + } + + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceUInt64 { + static List lift(RustBuffer buf) { + return FfiConverterSequenceUInt64.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = IpAddress.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += IpAddress.write(value[i], Uint8List.view(buf.buffer, offset)); + offset += FfiConverterUInt64.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => IpAddress.allocationSize(l)) + .map((l) => FfiConverterUInt64.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterMapTapScriptSigKeyToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapTapScriptSigKeyToUint8List.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalOutputStatus { + static OutputStatus? lift(RustBuffer buf) { + return FfiConverterOptionalOutputStatus.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterTapScriptSigKey.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(map, offset - buf.offsetInBytes); + final result = FfiConverterOutputStatus.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterTapScriptSigKey.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterUint8List.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([OutputStatus? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return FfiConverterOutputStatus.allocationSize(value) + 1; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterTapScriptSigKey.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static RustBuffer lower(OutputStatus? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalOutputStatus.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalOutputStatus.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(OutputStatus? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return FfiConverterOutputStatus.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterSequenceTx { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTx.read(buf.asUint8List()).value; +class FfiConverterSequenceInput { + static List lift(RustBuffer buf) { + return FfiConverterSequenceInput.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterTx.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterInput.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterTx.write( + offset += FfiConverterInput.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -27430,103 +27493,106 @@ class FfiConverterSequenceTx { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterTx.allocationSize(l)) + .map((l) => FfiConverterInput.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceTransaction { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTransaction.read(buf.asUint8List()).value; +class FfiConverterSequenceOutPoint { + static List lift(RustBuffer buf) { + return FfiConverterSequenceOutPoint.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = Transaction.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterOutPoint.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += Transaction.write(value[i], Uint8List.view(buf.buffer, offset)); + offset += FfiConverterOutPoint.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => Transaction.allocationSize(l)) + .map((l) => FfiConverterOutPoint.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalSequenceUint8List { - static List? lift(RustBuffer buf) { - return FfiConverterOptionalSequenceUint8List.read(buf.asUint8List()).value; +class FfiConverterOptionalDescriptor { + static Descriptor? lift(RustBuffer buf) { + return FfiConverterOptionalDescriptor.read(buf.asUint8List()).value; } - static LiftRetVal?> read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterSequenceUint8List.read( + final result = Descriptor.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal?>(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([List? value]) { + static int allocationSize([Descriptor? value]) { if (value == null) { return 1; } - return FfiConverterSequenceUint8List.allocationSize(value) + 1; + return Descriptor.allocationSize(value) + 1; } - static RustBuffer lower(List? value) { + static RustBuffer lower(Descriptor? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalSequenceUint8List.allocationSize(value); + final length = FfiConverterOptionalDescriptor.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalSequenceUint8List.write(value, buf); + FfiConverterOptionalDescriptor.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(List? value, Uint8List buf) { + static int write(Descriptor? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterSequenceUint8List.write( + return Descriptor.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27534,124 +27600,146 @@ class FfiConverterOptionalSequenceUint8List { } } -class FfiConverterOptionalLockTime { - static LockTime? lift(RustBuffer buf) { - return FfiConverterOptionalLockTime.read(buf.asUint8List()).value; +class FfiConverterMapTxidToUInt64 { + static Map lift(RustBuffer buf) { + return FfiConverterMapTxidToUInt64.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = Txid.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - final result = FfiConverterLockTime.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([LockTime? value]) { - if (value == null) { - return 1; + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += Txid.write(entry.key, Uint8List.view(buf.buffer, offset)); + offset += FfiConverterUInt64.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterLockTime.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(LockTime? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + Txid.allocationSize(e.key) + + FfiConverterUInt64.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); + } + + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterSequenceTxid { + static List lift(RustBuffer buf) { + return FfiConverterSequenceTxid.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = Txid.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - final length = FfiConverterOptionalLockTime.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalLockTime.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += Txid.write(value[i], Uint8List.view(buf.buffer, offset)); + } + return offset - buf.offsetInBytes; } - static int write(LockTime? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterLockTime.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static int allocationSize(List value) { + return value.map((l) => Txid.allocationSize(l)).fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterMapControlBlockToTapScriptEntry { - static Map lift(RustBuffer buf) { - return FfiConverterMapControlBlockToTapScriptEntry.read( - buf.asUint8List(), - ).value; +class FfiConverterSequenceString { + static List lift(RustBuffer buf) { + return FfiConverterSequenceString.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterControlBlock.read( - Uint8List.view(buf.buffer, offset), - ); - offset += k.bytesRead; - final v = FfiConverterTapScriptEntry.read( - Uint8List.view(buf.buffer, offset), - ); - offset += v.bytesRead; - map[k.value] = v.value; + final ret = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterControlBlock.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterTapScriptEntry.write( - entry.value, + for (var i = 0; i < value.length; i++) { + offset += FfiConverterString.write( + value[i], Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterControlBlock.allocationSize(e.key) + - FfiConverterTapScriptEntry.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterString.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static RustBuffer lower(Map value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUInt16 { +class FfiConverterOptionalUInt32 { static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt16.read(buf.asUint8List()).value; + return FfiConverterOptionalUInt32.read(buf.asUint8List()).value; } static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt16.read( + final result = FfiConverterUInt32.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); return LiftRetVal(result.value, result.bytesRead + 1); @@ -27661,17 +27749,17 @@ class FfiConverterOptionalUInt16 { if (value == null) { return 1; } - return FfiConverterUInt16.allocationSize(value) + 1; + return FfiConverterUInt32.allocationSize(value) + 1; } static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt16.allocationSize(value); + final length = FfiConverterOptionalUInt32.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt16.write(value, buf); + FfiConverterOptionalUInt32.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; @@ -27684,7 +27772,7 @@ class FfiConverterOptionalUInt16 { return 1; } buf[0] = 1; - return FfiConverterUInt16.write( + return FfiConverterUInt32.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27692,49 +27780,49 @@ class FfiConverterOptionalUInt16 { } } -class FfiConverterOptionalInt64 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalInt64.read(buf.asUint8List()).value; +class FfiConverterOptionalTransaction { + static Transaction? lift(RustBuffer buf) { + return FfiConverterOptionalTransaction.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterInt64.read( + final result = Transaction.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int? value]) { + static int allocationSize([Transaction? value]) { if (value == null) { return 1; } - return FfiConverterInt64.allocationSize(value) + 1; + return Transaction.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(Transaction? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalInt64.allocationSize(value); + final length = FfiConverterOptionalTransaction.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalInt64.write(value, buf); + FfiConverterOptionalTransaction.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(Transaction? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterInt64.write( + return Transaction.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27742,56 +27830,72 @@ class FfiConverterOptionalInt64 { } } -class FfiConverterOptionalConfirmationBlockTime { - static ConfirmationBlockTime? lift(RustBuffer buf) { - return FfiConverterOptionalConfirmationBlockTime.read( - buf.asUint8List(), - ).value; +class FfiConverterInt32 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt32(0), 4); } - static LiftRetVal read(Uint8List buf) { + static int lower(int value) { + if (value < -2147483648 || value > 2147483647) { + throw ArgumentError("Value out of range for i32: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 4; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, lower(value)); + return 4; + } +} + +class FfiConverterOptionalTxOut { + static TxOut? lift(RustBuffer buf) { + return FfiConverterOptionalTxOut.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterConfirmationBlockTime.read( + final result = FfiConverterTxOut.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal( - result.value, - result.bytesRead + 1, - ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([ConfirmationBlockTime? value]) { + static int allocationSize([TxOut? value]) { if (value == null) { return 1; } - return FfiConverterConfirmationBlockTime.allocationSize(value) + 1; + return FfiConverterTxOut.allocationSize(value) + 1; } - static RustBuffer lower(ConfirmationBlockTime? value) { + static RustBuffer lower(TxOut? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalConfirmationBlockTime.allocationSize( - value, - ); + final length = FfiConverterOptionalTxOut.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalConfirmationBlockTime.write(value, buf); + FfiConverterOptionalTxOut.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(ConfirmationBlockTime? value, Uint8List buf) { + static int write(TxOut? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterConfirmationBlockTime.write( + return FfiConverterTxOut.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -27799,134 +27903,137 @@ class FfiConverterOptionalConfirmationBlockTime { } } -class FfiConverterOptionalNetwork { - static Network? lift(RustBuffer buf) { - return FfiConverterOptionalNetwork.read(buf.asUint8List()).value; +class FfiConverterMapControlBlockToTapScriptEntry { + static Map lift(RustBuffer buf) { + return FfiConverterMapControlBlockToTapScriptEntry.read( + buf.asUint8List(), + ).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + final map = {}; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final k = FfiConverterControlBlock.read( + Uint8List.view(buf.buffer, offset), + ); + offset += k.bytesRead; + final v = FfiConverterTapScriptEntry.read( + Uint8List.view(buf.buffer, offset), + ); + offset += v.bytesRead; + map[k.value] = v.value; } - final result = FfiConverterNetwork.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int allocationSize([Network? value]) { - if (value == null) { - return 1; + static int write(Map value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (final entry in value.entries) { + offset += FfiConverterControlBlock.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterTapScriptEntry.write( + entry.value, + Uint8List.view(buf.buffer, offset), + ); } - return FfiConverterNetwork.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(Network? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalNetwork.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalNetwork.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterControlBlock.allocationSize(e.key) + + FfiConverterTapScriptEntry.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static int write(Network? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return FfiConverterNetwork.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(Map value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterOptionalBlockHash { - static BlockHash? lift(RustBuffer buf) { - return FfiConverterOptionalBlockHash.read(buf.asUint8List()).value; +class FfiConverterSequenceCanonicalTx { + static List lift(RustBuffer buf) { + return FfiConverterSequenceCanonicalTx.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { - if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { - return LiftRetVal(null, 1); + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterCanonicalTx.read( + Uint8List.view(buf.buffer, offset), + ); + offset += ret.bytesRead; + res.add(ret.value); } - final result = BlockHash.read( - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int allocationSize([BlockHash? value]) { - if (value == null) { - return 1; + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterCanonicalTx.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); } - return BlockHash.allocationSize(value) + 1; + return offset - buf.offsetInBytes; } - static RustBuffer lower(BlockHash? value) { - if (value == null) { - return toRustBuffer(Uint8List.fromList([0])); - } - final length = FfiConverterOptionalBlockHash.allocationSize(value); - final Pointer frameData = calloc(length); - final buf = frameData.asTypedList(length); - FfiConverterOptionalBlockHash.write(value, buf); - final bytes = calloc(); - bytes.ref.len = length; - bytes.ref.data = frameData; - return RustBuffer.fromBytes(bytes.ref); + static int allocationSize(List value) { + return value + .map((l) => FfiConverterCanonicalTx.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; } - static int write(BlockHash? value, Uint8List buf) { - if (value == null) { - buf[0] = 0; - return 1; - } - buf[0] = 1; - return BlockHash.write( - value, - Uint8List.view(buf.buffer, buf.offsetInBytes + 1), - ) + - 1; + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); } } -class FfiConverterMapStringToUint8List { - static Map lift(RustBuffer buf) { - return FfiConverterMapStringToUint8List.read(buf.asUint8List()).value; +class FfiConverterMapUInt16ToDouble64 { + static Map lift(RustBuffer buf) { + return FfiConverterMapUInt16ToDouble64.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); + final k = FfiConverterUInt16.read(Uint8List.view(buf.buffer, offset)); offset += k.bytesRead; - final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); + final v = FfiConverterDouble64.read(Uint8List.view(buf.buffer, offset)); offset += v.bytesRead; map[k.value] = v.value; } return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (final entry in value.entries) { - offset += FfiConverterString.write( + offset += FfiConverterUInt16.write( entry.key, Uint8List.view(buf.buffer, offset), ); - offset += FfiConverterUint8List.write( + offset += FfiConverterDouble64.write( entry.value, Uint8List.view(buf.buffer, offset), ); @@ -27934,66 +28041,89 @@ class FfiConverterMapStringToUint8List { return offset - buf.offsetInBytes; } - static int allocationSize(Map value) { + static int allocationSize(Map value) { return value.entries .map( (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterUint8List.allocationSize(e.value), + FfiConverterUInt16.allocationSize(e.key) + + FfiConverterDouble64.allocationSize(e.value), ) .fold(4, (a, b) => a + b); } - static RustBuffer lower(Map value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUInt32 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt32.read(buf.asUint8List()).value; +class FfiConverterUInt16 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint16(0), 2); } - static LiftRetVal read(Uint8List buf) { + static int lower(int value) { + if (value < 0 || value > 65535) { + throw ArgumentError("Value out of range for u16: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 2; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint16(0, lower(value)); + return 2; + } +} + +class FfiConverterOptionalTapTree { + static TapTree? lift(RustBuffer buf) { + return FfiConverterOptionalTapTree.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt32.read( + final result = TapTree.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int? value]) { + static int allocationSize([TapTree? value]) { if (value == null) { return 1; } - return FfiConverterUInt32.allocationSize(value) + 1; + return TapTree.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(TapTree? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt32.allocationSize(value); + final length = FfiConverterOptionalTapTree.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt32.write(value, buf); + FfiConverterOptionalTapTree.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(TapTree? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUInt32.write( + return TapTree.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28001,30 +28131,51 @@ class FfiConverterOptionalUInt32 { } } -class FfiConverterSequenceChainChange { - static List lift(RustBuffer buf) { - return FfiConverterSequenceChainChange.read(buf.asUint8List()).value; +class FfiConverterInt64 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt64(0), 8); } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static int lower(int value) { + if (value < -9223372036854775808 || value > 9223372036854775807) { + throw ArgumentError("Value out of range for i64: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 8; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt64(0, lower(value)); + return 8; + } +} + +class FfiConverterSequencePkOrF { + static List lift(RustBuffer buf) { + return FfiConverterSequencePkOrF.read(buf.asUint8List()).value; + } + + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterChainChange.read( - Uint8List.view(buf.buffer, offset), - ); + final ret = FfiConverterPkOrF.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterChainChange.write( + offset += FfiConverterPkOrF.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -28032,89 +28183,94 @@ class FfiConverterSequenceChainChange { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterChainChange.allocationSize(l)) + .map((l) => FfiConverterPkOrF.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceEvictedTx { - static List lift(RustBuffer buf) { - return FfiConverterSequenceEvictedTx.read(buf.asUint8List()).value; +class FfiConverterMapKeyToUint8List { + static Map lift(RustBuffer buf) { + return FfiConverterMapKeyToUint8List.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + final map = {}; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterEvictedTx.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); + final k = FfiConverterKey.read(Uint8List.view(buf.buffer, offset)); + offset += k.bytesRead; + final v = FfiConverterUint8List.read(Uint8List.view(buf.buffer, offset)); + offset += v.bytesRead; + map[k.value] = v.value; } - return LiftRetVal(res, offset - buf.offsetInBytes); + return LiftRetVal(map, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(Map value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterEvictedTx.write( - value[i], + for (final entry in value.entries) { + offset += FfiConverterKey.write( + entry.key, + Uint8List.view(buf.buffer, offset), + ); + offset += FfiConverterUint8List.write( + entry.value, Uint8List.view(buf.buffer, offset), ); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterEvictedTx.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static int allocationSize(Map value) { + return value.entries + .map( + (e) => + FfiConverterKey.allocationSize(e.key) + + FfiConverterUint8List.allocationSize(e.value), + ) + .fold(4, (a, b) => a + b); } - static RustBuffer lower(List value) { + static RustBuffer lower(Map value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterSequenceAddressInfo { - static List lift(RustBuffer buf) { - return FfiConverterSequenceAddressInfo.read(buf.asUint8List()).value; +class FfiConverterSequenceOutput { + static List lift(RustBuffer buf) { + return FfiConverterSequenceOutput.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterAddressInfo.read( - Uint8List.view(buf.buffer, offset), - ); + for (var i = 0; i < length; i++) { + final ret = FfiConverterOutput.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterAddressInfo.write( + offset += FfiConverterOutput.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -28122,61 +28278,86 @@ class FfiConverterSequenceAddressInfo { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterAddressInfo.allocationSize(l)) + .map((l) => FfiConverterOutput.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalTxid { - static Txid? lift(RustBuffer buf) { - return FfiConverterOptionalTxid.read(buf.asUint8List()).value; +class FfiConverterUInt32 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint32(0), 4); } - static LiftRetVal read(Uint8List buf) { + static int lower(int value) { + if (value < 0 || value > 4294967295) { + throw ArgumentError("Value out of range for u32: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 4; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint32(0, lower(value)); + return 4; + } +} + +class FfiConverterOptionalPolicy { + static Policy? lift(RustBuffer buf) { + return FfiConverterOptionalPolicy.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Txid.read(Uint8List.view(buf.buffer, buf.offsetInBytes + 1)); - return LiftRetVal(result.value, result.bytesRead + 1); + final result = Policy.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Txid? value]) { + static int allocationSize([Policy? value]) { if (value == null) { return 1; } - return Txid.allocationSize(value) + 1; + return Policy.allocationSize(value) + 1; } - static RustBuffer lower(Txid? value) { + static RustBuffer lower(Policy? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxid.allocationSize(value); + final length = FfiConverterOptionalPolicy.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxid.write(value, buf); + FfiConverterOptionalPolicy.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Txid? value, Uint8List buf) { + static int write(Policy? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Txid.write( + return Policy.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28184,49 +28365,49 @@ class FfiConverterOptionalTxid { } } -class FfiConverterOptionalTransaction { - static Transaction? lift(RustBuffer buf) { - return FfiConverterOptionalTransaction.read(buf.asUint8List()).value; +class FfiConverterOptionalBlockHash { + static BlockHash? lift(RustBuffer buf) { + return FfiConverterOptionalBlockHash.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Transaction.read( + final result = BlockHash.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Transaction? value]) { + static int allocationSize([BlockHash? value]) { if (value == null) { return 1; } - return Transaction.allocationSize(value) + 1; + return BlockHash.allocationSize(value) + 1; } - static RustBuffer lower(Transaction? value) { + static RustBuffer lower(BlockHash? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTransaction.allocationSize(value); + final length = FfiConverterOptionalBlockHash.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTransaction.write(value, buf); + FfiConverterOptionalBlockHash.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Transaction? value, Uint8List buf) { + static int write(BlockHash? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Transaction.write( + return BlockHash.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28234,49 +28415,115 @@ class FfiConverterOptionalTransaction { } } -class FfiConverterOptionalMerkleProof { - static MerkleProof? lift(RustBuffer buf) { - return FfiConverterOptionalMerkleProof.read(buf.asUint8List()).value; +class FfiConverterSequenceUInt32 { + static List lift(RustBuffer buf) { + return FfiConverterSequenceUInt32.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal> read(Uint8List buf) { + List res = []; + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < length; i++) { + final ret = FfiConverterUInt32.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); + } + return LiftRetVal(res, offset - buf.offsetInBytes); + } + + static int write(List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + int offset = buf.offsetInBytes + 4; + for (var i = 0; i < value.length; i++) { + offset += FfiConverterUInt32.write( + value[i], + Uint8List.view(buf.buffer, offset), + ); + } + return offset - buf.offsetInBytes; + } + + static int allocationSize(List value) { + return value + .map((l) => FfiConverterUInt32.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { + final buf = Uint8List(allocationSize(value)); + write(value, buf); + return toRustBuffer(buf); + } +} + +class FfiConverterUInt64 { + static int lift(int value) => value; + static LiftRetVal read(Uint8List buf) { + return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint64(0), 8); + } + + static int lower(int value) { + if (value < 0) { + throw ArgumentError("Value out of range for u64: " + value.toString()); + } + return value; + } + + static int allocationSize([int value = 0]) { + return 8; + } + + static int write(int value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setUint64(0, lower(value)); + return 8; + } +} + +class FfiConverterOptionalNetwork { + static Network? lift(RustBuffer buf) { + return FfiConverterOptionalNetwork.read(buf.asUint8List()).value; + } + + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterMerkleProof.read( + final result = FfiConverterNetwork.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([MerkleProof? value]) { + static int allocationSize([Network? value]) { if (value == null) { return 1; } - return FfiConverterMerkleProof.allocationSize(value) + 1; + return FfiConverterNetwork.allocationSize(value) + 1; } - static RustBuffer lower(MerkleProof? value) { + static RustBuffer lower(Network? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalMerkleProof.allocationSize(value); + final length = FfiConverterOptionalNetwork.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalMerkleProof.write(value, buf); + FfiConverterOptionalNetwork.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(MerkleProof? value, Uint8List buf) { + static int write(Network? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterMerkleProof.write( + return FfiConverterNetwork.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28284,83 +28531,40 @@ class FfiConverterOptionalMerkleProof { } } -class FfiConverterUint8List { - static Uint8List lift(RustBuffer value) { - return FfiConverterUint8List.read(value.asUint8List()).value; - } - - static LiftRetVal read(Uint8List buf) { - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - final bytes = Uint8List.view(buf.buffer, buf.offsetInBytes + 4, length); - return LiftRetVal(bytes, length + 4); - } - - static RustBuffer lower(Uint8List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } - - static int allocationSize([Uint8List? value]) { - if (value == null) { - return 4; - } - return 4 + value.length; - } - - static int write(Uint8List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - buf.setRange(4, 4 + value.length, value); - return 4 + value.length; - } -} - -class FfiConverterMapStringToKeySource { - static Map lift(RustBuffer buf) { - return FfiConverterMapStringToKeySource.read(buf.asUint8List()).value; +class FfiConverterSequenceLeafNode { + static List lift(RustBuffer buf) { + return FfiConverterSequenceLeafNode.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - final map = {}; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final k = FfiConverterString.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterKeySource.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; + final ret = LeafNode.read(Uint8List.view(buf.buffer, offset)); + offset += ret.bytesRead; + res.add(ret.value); } - return LiftRetVal(map, offset - buf.offsetInBytes); + return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(Map value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterString.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterKeySource.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); + for (var i = 0; i < value.length; i++) { + offset += LeafNode.write(value[i], Uint8List.view(buf.buffer, offset)); } - return offset - buf.offsetInBytes; - } - - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterString.allocationSize(e.key) + - FfiConverterKeySource.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); + return offset - buf.offsetInBytes; } - static RustBuffer lower(Map value) { + static int allocationSize(List value) { + return value + .map((l) => LeafNode.allocationSize(l)) + .fold(0, (a, b) => a + b) + + 4; + } + + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); @@ -28412,28 +28616,30 @@ class FfiConverterSequenceUnconfirmedTx { } } -class FfiConverterSequencePeer { - static List lift(RustBuffer buf) { - return FfiConverterSequencePeer.read(buf.asUint8List()).value; +class FfiConverterSequenceWalletEvent { + static List lift(RustBuffer buf) { + return FfiConverterSequenceWalletEvent.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = FfiConverterPeer.read(Uint8List.view(buf.buffer, offset)); + final ret = FfiConverterWalletEvent.read( + Uint8List.view(buf.buffer, offset), + ); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += FfiConverterPeer.write( + offset += FfiConverterWalletEvent.write( value[i], Uint8List.view(buf.buffer, offset), ); @@ -28441,63 +28647,63 @@ class FfiConverterSequencePeer { return offset - buf.offsetInBytes; } - static int allocationSize(List value) { + static int allocationSize(List value) { return value - .map((l) => FfiConverterPeer.allocationSize(l)) + .map((l) => FfiConverterWalletEvent.allocationSize(l)) .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterOptionalUInt8 { - static int? lift(RustBuffer buf) { - return FfiConverterOptionalUInt8.read(buf.asUint8List()).value; +class FfiConverterOptionalLocalOutput { + static LocalOutput? lift(RustBuffer buf) { + return FfiConverterOptionalLocalOutput.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterUInt8.read( + final result = FfiConverterLocalOutput.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([int? value]) { + static int allocationSize([LocalOutput? value]) { if (value == null) { return 1; } - return FfiConverterUInt8.allocationSize(value) + 1; + return FfiConverterLocalOutput.allocationSize(value) + 1; } - static RustBuffer lower(int? value) { + static RustBuffer lower(LocalOutput? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalUInt8.allocationSize(value); + final length = FfiConverterOptionalLocalOutput.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalUInt8.write(value, buf); + FfiConverterOptionalLocalOutput.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(int? value, Uint8List buf) { + static int write(LocalOutput? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterUInt8.write( + return FfiConverterLocalOutput.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28505,258 +28711,80 @@ class FfiConverterOptionalUInt8 { } } -class FfiConverterUInt8 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint8(0), 1); - } - - static int lower(int value) { - if (value < 0 || value > 255) { - throw ArgumentError("Value out of range for u8: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 1; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint8(0, lower(value)); - return 1; - } -} - -class FfiConverterMapUInt16ToDouble64 { - static Map lift(RustBuffer buf) { - return FfiConverterMapUInt16ToDouble64.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - final map = {}; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final k = FfiConverterUInt16.read(Uint8List.view(buf.buffer, offset)); - offset += k.bytesRead; - final v = FfiConverterDouble64.read(Uint8List.view(buf.buffer, offset)); - offset += v.bytesRead; - map[k.value] = v.value; - } - return LiftRetVal(map, offset - buf.offsetInBytes); - } - - static int write(Map value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (final entry in value.entries) { - offset += FfiConverterUInt16.write( - entry.key, - Uint8List.view(buf.buffer, offset), - ); - offset += FfiConverterDouble64.write( - entry.value, - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(Map value) { - return value.entries - .map( - (e) => - FfiConverterUInt16.allocationSize(e.key) + - FfiConverterDouble64.allocationSize(e.value), - ) - .fold(4, (a, b) => a + b); - } - - static RustBuffer lower(Map value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterUInt32 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getUint32(0), 4); - } - - static int lower(int value) { - if (value < 0 || value > 4294967295) { - throw ArgumentError("Value out of range for u32: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 4; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setUint32(0, lower(value)); - return 4; - } -} - -class FfiConverterInt32 { - static int lift(int value) => value; - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(buf.buffer.asByteData(buf.offsetInBytes).getInt32(0), 4); - } - - static int lower(int value) { - if (value < -2147483648 || value > 2147483647) { - throw ArgumentError("Value out of range for i32: " + value.toString()); - } - return value; - } - - static int allocationSize([int value = 0]) { - return 4; - } - - static int write(int value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, lower(value)); - return 4; - } -} - -class FfiConverterSequenceUInt64 { - static List lift(RustBuffer buf) { - return FfiConverterSequenceUInt64.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterUInt64.read(Uint8List.view(buf.buffer, offset)); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterUInt64.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; - } - - static int allocationSize(List value) { - return value - .map((l) => FfiConverterUInt64.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; - } - - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); - } -} - -class FfiConverterSequenceCanonicalTx { - static List lift(RustBuffer buf) { - return FfiConverterSequenceCanonicalTx.read(buf.asUint8List()).value; - } - - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterCanonicalTx.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); - } - return LiftRetVal(res, offset - buf.offsetInBytes); - } - - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterCanonicalTx.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); - } - return offset - buf.offsetInBytes; +class FfiConverterUint8List { + static Uint8List lift(RustBuffer value) { + return FfiConverterUint8List.read(value.asUint8List()).value; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterCanonicalTx.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static LiftRetVal read(Uint8List buf) { + final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); + final bytes = Uint8List.view(buf.buffer, buf.offsetInBytes + 4, length); + return LiftRetVal(bytes, length + 4); } - static RustBuffer lower(List value) { + static RustBuffer lower(Uint8List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } + + static int allocationSize([Uint8List? value]) { + if (value == null) { + return 4; + } + return 4 + value.length; + } + + static int write(Uint8List value, Uint8List buf) { + buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); + buf.setRange(4, 4 + value.length, value); + return 4 + value.length; + } } -class FfiConverterOptionalPolicy { - static Policy? lift(RustBuffer buf) { - return FfiConverterOptionalPolicy.read(buf.asUint8List()).value; +class FfiConverterOptionalAmount { + static Amount? lift(RustBuffer buf) { + return FfiConverterOptionalAmount.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Policy.read( + final result = Amount.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Policy? value]) { + static int allocationSize([Amount? value]) { if (value == null) { return 1; } - return Policy.allocationSize(value) + 1; + return Amount.allocationSize(value) + 1; } - static RustBuffer lower(Policy? value) { + static RustBuffer lower(Amount? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalPolicy.allocationSize(value); + final length = FfiConverterOptionalAmount.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalPolicy.write(value, buf); + FfiConverterOptionalAmount.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Policy? value, Uint8List buf) { + static int write(Amount? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Policy.write( + return Amount.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28764,114 +28792,89 @@ class FfiConverterOptionalPolicy { } } -class FfiConverterSequenceTxid { - static List lift(RustBuffer buf) { - return FfiConverterSequenceTxid.read(buf.asUint8List()).value; +class FfiConverterSequenceDescriptor { + static List lift(RustBuffer buf) { + return FfiConverterSequenceDescriptor.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; + static LiftRetVal> read(Uint8List buf) { + List res = []; final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); int offset = buf.offsetInBytes + 4; for (var i = 0; i < length; i++) { - final ret = Txid.read(Uint8List.view(buf.buffer, offset)); + final ret = Descriptor.read(Uint8List.view(buf.buffer, offset)); offset += ret.bytesRead; res.add(ret.value); } return LiftRetVal(res, offset - buf.offsetInBytes); } - static int write(List value, Uint8List buf) { + static int write(List value, Uint8List buf) { buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); int offset = buf.offsetInBytes + 4; for (var i = 0; i < value.length; i++) { - offset += Txid.write(value[i], Uint8List.view(buf.buffer, offset)); + offset += Descriptor.write(value[i], Uint8List.view(buf.buffer, offset)); } return offset - buf.offsetInBytes; } - static int allocationSize(List value) { - return value.map((l) => Txid.allocationSize(l)).fold(0, (a, b) => a + b) + + static int allocationSize(List value) { + return value + .map((l) => Descriptor.allocationSize(l)) + .fold(0, (a, b) => a + b) + 4; } - static RustBuffer lower(List value) { + static RustBuffer lower(List value) { final buf = Uint8List(allocationSize(value)); write(value, buf); return toRustBuffer(buf); } } -class FfiConverterBool { - static bool lift(int value) { - return value == 1; - } - - static int lower(bool value) { - return value ? 1 : 0; - } - - static LiftRetVal read(Uint8List buf) { - return LiftRetVal(FfiConverterBool.lift(buf.first), 1); - } - - static RustBuffer lowerIntoRustBuffer(bool value) { - return toRustBuffer(Uint8List.fromList([FfiConverterBool.lower(value)])); - } - - static int allocationSize([bool value = false]) { - return 1; - } - - static int write(bool value, Uint8List buf) { - buf.setAll(0, [value ? 1 : 0]); - return allocationSize(); - } -} - -class FfiConverterOptionalDescriptor { - static Descriptor? lift(RustBuffer buf) { - return FfiConverterOptionalDescriptor.read(buf.asUint8List()).value; +class FfiConverterOptionalUInt16 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalUInt16.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = Descriptor.read( + final result = FfiConverterUInt16.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([Descriptor? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return Descriptor.allocationSize(value) + 1; + return FfiConverterUInt16.allocationSize(value) + 1; } - static RustBuffer lower(Descriptor? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalDescriptor.allocationSize(value); + final length = FfiConverterOptionalUInt16.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalDescriptor.write(value, buf); + FfiConverterOptionalUInt16.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(Descriptor? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return Descriptor.write( + return FfiConverterUInt16.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28879,55 +28882,49 @@ class FfiConverterOptionalDescriptor { } } -class FfiConverterOptionalSequencePsbtFinalizeException { - static List? lift(RustBuffer buf) { - return FfiConverterOptionalSequencePsbtFinalizeException.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalUInt64 { + static int? lift(RustBuffer buf) { + return FfiConverterOptionalUInt64.read(buf.asUint8List()).value; } - static LiftRetVal?> read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterSequencePsbtFinalizeException.read( + final result = FfiConverterUInt64.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal?>( - result.value, - result.bytesRead + 1, - ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([List? value]) { + static int allocationSize([int? value]) { if (value == null) { return 1; } - return FfiConverterSequencePsbtFinalizeException.allocationSize(value) + 1; + return FfiConverterUInt64.allocationSize(value) + 1; } - static RustBuffer lower(List? value) { + static RustBuffer lower(int? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = - FfiConverterOptionalSequencePsbtFinalizeException.allocationSize(value); + final length = FfiConverterOptionalUInt64.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalSequencePsbtFinalizeException.write(value, buf); + FfiConverterOptionalUInt64.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(List? value, Uint8List buf) { + static int write(int? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterSequencePsbtFinalizeException.write( + return FfiConverterUInt64.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + @@ -28935,96 +28932,99 @@ class FfiConverterOptionalSequencePsbtFinalizeException { } } -class FfiConverterSequencePsbtFinalizeException { - static List lift(RustBuffer buf) { - return FfiConverterSequencePsbtFinalizeException.read( - buf.asUint8List(), - ).value; +class FfiConverterOptionalScript { + static Script? lift(RustBuffer buf) { + return FfiConverterOptionalScript.read(buf.asUint8List()).value; } - static LiftRetVal> read(Uint8List buf) { - List res = []; - final length = buf.buffer.asByteData(buf.offsetInBytes).getInt32(0); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < length; i++) { - final ret = FfiConverterPsbtFinalizeException.read( - Uint8List.view(buf.buffer, offset), - ); - offset += ret.bytesRead; - res.add(ret.value); + static LiftRetVal read(Uint8List buf) { + if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { + return LiftRetVal(null, 1); } - return LiftRetVal(res, offset - buf.offsetInBytes); + final result = Script.read( + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int write(List value, Uint8List buf) { - buf.buffer.asByteData(buf.offsetInBytes).setInt32(0, value.length); - int offset = buf.offsetInBytes + 4; - for (var i = 0; i < value.length; i++) { - offset += FfiConverterPsbtFinalizeException.write( - value[i], - Uint8List.view(buf.buffer, offset), - ); + static int allocationSize([Script? value]) { + if (value == null) { + return 1; } - return offset - buf.offsetInBytes; + return Script.allocationSize(value) + 1; } - static int allocationSize(List value) { - return value - .map((l) => FfiConverterPsbtFinalizeException.allocationSize(l)) - .fold(0, (a, b) => a + b) + - 4; + static RustBuffer lower(Script? value) { + if (value == null) { + return toRustBuffer(Uint8List.fromList([0])); + } + final length = FfiConverterOptionalScript.allocationSize(value); + final Pointer frameData = calloc(length); + final buf = frameData.asTypedList(length); + FfiConverterOptionalScript.write(value, buf); + final bytes = calloc(); + bytes.ref.len = length; + bytes.ref.data = frameData; + return RustBuffer.fromBytes(bytes.ref); } - static RustBuffer lower(List value) { - final buf = Uint8List(allocationSize(value)); - write(value, buf); - return toRustBuffer(buf); + static int write(Script? value, Uint8List buf) { + if (value == null) { + buf[0] = 0; + return 1; + } + buf[0] = 1; + return Script.write( + value, + Uint8List.view(buf.buffer, buf.offsetInBytes + 1), + ) + + 1; } } -class FfiConverterOptionalTxStatus { - static TxStatus? lift(RustBuffer buf) { - return FfiConverterOptionalTxStatus.read(buf.asUint8List()).value; +class FfiConverterOptionalDouble32 { + static double? lift(RustBuffer buf) { + return FfiConverterOptionalDouble32.read(buf.asUint8List()).value; } - static LiftRetVal read(Uint8List buf) { + static LiftRetVal read(Uint8List buf) { if (ByteData.view(buf.buffer, buf.offsetInBytes).getInt8(0) == 0) { return LiftRetVal(null, 1); } - final result = FfiConverterTxStatus.read( + final result = FfiConverterDouble32.read( Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ); - return LiftRetVal(result.value, result.bytesRead + 1); + return LiftRetVal(result.value, result.bytesRead + 1); } - static int allocationSize([TxStatus? value]) { + static int allocationSize([double? value]) { if (value == null) { return 1; } - return FfiConverterTxStatus.allocationSize(value) + 1; + return FfiConverterDouble32.allocationSize(value) + 1; } - static RustBuffer lower(TxStatus? value) { + static RustBuffer lower(double? value) { if (value == null) { return toRustBuffer(Uint8List.fromList([0])); } - final length = FfiConverterOptionalTxStatus.allocationSize(value); + final length = FfiConverterOptionalDouble32.allocationSize(value); final Pointer frameData = calloc(length); final buf = frameData.asTypedList(length); - FfiConverterOptionalTxStatus.write(value, buf); + FfiConverterOptionalDouble32.write(value, buf); final bytes = calloc(); bytes.ref.len = length; bytes.ref.data = frameData; return RustBuffer.fromBytes(bytes.ref); } - static int write(TxStatus? value, Uint8List buf) { + static int write(double? value, Uint8List buf) { if (value == null) { buf[0] = 0; return 1; } buf[0] = 1; - return FfiConverterTxStatus.write( + return FfiConverterDouble32.write( value, Uint8List.view(buf.buffer, buf.offsetInBytes + 1), ) + From 41d21f7389cda73aa3649d012956d85128e07a43 Mon Sep 17 00:00:00 2001 From: Johnosezele Date: Fri, 13 Mar 2026 15:26:30 +0100 Subject: [PATCH 3/6] Make walletRecordsProvider reactive with Notifier --- bdk_demo/lib/providers/wallet_providers.dart | 35 +++++++++++++++++--- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/bdk_demo/lib/providers/wallet_providers.dart b/bdk_demo/lib/providers/wallet_providers.dart index 55ece5f..7038d9c 100644 --- a/bdk_demo/lib/providers/wallet_providers.dart +++ b/bdk_demo/lib/providers/wallet_providers.dart @@ -16,10 +16,37 @@ class ActiveWalletRecordNotifier extends Notifier { void clear() => state = null; } -final walletRecordsProvider = Provider>((ref) { - final storage = ref.watch(storageServiceProvider); - return storage.getWalletRecords(); -}); +final walletRecordsProvider = + NotifierProvider>( + WalletRecordsNotifier.new, + ); + +class WalletRecordsNotifier extends Notifier> { + @override + List build() { + final storage = ref.watch(storageServiceProvider); + return storage.getWalletRecords(); + } + + Future addWalletRecord( + WalletRecord record, + WalletSecrets secrets, + ) async { + final storage = ref.read(storageServiceProvider); + await storage.addWalletRecord(record, secrets); + state = storage.getWalletRecords(); + } + + Future setFullScanCompleted(String walletId) async { + final storage = ref.read(storageServiceProvider); + await storage.setFullScanCompleted(walletId); + state = storage.getWalletRecords(); + } + + void refresh() { + state = ref.read(storageServiceProvider).getWalletRecords(); + } +} // TODO: Add activeWalletProvider. // TODO: Add balanceProvider, syncStateProvider. From b951b35597a3b90e47e60f76276f283f13c1ba54 Mon Sep 17 00:00:00 2001 From: Johnosezele Date: Fri, 13 Mar 2026 16:13:22 +0100 Subject: [PATCH 4/6] Write secrets first to avoid wallet meta data failure --- bdk_demo/lib/services/storage_service.dart | 25 +++++++++++++++------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/bdk_demo/lib/services/storage_service.dart b/bdk_demo/lib/services/storage_service.dart index 927964e..0b30073 100644 --- a/bdk_demo/lib/services/storage_service.dart +++ b/bdk_demo/lib/services/storage_service.dart @@ -43,16 +43,25 @@ class StorageService { WalletRecord record, WalletSecrets secrets, ) async { + final secretsKey = _SecureKeys.secrets(record.id); + + await _secure.write(key: secretsKey, value: jsonEncode(secrets.toJson())); + final records = getWalletRecords(); records.add(record); - await _prefs.setString( - _PrefKeys.walletRecords, - WalletRecord.encodeList(records), - ); - await _secure.write( - key: _SecureKeys.secrets(record.id), - value: jsonEncode(secrets.toJson()), - ); + + try { + final didPersist = await _prefs.setString( + _PrefKeys.walletRecords, + WalletRecord.encodeList(records), + ); + if (!didPersist) { + throw StateError('Failed to persist wallet metadata.'); + } + } catch (_) { + await _secure.delete(key: secretsKey); + rethrow; + } } Future getSecrets(String walletId) async { From 630c36652998b6ade5379df9df63c138b762b722 Mon Sep 17 00:00:00 2001 From: Johnosezele Date: Fri, 13 Mar 2026 16:33:28 +0100 Subject: [PATCH 5/6] hoist GoRouter into Riverpod provider --- bdk_demo/lib/app/app.dart | 4 ++-- bdk_demo/lib/providers/router_provider.dart | 10 ++++++++++ 2 files changed, 12 insertions(+), 2 deletions(-) create mode 100644 bdk_demo/lib/providers/router_provider.dart diff --git a/bdk_demo/lib/app/app.dart b/bdk_demo/lib/app/app.dart index 487b3b6..daedd5d 100644 --- a/bdk_demo/lib/app/app.dart +++ b/bdk_demo/lib/app/app.dart @@ -1,7 +1,7 @@ import 'package:flutter/material.dart'; import 'package:flutter_riverpod/flutter_riverpod.dart'; -import '../core/router/app_router.dart'; +import '../providers/router_provider.dart'; import '../core/theme/app_theme.dart'; import '../providers/settings_providers.dart'; @@ -11,7 +11,7 @@ class App extends ConsumerWidget { @override Widget build(BuildContext context, WidgetRef ref) { final themeMode = ref.watch(themeModeProvider); - final router = createRouter(); + final router = ref.watch(appRouterProvider); return MaterialApp.router( title: 'BDK-Dart Wallet', diff --git a/bdk_demo/lib/providers/router_provider.dart b/bdk_demo/lib/providers/router_provider.dart new file mode 100644 index 0000000..36b34f6 --- /dev/null +++ b/bdk_demo/lib/providers/router_provider.dart @@ -0,0 +1,10 @@ +import 'package:flutter_riverpod/flutter_riverpod.dart'; +import 'package:go_router/go_router.dart'; + +import '../core/router/app_router.dart'; + +final appRouterProvider = Provider((ref) { + final router = createRouter(); + ref.onDispose(router.dispose); + return router; +}); From 02ffbca8070e168d660a3df3b51349618a492405 Mon Sep 17 00:00:00 2001 From: Johnosezele Date: Fri, 13 Mar 2026 16:50:17 +0100 Subject: [PATCH 6/6] add app shell smoke widget tests --- bdk_demo/test/widget_test.dart | 50 ++++++++++++++++++++++++++++++++-- 1 file changed, 47 insertions(+), 3 deletions(-) diff --git a/bdk_demo/test/widget_test.dart b/bdk_demo/test/widget_test.dart index 7871a40..4acb26f 100644 --- a/bdk_demo/test/widget_test.dart +++ b/bdk_demo/test/widget_test.dart @@ -1,8 +1,52 @@ +import 'package:flutter/material.dart'; +import 'package:flutter_riverpod/flutter_riverpod.dart'; import 'package:flutter_test/flutter_test.dart'; +import 'package:shared_preferences/shared_preferences.dart'; + +import 'package:bdk_demo/app/app.dart'; +import 'package:bdk_demo/providers/settings_providers.dart'; +import 'package:bdk_demo/services/storage_service.dart'; void main() { - testWidgets('App scaffold builds', (WidgetTester tester) async { - // TODO: Implement widget tests - expect(true, isTrue); + testWidgets('App builds and shows WalletChoicePage', (tester) async { + SharedPreferences.setMockInitialValues({}); + final prefs = await SharedPreferences.getInstance(); + + await tester.pumpWidget( + ProviderScope( + overrides: [ + storageServiceProvider.overrideWithValue( + StorageService(prefs: prefs), + ), + ], + child: const App(), + ), + ); + await tester.pumpAndSettle(); + + expect(find.byType(MaterialApp), findsOneWidget); + expect(find.text('Use an Active Wallet'), findsOneWidget); + expect(find.text('Create a New Wallet'), findsOneWidget); + expect(find.text('Recover an Existing Wallet'), findsOneWidget); + }); + + testWidgets('Theme defaults to light mode', (tester) async { + SharedPreferences.setMockInitialValues({}); + final prefs = await SharedPreferences.getInstance(); + + await tester.pumpWidget( + ProviderScope( + overrides: [ + storageServiceProvider.overrideWithValue( + StorageService(prefs: prefs), + ), + ], + child: const App(), + ), + ); + await tester.pumpAndSettle(); + + final materialApp = tester.widget(find.byType(MaterialApp)); + expect(materialApp.themeMode, ThemeMode.light); }); }