diff --git a/CHANGELOG.md b/CHANGELOG.md index 335cfa3..43e570f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,29 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [v0.3.3](https://github.com/MicroClub-USTHB/M-Security/releases/tag/v0.3.3) - 2026-03-28 + +### Added + +- Zero-copy vault reads via `memmap2` memory-mapped I/O — `vault_read` and `vault_read_stream` now slice directly into mapped file pages instead of allocating heap buffers with `read_exact`. +- `VaultMmap` wrapper with `mlock()` on unix to pin ciphertext pages in RAM and prevent swap-to-disk. Graceful fallback to heap reads when mmap fails (32-bit targets, low `mlock` limits). +- mmap invalidation/recreation after every vault mutation (write, delete, defrag, resize). +- ELF linker version script (`ffi-exports.map`) restricting Android/Linux `.so` dynamic symbol table to FRB FFI symbols only — hides `#[no_mangle]` symbols leaked by dependencies. +- `build.rs` for conditional version script application on Android/Linux cdylib builds. + +### Changed + +- Switched all 50 FRB functions from SSE to CST+DCO codec via `full_dep: true` — `Vec` returns now use `allo-isolate` `ExternalTypedData` (pointer transfer, no memcpy) instead of SSE serialization. +- Release profile hardened: `lto = "fat"`, `codegen-units = 1`, `strip = "symbols"`, `opt-level = 3`. +- `VaultHandle` field order: `mmap` before `file` so `munlock`/`munmap` runs while the fd is still open. + +### Security + +- Symbol stripping removes internal Rust function names from release binaries — `nm -D` shows only FRB entry points and libc on ELF targets. +- `mlock()` prevents OS from swapping mmap'd ciphertext pages to disk swap. +- Fewer intermediate `Vec` copies means shorter plaintext residency in memory. +- ZeroizeOnDrop behavior preserved — no regression from zero-copy refactoring. + ## [v0.3.2](https://github.com/MicroClub-USTHB/M-Security/releases/tag/v0.3.2) - 2026-03-26 ### Added diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d607272..e131d83 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -16,14 +16,11 @@ Thank you for your interest in contributing to M-Security! This project is built ## Project Vision -M-Security aims to be a complete security toolkit for Flutter. The current release (v0.3.2) includes the cryptographic foundation, streaming encryption, compression, EVFS v2 (defragmentation, resize, health check), EVFS v3 (streaming I/O), and an encrypted virtual file system. Future releases will continue building on top of it: - -1. **Cryptographic primitives** (v0.1.0): AEAD encryption, hashing, password hashing, key derivation -2. **Streaming, compression, and EVFS** (v0.3.0): Chunk-based streaming encryption with progress callbacks, Zstd/Brotli compression pipeline, `.vault` container with named segments, WAL crash recovery, shadow index, and secure deletion -3. **EVFS v2: Defrag, resize, health** (v0.3.1): Vault defragmentation with per-move WAL crash safety, vault resize (grow/shrink) with shadow index + WAL relocation, vault health check with consistency invariant, dynamic index sizing -4. **EVFS v3: Streaming I/O** (v0.3.2, current): Constant-memory streaming writes/reads with per-chunk AEAD, domain-separated nonces, VaultChunkAad for splice defense, progress callbacks, interop between streaming and monolithic segments -5. **Stealth storage** (planned): Ephemeral secrets in Rust-managed memory with derived-path obfuscation -6. **Hardware integration** (planned): Key wrap with Secure Enclave (iOS) / KeyStore (Android), biometric unlock flow (FaceID/Fingerprint), native Swift/Kotlin bridge layer +M-Security aims to be a unified, high-performance security layer for Flutter, making strong data protection simple to use and easy to integrate. It is designed to give developers a reliable foundation for handling sensitive data without sacrificing performance or developer experience. + +The project focuses on securing data across its entire lifecycle, including storage, in-app processing, and access, while maintaining a consistent and intuitive API. It also serves as a cross-platform trust layer, bringing platform-specific security features into a single, cohesive interface. + +Ultimately, M-Security strives to become a long-term security backbone for Flutter applications, where robust security is built in by default rather than added later. Contributions to any of these areas are welcome. If you want to work on an upcoming feature, open an issue first to discuss the approach. diff --git a/README.md b/README.md index c2fb426..dab3726 100644 --- a/README.md +++ b/README.md @@ -29,6 +29,7 @@ Built and maintained by the **Dev Department** of [MicroClub](https://github.com | **Password Hashing** | Argon2id | PHC winner, Mobile and Desktop presets | | **Key Derivation** | HKDF-SHA256 | RFC 5869, extract-then-expand with domain separation | | **Encrypted VFS (EVFS)** | `.vault` container | Named segments, WAL recovery, shadow index, secure deletion | +| **Zero-Copy I/O** | mmap + DCO codec | Memory-mapped vault reads, zero-copy Rust-to-Dart transfers | **Security by design:** @@ -38,6 +39,8 @@ Built and maintained by the **Dev Department** of [MicroClub](https://github.com - AEAD tag verification prevents silent decryption of tampered data - `panic = "abort"` in release profile, preventing undefined behavior from panics crossing FFI - `clippy::unwrap_used = "deny"`, ensuring all operations return `Result` +- Release builds strip all symbols except FRB entry points (LTO + ELF version script) +- `mlock()` pins mmap'd ciphertext pages to prevent swap-to-disk (unix) ## Installation @@ -45,7 +48,7 @@ Add to your `pubspec.yaml`: ```yaml dependencies: - m_security: ^0.3.2 + m_security: ^0.3.3 ``` Then run: @@ -329,13 +332,13 @@ hkdf_expand(prk, info, output_len) -> Result> ## Testing -**Rust unit tests** (317 tests including EVFS streaming and defrag): +**Rust unit tests** (331 tests including EVFS streaming and defrag): ```bash cd rust && cargo test ``` -**Dart integration tests** (63 tests across all features, requires a running device/simulator): +**Dart integration tests** (76 tests across all features, requires a running device/simulator): ```bash cd example @@ -351,7 +354,7 @@ flutter test integration_test/ | Dart SDK | ^3.10.8 | | Flutter SDK | >=3.3.0 | -**Rust crates:** `aes-gcm` 0.10, `chacha20poly1305` 0.10, `blake3` 1.8, `sha3` 0.10, `argon2` 0.5, `hkdf` 0.12, `zstd` 0.13, `brotli` 7.0, `zeroize` 1.8 +**Rust crates:** `aes-gcm` 0.10, `chacha20poly1305` 0.10, `blake3` 1.8, `sha3` 0.10, `argon2` 0.5, `hkdf` 0.12, `zstd` 0.13, `brotli` 7.0, `zeroize` 1.8, `memmap2` 0.9 ## Roadmap @@ -361,7 +364,8 @@ flutter test integration_test/ | **Compression pipeline** | Zstd/Brotli compression integrated into streaming and EVFS | v0.3.0 | | **Encrypted Virtual File System (EVFS)** | `.vault` container with named segments, WAL recovery, shadow index, secure deletion | v0.3.0 | | **EVFS v2: Defrag & resize** | Online defragmentation, vault resizing, health diagnostics | v0.3.1 | -| **EVFS v3: Streaming I/O** | Constant-memory streaming reads/writes, per-chunk AEAD, progress callbacks | v0.3.2 | +| **EVFS v2: Streaming I/O** | Constant-memory streaming reads/writes, per-chunk AEAD, progress callbacks | v0.3.2 | +| **Zero-copy FFI optimization** | mmap vault reads, DCO codec, release profile hardening, symbol stripping | v0.3.3 | | **EVFS v2: Key rotation** | Re-encrypt vault with new master key | Planned | | **Stealth storage** | Ephemeral secrets in Rust-managed memory with derived-path obfuscation | Planned | | **Hardware key wrap** | Master key in Secure Enclave (iOS) / KeyStore (Android) with biometric unlock | Planned | diff --git a/example/lib/main.dart b/example/lib/main.dart index 5ca93d8..7d717ce 100644 --- a/example/lib/main.dart +++ b/example/lib/main.dart @@ -21,7 +21,7 @@ class ExampleApp extends StatelessWidget { @override Widget build(BuildContext context) { return MaterialApp( - title: 'M-Security v0.3.2', + title: 'M-Security v0.3.3', theme: ThemeData(colorSchemeSeed: Colors.blue, useMaterial3: true), home: const DemoHome(), ); @@ -41,7 +41,7 @@ class _DemoHomeState extends State { @override Widget build(BuildContext context) { return Scaffold( - appBar: AppBar(title: const Text('M-Security v0.3.2')), + appBar: AppBar(title: const Text('M-Security v0.3.3')), body: IndexedStack( index: _tab, children: const [ @@ -774,7 +774,8 @@ class _VaultTabState extends State<_VaultTab> { onProgress: (p) => setState(() => _streamProgress = p), ); - _status = 'Stream-wrote ${_fmtBytes(BigInt.from(sizeBytes))} as ' + _status = + 'Stream-wrote ${_fmtBytes(BigInt.from(sizeBytes))} as ' '"stream-${_streamSizeKb.text}kb.bin"'; await _refreshList(); await _refreshCapacity(); @@ -816,7 +817,8 @@ class _VaultTabState extends State<_VaultTab> { offset += chunk.length; } - _status = 'Stream-read "$name": ${_fmtBytes(BigInt.from(total))} ' + _status = + 'Stream-read "$name": ${_fmtBytes(BigInt.from(total))} ' 'in ${chunks.length} chunks — ${match ? "PASS" : "FAIL"}'; } catch (e) { _status = 'Error: $e'; @@ -1097,8 +1099,7 @@ class _VaultTabState extends State<_VaultTab> { const Divider(height: 24), // Streaming segment I/O - Text('Streaming I/O', - style: Theme.of(context).textTheme.titleSmall), + Text('Streaming I/O', style: Theme.of(context).textTheme.titleSmall), const SizedBox(height: 8), TextField( controller: _streamSizeKb, @@ -1133,7 +1134,8 @@ class _VaultTabState extends State<_VaultTab> { Padding( padding: const EdgeInsets.only(top: 8), child: LinearProgressIndicator( - value: _loading ? _streamProgress : 1), + value: _loading ? _streamProgress : 1, + ), ), ], diff --git a/example/pubspec.lock b/example/pubspec.lock index 064ed09..817012b 100644 --- a/example/pubspec.lock +++ b/example/pubspec.lock @@ -176,7 +176,7 @@ packages: path: ".." relative: true source: path - version: "0.3.2" + version: "0.3.3" matcher: dependency: transitive description: diff --git a/flutter_rust_bridge.yaml b/flutter_rust_bridge.yaml index c9f390c..62209a1 100644 --- a/flutter_rust_bridge.yaml +++ b/flutter_rust_bridge.yaml @@ -2,5 +2,6 @@ rust_input: crate::api rust_root: rust/ dart_output: lib/src/rust enable_lifetime: true +full_dep: true rust_features: - compression diff --git a/ios/m_security.podspec b/ios/m_security.podspec index 24bdd39..db4060f 100644 --- a/ios/m_security.podspec +++ b/ios/m_security.podspec @@ -4,7 +4,7 @@ # Pod::Spec.new do |s| s.name = 'm_security' - s.version = '0.3.2' + s.version = '0.3.3' s.summary = 'A high-performance cryptographic SDK for Flutter powered by native Rust via FFI.' s.description = <<-DESC A high-performance cryptographic SDK for Flutter powered by native Rust via FFI. diff --git a/lib/src/rust/api/encryption.dart b/lib/src/rust/api/encryption.dart index 1379d67..288faf2 100644 --- a/lib/src/rust/api/encryption.dart +++ b/lib/src/rust/api/encryption.dart @@ -64,5 +64,5 @@ Future encryptionAlgorithmId({required CipherHandle cipher}) => RustLib .api .crateApiEncryptionEncryptionAlgorithmId(cipher: cipher); -// Rust type: RustOpaqueMoi> +// Rust type: RustOpaqueNom> abstract class CipherHandle implements RustOpaqueInterface {} diff --git a/lib/src/rust/api/evfs/types.dart b/lib/src/rust/api/evfs/types.dart index a93b6d5..f84c208 100644 --- a/lib/src/rust/api/evfs/types.dart +++ b/lib/src/rust/api/evfs/types.dart @@ -6,9 +6,11 @@ import '../../frb_generated.dart'; import 'package:flutter_rust_bridge/flutter_rust_bridge_for_generated.dart'; -// These function are ignored because they are on traits that is not defined in current crate (put an empty `#[frb]` on it to unignore): `clone`, `eq`, `fmt` +// These functions are ignored because they are not marked as `pub`: `new`, `refresh_mmap`, `slice` +// These types are ignored because they are neither used by any `pub` functions nor (for structs and enums) marked `#[frb(unignore)]`: `VaultMmap` +// These function are ignored because they are on traits that is not defined in current crate (put an empty `#[frb]` on it to unignore): `clone`, `drop`, `eq`, `fmt` -// Rust type: RustOpaqueMoi> +// Rust type: RustOpaqueNom> abstract class VaultHandle implements RustOpaqueInterface { /// Compute health information from the in-memory index only (no file I/O or WAL writes). Future health(); diff --git a/lib/src/rust/api/hashing.dart b/lib/src/rust/api/hashing.dart index 4735b83..e4427ef 100644 --- a/lib/src/rust/api/hashing.dart +++ b/lib/src/rust/api/hashing.dart @@ -50,5 +50,5 @@ Future blake3Hash({required List data}) => Future sha3Hash({required List data}) => RustLib.instance.api.crateApiHashingSha3Hash(data: data); -// Rust type: RustOpaqueMoi> +// Rust type: RustOpaqueNom> abstract class HasherHandle implements RustOpaqueInterface {} diff --git a/lib/src/rust/frb_generated.dart b/lib/src/rust/frb_generated.dart index 933f4a8..143d2ff 100644 --- a/lib/src/rust/frb_generated.dart +++ b/lib/src/rust/frb_generated.dart @@ -336,20 +336,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - that, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 1, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + that, + ); + return wire.wire__crate__api__evfs__types__VaultHandle_health( + port_, + arg0, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_vault_health_info, + codec: DcoCodec( + decodeSuccessData: dco_decode_vault_health_info, decodeErrorData: null, ), constMeta: kCrateApiEvfsTypesVaultHandleHealthConstMeta, @@ -370,19 +367,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(password, serializer); - sse_encode_argon_2_preset(preset, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 2, - port: port_, + var arg0 = cst_encode_String(password); + var arg1 = cst_encode_argon_2_preset(preset); + return wire.wire__crate__api__hashing__argon2__argon2id_hash( + port_, + arg0, + arg1, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_String, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_String, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingArgon2Argon2IdHashConstMeta, argValues: [password, preset], @@ -406,20 +401,20 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(password, serializer); - sse_encode_String(salt, serializer); - sse_encode_argon_2_preset(preset, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 3, - port: port_, - ); + var arg0 = cst_encode_String(password); + var arg1 = cst_encode_String(salt); + var arg2 = cst_encode_argon_2_preset(preset); + return wire + .wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + port_, + arg0, + arg1, + arg2, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_String, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_String, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingArgon2Argon2IdHashWithSaltConstMeta, argValues: [password, salt, preset], @@ -442,19 +437,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(phcHash, serializer); - sse_encode_String(password, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 4, - port: port_, + var arg0 = cst_encode_String(phcHash); + var arg1 = cst_encode_String(password); + return wire.wire__crate__api__hashing__argon2__argon2id_verify( + port_, + arg0, + arg1, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingArgon2Argon2IdVerifyConstMeta, argValues: [phcHash, password], @@ -474,17 +467,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(data, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 5, - port: port_, - ); + var arg0 = cst_encode_list_prim_u_8_loose(data); + return wire.wire__crate__api__hashing__blake3_hash(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, decodeErrorData: null, ), constMeta: kCrateApiHashingBlake3HashConstMeta, @@ -505,19 +492,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(data, serializer); - sse_encode_box_autoadd_compression_config(config, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 6, - port: port_, + var arg0 = cst_encode_list_prim_u_8_loose(data); + var arg1 = cst_encode_box_autoadd_compression_config(config); + return wire.wire__crate__api__compression__compress( + port_, + arg0, + arg1, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiCompressionCompressConstMeta, argValues: [data, config], @@ -536,18 +521,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_u_8(byte, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 7, - port: port_, - ); + var arg0 = cst_encode_u_8(byte); + return wire + .wire__crate__api__compression__compression_algorithm_from_u8( + port_, + arg0, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_compression_algorithm, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_compression_algorithm, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiCompressionCompressionAlgorithmFromU8ConstMeta, argValues: [byte], @@ -569,17 +552,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_compression_algorithm(that, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 8, - port: port_, - ); + var arg0 = cst_encode_compression_algorithm(that); + return wire + .wire__crate__api__compression__compression_algorithm_to_u8( + port_, + arg0, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_u_8, + codec: DcoCodec( + decodeSuccessData: dco_decode_u_8, decodeErrorData: null, ), constMeta: kCrateApiCompressionCompressionAlgorithmToU8ConstMeta, @@ -602,19 +583,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(key, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 9, - port: port_, + var arg0 = cst_encode_list_prim_u_8_loose(key); + return wire.wire__crate__api__encryption__create_aes256_gcm( + port_, + arg0, ); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle, - decodeErrorData: sse_decode_crypto_error, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionCreateAes256GcmConstMeta, argValues: [key], @@ -631,17 +609,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 10, - port: port_, - ); + return wire.wire__crate__api__hashing__create_blake3(port_); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle, decodeErrorData: null, ), constMeta: kCrateApiHashingCreateBlake3ConstMeta, @@ -661,19 +633,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(key, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 11, - port: port_, + var arg0 = cst_encode_list_prim_u_8_loose(key); + return wire.wire__crate__api__encryption__create_chacha20_poly1305( + port_, + arg0, ); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle, - decodeErrorData: sse_decode_crypto_error, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionCreateChacha20Poly1305ConstMeta, argValues: [key], @@ -693,17 +662,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 12, - port: port_, + return wire.wire__crate__api__encryption__create_noop_encryption( + port_, ); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle, decodeErrorData: null, ), constMeta: kCrateApiEncryptionCreateNoopEncryptionConstMeta, @@ -721,17 +686,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 13, - port: port_, - ); + return wire.wire__crate__api__hashing__create_sha3(port_); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle, decodeErrorData: null, ), constMeta: kCrateApiHashingCreateSha3ConstMeta, @@ -752,19 +711,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(data, serializer); - sse_encode_compression_algorithm(algorithm, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 14, - port: port_, + var arg0 = cst_encode_list_prim_u_8_loose(data); + var arg1 = cst_encode_compression_algorithm(algorithm); + return wire.wire__crate__api__compression__decompress( + port_, + arg0, + arg1, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiCompressionDecompressConstMeta, argValues: [data, algorithm], @@ -788,23 +745,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - sse_encode_list_prim_u_8_loose(ciphertext, serializer); - sse_encode_list_prim_u_8_loose(aad, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 15, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + var arg1 = cst_encode_list_prim_u_8_loose(ciphertext); + var arg2 = cst_encode_list_prim_u_8_loose(aad); + return wire.wire__crate__api__encryption__decrypt( + port_, + arg0, + arg1, + arg2, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionDecryptConstMeta, argValues: [cipher, ciphertext, aad], @@ -827,23 +783,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - sse_encode_list_prim_u_8_loose(plaintext, serializer); - sse_encode_list_prim_u_8_loose(aad, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 16, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + var arg1 = cst_encode_list_prim_u_8_loose(plaintext); + var arg2 = cst_encode_list_prim_u_8_loose(aad); + return wire.wire__crate__api__encryption__encrypt( + port_, + arg0, + arg1, + arg2, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionEncryptConstMeta, argValues: [cipher, plaintext, aad], @@ -864,20 +819,17 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 17, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + return wire.wire__crate__api__encryption__encryption_algorithm_id( + port_, + arg0, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_String, + codec: DcoCodec( + decodeSuccessData: dco_decode_String, decodeErrorData: null, ), constMeta: kCrateApiEncryptionEncryptionAlgorithmIdConstMeta, @@ -898,17 +850,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 18, - port: port_, + return wire.wire__crate__api__encryption__generate_aes256_gcm_key( + port_, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionGenerateAes256GcmKeyConstMeta, argValues: [], @@ -925,17 +873,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 19, - port: port_, + return wire.wire__crate__api__encryption__aes_gcm__generate_aes_key( + port_, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionAesGcmGenerateAesKeyConstMeta, argValues: [], @@ -952,17 +896,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 20, - port: port_, - ); + return wire + .wire__crate__api__encryption__generate_chacha20_poly1305_key( + port_, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionGenerateChacha20Poly1305KeyConstMeta, argValues: [], @@ -982,17 +923,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 21, - port: port_, - ); + return wire + .wire__crate__api__encryption__chacha20__generate_chacha_key( + port_, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEncryptionChacha20GenerateChachaKeyConstMeta, argValues: [], @@ -1011,21 +949,18 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 22, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + handle, + ); + return wire.wire__crate__api__hashing__hasher_algorithm_id( + port_, + arg0, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_String, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_String, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingHasherAlgorithmIdConstMeta, argValues: [handle], @@ -1047,21 +982,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 23, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + handle, + ); + return wire.wire__crate__api__hashing__hasher_finalize(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingHasherFinalizeConstMeta, argValues: [handle], @@ -1078,21 +1007,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 24, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + handle, + ); + return wire.wire__crate__api__hashing__hasher_reset(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingHasherResetConstMeta, argValues: [handle], @@ -1112,22 +1035,20 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - handle, - serializer, - ); - sse_encode_list_prim_u_8_loose(data, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 25, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + handle, + ); + var arg1 = cst_encode_list_prim_u_8_loose(data); + return wire.wire__crate__api__hashing__hasher_update( + port_, + arg0, + arg1, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiHashingHasherUpdateConstMeta, argValues: [handle, data], @@ -1152,16 +1073,20 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync( SyncTask( callFfi: () { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(ikm, serializer); - sse_encode_opt_list_prim_u_8_strict(salt, serializer); - sse_encode_list_prim_u_8_loose(info, serializer); - sse_encode_usize(outputLen, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 26)!; + var arg0 = cst_encode_list_prim_u_8_loose(ikm); + var arg1 = cst_encode_opt_list_prim_u_8_strict(salt); + var arg2 = cst_encode_list_prim_u_8_loose(info); + var arg3 = cst_encode_usize(outputLen); + return wire.wire__crate__api__kdf__hkdf__hkdf_derive( + arg0, + arg1, + arg2, + arg3, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiKdfHkdfHkdfDeriveConstMeta, argValues: [ikm, salt, info, outputLen], @@ -1184,20 +1109,19 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(prk, serializer); - sse_encode_list_prim_u_8_loose(info, serializer); - sse_encode_usize(outputLen, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 27, - port: port_, + var arg0 = cst_encode_list_prim_u_8_loose(prk); + var arg1 = cst_encode_list_prim_u_8_loose(info); + var arg2 = cst_encode_usize(outputLen); + return wire.wire__crate__api__kdf__hkdf__hkdf_expand( + port_, + arg0, + arg1, + arg2, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiKdfHkdfHkdfExpandConstMeta, argValues: [prk, info, outputLen], @@ -1219,14 +1143,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeSync( SyncTask( callFfi: () { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(ikm, serializer); - sse_encode_opt_list_prim_u_8_strict(salt, serializer); - return pdeCallFfi(generalizedFrbRustBinding, serializer, funcId: 28)!; + var arg0 = cst_encode_list_prim_u_8_loose(ikm); + var arg1 = cst_encode_opt_list_prim_u_8_strict(salt); + return wire.wire__crate__api__kdf__hkdf__hkdf_extract(arg0, arg1); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiKdfHkdfHkdfExtractConstMeta, argValues: [ikm, salt], @@ -1243,17 +1166,11 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_list_prim_u_8_loose(data, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 29, - port: port_, - ); + var arg0 = cst_encode_list_prim_u_8_loose(data); + return wire.wire__crate__api__hashing__sha3_hash(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, decodeErrorData: null, ), constMeta: kCrateApiHashingSha3HashConstMeta, @@ -1273,17 +1190,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(filePath, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 30, - port: port_, + var arg0 = cst_encode_String(filePath); + return wire.wire__crate__api__compression__should_skip_compression( + port_, + arg0, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_bool, + codec: DcoCodec( + decodeSuccessData: dco_decode_bool, decodeErrorData: null, ), constMeta: kCrateApiCompressionShouldSkipCompressionConstMeta, @@ -1311,25 +1225,27 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - sse_encode_box_autoadd_compression_config(compression, serializer); - sse_encode_String(inputPath, serializer); - sse_encode_String(outputPath, serializer); - sse_encode_StreamSink_f_64_Sse(progressSink, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 31, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + var arg1 = cst_encode_box_autoadd_compression_config(compression); + var arg2 = cst_encode_String(inputPath); + var arg3 = cst_encode_String(outputPath); + var arg4 = cst_encode_StreamSink_f_64_Dco(progressSink); + return wire + .wire__crate__api__streaming__stream_compress_encrypt_file( + port_, + arg0, + arg1, + arg2, + arg3, + arg4, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiStreamingStreamCompressEncryptFileConstMeta, argValues: [cipher, compression, inputPath, outputPath, progressSink], @@ -1363,24 +1279,25 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - sse_encode_String(inputPath, serializer); - sse_encode_String(outputPath, serializer); - sse_encode_StreamSink_f_64_Sse(progressSink, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 32, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + var arg1 = cst_encode_String(inputPath); + var arg2 = cst_encode_String(outputPath); + var arg3 = cst_encode_StreamSink_f_64_Dco(progressSink); + return wire + .wire__crate__api__streaming__stream_decrypt_decompress_file( + port_, + arg0, + arg1, + arg2, + arg3, + ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiStreamingStreamDecryptDecompressFileConstMeta, argValues: [cipher, inputPath, outputPath, progressSink], @@ -1408,24 +1325,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - sse_encode_String(inputPath, serializer); - sse_encode_String(outputPath, serializer); - sse_encode_StreamSink_f_64_Sse(progressSink, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 33, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + var arg1 = cst_encode_String(inputPath); + var arg2 = cst_encode_String(outputPath); + var arg3 = cst_encode_StreamSink_f_64_Dco(progressSink); + return wire.wire__crate__api__streaming__stream_decrypt_file( + port_, + arg0, + arg1, + arg2, + arg3, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiStreamingStreamDecryptFileConstMeta, argValues: [cipher, inputPath, outputPath, progressSink], @@ -1453,24 +1370,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - cipher, - serializer, - ); - sse_encode_String(inputPath, serializer); - sse_encode_String(outputPath, serializer); - sse_encode_StreamSink_f_64_Sse(progressSink, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 34, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + cipher, + ); + var arg1 = cst_encode_String(inputPath); + var arg2 = cst_encode_String(outputPath); + var arg3 = cst_encode_StreamSink_f_64_Dco(progressSink); + return wire.wire__crate__api__streaming__stream_encrypt_file( + port_, + arg0, + arg1, + arg2, + arg3, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiStreamingStreamEncryptFileConstMeta, argValues: [cipher, inputPath, outputPath, progressSink], @@ -1497,23 +1414,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - hasher, - serializer, - ); - sse_encode_String(filePath, serializer); - sse_encode_StreamSink_f_64_Sse(progressSink, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 35, - port: port_, + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + hasher, + ); + var arg1 = cst_encode_String(filePath); + var arg2 = cst_encode_StreamSink_f_64_Dco(progressSink); + return wire.wire__crate__api__streaming__stream_hash_file( + port_, + arg0, + arg1, + arg2, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiStreamingStreamHashFileConstMeta, argValues: [hasher, filePath, progressSink], @@ -1537,20 +1453,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 36, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + return wire.wire__crate__api__evfs__vault_capacity(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_vault_capacity_info, + codec: DcoCodec( + decodeSuccessData: dco_decode_vault_capacity_info, decodeErrorData: null, ), constMeta: kCrateApiEvfsVaultCapacityConstMeta, @@ -1568,21 +1478,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 37, - port: port_, - ); + var arg0 = + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + return wire.wire__crate__api__evfs__vault_close(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultCloseConstMeta, argValues: [handle], @@ -1604,22 +1508,22 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(path, serializer); - sse_encode_list_prim_u_8_loose(key, serializer); - sse_encode_String(algorithm, serializer); - sse_encode_u_64(capacityBytes, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 38, - port: port_, + var arg0 = cst_encode_String(path); + var arg1 = cst_encode_list_prim_u_8_loose(key); + var arg2 = cst_encode_String(algorithm); + var arg3 = cst_encode_u_64(capacityBytes); + return wire.wire__crate__api__evfs__vault_create( + port_, + arg0, + arg1, + arg2, + arg3, ); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle, - decodeErrorData: sse_decode_crypto_error, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultCreateConstMeta, argValues: [path, key, algorithm, capacityBytes], @@ -1640,21 +1544,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 39, - port: port_, - ); + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + return wire.wire__crate__api__evfs__vault_defragment(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_defrag_result, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_defrag_result, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultDefragmentConstMeta, argValues: [handle], @@ -1674,22 +1572,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - sse_encode_String(name, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 40, - port: port_, - ); + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + var arg1 = cst_encode_String(name); + return wire.wire__crate__api__evfs__vault_delete(port_, arg0, arg1); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultDeleteConstMeta, argValues: [handle, name], @@ -1710,20 +1602,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 41, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + return wire.wire__crate__api__evfs__vault_health(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_vault_health_info, + codec: DcoCodec( + decodeSuccessData: dco_decode_vault_health_info, decodeErrorData: null, ), constMeta: kCrateApiEvfsVaultHealthConstMeta, @@ -1741,20 +1627,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 42, - port: port_, - ); + var arg0 = + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + return wire.wire__crate__api__evfs__vault_list(port_, arg0); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_String, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_String, decodeErrorData: null, ), constMeta: kCrateApiEvfsVaultListConstMeta, @@ -1775,20 +1655,14 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_String(path, serializer); - sse_encode_list_prim_u_8_loose(key, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 43, - port: port_, - ); + var arg0 = cst_encode_String(path); + var arg1 = cst_encode_list_prim_u_8_loose(key); + return wire.wire__crate__api__evfs__vault_open(port_, arg0, arg1); }, - codec: SseCodec( + codec: DcoCodec( decodeSuccessData: - sse_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle, - decodeErrorData: sse_decode_crypto_error, + dco_decode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultOpenConstMeta, argValues: [path, key], @@ -1808,22 +1682,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - sse_encode_String(name, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 44, - port: port_, - ); + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + var arg1 = cst_encode_String(name); + return wire.wire__crate__api__evfs__vault_read(port_, arg0, arg1); }, - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultReadConstMeta, argValues: [handle, name], @@ -1848,25 +1716,26 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - sse_encode_String(name, serializer); - sse_encode_bool(verifyChecksum, serializer); - sse_encode_StreamSink_list_prim_u_8_strict_Sse(sink, serializer); - sse_encode_StreamSink_f_64_Sse(onProgress, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 45, - port: port_, + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + var arg1 = cst_encode_String(name); + var arg2 = cst_encode_bool(verifyChecksum); + var arg3 = cst_encode_StreamSink_list_prim_u_8_strict_Dco(sink); + var arg4 = cst_encode_StreamSink_f_64_Dco(onProgress); + return wire.wire__crate__api__evfs__vault_read_stream( + port_, + arg0, + arg1, + arg2, + arg3, + arg4, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultReadStreamConstMeta, argValues: [handle, name, verifyChecksum, sink, onProgress], @@ -1889,22 +1758,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - sse_encode_u_64(newCapacity, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 46, - port: port_, - ); + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + var arg1 = cst_encode_u_64(newCapacity); + return wire.wire__crate__api__evfs__vault_resize(port_, arg0, arg1); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultResizeConstMeta, argValues: [handle, newCapacity], @@ -1928,27 +1791,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { return handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - sse_encode_String(name, serializer); - sse_encode_list_prim_u_8_loose(data, serializer); - sse_encode_opt_box_autoadd_compression_config( - compression, - serializer, - ); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 47, - port: port_, + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + var arg1 = cst_encode_String(name); + var arg2 = cst_encode_list_prim_u_8_loose(data); + var arg3 = cst_encode_opt_box_autoadd_compression_config(compression); + return wire.wire__crate__api__evfs__vault_write( + port_, + arg0, + arg1, + arg2, + arg3, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultWriteConstMeta, argValues: [handle, name, data, compression], @@ -1973,24 +1833,24 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { handler.executeNormal( NormalTask( callFfi: (port_) { - final serializer = SseSerializer(generalizedFrbRustBinding); - sse_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - handle, - serializer, - ); - sse_encode_String(name, serializer); - sse_encode_String(filePath, serializer); - sse_encode_StreamSink_f_64_Sse(onProgress, serializer); - pdeCallFfi( - generalizedFrbRustBinding, - serializer, - funcId: 48, - port: port_, + var arg0 = + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + handle, + ); + var arg1 = cst_encode_String(name); + var arg2 = cst_encode_String(filePath); + var arg3 = cst_encode_StreamSink_f_64_Dco(onProgress); + return wire.wire__crate__api__evfs__vault_write_file( + port_, + arg0, + arg1, + arg2, + arg3, ); }, - codec: SseCodec( - decodeSuccessData: sse_decode_unit, - decodeErrorData: sse_decode_crypto_error, + codec: DcoCodec( + decodeSuccessData: dco_decode_unit, + decodeErrorData: dco_decode_crypto_error, ), constMeta: kCrateApiEvfsVaultWriteFileConstMeta, argValues: [handle, name, filePath, onProgress], @@ -2127,13 +1987,13 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - RustStreamSink dco_decode_StreamSink_f_64_Sse(dynamic raw) { + RustStreamSink dco_decode_StreamSink_f_64_Dco(dynamic raw) { // Codec=Dco (DartCObject based), see doc to use other codecs throw UnimplementedError(); } @protected - RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Dco( dynamic raw, ) { // Codec=Dco (DartCObject based), see doc to use other codecs @@ -2486,7 +2346,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - RustStreamSink sse_decode_StreamSink_f_64_Sse( + RustStreamSink sse_decode_StreamSink_f_64_Dco( SseDeserializer deserializer, ) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -2494,7 +2354,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Dco( SseDeserializer deserializer, ) { // Codec=Sse (Serialization based), see doc to use other codecs @@ -2770,6 +2630,154 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { ); } + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as CipherHandleImpl).frbInternalCstEncode(move: true); + } + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as HasherHandleImpl).frbInternalCstEncode(move: true); + } + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as VaultHandleImpl).frbInternalCstEncode(move: true); + } + + @protected + int + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as VaultHandleImpl).frbInternalCstEncode(move: false); + } + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as CipherHandleImpl).frbInternalCstEncode(move: false); + } + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as HasherHandleImpl).frbInternalCstEncode(move: false); + } + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as VaultHandleImpl).frbInternalCstEncode(move: false); + } + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as CipherHandleImpl).frbInternalCstEncode(); + } + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as HasherHandleImpl).frbInternalCstEncode(); + } + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + // ignore: invalid_use_of_internal_member + return (raw as VaultHandleImpl).frbInternalCstEncode(); + } + + @protected + int cst_encode_argon_2_preset(Argon2Preset raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_i_32(raw.index); + } + + @protected + bool cst_encode_bool(bool raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + + @protected + int cst_encode_compression_algorithm(CompressionAlgorithm raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_i_32(raw.index); + } + + @protected + double cst_encode_f_64(double raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + + @protected + int cst_encode_i_32(int raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + + @protected + int cst_encode_u_32(int raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + + @protected + int cst_encode_u_8(int raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + + @protected + void cst_encode_unit(void raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + @protected void sse_encode_AnyhowException( AnyhowException self, @@ -2910,16 +2918,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_StreamSink_f_64_Sse( + void sse_encode_StreamSink_f_64_Dco( RustStreamSink self, SseSerializer serializer, ) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String( self.setupAndSerialize( - codec: SseCodec( - decodeSuccessData: sse_decode_f_64, - decodeErrorData: sse_decode_AnyhowException, + codec: DcoCodec( + decodeSuccessData: dco_decode_f_64, + decodeErrorData: dco_decode_AnyhowException, ), ), serializer, @@ -2927,16 +2935,16 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi { } @protected - void sse_encode_StreamSink_list_prim_u_8_strict_Sse( + void sse_encode_StreamSink_list_prim_u_8_strict_Dco( RustStreamSink self, SseSerializer serializer, ) { // Codec=Sse (Serialization based), see doc to use other codecs sse_encode_String( self.setupAndSerialize( - codec: SseCodec( - decodeSuccessData: sse_decode_list_prim_u_8_strict, - decodeErrorData: sse_decode_AnyhowException, + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_AnyhowException, ), ), serializer, diff --git a/lib/src/rust/frb_generated.io.dart b/lib/src/rust/frb_generated.io.dart index 07a4576..497e30e 100644 --- a/lib/src/rust/frb_generated.io.dart +++ b/lib/src/rust/frb_generated.io.dart @@ -104,10 +104,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ); @protected - RustStreamSink dco_decode_StreamSink_f_64_Sse(dynamic raw); + RustStreamSink dco_decode_StreamSink_f_64_Dco(dynamic raw); @protected - RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Dco( dynamic raw, ); @@ -247,12 +247,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ); @protected - RustStreamSink sse_decode_StreamSink_f_64_Sse( + RustStreamSink sse_decode_StreamSink_f_64_Dco( SseDeserializer deserializer, ); @protected - RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Dco( SseDeserializer deserializer, ); @@ -336,6 +336,356 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected VaultHealthInfo sse_decode_vault_health_info(SseDeserializer deserializer); + @protected + ffi.Pointer cst_encode_AnyhowException( + AnyhowException raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + throw UnimplementedError(); + } + + @protected + ffi.Pointer cst_encode_StreamSink_f_64_Dco( + RustStreamSink raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_String( + raw.setupAndSerialize( + codec: DcoCodec( + decodeSuccessData: dco_decode_f_64, + decodeErrorData: dco_decode_AnyhowException, + ), + ), + ); + } + + @protected + ffi.Pointer + cst_encode_StreamSink_list_prim_u_8_strict_Dco( + RustStreamSink raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_String( + raw.setupAndSerialize( + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_AnyhowException, + ), + ), + ); + } + + @protected + ffi.Pointer cst_encode_String(String raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_list_prim_u_8_strict(utf8.encoder.convert(raw)); + } + + @protected + ffi.Pointer + cst_encode_box_autoadd_compression_config(CompressionConfig raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ptr = wire.cst_new_box_autoadd_compression_config(); + cst_api_fill_to_wire_compression_config(raw, ptr.ref); + return ptr; + } + + @protected + ffi.Pointer cst_encode_box_autoadd_i_32(int raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return wire.cst_new_box_autoadd_i_32(cst_encode_i_32(raw)); + } + + @protected + ffi.Pointer cst_encode_list_String(List raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ans = wire.cst_new_list_String(raw.length); + for (var i = 0; i < raw.length; ++i) { + ans.ref.ptr[i] = cst_encode_String(raw[i]); + } + return ans; + } + + @protected + ffi.Pointer cst_encode_list_prim_u_8_loose( + List raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ans = wire.cst_new_list_prim_u_8_loose(raw.length); + ans.ref.ptr.asTypedList(raw.length).setAll(0, raw); + return ans; + } + + @protected + ffi.Pointer cst_encode_list_prim_u_8_strict( + Uint8List raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + final ans = wire.cst_new_list_prim_u_8_strict(raw.length); + ans.ref.ptr.asTypedList(raw.length).setAll(0, raw); + return ans; + } + + @protected + ffi.Pointer + cst_encode_opt_box_autoadd_compression_config(CompressionConfig? raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw == null + ? ffi.nullptr + : cst_encode_box_autoadd_compression_config(raw); + } + + @protected + ffi.Pointer cst_encode_opt_box_autoadd_i_32(int? raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw == null ? ffi.nullptr : cst_encode_box_autoadd_i_32(raw); + } + + @protected + ffi.Pointer + cst_encode_opt_list_prim_u_8_strict(Uint8List? raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw == null ? ffi.nullptr : cst_encode_list_prim_u_8_strict(raw); + } + + @protected + int cst_encode_u_64(BigInt raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw.toSigned(64).toInt(); + } + + @protected + int cst_encode_usize(BigInt raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw.toSigned(64).toInt(); + } + + @protected + void cst_api_fill_to_wire_box_autoadd_compression_config( + CompressionConfig apiObj, + ffi.Pointer wireObj, + ) { + cst_api_fill_to_wire_compression_config(apiObj, wireObj.ref); + } + + @protected + void cst_api_fill_to_wire_compression_config( + CompressionConfig apiObj, + wire_cst_compression_config wireObj, + ) { + wireObj.algorithm = cst_encode_compression_algorithm(apiObj.algorithm); + wireObj.level = cst_encode_opt_box_autoadd_i_32(apiObj.level); + } + + @protected + void cst_api_fill_to_wire_crypto_error( + CryptoError apiObj, + wire_cst_crypto_error wireObj, + ) { + if (apiObj is CryptoError_InvalidKeyLength) { + var pre_expected = cst_encode_usize(apiObj.expected); + var pre_actual = cst_encode_usize(apiObj.actual); + wireObj.tag = 0; + wireObj.kind.InvalidKeyLength.expected = pre_expected; + wireObj.kind.InvalidKeyLength.actual = pre_actual; + return; + } + if (apiObj is CryptoError_InvalidNonce) { + wireObj.tag = 1; + return; + } + if (apiObj is CryptoError_EncryptionFailed) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 2; + wireObj.kind.EncryptionFailed.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_DecryptionFailed) { + wireObj.tag = 3; + return; + } + if (apiObj is CryptoError_HashingFailed) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 4; + wireObj.kind.HashingFailed.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_KdfFailed) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 5; + wireObj.kind.KdfFailed.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_IoError) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 6; + wireObj.kind.IoError.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_InvalidParameter) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 7; + wireObj.kind.InvalidParameter.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_CompressionFailed) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 8; + wireObj.kind.CompressionFailed.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_AuthenticationFailed) { + wireObj.tag = 9; + return; + } + if (apiObj is CryptoError_VaultFull) { + var pre_needed = cst_encode_u_64(apiObj.needed); + var pre_available = cst_encode_u_64(apiObj.available); + wireObj.tag = 10; + wireObj.kind.VaultFull.needed = pre_needed; + wireObj.kind.VaultFull.available = pre_available; + return; + } + if (apiObj is CryptoError_VaultLocked) { + wireObj.tag = 11; + return; + } + if (apiObj is CryptoError_SegmentNotFound) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 12; + wireObj.kind.SegmentNotFound.field0 = pre_field0; + return; + } + if (apiObj is CryptoError_VaultCorrupted) { + var pre_field0 = cst_encode_String(apiObj.field0); + wireObj.tag = 13; + wireObj.kind.VaultCorrupted.field0 = pre_field0; + return; + } + } + + @protected + void cst_api_fill_to_wire_defrag_result( + DefragResult apiObj, + wire_cst_defrag_result wireObj, + ) { + wireObj.segments_moved = cst_encode_u_32(apiObj.segmentsMoved); + wireObj.bytes_reclaimed = cst_encode_u_64(apiObj.bytesReclaimed); + wireObj.free_regions_before = cst_encode_u_32(apiObj.freeRegionsBefore); + } + + @protected + void cst_api_fill_to_wire_vault_capacity_info( + VaultCapacityInfo apiObj, + wire_cst_vault_capacity_info wireObj, + ) { + wireObj.total_bytes = cst_encode_u_64(apiObj.totalBytes); + wireObj.used_bytes = cst_encode_u_64(apiObj.usedBytes); + wireObj.free_list_bytes = cst_encode_u_64(apiObj.freeListBytes); + wireObj.unallocated_bytes = cst_encode_u_64(apiObj.unallocatedBytes); + wireObj.segment_count = cst_encode_usize(apiObj.segmentCount); + } + + @protected + void cst_api_fill_to_wire_vault_health_info( + VaultHealthInfo apiObj, + wire_cst_vault_health_info wireObj, + ) { + wireObj.total_bytes = cst_encode_u_64(apiObj.totalBytes); + wireObj.used_bytes = cst_encode_u_64(apiObj.usedBytes); + wireObj.free_list_bytes = cst_encode_u_64(apiObj.freeListBytes); + wireObj.unallocated_bytes = cst_encode_u_64(apiObj.unallocatedBytes); + wireObj.segment_count = cst_encode_u_32(apiObj.segmentCount); + wireObj.free_region_count = cst_encode_u_32(apiObj.freeRegionCount); + wireObj.largest_free_block = cst_encode_u_64(apiObj.largestFreeBlock); + wireObj.fragmentation_ratio = cst_encode_f_64(apiObj.fragmentationRatio); + wireObj.is_consistent = cst_encode_bool(apiObj.isConsistent); + } + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ); + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ); + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ); + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ); + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ); + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ); + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int cst_encode_argon_2_preset(Argon2Preset raw); + + @protected + bool cst_encode_bool(bool raw); + + @protected + int cst_encode_compression_algorithm(CompressionAlgorithm raw); + + @protected + double cst_encode_f_64(double raw); + + @protected + int cst_encode_i_32(int raw); + + @protected + int cst_encode_u_32(int raw); + + @protected + int cst_encode_u_8(int raw); + + @protected + void cst_encode_unit(void raw); + @protected void sse_encode_AnyhowException( AnyhowException self, @@ -413,13 +763,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ); @protected - void sse_encode_StreamSink_f_64_Sse( + void sse_encode_StreamSink_f_64_Dco( RustStreamSink self, SseSerializer serializer, ); @protected - void sse_encode_StreamSink_list_prim_u_8_strict_Sse( + void sse_encode_StreamSink_list_prim_u_8_strict_Dco( RustStreamSink self, SseSerializer serializer, ); @@ -523,6 +873,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { // Section: wire_class +// ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names +// AUTO GENERATED FILE, DO NOT EDIT. +// +// Generated by `package:ffigen`. +// ignore_for_file: type=lint, unused_import + +/// generated by flutter_rust_bridge class RustLibWire implements BaseWire { factory RustLibWire.fromExternalLibrary(ExternalLibrary lib) => RustLibWire(lib.ffiDynamicLibrary); @@ -535,6 +892,1190 @@ class RustLibWire implements BaseWire { RustLibWire(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup; + /// The symbols are looked up with [lookup]. + RustLibWire.fromLookup( + ffi.Pointer Function(String symbolName) lookup, + ) : _lookup = lookup; + + void store_dart_post_cobject(DartPostCObjectFnType ptr) { + return _store_dart_post_cobject(ptr); + } + + late final _store_dart_post_cobjectPtr = + _lookup>( + 'store_dart_post_cobject', + ); + late final _store_dart_post_cobject = _store_dart_post_cobjectPtr + .asFunction(); + + void wire__crate__api__evfs__types__VaultHandle_health(int port_, int that) { + return _wire__crate__api__evfs__types__VaultHandle_health(port_, that); + } + + late final _wire__crate__api__evfs__types__VaultHandle_healthPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__evfs__types__VaultHandle_health', + ); + late final _wire__crate__api__evfs__types__VaultHandle_health = + _wire__crate__api__evfs__types__VaultHandle_healthPtr + .asFunction(); + + void wire__crate__api__hashing__argon2__argon2id_hash( + int port_, + ffi.Pointer password, + int preset, + ) { + return _wire__crate__api__hashing__argon2__argon2id_hash( + port_, + password, + preset, + ); + } + + late final _wire__crate__api__hashing__argon2__argon2id_hashPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Int32, + ) + > + >('frbgen_m_security_wire__crate__api__hashing__argon2__argon2id_hash'); + late final _wire__crate__api__hashing__argon2__argon2id_hash = + _wire__crate__api__hashing__argon2__argon2id_hashPtr + .asFunction< + void Function(int, ffi.Pointer, int) + >(); + + void wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + int port_, + ffi.Pointer password, + ffi.Pointer salt, + int preset, + ) { + return _wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + port_, + password, + salt, + preset, + ); + } + + late final _wire__crate__api__hashing__argon2__argon2id_hash_with_saltPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ffi.Int32, + ) + > + >( + 'frbgen_m_security_wire__crate__api__hashing__argon2__argon2id_hash_with_salt', + ); + late final _wire__crate__api__hashing__argon2__argon2id_hash_with_salt = + _wire__crate__api__hashing__argon2__argon2id_hash_with_saltPtr + .asFunction< + void Function( + int, + ffi.Pointer, + ffi.Pointer, + int, + ) + >(); + + void wire__crate__api__hashing__argon2__argon2id_verify( + int port_, + ffi.Pointer phc_hash, + ffi.Pointer password, + ) { + return _wire__crate__api__hashing__argon2__argon2id_verify( + port_, + phc_hash, + password, + ); + } + + late final _wire__crate__api__hashing__argon2__argon2id_verifyPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__hashing__argon2__argon2id_verify'); + late final _wire__crate__api__hashing__argon2__argon2id_verify = + _wire__crate__api__hashing__argon2__argon2id_verifyPtr + .asFunction< + void Function( + int, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__hashing__blake3_hash( + int port_, + ffi.Pointer data, + ) { + return _wire__crate__api__hashing__blake3_hash(port_, data); + } + + late final _wire__crate__api__hashing__blake3_hashPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__hashing__blake3_hash'); + late final _wire__crate__api__hashing__blake3_hash = + _wire__crate__api__hashing__blake3_hashPtr + .asFunction< + void Function(int, ffi.Pointer) + >(); + + void wire__crate__api__compression__compress( + int port_, + ffi.Pointer data, + ffi.Pointer config, + ) { + return _wire__crate__api__compression__compress(port_, data, config); + } + + late final _wire__crate__api__compression__compressPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__compression__compress'); + late final _wire__crate__api__compression__compress = + _wire__crate__api__compression__compressPtr + .asFunction< + void Function( + int, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__compression__compression_algorithm_from_u8( + int port_, + int byte, + ) { + return _wire__crate__api__compression__compression_algorithm_from_u8( + port_, + byte, + ); + } + + late final _wire__crate__api__compression__compression_algorithm_from_u8Ptr = + _lookup>( + 'frbgen_m_security_wire__crate__api__compression__compression_algorithm_from_u8', + ); + late final _wire__crate__api__compression__compression_algorithm_from_u8 = + _wire__crate__api__compression__compression_algorithm_from_u8Ptr + .asFunction(); + + void wire__crate__api__compression__compression_algorithm_to_u8( + int port_, + int that, + ) { + return _wire__crate__api__compression__compression_algorithm_to_u8( + port_, + that, + ); + } + + late final _wire__crate__api__compression__compression_algorithm_to_u8Ptr = + _lookup>( + 'frbgen_m_security_wire__crate__api__compression__compression_algorithm_to_u8', + ); + late final _wire__crate__api__compression__compression_algorithm_to_u8 = + _wire__crate__api__compression__compression_algorithm_to_u8Ptr + .asFunction(); + + void wire__crate__api__encryption__create_aes256_gcm( + int port_, + ffi.Pointer key, + ) { + return _wire__crate__api__encryption__create_aes256_gcm(port_, key); + } + + late final _wire__crate__api__encryption__create_aes256_gcmPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__encryption__create_aes256_gcm'); + late final _wire__crate__api__encryption__create_aes256_gcm = + _wire__crate__api__encryption__create_aes256_gcmPtr + .asFunction< + void Function(int, ffi.Pointer) + >(); + + void wire__crate__api__hashing__create_blake3(int port_) { + return _wire__crate__api__hashing__create_blake3(port_); + } + + late final _wire__crate__api__hashing__create_blake3Ptr = + _lookup>( + 'frbgen_m_security_wire__crate__api__hashing__create_blake3', + ); + late final _wire__crate__api__hashing__create_blake3 = + _wire__crate__api__hashing__create_blake3Ptr + .asFunction(); + + void wire__crate__api__encryption__create_chacha20_poly1305( + int port_, + ffi.Pointer key, + ) { + return _wire__crate__api__encryption__create_chacha20_poly1305(port_, key); + } + + late final _wire__crate__api__encryption__create_chacha20_poly1305Ptr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ) + > + >( + 'frbgen_m_security_wire__crate__api__encryption__create_chacha20_poly1305', + ); + late final _wire__crate__api__encryption__create_chacha20_poly1305 = + _wire__crate__api__encryption__create_chacha20_poly1305Ptr + .asFunction< + void Function(int, ffi.Pointer) + >(); + + void wire__crate__api__encryption__create_noop_encryption(int port_) { + return _wire__crate__api__encryption__create_noop_encryption(port_); + } + + late final _wire__crate__api__encryption__create_noop_encryptionPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__encryption__create_noop_encryption', + ); + late final _wire__crate__api__encryption__create_noop_encryption = + _wire__crate__api__encryption__create_noop_encryptionPtr + .asFunction(); + + void wire__crate__api__hashing__create_sha3(int port_) { + return _wire__crate__api__hashing__create_sha3(port_); + } + + late final _wire__crate__api__hashing__create_sha3Ptr = + _lookup>( + 'frbgen_m_security_wire__crate__api__hashing__create_sha3', + ); + late final _wire__crate__api__hashing__create_sha3 = + _wire__crate__api__hashing__create_sha3Ptr + .asFunction(); + + void wire__crate__api__compression__decompress( + int port_, + ffi.Pointer data, + int algorithm, + ) { + return _wire__crate__api__compression__decompress(port_, data, algorithm); + } + + late final _wire__crate__api__compression__decompressPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Int32, + ) + > + >('frbgen_m_security_wire__crate__api__compression__decompress'); + late final _wire__crate__api__compression__decompress = + _wire__crate__api__compression__decompressPtr + .asFunction< + void Function(int, ffi.Pointer, int) + >(); + + void wire__crate__api__encryption__decrypt( + int port_, + int cipher, + ffi.Pointer ciphertext, + ffi.Pointer aad, + ) { + return _wire__crate__api__encryption__decrypt( + port_, + cipher, + ciphertext, + aad, + ); + } + + late final _wire__crate__api__encryption__decryptPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__encryption__decrypt'); + late final _wire__crate__api__encryption__decrypt = + _wire__crate__api__encryption__decryptPtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__encryption__encrypt( + int port_, + int cipher, + ffi.Pointer plaintext, + ffi.Pointer aad, + ) { + return _wire__crate__api__encryption__encrypt( + port_, + cipher, + plaintext, + aad, + ); + } + + late final _wire__crate__api__encryption__encryptPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__encryption__encrypt'); + late final _wire__crate__api__encryption__encrypt = + _wire__crate__api__encryption__encryptPtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__encryption__encryption_algorithm_id( + int port_, + int cipher, + ) { + return _wire__crate__api__encryption__encryption_algorithm_id( + port_, + cipher, + ); + } + + late final _wire__crate__api__encryption__encryption_algorithm_idPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__encryption__encryption_algorithm_id', + ); + late final _wire__crate__api__encryption__encryption_algorithm_id = + _wire__crate__api__encryption__encryption_algorithm_idPtr + .asFunction(); + + void wire__crate__api__encryption__generate_aes256_gcm_key(int port_) { + return _wire__crate__api__encryption__generate_aes256_gcm_key(port_); + } + + late final _wire__crate__api__encryption__generate_aes256_gcm_keyPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__encryption__generate_aes256_gcm_key', + ); + late final _wire__crate__api__encryption__generate_aes256_gcm_key = + _wire__crate__api__encryption__generate_aes256_gcm_keyPtr + .asFunction(); + + void wire__crate__api__encryption__aes_gcm__generate_aes_key(int port_) { + return _wire__crate__api__encryption__aes_gcm__generate_aes_key(port_); + } + + late final _wire__crate__api__encryption__aes_gcm__generate_aes_keyPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__encryption__aes_gcm__generate_aes_key', + ); + late final _wire__crate__api__encryption__aes_gcm__generate_aes_key = + _wire__crate__api__encryption__aes_gcm__generate_aes_keyPtr + .asFunction(); + + void wire__crate__api__encryption__generate_chacha20_poly1305_key(int port_) { + return _wire__crate__api__encryption__generate_chacha20_poly1305_key(port_); + } + + late final _wire__crate__api__encryption__generate_chacha20_poly1305_keyPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__encryption__generate_chacha20_poly1305_key', + ); + late final _wire__crate__api__encryption__generate_chacha20_poly1305_key = + _wire__crate__api__encryption__generate_chacha20_poly1305_keyPtr + .asFunction(); + + void wire__crate__api__encryption__chacha20__generate_chacha_key(int port_) { + return _wire__crate__api__encryption__chacha20__generate_chacha_key(port_); + } + + late final _wire__crate__api__encryption__chacha20__generate_chacha_keyPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__encryption__chacha20__generate_chacha_key', + ); + late final _wire__crate__api__encryption__chacha20__generate_chacha_key = + _wire__crate__api__encryption__chacha20__generate_chacha_keyPtr + .asFunction(); + + void wire__crate__api__hashing__hasher_algorithm_id(int port_, int handle) { + return _wire__crate__api__hashing__hasher_algorithm_id(port_, handle); + } + + late final _wire__crate__api__hashing__hasher_algorithm_idPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__hashing__hasher_algorithm_id', + ); + late final _wire__crate__api__hashing__hasher_algorithm_id = + _wire__crate__api__hashing__hasher_algorithm_idPtr + .asFunction(); + + void wire__crate__api__hashing__hasher_finalize(int port_, int handle) { + return _wire__crate__api__hashing__hasher_finalize(port_, handle); + } + + late final _wire__crate__api__hashing__hasher_finalizePtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__hashing__hasher_finalize', + ); + late final _wire__crate__api__hashing__hasher_finalize = + _wire__crate__api__hashing__hasher_finalizePtr + .asFunction(); + + void wire__crate__api__hashing__hasher_reset(int port_, int handle) { + return _wire__crate__api__hashing__hasher_reset(port_, handle); + } + + late final _wire__crate__api__hashing__hasher_resetPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__hashing__hasher_reset', + ); + late final _wire__crate__api__hashing__hasher_reset = + _wire__crate__api__hashing__hasher_resetPtr + .asFunction(); + + void wire__crate__api__hashing__hasher_update( + int port_, + int handle, + ffi.Pointer data, + ) { + return _wire__crate__api__hashing__hasher_update(port_, handle, data); + } + + late final _wire__crate__api__hashing__hasher_updatePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__hashing__hasher_update'); + late final _wire__crate__api__hashing__hasher_update = + _wire__crate__api__hashing__hasher_updatePtr + .asFunction< + void Function(int, int, ffi.Pointer) + >(); + + WireSyncRust2DartDco wire__crate__api__kdf__hkdf__hkdf_derive( + ffi.Pointer ikm, + ffi.Pointer salt, + ffi.Pointer info, + int output_len, + ) { + return _wire__crate__api__kdf__hkdf__hkdf_derive( + ikm, + salt, + info, + output_len, + ); + } + + late final _wire__crate__api__kdf__hkdf__hkdf_derivePtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartDco Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UintPtr, + ) + > + >('frbgen_m_security_wire__crate__api__kdf__hkdf__hkdf_derive'); + late final _wire__crate__api__kdf__hkdf__hkdf_derive = + _wire__crate__api__kdf__hkdf__hkdf_derivePtr + .asFunction< + WireSyncRust2DartDco Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ) + >(); + + void wire__crate__api__kdf__hkdf__hkdf_expand( + int port_, + ffi.Pointer prk, + ffi.Pointer info, + int output_len, + ) { + return _wire__crate__api__kdf__hkdf__hkdf_expand( + port_, + prk, + info, + output_len, + ); + } + + late final _wire__crate__api__kdf__hkdf__hkdf_expandPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ffi.UintPtr, + ) + > + >('frbgen_m_security_wire__crate__api__kdf__hkdf__hkdf_expand'); + late final _wire__crate__api__kdf__hkdf__hkdf_expand = + _wire__crate__api__kdf__hkdf__hkdf_expandPtr + .asFunction< + void Function( + int, + ffi.Pointer, + ffi.Pointer, + int, + ) + >(); + + WireSyncRust2DartDco wire__crate__api__kdf__hkdf__hkdf_extract( + ffi.Pointer ikm, + ffi.Pointer salt, + ) { + return _wire__crate__api__kdf__hkdf__hkdf_extract(ikm, salt); + } + + late final _wire__crate__api__kdf__hkdf__hkdf_extractPtr = + _lookup< + ffi.NativeFunction< + WireSyncRust2DartDco Function( + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__kdf__hkdf__hkdf_extract'); + late final _wire__crate__api__kdf__hkdf__hkdf_extract = + _wire__crate__api__kdf__hkdf__hkdf_extractPtr + .asFunction< + WireSyncRust2DartDco Function( + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__hashing__sha3_hash( + int port_, + ffi.Pointer data, + ) { + return _wire__crate__api__hashing__sha3_hash(port_, data); + } + + late final _wire__crate__api__hashing__sha3_hashPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__hashing__sha3_hash'); + late final _wire__crate__api__hashing__sha3_hash = + _wire__crate__api__hashing__sha3_hashPtr + .asFunction< + void Function(int, ffi.Pointer) + >(); + + void wire__crate__api__compression__should_skip_compression( + int port_, + ffi.Pointer file_path, + ) { + return _wire__crate__api__compression__should_skip_compression( + port_, + file_path, + ); + } + + late final _wire__crate__api__compression__should_skip_compressionPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ) + > + >( + 'frbgen_m_security_wire__crate__api__compression__should_skip_compression', + ); + late final _wire__crate__api__compression__should_skip_compression = + _wire__crate__api__compression__should_skip_compressionPtr + .asFunction< + void Function(int, ffi.Pointer) + >(); + + void wire__crate__api__streaming__stream_compress_encrypt_file( + int port_, + int cipher, + ffi.Pointer compression, + ffi.Pointer input_path, + ffi.Pointer output_path, + ffi.Pointer progress_sink, + ) { + return _wire__crate__api__streaming__stream_compress_encrypt_file( + port_, + cipher, + compression, + input_path, + output_path, + progress_sink, + ); + } + + late final _wire__crate__api__streaming__stream_compress_encrypt_filePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + > + >( + 'frbgen_m_security_wire__crate__api__streaming__stream_compress_encrypt_file', + ); + late final _wire__crate__api__streaming__stream_compress_encrypt_file = + _wire__crate__api__streaming__stream_compress_encrypt_filePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__streaming__stream_decrypt_decompress_file( + int port_, + int cipher, + ffi.Pointer input_path, + ffi.Pointer output_path, + ffi.Pointer progress_sink, + ) { + return _wire__crate__api__streaming__stream_decrypt_decompress_file( + port_, + cipher, + input_path, + output_path, + progress_sink, + ); + } + + late final _wire__crate__api__streaming__stream_decrypt_decompress_filePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + > + >( + 'frbgen_m_security_wire__crate__api__streaming__stream_decrypt_decompress_file', + ); + late final _wire__crate__api__streaming__stream_decrypt_decompress_file = + _wire__crate__api__streaming__stream_decrypt_decompress_filePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__streaming__stream_decrypt_file( + int port_, + int cipher, + ffi.Pointer input_path, + ffi.Pointer output_path, + ffi.Pointer progress_sink, + ) { + return _wire__crate__api__streaming__stream_decrypt_file( + port_, + cipher, + input_path, + output_path, + progress_sink, + ); + } + + late final _wire__crate__api__streaming__stream_decrypt_filePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__streaming__stream_decrypt_file'); + late final _wire__crate__api__streaming__stream_decrypt_file = + _wire__crate__api__streaming__stream_decrypt_filePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__streaming__stream_encrypt_file( + int port_, + int cipher, + ffi.Pointer input_path, + ffi.Pointer output_path, + ffi.Pointer progress_sink, + ) { + return _wire__crate__api__streaming__stream_encrypt_file( + port_, + cipher, + input_path, + output_path, + progress_sink, + ); + } + + late final _wire__crate__api__streaming__stream_encrypt_filePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__streaming__stream_encrypt_file'); + late final _wire__crate__api__streaming__stream_encrypt_file = + _wire__crate__api__streaming__stream_encrypt_filePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__streaming__stream_hash_file( + int port_, + int hasher, + ffi.Pointer file_path, + ffi.Pointer progress_sink, + ) { + return _wire__crate__api__streaming__stream_hash_file( + port_, + hasher, + file_path, + progress_sink, + ); + } + + late final _wire__crate__api__streaming__stream_hash_filePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__streaming__stream_hash_file'); + late final _wire__crate__api__streaming__stream_hash_file = + _wire__crate__api__streaming__stream_hash_filePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__evfs__vault_capacity(int port_, int handle) { + return _wire__crate__api__evfs__vault_capacity(port_, handle); + } + + late final _wire__crate__api__evfs__vault_capacityPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__evfs__vault_capacity', + ); + late final _wire__crate__api__evfs__vault_capacity = + _wire__crate__api__evfs__vault_capacityPtr + .asFunction(); + + void wire__crate__api__evfs__vault_close(int port_, int handle) { + return _wire__crate__api__evfs__vault_close(port_, handle); + } + + late final _wire__crate__api__evfs__vault_closePtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__evfs__vault_close', + ); + late final _wire__crate__api__evfs__vault_close = + _wire__crate__api__evfs__vault_closePtr + .asFunction(); + + void wire__crate__api__evfs__vault_create( + int port_, + ffi.Pointer path, + ffi.Pointer key, + ffi.Pointer algorithm, + int capacity_bytes, + ) { + return _wire__crate__api__evfs__vault_create( + port_, + path, + key, + algorithm, + capacity_bytes, + ); + } + + late final _wire__crate__api__evfs__vault_createPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint64, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_create'); + late final _wire__crate__api__evfs__vault_create = + _wire__crate__api__evfs__vault_createPtr + .asFunction< + void Function( + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ) + >(); + + void wire__crate__api__evfs__vault_defragment(int port_, int handle) { + return _wire__crate__api__evfs__vault_defragment(port_, handle); + } + + late final _wire__crate__api__evfs__vault_defragmentPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__evfs__vault_defragment', + ); + late final _wire__crate__api__evfs__vault_defragment = + _wire__crate__api__evfs__vault_defragmentPtr + .asFunction(); + + void wire__crate__api__evfs__vault_delete( + int port_, + int handle, + ffi.Pointer name, + ) { + return _wire__crate__api__evfs__vault_delete(port_, handle, name); + } + + late final _wire__crate__api__evfs__vault_deletePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_delete'); + late final _wire__crate__api__evfs__vault_delete = + _wire__crate__api__evfs__vault_deletePtr + .asFunction< + void Function(int, int, ffi.Pointer) + >(); + + void wire__crate__api__evfs__vault_health(int port_, int handle) { + return _wire__crate__api__evfs__vault_health(port_, handle); + } + + late final _wire__crate__api__evfs__vault_healthPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__evfs__vault_health', + ); + late final _wire__crate__api__evfs__vault_health = + _wire__crate__api__evfs__vault_healthPtr + .asFunction(); + + void wire__crate__api__evfs__vault_list(int port_, int handle) { + return _wire__crate__api__evfs__vault_list(port_, handle); + } + + late final _wire__crate__api__evfs__vault_listPtr = + _lookup>( + 'frbgen_m_security_wire__crate__api__evfs__vault_list', + ); + late final _wire__crate__api__evfs__vault_list = + _wire__crate__api__evfs__vault_listPtr + .asFunction(); + + void wire__crate__api__evfs__vault_open( + int port_, + ffi.Pointer path, + ffi.Pointer key, + ) { + return _wire__crate__api__evfs__vault_open(port_, path, key); + } + + late final _wire__crate__api__evfs__vault_openPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_open'); + late final _wire__crate__api__evfs__vault_open = + _wire__crate__api__evfs__vault_openPtr + .asFunction< + void Function( + int, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__evfs__vault_read( + int port_, + int handle, + ffi.Pointer name, + ) { + return _wire__crate__api__evfs__vault_read(port_, handle, name); + } + + late final _wire__crate__api__evfs__vault_readPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_read'); + late final _wire__crate__api__evfs__vault_read = + _wire__crate__api__evfs__vault_readPtr + .asFunction< + void Function(int, int, ffi.Pointer) + >(); + + void wire__crate__api__evfs__vault_read_stream( + int port_, + int handle, + ffi.Pointer name, + bool verify_checksum, + ffi.Pointer sink, + ffi.Pointer on_progress, + ) { + return _wire__crate__api__evfs__vault_read_stream( + port_, + handle, + name, + verify_checksum, + sink, + on_progress, + ); + } + + late final _wire__crate__api__evfs__vault_read_streamPtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Bool, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_read_stream'); + late final _wire__crate__api__evfs__vault_read_stream = + _wire__crate__api__evfs__vault_read_streamPtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + bool, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__evfs__vault_resize( + int port_, + int handle, + int new_capacity, + ) { + return _wire__crate__api__evfs__vault_resize(port_, handle, new_capacity); + } + + late final _wire__crate__api__evfs__vault_resizePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Int64, ffi.UintPtr, ffi.Uint64) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_resize'); + late final _wire__crate__api__evfs__vault_resize = + _wire__crate__api__evfs__vault_resizePtr + .asFunction(); + + void wire__crate__api__evfs__vault_write( + int port_, + int handle, + ffi.Pointer name, + ffi.Pointer data, + ffi.Pointer compression, + ) { + return _wire__crate__api__evfs__vault_write( + port_, + handle, + name, + data, + compression, + ); + } + + late final _wire__crate__api__evfs__vault_writePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_write'); + late final _wire__crate__api__evfs__vault_write = + _wire__crate__api__evfs__vault_writePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + >(); + + void wire__crate__api__evfs__vault_write_file( + int port_, + int handle, + ffi.Pointer name, + ffi.Pointer file_path, + ffi.Pointer on_progress, + ) { + return _wire__crate__api__evfs__vault_write_file( + port_, + handle, + name, + file_path, + on_progress, + ); + } + + late final _wire__crate__api__evfs__vault_write_filePtr = + _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int64, + ffi.UintPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + > + >('frbgen_m_security_wire__crate__api__evfs__vault_write_file'); + late final _wire__crate__api__evfs__vault_write_file = + _wire__crate__api__evfs__vault_write_filePtr + .asFunction< + void Function( + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ) + >(); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( ffi.Pointer ptr, @@ -636,4 +2177,291 @@ class RustLibWire implements BaseWire { late final _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle = _rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandlePtr .asFunction)>(); + + ffi.Pointer + cst_new_box_autoadd_compression_config() { + return _cst_new_box_autoadd_compression_config(); + } + + late final _cst_new_box_autoadd_compression_configPtr = + _lookup< + ffi.NativeFunction Function()> + >('frbgen_m_security_cst_new_box_autoadd_compression_config'); + late final _cst_new_box_autoadd_compression_config = + _cst_new_box_autoadd_compression_configPtr + .asFunction Function()>(); + + ffi.Pointer cst_new_box_autoadd_i_32(int value) { + return _cst_new_box_autoadd_i_32(value); + } + + late final _cst_new_box_autoadd_i_32Ptr = + _lookup Function(ffi.Int32)>>( + 'frbgen_m_security_cst_new_box_autoadd_i_32', + ); + late final _cst_new_box_autoadd_i_32 = _cst_new_box_autoadd_i_32Ptr + .asFunction Function(int)>(); + + ffi.Pointer cst_new_list_String(int len) { + return _cst_new_list_String(len); + } + + late final _cst_new_list_StringPtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Int32) + > + >('frbgen_m_security_cst_new_list_String'); + late final _cst_new_list_String = _cst_new_list_StringPtr + .asFunction Function(int)>(); + + ffi.Pointer cst_new_list_prim_u_8_loose( + int len, + ) { + return _cst_new_list_prim_u_8_loose(len); + } + + late final _cst_new_list_prim_u_8_loosePtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Int32) + > + >('frbgen_m_security_cst_new_list_prim_u_8_loose'); + late final _cst_new_list_prim_u_8_loose = _cst_new_list_prim_u_8_loosePtr + .asFunction Function(int)>(); + + ffi.Pointer cst_new_list_prim_u_8_strict( + int len, + ) { + return _cst_new_list_prim_u_8_strict(len); + } + + late final _cst_new_list_prim_u_8_strictPtr = + _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Int32) + > + >('frbgen_m_security_cst_new_list_prim_u_8_strict'); + late final _cst_new_list_prim_u_8_strict = _cst_new_list_prim_u_8_strictPtr + .asFunction Function(int)>(); + + int dummy_method_to_enforce_bundling() { + return _dummy_method_to_enforce_bundling(); + } + + late final _dummy_method_to_enforce_bundlingPtr = + _lookup>( + 'dummy_method_to_enforce_bundling', + ); + late final _dummy_method_to_enforce_bundling = + _dummy_method_to_enforce_bundlingPtr.asFunction(); +} + +typedef DartPort = ffi.Int64; +typedef DartDartPort = int; +typedef DartPostCObjectFnTypeFunction = + ffi.Bool Function(DartPort port_id, ffi.Pointer message); +typedef DartDartPostCObjectFnTypeFunction = + bool Function(DartDartPort port_id, ffi.Pointer message); +typedef DartPostCObjectFnType = + ffi.Pointer>; + +final class wire_cst_list_prim_u_8_strict extends ffi.Struct { + external ffi.Pointer ptr; + + @ffi.Int32() + external int len; +} + +final class wire_cst_list_prim_u_8_loose extends ffi.Struct { + external ffi.Pointer ptr; + + @ffi.Int32() + external int len; +} + +final class wire_cst_compression_config extends ffi.Struct { + @ffi.Int32() + external int algorithm; + + external ffi.Pointer level; +} + +final class wire_cst_list_String extends ffi.Struct { + external ffi.Pointer> ptr; + + @ffi.Int32() + external int len; +} + +final class wire_cst_CryptoError_InvalidKeyLength extends ffi.Struct { + @ffi.UintPtr() + external int expected; + + @ffi.UintPtr() + external int actual; +} + +final class wire_cst_CryptoError_EncryptionFailed extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_HashingFailed extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_KdfFailed extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_IoError extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_InvalidParameter extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_CompressionFailed extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_VaultFull extends ffi.Struct { + @ffi.Uint64() + external int needed; + + @ffi.Uint64() + external int available; +} + +final class wire_cst_CryptoError_SegmentNotFound extends ffi.Struct { + external ffi.Pointer field0; +} + +final class wire_cst_CryptoError_VaultCorrupted extends ffi.Struct { + external ffi.Pointer field0; +} + +final class CryptoErrorKind extends ffi.Union { + external wire_cst_CryptoError_InvalidKeyLength InvalidKeyLength; + + external wire_cst_CryptoError_EncryptionFailed EncryptionFailed; + + external wire_cst_CryptoError_HashingFailed HashingFailed; + + external wire_cst_CryptoError_KdfFailed KdfFailed; + + external wire_cst_CryptoError_IoError IoError; + + external wire_cst_CryptoError_InvalidParameter InvalidParameter; + + external wire_cst_CryptoError_CompressionFailed CompressionFailed; + + external wire_cst_CryptoError_VaultFull VaultFull; + + external wire_cst_CryptoError_SegmentNotFound SegmentNotFound; + + external wire_cst_CryptoError_VaultCorrupted VaultCorrupted; +} + +final class wire_cst_crypto_error extends ffi.Struct { + @ffi.Int32() + external int tag; + + external CryptoErrorKind kind; +} + +final class wire_cst_defrag_result extends ffi.Struct { + @ffi.Uint32() + external int segments_moved; + + @ffi.Uint64() + external int bytes_reclaimed; + + @ffi.Uint32() + external int free_regions_before; +} + +final class wire_cst_vault_capacity_info extends ffi.Struct { + @ffi.Uint64() + external int total_bytes; + + @ffi.Uint64() + external int used_bytes; + + @ffi.Uint64() + external int free_list_bytes; + + @ffi.Uint64() + external int unallocated_bytes; + + @ffi.UintPtr() + external int segment_count; +} + +final class wire_cst_vault_health_info extends ffi.Struct { + @ffi.Uint64() + external int total_bytes; + + @ffi.Uint64() + external int used_bytes; + + @ffi.Uint64() + external int free_list_bytes; + + @ffi.Uint64() + external int unallocated_bytes; + + @ffi.Uint32() + external int segment_count; + + @ffi.Uint32() + external int free_region_count; + + @ffi.Uint64() + external int largest_free_block; + + @ffi.Double() + external double fragmentation_ratio; + + @ffi.Bool() + external bool is_consistent; } + +const int DEFAULT_LEVEL = 3; + +const int MIN_LEVEL = 1; + +const int MAX_LEVEL = 22; + +const int VAULT_VERSION = 1; + +const int VAULT_HEADER_SIZE = 32; + +const int MAX_SEGMENT_NAME_LEN = 255; + +const int MIN_INDEX_PAD_SIZE = 65536; + +const int PRIMARY_INDEX_OFFSET = 32; + +const int MAX_INDEX_PAD_SIZE = 16777216; + +const int VAULT_CHUNK_AAD_SIZE = 17; + +const int FORMAT_VERSION = 1; + +const int HEADER_SIZE = 6; + +const int CHUNK_SIZE = 65536; + +const int NONCE_SIZE = 12; + +const int TAG_SIZE = 16; + +const int ENCRYPTED_CHUNK_SIZE = 65564; + +const int STREAM_VERSION = 1; + +const int STREAM_HEADER_SIZE = 16; + +const int AAD_SIZE = 9; diff --git a/lib/src/rust/frb_generated.web.dart b/lib/src/rust/frb_generated.web.dart index 8f7688a..86c7dbe 100644 --- a/lib/src/rust/frb_generated.web.dart +++ b/lib/src/rust/frb_generated.web.dart @@ -106,10 +106,10 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ); @protected - RustStreamSink dco_decode_StreamSink_f_64_Sse(dynamic raw); + RustStreamSink dco_decode_StreamSink_f_64_Dco(dynamic raw); @protected - RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink dco_decode_StreamSink_list_prim_u_8_strict_Dco( dynamic raw, ); @@ -249,12 +249,12 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ); @protected - RustStreamSink sse_decode_StreamSink_f_64_Sse( + RustStreamSink sse_decode_StreamSink_f_64_Dco( SseDeserializer deserializer, ); @protected - RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Sse( + RustStreamSink sse_decode_StreamSink_list_prim_u_8_strict_Dco( SseDeserializer deserializer, ); @@ -338,6 +338,294 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { @protected VaultHealthInfo sse_decode_vault_health_info(SseDeserializer deserializer); + @protected + String cst_encode_AnyhowException(AnyhowException raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + throw UnimplementedError(); + } + + @protected + String cst_encode_StreamSink_f_64_Dco(RustStreamSink raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_String( + raw.setupAndSerialize( + codec: DcoCodec( + decodeSuccessData: dco_decode_f_64, + decodeErrorData: dco_decode_AnyhowException, + ), + ), + ); + } + + @protected + String cst_encode_StreamSink_list_prim_u_8_strict_Dco( + RustStreamSink raw, + ) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_String( + raw.setupAndSerialize( + codec: DcoCodec( + decodeSuccessData: dco_decode_list_prim_u_8_strict, + decodeErrorData: dco_decode_AnyhowException, + ), + ), + ); + } + + @protected + String cst_encode_String(String raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw; + } + + @protected + JSAny cst_encode_box_autoadd_compression_config(CompressionConfig raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_compression_config(raw); + } + + @protected + int cst_encode_box_autoadd_i_32(int raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return cst_encode_i_32(raw); + } + + @protected + JSAny cst_encode_compression_config(CompressionConfig raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [ + cst_encode_compression_algorithm(raw.algorithm), + cst_encode_opt_box_autoadd_i_32(raw.level), + ].jsify()!; + } + + @protected + JSAny cst_encode_crypto_error(CryptoError raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + if (raw is CryptoError_InvalidKeyLength) { + return [ + 0, + cst_encode_usize(raw.expected), + cst_encode_usize(raw.actual), + ].jsify()!; + } + if (raw is CryptoError_InvalidNonce) { + return [1].jsify()!; + } + if (raw is CryptoError_EncryptionFailed) { + return [2, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_DecryptionFailed) { + return [3].jsify()!; + } + if (raw is CryptoError_HashingFailed) { + return [4, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_KdfFailed) { + return [5, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_IoError) { + return [6, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_InvalidParameter) { + return [7, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_CompressionFailed) { + return [8, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_AuthenticationFailed) { + return [9].jsify()!; + } + if (raw is CryptoError_VaultFull) { + return [ + 10, + cst_encode_u_64(raw.needed), + cst_encode_u_64(raw.available), + ].jsify()!; + } + if (raw is CryptoError_VaultLocked) { + return [11].jsify()!; + } + if (raw is CryptoError_SegmentNotFound) { + return [12, cst_encode_String(raw.field0)].jsify()!; + } + if (raw is CryptoError_VaultCorrupted) { + return [13, cst_encode_String(raw.field0)].jsify()!; + } + + throw Exception('unreachable'); + } + + @protected + JSAny cst_encode_defrag_result(DefragResult raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [ + cst_encode_u_32(raw.segmentsMoved), + cst_encode_u_64(raw.bytesReclaimed), + cst_encode_u_32(raw.freeRegionsBefore), + ].jsify()!; + } + + @protected + JSAny cst_encode_list_String(List raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw.map(cst_encode_String).toList().jsify()!; + } + + @protected + JSAny cst_encode_list_prim_u_8_loose(List raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw.jsify()!; + } + + @protected + JSAny cst_encode_list_prim_u_8_strict(Uint8List raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw.jsify()!; + } + + @protected + JSAny? cst_encode_opt_box_autoadd_compression_config(CompressionConfig? raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw == null ? null : cst_encode_box_autoadd_compression_config(raw); + } + + @protected + int? cst_encode_opt_box_autoadd_i_32(int? raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw == null ? null : cst_encode_box_autoadd_i_32(raw); + } + + @protected + JSAny? cst_encode_opt_list_prim_u_8_strict(Uint8List? raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return raw == null ? null : cst_encode_list_prim_u_8_strict(raw); + } + + @protected + JSAny cst_encode_u_64(BigInt raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return castNativeBigInt(raw); + } + + @protected + JSAny cst_encode_usize(BigInt raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return castNativeBigInt(raw); + } + + @protected + JSAny cst_encode_vault_capacity_info(VaultCapacityInfo raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [ + cst_encode_u_64(raw.totalBytes), + cst_encode_u_64(raw.usedBytes), + cst_encode_u_64(raw.freeListBytes), + cst_encode_u_64(raw.unallocatedBytes), + cst_encode_usize(raw.segmentCount), + ].jsify()!; + } + + @protected + JSAny cst_encode_vault_health_info(VaultHealthInfo raw) { + // Codec=Cst (C-struct based), see doc to use other codecs + return [ + cst_encode_u_64(raw.totalBytes), + cst_encode_u_64(raw.usedBytes), + cst_encode_u_64(raw.freeListBytes), + cst_encode_u_64(raw.unallocatedBytes), + cst_encode_u_32(raw.segmentCount), + cst_encode_u_32(raw.freeRegionCount), + cst_encode_u_64(raw.largestFreeBlock), + cst_encode_f_64(raw.fragmentationRatio), + cst_encode_bool(raw.isConsistent), + ].jsify()!; + } + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ); + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ); + + @protected + int + cst_encode_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int + cst_encode_Auto_RefMut_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ); + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ); + + @protected + int + cst_encode_Auto_Ref_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + CipherHandle raw, + ); + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + HasherHandle raw, + ); + + @protected + int + cst_encode_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + VaultHandle raw, + ); + + @protected + int cst_encode_argon_2_preset(Argon2Preset raw); + + @protected + bool cst_encode_bool(bool raw); + + @protected + int cst_encode_compression_algorithm(CompressionAlgorithm raw); + + @protected + double cst_encode_f_64(double raw); + + @protected + int cst_encode_i_32(int raw); + + @protected + int cst_encode_u_32(int raw); + + @protected + int cst_encode_u_8(int raw); + + @protected + void cst_encode_unit(void raw); + @protected void sse_encode_AnyhowException( AnyhowException self, @@ -415,13 +703,13 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { ); @protected - void sse_encode_StreamSink_f_64_Sse( + void sse_encode_StreamSink_f_64_Dco( RustStreamSink self, SseSerializer serializer, ); @protected - void sse_encode_StreamSink_list_prim_u_8_strict_Sse( + void sse_encode_StreamSink_list_prim_u_8_strict_Dco( RustStreamSink self, SseSerializer serializer, ); @@ -528,6 +816,393 @@ abstract class RustLibApiImplPlatform extends BaseApiImpl { class RustLibWire implements BaseWire { RustLibWire.fromExternalLibrary(ExternalLibrary lib); + void wire__crate__api__evfs__types__VaultHandle_health( + NativePortType port_, + int that, + ) => + wasmModule.wire__crate__api__evfs__types__VaultHandle_health(port_, that); + + void wire__crate__api__hashing__argon2__argon2id_hash( + NativePortType port_, + String password, + int preset, + ) => wasmModule.wire__crate__api__hashing__argon2__argon2id_hash( + port_, + password, + preset, + ); + + void wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + NativePortType port_, + String password, + String salt, + int preset, + ) => wasmModule.wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + port_, + password, + salt, + preset, + ); + + void wire__crate__api__hashing__argon2__argon2id_verify( + NativePortType port_, + String phc_hash, + String password, + ) => wasmModule.wire__crate__api__hashing__argon2__argon2id_verify( + port_, + phc_hash, + password, + ); + + void wire__crate__api__hashing__blake3_hash( + NativePortType port_, + JSAny data, + ) => wasmModule.wire__crate__api__hashing__blake3_hash(port_, data); + + void wire__crate__api__compression__compress( + NativePortType port_, + JSAny data, + JSAny config, + ) => wasmModule.wire__crate__api__compression__compress(port_, data, config); + + void wire__crate__api__compression__compression_algorithm_from_u8( + NativePortType port_, + int byte, + ) => wasmModule.wire__crate__api__compression__compression_algorithm_from_u8( + port_, + byte, + ); + + void wire__crate__api__compression__compression_algorithm_to_u8( + NativePortType port_, + int that, + ) => wasmModule.wire__crate__api__compression__compression_algorithm_to_u8( + port_, + that, + ); + + void wire__crate__api__encryption__create_aes256_gcm( + NativePortType port_, + JSAny key, + ) => wasmModule.wire__crate__api__encryption__create_aes256_gcm(port_, key); + + void wire__crate__api__hashing__create_blake3(NativePortType port_) => + wasmModule.wire__crate__api__hashing__create_blake3(port_); + + void wire__crate__api__encryption__create_chacha20_poly1305( + NativePortType port_, + JSAny key, + ) => wasmModule.wire__crate__api__encryption__create_chacha20_poly1305( + port_, + key, + ); + + void wire__crate__api__encryption__create_noop_encryption( + NativePortType port_, + ) => wasmModule.wire__crate__api__encryption__create_noop_encryption(port_); + + void wire__crate__api__hashing__create_sha3(NativePortType port_) => + wasmModule.wire__crate__api__hashing__create_sha3(port_); + + void wire__crate__api__compression__decompress( + NativePortType port_, + JSAny data, + int algorithm, + ) => wasmModule.wire__crate__api__compression__decompress( + port_, + data, + algorithm, + ); + + void wire__crate__api__encryption__decrypt( + NativePortType port_, + int cipher, + JSAny ciphertext, + JSAny aad, + ) => wasmModule.wire__crate__api__encryption__decrypt( + port_, + cipher, + ciphertext, + aad, + ); + + void wire__crate__api__encryption__encrypt( + NativePortType port_, + int cipher, + JSAny plaintext, + JSAny aad, + ) => wasmModule.wire__crate__api__encryption__encrypt( + port_, + cipher, + plaintext, + aad, + ); + + void wire__crate__api__encryption__encryption_algorithm_id( + NativePortType port_, + int cipher, + ) => wasmModule.wire__crate__api__encryption__encryption_algorithm_id( + port_, + cipher, + ); + + void wire__crate__api__encryption__generate_aes256_gcm_key( + NativePortType port_, + ) => wasmModule.wire__crate__api__encryption__generate_aes256_gcm_key(port_); + + void wire__crate__api__encryption__aes_gcm__generate_aes_key( + NativePortType port_, + ) => + wasmModule.wire__crate__api__encryption__aes_gcm__generate_aes_key(port_); + + void wire__crate__api__encryption__generate_chacha20_poly1305_key( + NativePortType port_, + ) => wasmModule.wire__crate__api__encryption__generate_chacha20_poly1305_key( + port_, + ); + + void wire__crate__api__encryption__chacha20__generate_chacha_key( + NativePortType port_, + ) => wasmModule.wire__crate__api__encryption__chacha20__generate_chacha_key( + port_, + ); + + void wire__crate__api__hashing__hasher_algorithm_id( + NativePortType port_, + int handle, + ) => wasmModule.wire__crate__api__hashing__hasher_algorithm_id(port_, handle); + + void wire__crate__api__hashing__hasher_finalize( + NativePortType port_, + int handle, + ) => wasmModule.wire__crate__api__hashing__hasher_finalize(port_, handle); + + void wire__crate__api__hashing__hasher_reset( + NativePortType port_, + int handle, + ) => wasmModule.wire__crate__api__hashing__hasher_reset(port_, handle); + + void wire__crate__api__hashing__hasher_update( + NativePortType port_, + int handle, + JSAny data, + ) => wasmModule.wire__crate__api__hashing__hasher_update(port_, handle, data); + + JSAny? /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__kdf__hkdf__hkdf_derive( + JSAny ikm, + JSAny? salt, + JSAny info, + JSAny output_len, + ) => wasmModule.wire__crate__api__kdf__hkdf__hkdf_derive( + ikm, + salt, + info, + output_len, + ); + + void wire__crate__api__kdf__hkdf__hkdf_expand( + NativePortType port_, + JSAny prk, + JSAny info, + JSAny output_len, + ) => wasmModule.wire__crate__api__kdf__hkdf__hkdf_expand( + port_, + prk, + info, + output_len, + ); + + JSAny? /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__kdf__hkdf__hkdf_extract(JSAny ikm, JSAny? salt) => + wasmModule.wire__crate__api__kdf__hkdf__hkdf_extract(ikm, salt); + + void wire__crate__api__hashing__sha3_hash(NativePortType port_, JSAny data) => + wasmModule.wire__crate__api__hashing__sha3_hash(port_, data); + + void wire__crate__api__compression__should_skip_compression( + NativePortType port_, + String file_path, + ) => wasmModule.wire__crate__api__compression__should_skip_compression( + port_, + file_path, + ); + + void wire__crate__api__streaming__stream_compress_encrypt_file( + NativePortType port_, + int cipher, + JSAny compression, + String input_path, + String output_path, + String progress_sink, + ) => wasmModule.wire__crate__api__streaming__stream_compress_encrypt_file( + port_, + cipher, + compression, + input_path, + output_path, + progress_sink, + ); + + void wire__crate__api__streaming__stream_decrypt_decompress_file( + NativePortType port_, + int cipher, + String input_path, + String output_path, + String progress_sink, + ) => wasmModule.wire__crate__api__streaming__stream_decrypt_decompress_file( + port_, + cipher, + input_path, + output_path, + progress_sink, + ); + + void wire__crate__api__streaming__stream_decrypt_file( + NativePortType port_, + int cipher, + String input_path, + String output_path, + String progress_sink, + ) => wasmModule.wire__crate__api__streaming__stream_decrypt_file( + port_, + cipher, + input_path, + output_path, + progress_sink, + ); + + void wire__crate__api__streaming__stream_encrypt_file( + NativePortType port_, + int cipher, + String input_path, + String output_path, + String progress_sink, + ) => wasmModule.wire__crate__api__streaming__stream_encrypt_file( + port_, + cipher, + input_path, + output_path, + progress_sink, + ); + + void wire__crate__api__streaming__stream_hash_file( + NativePortType port_, + int hasher, + String file_path, + String progress_sink, + ) => wasmModule.wire__crate__api__streaming__stream_hash_file( + port_, + hasher, + file_path, + progress_sink, + ); + + void wire__crate__api__evfs__vault_capacity( + NativePortType port_, + int handle, + ) => wasmModule.wire__crate__api__evfs__vault_capacity(port_, handle); + + void wire__crate__api__evfs__vault_close(NativePortType port_, int handle) => + wasmModule.wire__crate__api__evfs__vault_close(port_, handle); + + void wire__crate__api__evfs__vault_create( + NativePortType port_, + String path, + JSAny key, + String algorithm, + JSAny capacity_bytes, + ) => wasmModule.wire__crate__api__evfs__vault_create( + port_, + path, + key, + algorithm, + capacity_bytes, + ); + + void wire__crate__api__evfs__vault_defragment( + NativePortType port_, + int handle, + ) => wasmModule.wire__crate__api__evfs__vault_defragment(port_, handle); + + void wire__crate__api__evfs__vault_delete( + NativePortType port_, + int handle, + String name, + ) => wasmModule.wire__crate__api__evfs__vault_delete(port_, handle, name); + + void wire__crate__api__evfs__vault_health(NativePortType port_, int handle) => + wasmModule.wire__crate__api__evfs__vault_health(port_, handle); + + void wire__crate__api__evfs__vault_list(NativePortType port_, int handle) => + wasmModule.wire__crate__api__evfs__vault_list(port_, handle); + + void wire__crate__api__evfs__vault_open( + NativePortType port_, + String path, + JSAny key, + ) => wasmModule.wire__crate__api__evfs__vault_open(port_, path, key); + + void wire__crate__api__evfs__vault_read( + NativePortType port_, + int handle, + String name, + ) => wasmModule.wire__crate__api__evfs__vault_read(port_, handle, name); + + void wire__crate__api__evfs__vault_read_stream( + NativePortType port_, + int handle, + String name, + bool verify_checksum, + String sink, + String on_progress, + ) => wasmModule.wire__crate__api__evfs__vault_read_stream( + port_, + handle, + name, + verify_checksum, + sink, + on_progress, + ); + + void wire__crate__api__evfs__vault_resize( + NativePortType port_, + int handle, + JSAny new_capacity, + ) => wasmModule.wire__crate__api__evfs__vault_resize( + port_, + handle, + new_capacity, + ); + + void wire__crate__api__evfs__vault_write( + NativePortType port_, + int handle, + String name, + JSAny data, + JSAny? compression, + ) => wasmModule.wire__crate__api__evfs__vault_write( + port_, + handle, + name, + data, + compression, + ); + + void wire__crate__api__evfs__vault_write_file( + NativePortType port_, + int handle, + String name, + String file_path, + String on_progress, + ) => wasmModule.wire__crate__api__evfs__vault_write_file( + port_, + handle, + name, + file_path, + on_progress, + ); + void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( int ptr, @@ -583,6 +1258,281 @@ external RustLibWasmModule get wasmModule; @JS() @anonymous extension type RustLibWasmModule._(JSObject _) implements JSObject { + external void wire__crate__api__evfs__types__VaultHandle_health( + NativePortType port_, + int that, + ); + + external void wire__crate__api__hashing__argon2__argon2id_hash( + NativePortType port_, + String password, + int preset, + ); + + external void wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + NativePortType port_, + String password, + String salt, + int preset, + ); + + external void wire__crate__api__hashing__argon2__argon2id_verify( + NativePortType port_, + String phc_hash, + String password, + ); + + external void wire__crate__api__hashing__blake3_hash( + NativePortType port_, + JSAny data, + ); + + external void wire__crate__api__compression__compress( + NativePortType port_, + JSAny data, + JSAny config, + ); + + external void wire__crate__api__compression__compression_algorithm_from_u8( + NativePortType port_, + int byte, + ); + + external void wire__crate__api__compression__compression_algorithm_to_u8( + NativePortType port_, + int that, + ); + + external void wire__crate__api__encryption__create_aes256_gcm( + NativePortType port_, + JSAny key, + ); + + external void wire__crate__api__hashing__create_blake3(NativePortType port_); + + external void wire__crate__api__encryption__create_chacha20_poly1305( + NativePortType port_, + JSAny key, + ); + + external void wire__crate__api__encryption__create_noop_encryption( + NativePortType port_, + ); + + external void wire__crate__api__hashing__create_sha3(NativePortType port_); + + external void wire__crate__api__compression__decompress( + NativePortType port_, + JSAny data, + int algorithm, + ); + + external void wire__crate__api__encryption__decrypt( + NativePortType port_, + int cipher, + JSAny ciphertext, + JSAny aad, + ); + + external void wire__crate__api__encryption__encrypt( + NativePortType port_, + int cipher, + JSAny plaintext, + JSAny aad, + ); + + external void wire__crate__api__encryption__encryption_algorithm_id( + NativePortType port_, + int cipher, + ); + + external void wire__crate__api__encryption__generate_aes256_gcm_key( + NativePortType port_, + ); + + external void wire__crate__api__encryption__aes_gcm__generate_aes_key( + NativePortType port_, + ); + + external void wire__crate__api__encryption__generate_chacha20_poly1305_key( + NativePortType port_, + ); + + external void wire__crate__api__encryption__chacha20__generate_chacha_key( + NativePortType port_, + ); + + external void wire__crate__api__hashing__hasher_algorithm_id( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__hashing__hasher_finalize( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__hashing__hasher_reset( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__hashing__hasher_update( + NativePortType port_, + int handle, + JSAny data, + ); + + external JSAny? /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__kdf__hkdf__hkdf_derive( + JSAny ikm, + JSAny? salt, + JSAny info, + JSAny output_len, + ); + + external void wire__crate__api__kdf__hkdf__hkdf_expand( + NativePortType port_, + JSAny prk, + JSAny info, + JSAny output_len, + ); + + external JSAny? /* flutter_rust_bridge::for_generated::WireSyncRust2DartDco */ + wire__crate__api__kdf__hkdf__hkdf_extract(JSAny ikm, JSAny? salt); + + external void wire__crate__api__hashing__sha3_hash( + NativePortType port_, + JSAny data, + ); + + external void wire__crate__api__compression__should_skip_compression( + NativePortType port_, + String file_path, + ); + + external void wire__crate__api__streaming__stream_compress_encrypt_file( + NativePortType port_, + int cipher, + JSAny compression, + String input_path, + String output_path, + String progress_sink, + ); + + external void wire__crate__api__streaming__stream_decrypt_decompress_file( + NativePortType port_, + int cipher, + String input_path, + String output_path, + String progress_sink, + ); + + external void wire__crate__api__streaming__stream_decrypt_file( + NativePortType port_, + int cipher, + String input_path, + String output_path, + String progress_sink, + ); + + external void wire__crate__api__streaming__stream_encrypt_file( + NativePortType port_, + int cipher, + String input_path, + String output_path, + String progress_sink, + ); + + external void wire__crate__api__streaming__stream_hash_file( + NativePortType port_, + int hasher, + String file_path, + String progress_sink, + ); + + external void wire__crate__api__evfs__vault_capacity( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__evfs__vault_close( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__evfs__vault_create( + NativePortType port_, + String path, + JSAny key, + String algorithm, + JSAny capacity_bytes, + ); + + external void wire__crate__api__evfs__vault_defragment( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__evfs__vault_delete( + NativePortType port_, + int handle, + String name, + ); + + external void wire__crate__api__evfs__vault_health( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__evfs__vault_list( + NativePortType port_, + int handle, + ); + + external void wire__crate__api__evfs__vault_open( + NativePortType port_, + String path, + JSAny key, + ); + + external void wire__crate__api__evfs__vault_read( + NativePortType port_, + int handle, + String name, + ); + + external void wire__crate__api__evfs__vault_read_stream( + NativePortType port_, + int handle, + String name, + bool verify_checksum, + String sink, + String on_progress, + ); + + external void wire__crate__api__evfs__vault_resize( + NativePortType port_, + int handle, + JSAny new_capacity, + ); + + external void wire__crate__api__evfs__vault_write( + NativePortType port_, + int handle, + String name, + JSAny data, + JSAny? compression, + ); + + external void wire__crate__api__evfs__vault_write_file( + NativePortType port_, + int handle, + String name, + String file_path, + String on_progress, + ); + external void rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( int ptr, diff --git a/macos/m_security.podspec b/macos/m_security.podspec index 729e1ec..ab678bf 100644 --- a/macos/m_security.podspec +++ b/macos/m_security.podspec @@ -4,7 +4,7 @@ # Pod::Spec.new do |s| s.name = 'm_security' - s.version = '0.3.2' + s.version = '0.3.3' s.summary = 'A high-performance cryptographic SDK for Flutter powered by native Rust via FFI.' s.description = <<-DESC A high-performance cryptographic SDK for Flutter powered by native Rust via FFI. diff --git a/pubspec.yaml b/pubspec.yaml index 5c74906..75b63b2 100644 --- a/pubspec.yaml +++ b/pubspec.yaml @@ -2,7 +2,7 @@ name: m_security description: >- A native Rust cryptographic SDK for Flutter via FFI. AES-256-GCM, ChaCha20-Poly1305, BLAKE3, SHA-3, Argon2id, HKDF, streaming encryption, and encrypted virtual file system. -version: 0.3.2 +version: 0.3.3 homepage: https://github.com/MicroClub-USTHB/M-Security repository: https://github.com/MicroClub-USTHB/M-Security issue_tracker: https://github.com/MicroClub-USTHB/M-Security/issues @@ -34,6 +34,7 @@ dev_dependencies: freezed: ^3.2.5 build_runner: ^2.11.1 test: ^1.29.0 + ffigen: ^20.1.1 flutter: plugin: diff --git a/rust/Cargo.lock b/rust/Cargo.lock index f2afaae..fd95d30 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -731,7 +731,7 @@ checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" [[package]] name = "m_security" -version = "0.3.2" +version = "0.3.3" dependencies = [ "aes-gcm", "argon2", @@ -743,7 +743,9 @@ dependencies = [ "fs4", "hex", "hkdf", + "libc", "log", + "memmap2", "rand", "sha2", "sha3", @@ -770,6 +772,15 @@ version = "2.6.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f665ee40bc4a3c5590afb1e9677db74a508659dfd71e126420da8274909a0167" +[[package]] +name = "memmap2" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "714098028fe011992e1c3962653c96b2d578c4b4bce9036e15ff220319b1e0e3" +dependencies = [ + "libc", +] + [[package]] name = "miniz_oxide" version = "0.7.1" diff --git a/rust/Cargo.toml b/rust/Cargo.toml index 87c3750..5d7614f 100644 --- a/rust/Cargo.toml +++ b/rust/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "m_security" -version = "0.3.2" +version = "0.3.3" edition = "2021" [lib] @@ -44,6 +44,10 @@ crc32fast = "1.4" # Advisory file locking fs4 = "0.12" +# Memory-mapped I/O for zero-copy vault reads +memmap2 = "0.9" +libc = "0.2" + # Compression zstd = { version = "0.13", optional = true } brotli = { version = "7.0", optional = true } @@ -51,10 +55,14 @@ brotli = { version = "7.0", optional = true } [features] default = ["compression"] compression = ["zstd", "brotli"] -testing = [] # exposes noop cipher — never enable in production builds +testing = [] # exposes noop cipher — never enable in production builds [profile.release] panic = "abort" +lto = "fat" +codegen-units = 1 +strip = "symbols" +opt-level = 3 [dev-dependencies] hex = "0.4" diff --git a/rust/build.rs b/rust/build.rs new file mode 100644 index 0000000..417568c --- /dev/null +++ b/rust/build.rs @@ -0,0 +1,18 @@ +fn main() { + println!("cargo:rerun-if-changed=ffi-exports.map"); + println!("cargo:rerun-if-changed=build.rs"); + + let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default(); + let manifest_dir = std::env::var("CARGO_MANIFEST_DIR") + .expect("CARGO_MANIFEST_DIR must be set"); + + // ELF targets (Android, Linux): use a version script to restrict the + // cdylib's dynamic symbol table to FRB FFI symbols only. + // This hides #[no_mangle] symbols leaked by dependencies (e.g. blake3). + // NOTE: macOS ld is not supported — rustc generates its own -exported_symbols_list + // for cdylib targets, and additional flags can only add to it, not restrict it. + // macOS .dylib is dev-only; production .so builds are covered. + if matches!(target_os.as_str(), "android" | "linux") { + println!("cargo:rustc-cdylib-link-arg=-Wl,--version-script={manifest_dir}/ffi-exports.map"); + } +} diff --git a/rust/ffi-exports.map b/rust/ffi-exports.map new file mode 100644 index 0000000..90dc378 --- /dev/null +++ b/rust/ffi-exports.map @@ -0,0 +1,11 @@ +/* Linker version script — only export FRB FFI symbols from the cdylib. + Everything else (including #[no_mangle] symbols from deps) becomes local. */ +{ + global: + frb_*; + frbgen_m_security_*; + free_zero_copy_buffer_*; + store_dart_post_cobject; + local: + *; +}; diff --git a/rust/src/api/evfs/helpers.rs b/rust/src/api/evfs/helpers.rs index 7621725..fbe54ed 100644 --- a/rust/src/api/evfs/helpers.rs +++ b/rust/src/api/evfs/helpers.rs @@ -97,10 +97,14 @@ pub(crate) fn capacity_from_file_size( /// Decrypt all chunks of a streaming segment, calling `on_chunk(plaintext, chunk_index)` /// for each decrypted chunk. Returns the BLAKE3 checksum of the full decrypted data. +/// +/// When `mmap` is `Some`, chunks are read via zero-copy slices into the mapped +/// file. Falls back to heap-allocated `read_exact` when mmap is unavailable. #[allow(clippy::too_many_arguments)] #[cfg(feature = "compression")] pub(crate) fn decrypt_streaming_chunks( file: &mut File, + mmap: Option<&super::types::VaultMmap>, cipher_key: &[u8], nonce_key: &[u8], algorithm: Algorithm, @@ -112,6 +116,7 @@ pub(crate) fn decrypt_streaming_chunks( mut on_chunk: impl FnMut(Vec, u32) -> Result<(), CryptoError>, ) -> Result<[u8; 32], CryptoError> { let data_region = format::data_region_offset(index_pad_size); + let enc_chunk_size = crate::core::streaming::ENCRYPTED_CHUNK_SIZE; let mut hasher = blake3::Hasher::new(); let mut decompressor = if compression != CompressionAlgorithm::None { Some(crate::core::compression::streaming::new_decompressor( @@ -124,16 +129,26 @@ pub(crate) fn decrypt_streaming_chunks( for i in 0..chunk_count { let chunk_offset = (i as u64) - .checked_mul(crate::core::streaming::ENCRYPTED_CHUNK_SIZE as u64) + .checked_mul(enc_chunk_size as u64) .and_then(|co| data_region.checked_add(seg_offset)?.checked_add(co)) .ok_or_else(|| CryptoError::InvalidParameter("chunk offset overflow".into()))?; - file.seek(SeekFrom::Start(chunk_offset))?; - let mut encrypted = vec![0u8; crate::core::streaming::ENCRYPTED_CHUNK_SIZE]; - file.read_exact(&mut encrypted)?; + // Zero-copy path: slice directly into mmap; fallback: heap read + let heap_buf; + let encrypted_ref: &[u8] = if let Some(m) = mmap { + m.slice(chunk_offset, enc_chunk_size as u64)? + } else { + file.seek(SeekFrom::Start(chunk_offset))?; + heap_buf = { + let mut buf = vec![0u8; enc_chunk_size]; + file.read_exact(&mut buf)?; + buf + }; + &heap_buf + }; let expected_nonce = segment::derive_chunk_nonce(nonce_key, i as u64, generation)?; - let (stored_nonce, _) = encrypted.split_at(crate::core::streaming::NONCE_SIZE); + let (stored_nonce, _) = encrypted_ref.split_at(crate::core::streaming::NONCE_SIZE); if stored_nonce.ct_ne(&expected_nonce).into() { return Err(CryptoError::AuthenticationFailed); } @@ -148,7 +163,7 @@ pub(crate) fn decrypt_streaming_chunks( let decrypted = segment::aead_decrypt_with_stored_nonce( cipher_key, - &encrypted, + encrypted_ref, &aad, algorithm, )?; diff --git a/rust/src/api/evfs/mod.rs b/rust/src/api/evfs/mod.rs index e803957..b39721e 100644 --- a/rust/src/api/evfs/mod.rs +++ b/rust/src/api/evfs/mod.rs @@ -7,6 +7,7 @@ pub mod types; use helpers::*; pub use types::*; +use types::VaultMmap; use crate::api::compression::{CompressionAlgorithm, CompressionConfig}; use crate::core::error::CryptoError; @@ -74,12 +75,14 @@ pub fn vault_create( let mut wal = WriteAheadLog::open(&path)?; wal.checkpoint()?; + let mmap = VaultMmap::new(&file).ok(); Ok(VaultHandle { path, algorithm: algo, keys, index, index_pad_size, + mmap, file, wal, lock, @@ -227,12 +230,14 @@ pub fn vault_open(path: String, mut key: Vec) -> Result Result, Cry let mut full_plaintext = Vec::new(); let checksum = decrypt_streaming_chunks( &mut handle.file, + handle.mmap.as_ref(), handle.keys.cipher_key.as_bytes(), handle.keys.nonce_key.as_bytes(), handle.algorithm, @@ -373,19 +380,8 @@ pub fn vault_read(handle: &mut VaultHandle, name: String) -> Result, Cry return Ok(full_plaintext); } - // Existing monolithic read logic (used when chunk_count == 0) - let read_len = usize::try_from(seg_size).map_err(|_| { - CryptoError::VaultCorrupted(format!( - "segment size {seg_size} exceeds platform address space" - )) - })?; - handle.file.seek(SeekFrom::Start( - format::data_region_offset(handle.index_pad_size) + seg_offset, - ))?; - let mut encrypted = vec![0u8; read_len]; - handle.file.read_exact(&mut encrypted)?; - - // Decrypt-then-decompress + // Monolithic read (chunk_count == 0): prefer mmap zero-copy, fall back to heap + let abs_offset = format::data_region_offset(handle.index_pad_size) + seg_offset; let params = SegmentCryptoParams { cipher_key: handle.keys.cipher_key.as_bytes(), nonce_key: handle.keys.nonce_key.as_bytes(), @@ -393,7 +389,22 @@ pub fn vault_read(handle: &mut VaultHandle, name: String) -> Result, Cry segment_index: 0, generation: seg_gen, }; - let plaintext = segment::decrypt_segment(¶ms, &encrypted, seg_compression)?; + + let plaintext = if let Some(ref mmap) = handle.mmap { + let encrypted = mmap.slice(abs_offset, seg_size)?; + segment::decrypt_segment(¶ms, encrypted, seg_compression)? + } else { + // Fallback: heap-allocated read_exact (32-bit or mmap-failed) + let read_len = usize::try_from(seg_size).map_err(|_| { + CryptoError::VaultCorrupted(format!( + "segment size {seg_size} exceeds platform address space" + )) + })?; + handle.file.seek(SeekFrom::Start(abs_offset))?; + let mut buf = vec![0u8; read_len]; + handle.file.read_exact(&mut buf)?; + segment::decrypt_segment(¶ms, &buf, seg_compression)? + }; // Verify checksum on decompressed plaintext if !segment::verify_checksum(&plaintext, &seg_checksum) { @@ -435,6 +446,7 @@ pub fn vault_read_stream( let checksum = decrypt_streaming_chunks( &mut handle.file, + handle.mmap.as_ref(), handle.keys.cipher_key.as_bytes(), handle.keys.nonce_key.as_bytes(), handle.algorithm, @@ -605,6 +617,7 @@ pub fn vault_write_stream( handle.wal.commit()?; handle.wal.checkpoint()?; + handle.refresh_mmap(); Ok(()) } @@ -754,8 +767,9 @@ pub fn vault_delete(handle: &mut VaultHandle, name: String) -> Result<(), Crypto handle.index_pad_size, )?; - // WAL commit + // WAL commit + refresh mmap (file contents changed) handle.wal.commit()?; + handle.refresh_mmap(); Ok(()) } @@ -810,6 +824,7 @@ fn vault_resize_grow_impl( handle.wal.commit()?; handle.wal.checkpoint()?; + handle.refresh_mmap(); Ok(()) } @@ -878,6 +893,7 @@ fn vault_resize_shrink_impl( handle.wal.commit()?; handle.wal.checkpoint()?; + handle.refresh_mmap(); Ok(()) } @@ -1042,8 +1058,9 @@ pub fn vault_defragment(handle: &mut VaultHandle) -> Result Result { + // SAFETY: the caller holds an exclusive advisory flock via VaultLock, + // ensuring no cooperating process modifies the file while mapped. + // Non-cooperating processes are outside this library's threat model. + let mmap = unsafe { Mmap::map(file) } + .map_err(|e| CryptoError::IoError(format!("mmap failed: {e}")))?; + + // Lock pages to prevent kernel from swapping ciphertext to disk. + // Failure is non-fatal (mlock limits may be low on some systems). + #[cfg(unix)] + { + unsafe { + libc::mlock(mmap.as_ptr().cast::(), mmap.len()); + } + } + + Ok(Self { mmap }) + } + + /// Return a byte slice into the mapped region at `[offset..offset+len]`. + /// + /// Returns `Err` if the range is out of bounds (e.g. 32-bit overflow or + /// the file was truncated between mapping and read). + pub(crate) fn slice(&self, offset: u64, len: u64) -> Result<&[u8], CryptoError> { + let start = usize::try_from(offset).map_err(|_| { + CryptoError::VaultCorrupted(format!("mmap offset {offset} exceeds address space")) + })?; + let size = usize::try_from(len).map_err(|_| { + CryptoError::VaultCorrupted(format!("mmap length {len} exceeds address space")) + })?; + let end = start.checked_add(size).ok_or_else(|| { + CryptoError::VaultCorrupted("mmap range overflow".into()) + })?; + if end > self.mmap.len() { + return Err(CryptoError::VaultCorrupted(format!( + "mmap read {start}..{end} exceeds file size {}", + self.mmap.len() + ))); + } + Ok(&self.mmap[start..end]) + } +} + +#[cfg(unix)] +impl Drop for VaultMmap { + fn drop(&mut self) { + // Unlock pages before the mmap is unmapped + unsafe { + libc::munlock(self.mmap.as_ptr().cast::(), self.mmap.len()); + } + } +} + // --------------------------------------------------------------------------- // VaultHandle // --------------------------------------------------------------------------- @@ -22,11 +95,21 @@ pub struct VaultHandle { pub(crate) index: SegmentIndex, /// Padded plaintext index size, set at creation and read from header on open. pub(crate) index_pad_size: usize, + /// Read-only mmap for zero-copy reads. None if mmap failed (32-bit fallback). + /// Dropped before `file` so munlock/munmap runs while the fd is still open. + pub(crate) mmap: Option, pub(crate) file: File, pub(crate) wal: WriteAheadLog, pub(crate) lock: VaultLock, } +impl VaultHandle { + /// (Re)create the mmap after a mutation. Silently falls back to None on failure. + pub(crate) fn refresh_mmap(&mut self) { + self.mmap = VaultMmap::new(&self.file).ok(); + } +} + /// Capacity info returned to callers. #[frb(non_opaque)] pub struct VaultCapacityInfo { diff --git a/rust/src/frb_generated.rs b/rust/src/frb_generated.rs index 940bb94..6e9658d 100644 --- a/rust/src/frb_generated.rs +++ b/rust/src/frb_generated.rs @@ -35,9 +35,9 @@ use flutter_rust_bridge::{Handler, IntoIntoDart}; // Section: boilerplate flutter_rust_bridge::frb_generated_boilerplate!( - default_stream_sink_codec = SseCodec, - default_rust_opaque = RustOpaqueMoi, - default_rust_auto_opaque = RustAutoOpaqueMoi, + default_stream_sink_codec = DcoCodec, + default_rust_opaque = RustOpaqueNom, + default_rust_auto_opaque = RustAutoOpaqueNom, ); pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.11.1"; pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 2084471439; @@ -50,32 +50,20 @@ flutter_rust_bridge::frb_generated_default_handler!(); fn wire__crate__api__evfs__types__VaultHandle_health_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + that: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "VaultHandle_health", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_that = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_that = that.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let mut api_that_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -101,32 +89,20 @@ fn wire__crate__api__evfs__types__VaultHandle_health_impl( } fn wire__crate__api__hashing__argon2__argon2id_hash_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + password: impl CstDecode, + preset: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "argon2id_hash", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_password = ::sse_decode(&mut deserializer); - let api_preset = - ::sse_decode(&mut deserializer); - deserializer.end(); + let api_password = password.cst_decode(); + let api_preset = preset.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::hashing::argon2::argon2id_hash(api_password, api_preset)?; Ok(output_ok) @@ -137,33 +113,22 @@ fn wire__crate__api__hashing__argon2__argon2id_hash_impl( } fn wire__crate__api__hashing__argon2__argon2id_hash_with_salt_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + password: impl CstDecode, + salt: impl CstDecode, + preset: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "argon2id_hash_with_salt", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_password = ::sse_decode(&mut deserializer); - let api_salt = ::sse_decode(&mut deserializer); - let api_preset = - ::sse_decode(&mut deserializer); - deserializer.end(); + let api_password = password.cst_decode(); + let api_salt = salt.cst_decode(); + let api_preset = preset.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::hashing::argon2::argon2id_hash_with_salt( api_password, api_salt, @@ -177,31 +142,20 @@ fn wire__crate__api__hashing__argon2__argon2id_hash_with_salt_impl( } fn wire__crate__api__hashing__argon2__argon2id_verify_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + phc_hash: impl CstDecode, + password: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "argon2id_verify", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_phc_hash = ::sse_decode(&mut deserializer); - let api_password = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_phc_hash = phc_hash.cst_decode(); + let api_password = password.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::hashing::argon2::argon2id_verify(api_phc_hash, api_password)?; Ok(output_ok) @@ -212,30 +166,18 @@ fn wire__crate__api__hashing__argon2__argon2id_verify_impl( } fn wire__crate__api__hashing__blake3_hash_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + data: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "blake3_hash", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_data = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_data = data.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok(crate::api::hashing::blake3_hash(api_data))?; Ok(output_ok) @@ -246,32 +188,20 @@ fn wire__crate__api__hashing__blake3_hash_impl( } fn wire__crate__api__compression__compress_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + data: impl CstDecode>, + config: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "compress", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_data = >::sse_decode(&mut deserializer); - let api_config = - ::sse_decode(&mut deserializer); - deserializer.end(); + let api_data = data.cst_decode(); + let api_config = config.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::compression::compress(&api_data, &api_config)?; Ok(output_ok) })()) @@ -281,30 +211,18 @@ fn wire__crate__api__compression__compress_impl( } fn wire__crate__api__compression__compression_algorithm_from_u8_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + byte: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "compression_algorithm_from_u8", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_byte = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_byte = byte.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::compression::CompressionAlgorithm::from_u8(api_byte)?; Ok(output_ok) @@ -315,31 +233,18 @@ fn wire__crate__api__compression__compression_algorithm_from_u8_impl( } fn wire__crate__api__compression__compression_algorithm_to_u8_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + that: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "compression_algorithm_to_u8", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_that = - ::sse_decode(&mut deserializer); - deserializer.end(); + let api_that = that.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok( crate::api::compression::CompressionAlgorithm::to_u8(api_that), )?; @@ -351,30 +256,18 @@ fn wire__crate__api__compression__compression_algorithm_to_u8_impl( } fn wire__crate__api__encryption__create_aes256_gcm_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + key: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "create_aes256_gcm", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_key = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_key = key.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::encryption::create_aes256_gcm(api_key)?; Ok(output_ok) })()) @@ -384,29 +277,16 @@ fn wire__crate__api__encryption__create_aes256_gcm_impl( } fn wire__crate__api__hashing__create_blake3_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "create_blake3", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok(crate::api::hashing::create_blake3())?; Ok(output_ok) })()) @@ -416,30 +296,18 @@ fn wire__crate__api__hashing__create_blake3_impl( } fn wire__crate__api__encryption__create_chacha20_poly1305_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + key: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "create_chacha20_poly1305", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_key = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_key = key.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::encryption::create_chacha20_poly1305(api_key)?; Ok(output_ok) })()) @@ -449,29 +317,16 @@ fn wire__crate__api__encryption__create_chacha20_poly1305_impl( } fn wire__crate__api__encryption__create_noop_encryption_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "create_noop_encryption", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok(crate::api::encryption::create_noop_encryption())?; Ok(output_ok) @@ -482,29 +337,16 @@ fn wire__crate__api__encryption__create_noop_encryption_impl( } fn wire__crate__api__hashing__create_sha3_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "create_sha3", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok(crate::api::hashing::create_sha3())?; Ok(output_ok) })()) @@ -514,32 +356,20 @@ fn wire__crate__api__hashing__create_sha3_impl( } fn wire__crate__api__compression__decompress_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + data: impl CstDecode>, + algorithm: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "decompress", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_data = >::sse_decode(&mut deserializer); - let api_algorithm = - ::sse_decode(&mut deserializer); - deserializer.end(); + let api_data = data.cst_decode(); + let api_algorithm = algorithm.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::compression::decompress(&api_data, api_algorithm)?; Ok(output_ok) })()) @@ -549,34 +379,24 @@ fn wire__crate__api__compression__decompress_impl( } fn wire__crate__api__encryption__decrypt_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, + ciphertext: impl CstDecode>, + aad: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "decrypt", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - let api_ciphertext = >::sse_decode(&mut deserializer); - let api_aad = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_cipher = cipher.cst_decode(); + let api_ciphertext = ciphertext.cst_decode(); + let api_aad = aad.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -606,34 +426,24 @@ fn wire__crate__api__encryption__decrypt_impl( } fn wire__crate__api__encryption__encrypt_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, + plaintext: impl CstDecode>, + aad: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "encrypt", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - let api_plaintext = >::sse_decode(&mut deserializer); - let api_aad = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_cipher = cipher.cst_decode(); + let api_plaintext = plaintext.cst_decode(); + let api_aad = aad.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -663,32 +473,20 @@ fn wire__crate__api__encryption__encrypt_impl( } fn wire__crate__api__encryption__encryption_algorithm_id_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "encryption_algorithm_id", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_cipher = cipher.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -716,29 +514,16 @@ fn wire__crate__api__encryption__encryption_algorithm_id_impl( } fn wire__crate__api__encryption__generate_aes256_gcm_key_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "generate_aes256_gcm_key", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::encryption::generate_aes256_gcm_key()?; Ok(output_ok) })()) @@ -748,29 +533,16 @@ fn wire__crate__api__encryption__generate_aes256_gcm_key_impl( } fn wire__crate__api__encryption__aes_gcm__generate_aes_key_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "generate_aes_key", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::encryption::aes_gcm::generate_aes_key()?; Ok(output_ok) })()) @@ -780,29 +552,16 @@ fn wire__crate__api__encryption__aes_gcm__generate_aes_key_impl( } fn wire__crate__api__encryption__generate_chacha20_poly1305_key_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "generate_chacha20_poly1305_key", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::encryption::generate_chacha20_poly1305_key()?; Ok(output_ok) })()) @@ -812,29 +571,16 @@ fn wire__crate__api__encryption__generate_chacha20_poly1305_key_impl( } fn wire__crate__api__encryption__chacha20__generate_chacha_key_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "generate_chacha_key", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - deserializer.end(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::encryption::chacha20::generate_chacha_key()?; Ok(output_ok) })()) @@ -844,32 +590,20 @@ fn wire__crate__api__encryption__chacha20__generate_chacha_key_impl( } fn wire__crate__api__hashing__hasher_algorithm_id_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hasher_algorithm_id", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -895,32 +629,20 @@ fn wire__crate__api__hashing__hasher_algorithm_id_impl( } fn wire__crate__api__hashing__hasher_finalize_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hasher_finalize", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -946,32 +668,20 @@ fn wire__crate__api__hashing__hasher_finalize_impl( } fn wire__crate__api__hashing__hasher_reset_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hasher_reset", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -997,33 +707,22 @@ fn wire__crate__api__hashing__hasher_reset_impl( } fn wire__crate__api__hashing__hasher_update_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + data: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hasher_update", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_data = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_data = data.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1049,32 +748,23 @@ fn wire__crate__api__hashing__hasher_update_impl( ) } fn wire__crate__api__kdf__hkdf__hkdf_derive_impl( - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, -) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + ikm: impl CstDecode>, + salt: impl CstDecode>>, + info: impl CstDecode>, + output_len: impl CstDecode, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hkdf_derive", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_ikm = >::sse_decode(&mut deserializer); - let api_salt = >>::sse_decode(&mut deserializer); - let api_info = >::sse_decode(&mut deserializer); - let api_output_len = ::sse_decode(&mut deserializer); - deserializer.end(); - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + let api_ikm = ikm.cst_decode(); + let api_salt = salt.cst_decode(); + let api_info = info.cst_decode(); + let api_output_len = output_len.cst_decode(); + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::kdf::hkdf::hkdf_derive( api_ikm, api_salt, @@ -1088,32 +778,22 @@ fn wire__crate__api__kdf__hkdf__hkdf_derive_impl( } fn wire__crate__api__kdf__hkdf__hkdf_expand_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + prk: impl CstDecode>, + info: impl CstDecode>, + output_len: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hkdf_expand", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_prk = >::sse_decode(&mut deserializer); - let api_info = >::sse_decode(&mut deserializer); - let api_output_len = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_prk = prk.cst_decode(); + let api_info = info.cst_decode(); + let api_output_len = output_len.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::kdf::hkdf::hkdf_expand(api_prk, api_info, api_output_len)?; Ok(output_ok) @@ -1123,30 +803,19 @@ fn wire__crate__api__kdf__hkdf__hkdf_expand_impl( ) } fn wire__crate__api__kdf__hkdf__hkdf_extract_impl( - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, -) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( + ikm: impl CstDecode>, + salt: impl CstDecode>>, +) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "hkdf_extract", port: None, mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_ikm = >::sse_decode(&mut deserializer); - let api_salt = >>::sse_decode(&mut deserializer); - deserializer.end(); - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + let api_ikm = ikm.cst_decode(); + let api_salt = salt.cst_decode(); + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::kdf::hkdf::hkdf_extract(api_ikm, api_salt)?; Ok(output_ok) })()) @@ -1155,30 +824,18 @@ fn wire__crate__api__kdf__hkdf__hkdf_extract_impl( } fn wire__crate__api__hashing__sha3_hash_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + data: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "sha3_hash", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_data = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_data = data.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok(crate::api::hashing::sha3_hash(api_data))?; Ok(output_ok) })()) @@ -1188,30 +845,18 @@ fn wire__crate__api__hashing__sha3_hash_impl( } fn wire__crate__api__compression__should_skip_compression_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + file_path: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "should_skip_compression", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_file_path = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_file_path = file_path.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let output_ok = Result::<_, ()>::Ok( crate::api::compression::should_skip_compression(&api_file_path), )?; @@ -1223,40 +868,28 @@ fn wire__crate__api__compression__should_skip_compression_impl( } fn wire__crate__api__streaming__stream_compress_encrypt_file_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, + compression: impl CstDecode, + input_path: impl CstDecode, + output_path: impl CstDecode, + progress_sink: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "stream_compress_encrypt_file", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - let api_compression = - ::sse_decode(&mut deserializer); - let api_input_path = ::sse_decode(&mut deserializer); - let api_output_path = ::sse_decode(&mut deserializer); - let api_progress_sink = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_cipher = cipher.cst_decode(); + let api_compression = compression.cst_decode(); + let api_input_path = input_path.cst_decode(); + let api_output_path = output_path.cst_decode(); + let api_progress_sink = progress_sink.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1288,38 +921,26 @@ fn wire__crate__api__streaming__stream_compress_encrypt_file_impl( } fn wire__crate__api__streaming__stream_decrypt_decompress_file_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, + input_path: impl CstDecode, + output_path: impl CstDecode, + progress_sink: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "stream_decrypt_decompress_file", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - let api_input_path = ::sse_decode(&mut deserializer); - let api_output_path = ::sse_decode(&mut deserializer); - let api_progress_sink = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_cipher = cipher.cst_decode(); + let api_input_path = input_path.cst_decode(); + let api_output_path = output_path.cst_decode(); + let api_progress_sink = progress_sink.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1350,38 +971,26 @@ fn wire__crate__api__streaming__stream_decrypt_decompress_file_impl( } fn wire__crate__api__streaming__stream_decrypt_file_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, + input_path: impl CstDecode, + output_path: impl CstDecode, + progress_sink: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "stream_decrypt_file", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - let api_input_path = ::sse_decode(&mut deserializer); - let api_output_path = ::sse_decode(&mut deserializer); - let api_progress_sink = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_cipher = cipher.cst_decode(); + let api_input_path = input_path.cst_decode(); + let api_output_path = output_path.cst_decode(); + let api_progress_sink = progress_sink.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1412,38 +1021,26 @@ fn wire__crate__api__streaming__stream_decrypt_file_impl( } fn wire__crate__api__streaming__stream_encrypt_file_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + cipher: impl CstDecode< + RustOpaqueNom>, + >, + input_path: impl CstDecode, + output_path: impl CstDecode, + progress_sink: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "stream_encrypt_file", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_cipher = , - >>::sse_decode(&mut deserializer); - let api_input_path = ::sse_decode(&mut deserializer); - let api_output_path = ::sse_decode(&mut deserializer); - let api_progress_sink = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_cipher = cipher.cst_decode(); + let api_input_path = input_path.cst_decode(); + let api_output_path = output_path.cst_decode(); + let api_progress_sink = progress_sink.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_cipher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1474,37 +1071,24 @@ fn wire__crate__api__streaming__stream_encrypt_file_impl( } fn wire__crate__api__streaming__stream_hash_file_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + hasher: impl CstDecode< + RustOpaqueNom>, + >, + file_path: impl CstDecode, + progress_sink: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "stream_hash_file", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_hasher = , - >>::sse_decode(&mut deserializer); - let api_file_path = ::sse_decode(&mut deserializer); - let api_progress_sink = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_hasher = hasher.cst_decode(); + let api_file_path = file_path.cst_decode(); + let api_progress_sink = progress_sink.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_hasher_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1534,32 +1118,20 @@ fn wire__crate__api__streaming__stream_hash_file_impl( } fn wire__crate__api__evfs__vault_capacity_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_capacity", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1586,30 +1158,18 @@ fn wire__crate__api__evfs__vault_capacity_impl( } fn wire__crate__api__evfs__vault_close_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_close", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::evfs::vault_close(api_handle)?; Ok(output_ok) })()) @@ -1619,33 +1179,24 @@ fn wire__crate__api__evfs__vault_close_impl( } fn wire__crate__api__evfs__vault_create_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + path: impl CstDecode, + key: impl CstDecode>, + algorithm: impl CstDecode, + capacity_bytes: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_create", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_path = ::sse_decode(&mut deserializer); - let api_key = >::sse_decode(&mut deserializer); - let api_algorithm = ::sse_decode(&mut deserializer); - let api_capacity_bytes = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_path = path.cst_decode(); + let api_key = key.cst_decode(); + let api_algorithm = algorithm.cst_decode(); + let api_capacity_bytes = capacity_bytes.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::evfs::vault_create( api_path, api_key, @@ -1660,32 +1211,20 @@ fn wire__crate__api__evfs__vault_create_impl( } fn wire__crate__api__evfs__vault_defragment_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_defragment", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1711,33 +1250,22 @@ fn wire__crate__api__evfs__vault_defragment_impl( } fn wire__crate__api__evfs__vault_delete_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + name: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_delete", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_name = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_name = name.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1764,32 +1292,20 @@ fn wire__crate__api__evfs__vault_delete_impl( } fn wire__crate__api__evfs__vault_health_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_health", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1816,32 +1332,20 @@ fn wire__crate__api__evfs__vault_health_impl( } fn wire__crate__api__evfs__vault_list_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_list", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); move |context| { - transform_result_sse::<_, ()>((move || { + transform_result_dco::<_, _, ()>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1868,31 +1372,20 @@ fn wire__crate__api__evfs__vault_list_impl( } fn wire__crate__api__evfs__vault_open_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + path: impl CstDecode, + key: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_open", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_path = ::sse_decode(&mut deserializer); - let api_key = >::sse_decode(&mut deserializer); - deserializer.end(); + let api_path = path.cst_decode(); + let api_key = key.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let output_ok = crate::api::evfs::vault_open(api_path, api_key)?; Ok(output_ok) })()) @@ -1902,33 +1395,22 @@ fn wire__crate__api__evfs__vault_open_impl( } fn wire__crate__api__evfs__vault_read_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + name: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_read", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_name = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_name = name.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -1954,42 +1436,28 @@ fn wire__crate__api__evfs__vault_read_impl( } fn wire__crate__api__evfs__vault_read_stream_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + name: impl CstDecode, + verify_checksum: impl CstDecode, + sink: impl CstDecode, flutter_rust_bridge::for_generated::DcoCodec>>, + on_progress: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_read_stream", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_name = ::sse_decode(&mut deserializer); - let api_verify_checksum = ::sse_decode(&mut deserializer); - let api_sink = - , flutter_rust_bridge::for_generated::SseCodec>>::sse_decode( - &mut deserializer, - ); - let api_on_progress = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_name = name.cst_decode(); + let api_verify_checksum = verify_checksum.cst_decode(); + let api_sink = sink.cst_decode(); + let api_on_progress = on_progress.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -2021,33 +1489,22 @@ fn wire__crate__api__evfs__vault_read_stream_impl( } fn wire__crate__api__evfs__vault_resize_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + new_capacity: impl CstDecode, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_resize", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_new_capacity = ::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_new_capacity = new_capacity.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -2074,36 +1531,26 @@ fn wire__crate__api__evfs__vault_resize_impl( } fn wire__crate__api__evfs__vault_write_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + name: impl CstDecode, + data: impl CstDecode>, + compression: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_write", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_name = ::sse_decode(&mut deserializer); - let api_data = >::sse_decode(&mut deserializer); - let api_compression = - >::sse_decode(&mut deserializer); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_name = name.cst_decode(); + let api_data = data.cst_decode(); + let api_compression = compression.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -2134,38 +1581,26 @@ fn wire__crate__api__evfs__vault_write_impl( } fn wire__crate__api__evfs__vault_write_file_impl( port_: flutter_rust_bridge::for_generated::MessagePort, - ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr, - rust_vec_len_: i32, - data_len_: i32, + handle: impl CstDecode< + RustOpaqueNom>, + >, + name: impl CstDecode, + file_path: impl CstDecode, + on_progress: impl CstDecode>, ) { - FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( + FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::( flutter_rust_bridge::for_generated::TaskInfo { debug_name: "vault_write_file", port: Some(port_), mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal, }, move || { - let message = unsafe { - flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire( - ptr_, - rust_vec_len_, - data_len_, - ) - }; - let mut deserializer = - flutter_rust_bridge::for_generated::SseDeserializer::new(message); - let api_handle = , - >>::sse_decode(&mut deserializer); - let api_name = ::sse_decode(&mut deserializer); - let api_file_path = ::sse_decode(&mut deserializer); - let api_on_progress = - >::sse_decode( - &mut deserializer, - ); - deserializer.end(); + let api_handle = handle.cst_decode(); + let api_name = name.cst_decode(); + let api_file_path = file_path.cst_decode(); + let api_on_progress = on_progress.cst_decode(); move |context| { - transform_result_sse::<_, crate::core::error::CryptoError>((move || { + transform_result_dco::<_, _, crate::core::error::CryptoError>((move || { let mut api_handle_guard = None; let decode_indices_ = flutter_rust_bridge::for_generated::lockable_compute_decode_order(vec![ @@ -2195,20 +1630,71 @@ fn wire__crate__api__evfs__vault_write_file_impl( ) } -// Section: related_funcs - -flutter_rust_bridge::frb_generated_moi_arc_impl_value!( - flutter_rust_bridge::for_generated::RustAutoOpaqueInner -); -flutter_rust_bridge::frb_generated_moi_arc_impl_value!( - flutter_rust_bridge::for_generated::RustAutoOpaqueInner -); -flutter_rust_bridge::frb_generated_moi_arc_impl_value!( - flutter_rust_bridge::for_generated::RustAutoOpaqueInner -); - // Section: dart2rust +impl CstDecode for i32 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::hashing::argon2::Argon2Preset { + match self { + 0 => crate::api::hashing::argon2::Argon2Preset::Mobile, + 1 => crate::api::hashing::argon2::Argon2Preset::Desktop, + _ => unreachable!("Invalid variant for Argon2Preset: {}", self), + } + } +} +impl CstDecode for bool { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> bool { + self + } +} +impl CstDecode for i32 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::compression::CompressionAlgorithm { + match self { + 0 => crate::api::compression::CompressionAlgorithm::Zstd, + 1 => crate::api::compression::CompressionAlgorithm::Brotli, + 2 => crate::api::compression::CompressionAlgorithm::None, + _ => unreachable!("Invalid variant for CompressionAlgorithm: {}", self), + } + } +} +impl CstDecode for f64 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> f64 { + self + } +} +impl CstDecode for i32 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> i32 { + self + } +} +impl CstDecode for u32 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> u32 { + self + } +} +impl CstDecode for u64 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> u64 { + self + } +} +impl CstDecode for u8 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> u8 { + self + } +} +impl CstDecode for usize { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> usize { + self + } +} impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { @@ -2220,7 +1706,7 @@ impl SseDecode for flutter_rust_bridge::for_generated::anyhow::Error { impl SseDecode for CipherHandle { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = , >>::sse_decode(deserializer); return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner); @@ -2230,7 +1716,7 @@ impl SseDecode for CipherHandle { impl SseDecode for HasherHandle { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = , >>::sse_decode(deserializer); return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner); @@ -2240,7 +1726,7 @@ impl SseDecode for HasherHandle { impl SseDecode for VaultHandle { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { - let mut inner = , >>::sse_decode(deserializer); return flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(inner); @@ -2248,36 +1734,36 @@ impl SseDecode for VaultHandle { } impl SseDecode - for RustOpaqueMoi> + for RustOpaqueNom> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut inner = ::sse_decode(deserializer); - return decode_rust_opaque_moi(inner); + return unsafe { decode_rust_opaque_nom(inner) }; } } impl SseDecode - for RustOpaqueMoi> + for RustOpaqueNom> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut inner = ::sse_decode(deserializer); - return decode_rust_opaque_moi(inner); + return unsafe { decode_rust_opaque_nom(inner) }; } } impl SseDecode - for RustOpaqueMoi> + for RustOpaqueNom> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut inner = ::sse_decode(deserializer); - return decode_rust_opaque_moi(inner); + return unsafe { decode_rust_opaque_nom(inner) }; } } -impl SseDecode for StreamSink { +impl SseDecode for StreamSink { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut inner = ::sse_decode(deserializer); @@ -2285,7 +1771,7 @@ impl SseDecode for StreamSink } } -impl SseDecode for StreamSink, flutter_rust_bridge::for_generated::SseCodec> { +impl SseDecode for StreamSink, flutter_rust_bridge::for_generated::DcoCodec> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self { let mut inner = ::sse_decode(deserializer); @@ -2591,137 +2077,6 @@ fn pde_ffi_dispatcher_primary_impl( ) { // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { - 1 => wire__crate__api__evfs__types__VaultHandle_health_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 2 => { - wire__crate__api__hashing__argon2__argon2id_hash_impl(port, ptr, rust_vec_len, data_len) - } - 3 => wire__crate__api__hashing__argon2__argon2id_hash_with_salt_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 4 => wire__crate__api__hashing__argon2__argon2id_verify_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 5 => wire__crate__api__hashing__blake3_hash_impl(port, ptr, rust_vec_len, data_len), - 6 => wire__crate__api__compression__compress_impl(port, ptr, rust_vec_len, data_len), - 7 => wire__crate__api__compression__compression_algorithm_from_u8_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 8 => wire__crate__api__compression__compression_algorithm_to_u8_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 9 => { - wire__crate__api__encryption__create_aes256_gcm_impl(port, ptr, rust_vec_len, data_len) - } - 10 => wire__crate__api__hashing__create_blake3_impl(port, ptr, rust_vec_len, data_len), - 11 => wire__crate__api__encryption__create_chacha20_poly1305_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 12 => wire__crate__api__encryption__create_noop_encryption_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 13 => wire__crate__api__hashing__create_sha3_impl(port, ptr, rust_vec_len, data_len), - 14 => wire__crate__api__compression__decompress_impl(port, ptr, rust_vec_len, data_len), - 15 => wire__crate__api__encryption__decrypt_impl(port, ptr, rust_vec_len, data_len), - 16 => wire__crate__api__encryption__encrypt_impl(port, ptr, rust_vec_len, data_len), - 17 => wire__crate__api__encryption__encryption_algorithm_id_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 18 => wire__crate__api__encryption__generate_aes256_gcm_key_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 19 => wire__crate__api__encryption__aes_gcm__generate_aes_key_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 20 => wire__crate__api__encryption__generate_chacha20_poly1305_key_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 21 => wire__crate__api__encryption__chacha20__generate_chacha_key_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 22 => { - wire__crate__api__hashing__hasher_algorithm_id_impl(port, ptr, rust_vec_len, data_len) - } - 23 => wire__crate__api__hashing__hasher_finalize_impl(port, ptr, rust_vec_len, data_len), - 24 => wire__crate__api__hashing__hasher_reset_impl(port, ptr, rust_vec_len, data_len), - 25 => wire__crate__api__hashing__hasher_update_impl(port, ptr, rust_vec_len, data_len), - 27 => wire__crate__api__kdf__hkdf__hkdf_expand_impl(port, ptr, rust_vec_len, data_len), - 29 => wire__crate__api__hashing__sha3_hash_impl(port, ptr, rust_vec_len, data_len), - 30 => wire__crate__api__compression__should_skip_compression_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 31 => wire__crate__api__streaming__stream_compress_encrypt_file_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 32 => wire__crate__api__streaming__stream_decrypt_decompress_file_impl( - port, - ptr, - rust_vec_len, - data_len, - ), - 33 => { - wire__crate__api__streaming__stream_decrypt_file_impl(port, ptr, rust_vec_len, data_len) - } - 34 => { - wire__crate__api__streaming__stream_encrypt_file_impl(port, ptr, rust_vec_len, data_len) - } - 35 => wire__crate__api__streaming__stream_hash_file_impl(port, ptr, rust_vec_len, data_len), - 36 => wire__crate__api__evfs__vault_capacity_impl(port, ptr, rust_vec_len, data_len), - 37 => wire__crate__api__evfs__vault_close_impl(port, ptr, rust_vec_len, data_len), - 38 => wire__crate__api__evfs__vault_create_impl(port, ptr, rust_vec_len, data_len), - 39 => wire__crate__api__evfs__vault_defragment_impl(port, ptr, rust_vec_len, data_len), - 40 => wire__crate__api__evfs__vault_delete_impl(port, ptr, rust_vec_len, data_len), - 41 => wire__crate__api__evfs__vault_health_impl(port, ptr, rust_vec_len, data_len), - 42 => wire__crate__api__evfs__vault_list_impl(port, ptr, rust_vec_len, data_len), - 43 => wire__crate__api__evfs__vault_open_impl(port, ptr, rust_vec_len, data_len), - 44 => wire__crate__api__evfs__vault_read_impl(port, ptr, rust_vec_len, data_len), - 45 => wire__crate__api__evfs__vault_read_stream_impl(port, ptr, rust_vec_len, data_len), - 46 => wire__crate__api__evfs__vault_resize_impl(port, ptr, rust_vec_len, data_len), - 47 => wire__crate__api__evfs__vault_write_impl(port, ptr, rust_vec_len, data_len), - 48 => wire__crate__api__evfs__vault_write_file_impl(port, ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -2734,8 +2089,6 @@ fn pde_ffi_dispatcher_sync_impl( ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse { // Codec=Pde (Serialization + dispatch), see doc to use other codecs match func_id { - 26 => wire__crate__api__kdf__hkdf__hkdf_derive_impl(ptr, rust_vec_len, data_len), - 28 => wire__crate__api__kdf__hkdf__hkdf_extract_impl(ptr, rust_vec_len, data_len), _ => unreachable!(), } } @@ -2745,7 +2098,7 @@ fn pde_ffi_dispatcher_sync_impl( // Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for FrbWrapper { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { - flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0) + flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0) .into_dart() } } @@ -2760,7 +2113,7 @@ impl flutter_rust_bridge::IntoIntoDart> for CipherHandl // Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for FrbWrapper { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { - flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0) + flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0) .into_dart() } } @@ -2775,7 +2128,7 @@ impl flutter_rust_bridge::IntoIntoDart> for HasherHandl // Codec=Dco (DartCObject based), see doc to use other codecs impl flutter_rust_bridge::IntoDart for FrbWrapper { fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi { - flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0) + flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self.0) .into_dart() } } @@ -2997,26 +2350,26 @@ impl SseEncode for flutter_rust_bridge::for_generated::anyhow::Error { impl SseEncode for CipherHandle { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - >>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer); + >>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer); } } impl SseEncode for HasherHandle { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - >>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer); + >>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer); } } impl SseEncode for VaultHandle { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { - >>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer); + >>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, StdArc<_>>(self), serializer); } } impl SseEncode - for RustOpaqueMoi> + for RustOpaqueNom> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -3027,7 +2380,7 @@ impl SseEncode } impl SseEncode - for RustOpaqueMoi> + for RustOpaqueNom> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -3038,7 +2391,7 @@ impl SseEncode } impl SseEncode - for RustOpaqueMoi> + for RustOpaqueNom> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { @@ -3048,14 +2401,14 @@ impl SseEncode } } -impl SseEncode for StreamSink { +impl SseEncode for StreamSink { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { unimplemented!("") } } -impl SseEncode for StreamSink, flutter_rust_bridge::for_generated::SseCodec> { +impl SseEncode for StreamSink, flutter_rust_bridge::for_generated::DcoCodec> { // Codec=Sse (Serialization based), see doc to use other codecs fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) { unimplemented!("") @@ -3338,115 +2691,1908 @@ mod io { flutter_rust_bridge::frb_generated_boilerplate_io!(); + // Section: dart2rust + + impl CstDecode + for *mut wire_cst_list_prim_u_8_strict + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error { + unimplemented!() + } + } + impl CstDecode for usize { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> CipherHandle { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner, + >, + >::cst_decode( + self + )) + } + } + impl CstDecode for usize { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> HasherHandle { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner, + >, + >::cst_decode( + self + )) + } + } + impl CstDecode for usize { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> VaultHandle { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom>, + >::cst_decode( + self + )) + } + } + impl + CstDecode< + RustOpaqueNom>, + > for usize + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom> + { + unsafe { decode_rust_opaque_nom(self as _) } + } + } + impl + CstDecode< + RustOpaqueNom>, + > for usize + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom> + { + unsafe { decode_rust_opaque_nom(self as _) } + } + } + impl + CstDecode< + RustOpaqueNom>, + > for usize + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom> + { + unsafe { decode_rust_opaque_nom(self as _) } + } + } + impl CstDecode> + for *mut wire_cst_list_prim_u_8_strict + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> StreamSink { + let raw: String = self.cst_decode(); + StreamSink::deserialize(raw) + } + } + impl CstDecode, flutter_rust_bridge::for_generated::DcoCodec>> + for *mut wire_cst_list_prim_u_8_strict + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> StreamSink, flutter_rust_bridge::for_generated::DcoCodec> { + let raw: String = self.cst_decode(); + StreamSink::deserialize(raw) + } + } + impl CstDecode for *mut wire_cst_list_prim_u_8_strict { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> String { + let vec: Vec = self.cst_decode(); + String::from_utf8(vec).unwrap() + } + } + impl CstDecode for *mut wire_cst_compression_config { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::compression::CompressionConfig { + let wrap = unsafe { flutter_rust_bridge::for_generated::box_from_leak_ptr(self) }; + CstDecode::::cst_decode(*wrap).into() + } + } + impl CstDecode for *mut i32 { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> i32 { + unsafe { *flutter_rust_bridge::for_generated::box_from_leak_ptr(self) } + } + } + impl CstDecode for wire_cst_compression_config { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::compression::CompressionConfig { + crate::api::compression::CompressionConfig { + algorithm: self.algorithm.cst_decode(), + level: self.level.cst_decode(), + } + } + } + impl CstDecode for wire_cst_crypto_error { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::core::error::CryptoError { + match self.tag { + 0 => { + let ans = unsafe { self.kind.InvalidKeyLength }; + crate::core::error::CryptoError::InvalidKeyLength { + expected: ans.expected.cst_decode(), + actual: ans.actual.cst_decode(), + } + } + 1 => crate::core::error::CryptoError::InvalidNonce, + 2 => { + let ans = unsafe { self.kind.EncryptionFailed }; + crate::core::error::CryptoError::EncryptionFailed(ans.field0.cst_decode()) + } + 3 => crate::core::error::CryptoError::DecryptionFailed, + 4 => { + let ans = unsafe { self.kind.HashingFailed }; + crate::core::error::CryptoError::HashingFailed(ans.field0.cst_decode()) + } + 5 => { + let ans = unsafe { self.kind.KdfFailed }; + crate::core::error::CryptoError::KdfFailed(ans.field0.cst_decode()) + } + 6 => { + let ans = unsafe { self.kind.IoError }; + crate::core::error::CryptoError::IoError(ans.field0.cst_decode()) + } + 7 => { + let ans = unsafe { self.kind.InvalidParameter }; + crate::core::error::CryptoError::InvalidParameter(ans.field0.cst_decode()) + } + 8 => { + let ans = unsafe { self.kind.CompressionFailed }; + crate::core::error::CryptoError::CompressionFailed(ans.field0.cst_decode()) + } + 9 => crate::core::error::CryptoError::AuthenticationFailed, + 10 => { + let ans = unsafe { self.kind.VaultFull }; + crate::core::error::CryptoError::VaultFull { + needed: ans.needed.cst_decode(), + available: ans.available.cst_decode(), + } + } + 11 => crate::core::error::CryptoError::VaultLocked, + 12 => { + let ans = unsafe { self.kind.SegmentNotFound }; + crate::core::error::CryptoError::SegmentNotFound(ans.field0.cst_decode()) + } + 13 => { + let ans = unsafe { self.kind.VaultCorrupted }; + crate::core::error::CryptoError::VaultCorrupted(ans.field0.cst_decode()) + } + _ => unreachable!(), + } + } + } + impl CstDecode for wire_cst_defrag_result { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::evfs::types::DefragResult { + crate::api::evfs::types::DefragResult { + segments_moved: self.segments_moved.cst_decode(), + bytes_reclaimed: self.bytes_reclaimed.cst_decode(), + free_regions_before: self.free_regions_before.cst_decode(), + } + } + } + impl CstDecode> for *mut wire_cst_list_String { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Vec { + let vec = unsafe { + let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self); + flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len) + }; + vec.into_iter().map(CstDecode::cst_decode).collect() + } + } + impl CstDecode> for *mut wire_cst_list_prim_u_8_loose { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Vec { + unsafe { + let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self); + flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len) + } + } + } + impl CstDecode> for *mut wire_cst_list_prim_u_8_strict { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Vec { + unsafe { + let wrap = flutter_rust_bridge::for_generated::box_from_leak_ptr(self); + flutter_rust_bridge::for_generated::vec_from_leak_ptr(wrap.ptr, wrap.len) + } + } + } + impl CstDecode for wire_cst_vault_capacity_info { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::evfs::types::VaultCapacityInfo { + crate::api::evfs::types::VaultCapacityInfo { + total_bytes: self.total_bytes.cst_decode(), + used_bytes: self.used_bytes.cst_decode(), + free_list_bytes: self.free_list_bytes.cst_decode(), + unallocated_bytes: self.unallocated_bytes.cst_decode(), + segment_count: self.segment_count.cst_decode(), + } + } + } + impl CstDecode for wire_cst_vault_health_info { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::evfs::types::VaultHealthInfo { + crate::api::evfs::types::VaultHealthInfo { + total_bytes: self.total_bytes.cst_decode(), + used_bytes: self.used_bytes.cst_decode(), + free_list_bytes: self.free_list_bytes.cst_decode(), + unallocated_bytes: self.unallocated_bytes.cst_decode(), + segment_count: self.segment_count.cst_decode(), + free_region_count: self.free_region_count.cst_decode(), + largest_free_block: self.largest_free_block.cst_decode(), + fragmentation_ratio: self.fragmentation_ratio.cst_decode(), + is_consistent: self.is_consistent.cst_decode(), + } + } + } + impl NewWithNullPtr for wire_cst_compression_config { + fn new_with_null_ptr() -> Self { + Self { + algorithm: Default::default(), + level: core::ptr::null_mut(), + } + } + } + impl Default for wire_cst_compression_config { + fn default() -> Self { + Self::new_with_null_ptr() + } + } + impl NewWithNullPtr for wire_cst_crypto_error { + fn new_with_null_ptr() -> Self { + Self { + tag: -1, + kind: CryptoErrorKind { nil__: () }, + } + } + } + impl Default for wire_cst_crypto_error { + fn default() -> Self { + Self::new_with_null_ptr() + } + } + impl NewWithNullPtr for wire_cst_defrag_result { + fn new_with_null_ptr() -> Self { + Self { + segments_moved: Default::default(), + bytes_reclaimed: Default::default(), + free_regions_before: Default::default(), + } + } + } + impl Default for wire_cst_defrag_result { + fn default() -> Self { + Self::new_with_null_ptr() + } + } + impl NewWithNullPtr for wire_cst_vault_capacity_info { + fn new_with_null_ptr() -> Self { + Self { + total_bytes: Default::default(), + used_bytes: Default::default(), + free_list_bytes: Default::default(), + unallocated_bytes: Default::default(), + segment_count: Default::default(), + } + } + } + impl Default for wire_cst_vault_capacity_info { + fn default() -> Self { + Self::new_with_null_ptr() + } + } + impl NewWithNullPtr for wire_cst_vault_health_info { + fn new_with_null_ptr() -> Self { + Self { + total_bytes: Default::default(), + used_bytes: Default::default(), + free_list_bytes: Default::default(), + unallocated_bytes: Default::default(), + segment_count: Default::default(), + free_region_count: Default::default(), + largest_free_block: Default::default(), + fragmentation_ratio: Default::default(), + is_consistent: Default::default(), + } + } + } + impl Default for wire_cst_vault_health_info { + fn default() -> Self { + Self::new_with_null_ptr() + } + } + #[unsafe(no_mangle)] - pub extern "C" fn frbgen_m_security_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - ptr: *const std::ffi::c_void, + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__types__VaultHandle_health( + port_: i64, + that: usize, ) { - MoiArc::>::increment_strong_count(ptr as _); + wire__crate__api__evfs__types__VaultHandle_health_impl(port_, that) } #[unsafe(no_mangle)] - pub extern "C" fn frbgen_m_security_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - ptr: *const std::ffi::c_void, + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__argon2__argon2id_hash( + port_: i64, + password: *mut wire_cst_list_prim_u_8_strict, + preset: i32, ) { - MoiArc::>::decrement_strong_count(ptr as _); + wire__crate__api__hashing__argon2__argon2id_hash_impl(port_, password, preset) } #[unsafe(no_mangle)] - pub extern "C" fn frbgen_m_security_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - ptr: *const std::ffi::c_void, + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + port_: i64, + password: *mut wire_cst_list_prim_u_8_strict, + salt: *mut wire_cst_list_prim_u_8_strict, + preset: i32, ) { - MoiArc::>::increment_strong_count(ptr as _); + wire__crate__api__hashing__argon2__argon2id_hash_with_salt_impl( + port_, password, salt, preset, + ) } #[unsafe(no_mangle)] - pub extern "C" fn frbgen_m_security_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - ptr: *const std::ffi::c_void, + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__argon2__argon2id_verify( + port_: i64, + phc_hash: *mut wire_cst_list_prim_u_8_strict, + password: *mut wire_cst_list_prim_u_8_strict, ) { - MoiArc::>::decrement_strong_count(ptr as _); + wire__crate__api__hashing__argon2__argon2id_verify_impl(port_, phc_hash, password) } #[unsafe(no_mangle)] - pub extern "C" fn frbgen_m_security_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - ptr: *const std::ffi::c_void, + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__blake3_hash( + port_: i64, + data: *mut wire_cst_list_prim_u_8_loose, ) { - MoiArc::>::increment_strong_count(ptr as _); + wire__crate__api__hashing__blake3_hash_impl(port_, data) } #[unsafe(no_mangle)] - pub extern "C" fn frbgen_m_security_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - ptr: *const std::ffi::c_void, + pub extern "C" fn frbgen_m_security_wire__crate__api__compression__compress( + port_: i64, + data: *mut wire_cst_list_prim_u_8_loose, + config: *mut wire_cst_compression_config, ) { - MoiArc::>::decrement_strong_count(ptr as _); + wire__crate__api__compression__compress_impl(port_, data, config) } -} -#[cfg(not(target_family = "wasm"))] -pub use io::*; -/// cbindgen:ignore -#[cfg(target_family = "wasm")] -mod web { - // This file is automatically generated, so please do not edit it. - // @generated by `flutter_rust_bridge`@ 2.11.1. + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__compression__compression_algorithm_from_u8( + port_: i64, + byte: u8, + ) { + wire__crate__api__compression__compression_algorithm_from_u8_impl(port_, byte) + } - // Section: imports + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__compression__compression_algorithm_to_u8( + port_: i64, + that: i32, + ) { + wire__crate__api__compression__compression_algorithm_to_u8_impl(port_, that) + } - use super::*; - use crate::api::encryption::*; - use crate::api::evfs::types::*; - use crate::api::hashing::*; - use flutter_rust_bridge::for_generated::byteorder::{ - NativeEndian, ReadBytesExt, WriteBytesExt, - }; - use flutter_rust_bridge::for_generated::wasm_bindgen; - use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*; - use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable}; - use flutter_rust_bridge::{Handler, IntoIntoDart}; + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__create_aes256_gcm( + port_: i64, + key: *mut wire_cst_list_prim_u_8_loose, + ) { + wire__crate__api__encryption__create_aes256_gcm_impl(port_, key) + } - // Section: boilerplate + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__create_blake3(port_: i64) { + wire__crate__api__hashing__create_blake3_impl(port_) + } - flutter_rust_bridge::frb_generated_boilerplate_web!(); + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__create_chacha20_poly1305( + port_: i64, + key: *mut wire_cst_list_prim_u_8_loose, + ) { + wire__crate__api__encryption__create_chacha20_poly1305_impl(port_, key) + } - #[wasm_bindgen] - pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - ptr: *const std::ffi::c_void, + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__create_noop_encryption( + port_: i64, ) { - MoiArc::>::increment_strong_count(ptr as _); + wire__crate__api__encryption__create_noop_encryption_impl(port_) } - #[wasm_bindgen] - pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( - ptr: *const std::ffi::c_void, + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__create_sha3(port_: i64) { + wire__crate__api__hashing__create_sha3_impl(port_) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__compression__decompress( + port_: i64, + data: *mut wire_cst_list_prim_u_8_loose, + algorithm: i32, ) { - MoiArc::>::decrement_strong_count(ptr as _); + wire__crate__api__compression__decompress_impl(port_, data, algorithm) } - #[wasm_bindgen] - pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - ptr: *const std::ffi::c_void, + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__decrypt( + port_: i64, + cipher: usize, + ciphertext: *mut wire_cst_list_prim_u_8_loose, + aad: *mut wire_cst_list_prim_u_8_loose, ) { - MoiArc::>::increment_strong_count(ptr as _); + wire__crate__api__encryption__decrypt_impl(port_, cipher, ciphertext, aad) } - #[wasm_bindgen] - pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( - ptr: *const std::ffi::c_void, + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__encrypt( + port_: i64, + cipher: usize, + plaintext: *mut wire_cst_list_prim_u_8_loose, + aad: *mut wire_cst_list_prim_u_8_loose, ) { - MoiArc::>::decrement_strong_count(ptr as _); + wire__crate__api__encryption__encrypt_impl(port_, cipher, plaintext, aad) } - #[wasm_bindgen] - pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - ptr: *const std::ffi::c_void, + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__encryption_algorithm_id( + port_: i64, + cipher: usize, ) { - MoiArc::>::increment_strong_count(ptr as _); + wire__crate__api__encryption__encryption_algorithm_id_impl(port_, cipher) } - #[wasm_bindgen] - pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( - ptr: *const std::ffi::c_void, + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__generate_aes256_gcm_key( + port_: i64, + ) { + wire__crate__api__encryption__generate_aes256_gcm_key_impl(port_) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__aes_gcm__generate_aes_key( + port_: i64, ) { - MoiArc::>::decrement_strong_count(ptr as _); + wire__crate__api__encryption__aes_gcm__generate_aes_key_impl(port_) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__generate_chacha20_poly1305_key( + port_: i64, + ) { + wire__crate__api__encryption__generate_chacha20_poly1305_key_impl(port_) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__encryption__chacha20__generate_chacha_key( + port_: i64, + ) { + wire__crate__api__encryption__chacha20__generate_chacha_key_impl(port_) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__hasher_algorithm_id( + port_: i64, + handle: usize, + ) { + wire__crate__api__hashing__hasher_algorithm_id_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__hasher_finalize( + port_: i64, + handle: usize, + ) { + wire__crate__api__hashing__hasher_finalize_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__hasher_reset( + port_: i64, + handle: usize, + ) { + wire__crate__api__hashing__hasher_reset_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__hasher_update( + port_: i64, + handle: usize, + data: *mut wire_cst_list_prim_u_8_loose, + ) { + wire__crate__api__hashing__hasher_update_impl(port_, handle, data) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__kdf__hkdf__hkdf_derive( + ikm: *mut wire_cst_list_prim_u_8_loose, + salt: *mut wire_cst_list_prim_u_8_strict, + info: *mut wire_cst_list_prim_u_8_loose, + output_len: usize, + ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__kdf__hkdf__hkdf_derive_impl(ikm, salt, info, output_len) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__kdf__hkdf__hkdf_expand( + port_: i64, + prk: *mut wire_cst_list_prim_u_8_loose, + info: *mut wire_cst_list_prim_u_8_loose, + output_len: usize, + ) { + wire__crate__api__kdf__hkdf__hkdf_expand_impl(port_, prk, info, output_len) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__kdf__hkdf__hkdf_extract( + ikm: *mut wire_cst_list_prim_u_8_loose, + salt: *mut wire_cst_list_prim_u_8_strict, + ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__kdf__hkdf__hkdf_extract_impl(ikm, salt) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__hashing__sha3_hash( + port_: i64, + data: *mut wire_cst_list_prim_u_8_loose, + ) { + wire__crate__api__hashing__sha3_hash_impl(port_, data) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__compression__should_skip_compression( + port_: i64, + file_path: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__compression__should_skip_compression_impl(port_, file_path) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__streaming__stream_compress_encrypt_file( + port_: i64, + cipher: usize, + compression: *mut wire_cst_compression_config, + input_path: *mut wire_cst_list_prim_u_8_strict, + output_path: *mut wire_cst_list_prim_u_8_strict, + progress_sink: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__streaming__stream_compress_encrypt_file_impl( + port_, + cipher, + compression, + input_path, + output_path, + progress_sink, + ) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__streaming__stream_decrypt_decompress_file( + port_: i64, + cipher: usize, + input_path: *mut wire_cst_list_prim_u_8_strict, + output_path: *mut wire_cst_list_prim_u_8_strict, + progress_sink: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__streaming__stream_decrypt_decompress_file_impl( + port_, + cipher, + input_path, + output_path, + progress_sink, + ) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__streaming__stream_decrypt_file( + port_: i64, + cipher: usize, + input_path: *mut wire_cst_list_prim_u_8_strict, + output_path: *mut wire_cst_list_prim_u_8_strict, + progress_sink: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__streaming__stream_decrypt_file_impl( + port_, + cipher, + input_path, + output_path, + progress_sink, + ) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__streaming__stream_encrypt_file( + port_: i64, + cipher: usize, + input_path: *mut wire_cst_list_prim_u_8_strict, + output_path: *mut wire_cst_list_prim_u_8_strict, + progress_sink: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__streaming__stream_encrypt_file_impl( + port_, + cipher, + input_path, + output_path, + progress_sink, + ) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__streaming__stream_hash_file( + port_: i64, + hasher: usize, + file_path: *mut wire_cst_list_prim_u_8_strict, + progress_sink: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__streaming__stream_hash_file_impl(port_, hasher, file_path, progress_sink) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_capacity( + port_: i64, + handle: usize, + ) { + wire__crate__api__evfs__vault_capacity_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_close( + port_: i64, + handle: usize, + ) { + wire__crate__api__evfs__vault_close_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_create( + port_: i64, + path: *mut wire_cst_list_prim_u_8_strict, + key: *mut wire_cst_list_prim_u_8_loose, + algorithm: *mut wire_cst_list_prim_u_8_strict, + capacity_bytes: u64, + ) { + wire__crate__api__evfs__vault_create_impl(port_, path, key, algorithm, capacity_bytes) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_defragment( + port_: i64, + handle: usize, + ) { + wire__crate__api__evfs__vault_defragment_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_delete( + port_: i64, + handle: usize, + name: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__evfs__vault_delete_impl(port_, handle, name) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_health( + port_: i64, + handle: usize, + ) { + wire__crate__api__evfs__vault_health_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_list( + port_: i64, + handle: usize, + ) { + wire__crate__api__evfs__vault_list_impl(port_, handle) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_open( + port_: i64, + path: *mut wire_cst_list_prim_u_8_strict, + key: *mut wire_cst_list_prim_u_8_loose, + ) { + wire__crate__api__evfs__vault_open_impl(port_, path, key) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_read( + port_: i64, + handle: usize, + name: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__evfs__vault_read_impl(port_, handle, name) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_read_stream( + port_: i64, + handle: usize, + name: *mut wire_cst_list_prim_u_8_strict, + verify_checksum: bool, + sink: *mut wire_cst_list_prim_u_8_strict, + on_progress: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__evfs__vault_read_stream_impl( + port_, + handle, + name, + verify_checksum, + sink, + on_progress, + ) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_resize( + port_: i64, + handle: usize, + new_capacity: u64, + ) { + wire__crate__api__evfs__vault_resize_impl(port_, handle, new_capacity) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_write( + port_: i64, + handle: usize, + name: *mut wire_cst_list_prim_u_8_strict, + data: *mut wire_cst_list_prim_u_8_loose, + compression: *mut wire_cst_compression_config, + ) { + wire__crate__api__evfs__vault_write_impl(port_, handle, name, data, compression) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_wire__crate__api__evfs__vault_write_file( + port_: i64, + handle: usize, + name: *mut wire_cst_list_prim_u_8_strict, + file_path: *mut wire_cst_list_prim_u_8_strict, + on_progress: *mut wire_cst_list_prim_u_8_strict, + ) { + wire__crate__api__evfs__vault_write_file_impl(port_, handle, name, file_path, on_progress) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::increment_strong_count(ptr as _); + } + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::decrement_strong_count(ptr as _); + } + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::increment_strong_count(ptr as _); + } + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::decrement_strong_count(ptr as _); + } + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::increment_strong_count(ptr as _); + } + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::decrement_strong_count(ptr as _); + } + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_cst_new_box_autoadd_compression_config( + ) -> *mut wire_cst_compression_config { + flutter_rust_bridge::for_generated::new_leak_box_ptr( + wire_cst_compression_config::new_with_null_ptr(), + ) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_cst_new_box_autoadd_i_32(value: i32) -> *mut i32 { + flutter_rust_bridge::for_generated::new_leak_box_ptr(value) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_cst_new_list_String(len: i32) -> *mut wire_cst_list_String { + let wrap = wire_cst_list_String { + ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr( + <*mut wire_cst_list_prim_u_8_strict>::new_with_null_ptr(), + len, + ), + len, + }; + flutter_rust_bridge::for_generated::new_leak_box_ptr(wrap) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_cst_new_list_prim_u_8_loose( + len: i32, + ) -> *mut wire_cst_list_prim_u_8_loose { + let ans = wire_cst_list_prim_u_8_loose { + ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len), + len, + }; + flutter_rust_bridge::for_generated::new_leak_box_ptr(ans) + } + + #[unsafe(no_mangle)] + pub extern "C" fn frbgen_m_security_cst_new_list_prim_u_8_strict( + len: i32, + ) -> *mut wire_cst_list_prim_u_8_strict { + let ans = wire_cst_list_prim_u_8_strict { + ptr: flutter_rust_bridge::for_generated::new_leak_vec_ptr(Default::default(), len), + len, + }; + flutter_rust_bridge::for_generated::new_leak_box_ptr(ans) + } + + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_compression_config { + algorithm: i32, + level: *mut i32, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_crypto_error { + tag: i32, + kind: CryptoErrorKind, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub union CryptoErrorKind { + InvalidKeyLength: wire_cst_CryptoError_InvalidKeyLength, + EncryptionFailed: wire_cst_CryptoError_EncryptionFailed, + HashingFailed: wire_cst_CryptoError_HashingFailed, + KdfFailed: wire_cst_CryptoError_KdfFailed, + IoError: wire_cst_CryptoError_IoError, + InvalidParameter: wire_cst_CryptoError_InvalidParameter, + CompressionFailed: wire_cst_CryptoError_CompressionFailed, + VaultFull: wire_cst_CryptoError_VaultFull, + SegmentNotFound: wire_cst_CryptoError_SegmentNotFound, + VaultCorrupted: wire_cst_CryptoError_VaultCorrupted, + nil__: (), + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_InvalidKeyLength { + expected: usize, + actual: usize, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_EncryptionFailed { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_HashingFailed { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_KdfFailed { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_IoError { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_InvalidParameter { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_CompressionFailed { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_VaultFull { + needed: u64, + available: u64, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_SegmentNotFound { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_CryptoError_VaultCorrupted { + field0: *mut wire_cst_list_prim_u_8_strict, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_defrag_result { + segments_moved: u32, + bytes_reclaimed: u64, + free_regions_before: u32, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_list_String { + ptr: *mut *mut wire_cst_list_prim_u_8_strict, + len: i32, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_list_prim_u_8_loose { + ptr: *mut u8, + len: i32, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_list_prim_u_8_strict { + ptr: *mut u8, + len: i32, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_vault_capacity_info { + total_bytes: u64, + used_bytes: u64, + free_list_bytes: u64, + unallocated_bytes: u64, + segment_count: usize, + } + #[repr(C)] + #[derive(Clone, Copy)] + pub struct wire_cst_vault_health_info { + total_bytes: u64, + used_bytes: u64, + free_list_bytes: u64, + unallocated_bytes: u64, + segment_count: u32, + free_region_count: u32, + largest_free_block: u64, + fragmentation_ratio: f64, + is_consistent: bool, + } +} +#[cfg(not(target_family = "wasm"))] +pub use io::*; + +/// cbindgen:ignore +#[cfg(target_family = "wasm")] +mod web { + // This file is automatically generated, so please do not edit it. + // @generated by `flutter_rust_bridge`@ 2.11.1. + + // Section: imports + + use super::*; + use crate::api::encryption::*; + use crate::api::evfs::types::*; + use crate::api::hashing::*; + use flutter_rust_bridge::for_generated::byteorder::{ + NativeEndian, ReadBytesExt, WriteBytesExt, + }; + use flutter_rust_bridge::for_generated::wasm_bindgen; + use flutter_rust_bridge::for_generated::wasm_bindgen::prelude::*; + use flutter_rust_bridge::for_generated::{transform_result_dco, Lifetimeable, Lockable}; + use flutter_rust_bridge::{Handler, IntoIntoDart}; + + // Section: boilerplate + + flutter_rust_bridge::frb_generated_boilerplate_web!(); + + // Section: dart2rust + + impl CstDecode for String { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error { + unimplemented!() + } + } + impl CstDecode> for String { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> StreamSink { + StreamSink::deserialize(self) + } + } + impl CstDecode, flutter_rust_bridge::for_generated::DcoCodec>> for String { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> StreamSink, flutter_rust_bridge::for_generated::DcoCodec> { + StreamSink::deserialize(self) + } + } + impl CstDecode for String { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> String { + self + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::compression::CompressionConfig { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 2, + "Expected 2 elements, got {}", + self_.length() + ); + crate::api::compression::CompressionConfig { + algorithm: self_.get(0).cst_decode(), + level: self_.get(1).cst_decode(), + } + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::core::error::CryptoError { + let self_ = self.unchecked_into::(); + match self_.get(0).unchecked_into_f64() as _ { + 0 => crate::core::error::CryptoError::InvalidKeyLength { + expected: self_.get(1).cst_decode(), + actual: self_.get(2).cst_decode(), + }, + 1 => crate::core::error::CryptoError::InvalidNonce, + 2 => crate::core::error::CryptoError::EncryptionFailed(self_.get(1).cst_decode()), + 3 => crate::core::error::CryptoError::DecryptionFailed, + 4 => crate::core::error::CryptoError::HashingFailed(self_.get(1).cst_decode()), + 5 => crate::core::error::CryptoError::KdfFailed(self_.get(1).cst_decode()), + 6 => crate::core::error::CryptoError::IoError(self_.get(1).cst_decode()), + 7 => crate::core::error::CryptoError::InvalidParameter(self_.get(1).cst_decode()), + 8 => crate::core::error::CryptoError::CompressionFailed(self_.get(1).cst_decode()), + 9 => crate::core::error::CryptoError::AuthenticationFailed, + 10 => crate::core::error::CryptoError::VaultFull { + needed: self_.get(1).cst_decode(), + available: self_.get(2).cst_decode(), + }, + 11 => crate::core::error::CryptoError::VaultLocked, + 12 => crate::core::error::CryptoError::SegmentNotFound(self_.get(1).cst_decode()), + 13 => crate::core::error::CryptoError::VaultCorrupted(self_.get(1).cst_decode()), + _ => unreachable!(), + } + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::evfs::types::DefragResult { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 3, + "Expected 3 elements, got {}", + self_.length() + ); + crate::api::evfs::types::DefragResult { + segments_moved: self_.get(0).cst_decode(), + bytes_reclaimed: self_.get(1).cst_decode(), + free_regions_before: self_.get(2).cst_decode(), + } + } + } + impl CstDecode> for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Vec { + self.dyn_into::() + .unwrap() + .iter() + .map(CstDecode::cst_decode) + .collect() + } + } + impl CstDecode> for Box<[u8]> { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Vec { + self.into_vec() + } + } + impl CstDecode>> for Option> { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Option> { + self.map(CstDecode::cst_decode) + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::evfs::types::VaultCapacityInfo { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 5, + "Expected 5 elements, got {}", + self_.length() + ); + crate::api::evfs::types::VaultCapacityInfo { + total_bytes: self_.get(0).cst_decode(), + used_bytes: self_.get(1).cst_decode(), + free_list_bytes: self_.get(2).cst_decode(), + unallocated_bytes: self_.get(3).cst_decode(), + segment_count: self_.get(4).cst_decode(), + } + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::evfs::types::VaultHealthInfo { + let self_ = self + .dyn_into::() + .unwrap(); + assert_eq!( + self_.length(), + 9, + "Expected 9 elements, got {}", + self_.length() + ); + crate::api::evfs::types::VaultHealthInfo { + total_bytes: self_.get(0).cst_decode(), + used_bytes: self_.get(1).cst_decode(), + free_list_bytes: self_.get(2).cst_decode(), + unallocated_bytes: self_.get(3).cst_decode(), + segment_count: self_.get(4).cst_decode(), + free_region_count: self_.get(5).cst_decode(), + largest_free_block: self_.get(6).cst_decode(), + fragmentation_ratio: self_.get(7).cst_decode(), + is_consistent: self_.get(8).cst_decode(), + } + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> flutter_rust_bridge::for_generated::anyhow::Error { + unimplemented!() + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> CipherHandle { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner, + >, + >::cst_decode( + self + )) + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> HasherHandle { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom< + flutter_rust_bridge::for_generated::RustAutoOpaqueInner, + >, + >::cst_decode( + self + )) + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> VaultHandle { + flutter_rust_bridge::for_generated::rust_auto_opaque_decode_owned(CstDecode::< + RustOpaqueNom>, + >::cst_decode( + self + )) + } + } + impl + CstDecode< + RustOpaqueNom>, + > for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom> + { + #[cfg(target_pointer_width = "64")] + { + compile_error!("64-bit pointers are not supported."); + } + unsafe { decode_rust_opaque_nom((self.as_f64().unwrap() as usize) as _) } + } + } + impl + CstDecode< + RustOpaqueNom>, + > for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom> + { + #[cfg(target_pointer_width = "64")] + { + compile_error!("64-bit pointers are not supported."); + } + unsafe { decode_rust_opaque_nom((self.as_f64().unwrap() as usize) as _) } + } + } + impl + CstDecode< + RustOpaqueNom>, + > for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode( + self, + ) -> RustOpaqueNom> + { + #[cfg(target_pointer_width = "64")] + { + compile_error!("64-bit pointers are not supported."); + } + unsafe { decode_rust_opaque_nom((self.as_f64().unwrap() as usize) as _) } + } + } + impl CstDecode> + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> StreamSink { + StreamSink::deserialize(self.as_string().expect("should be a string")) + } + } + impl CstDecode, flutter_rust_bridge::for_generated::DcoCodec>> + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> StreamSink, flutter_rust_bridge::for_generated::DcoCodec> { + StreamSink::deserialize(self.as_string().expect("should be a string")) + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> String { + self.as_string().expect("non-UTF-8 string, or not a string") + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::hashing::argon2::Argon2Preset { + (self.unchecked_into_f64() as i32).cst_decode() + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> bool { + self.is_truthy() + } + } + impl CstDecode + for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue + { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> crate::api::compression::CompressionAlgorithm { + (self.unchecked_into_f64() as i32).cst_decode() + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> f64 { + self.unchecked_into_f64() as _ + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> i32 { + self.unchecked_into_f64() as _ + } + } + impl CstDecode> for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> Vec { + self.unchecked_into::() + .to_vec() + .into() + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> u32 { + self.unchecked_into_f64() as _ + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> u64 { + ::std::convert::TryInto::::try_into(self).unwrap() as _ + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> u8 { + self.unchecked_into_f64() as _ + } + } + impl CstDecode for flutter_rust_bridge::for_generated::wasm_bindgen::JsValue { + // Codec=Cst (C-struct based), see doc to use other codecs + fn cst_decode(self) -> usize { + ::std::convert::TryInto::::try_into(self).unwrap() as _ + } + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__types__VaultHandle_health( + port_: flutter_rust_bridge::for_generated::MessagePort, + that: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__types__VaultHandle_health_impl(port_, that) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__argon2__argon2id_hash( + port_: flutter_rust_bridge::for_generated::MessagePort, + password: String, + preset: i32, + ) { + wire__crate__api__hashing__argon2__argon2id_hash_impl(port_, password, preset) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__argon2__argon2id_hash_with_salt( + port_: flutter_rust_bridge::for_generated::MessagePort, + password: String, + salt: String, + preset: i32, + ) { + wire__crate__api__hashing__argon2__argon2id_hash_with_salt_impl( + port_, password, salt, preset, + ) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__argon2__argon2id_verify( + port_: flutter_rust_bridge::for_generated::MessagePort, + phc_hash: String, + password: String, + ) { + wire__crate__api__hashing__argon2__argon2id_verify_impl(port_, phc_hash, password) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__blake3_hash( + port_: flutter_rust_bridge::for_generated::MessagePort, + data: Box<[u8]>, + ) { + wire__crate__api__hashing__blake3_hash_impl(port_, data) + } + + #[wasm_bindgen] + pub fn wire__crate__api__compression__compress( + port_: flutter_rust_bridge::for_generated::MessagePort, + data: Box<[u8]>, + config: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__compression__compress_impl(port_, data, config) + } + + #[wasm_bindgen] + pub fn wire__crate__api__compression__compression_algorithm_from_u8( + port_: flutter_rust_bridge::for_generated::MessagePort, + byte: u8, + ) { + wire__crate__api__compression__compression_algorithm_from_u8_impl(port_, byte) + } + + #[wasm_bindgen] + pub fn wire__crate__api__compression__compression_algorithm_to_u8( + port_: flutter_rust_bridge::for_generated::MessagePort, + that: i32, + ) { + wire__crate__api__compression__compression_algorithm_to_u8_impl(port_, that) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__create_aes256_gcm( + port_: flutter_rust_bridge::for_generated::MessagePort, + key: Box<[u8]>, + ) { + wire__crate__api__encryption__create_aes256_gcm_impl(port_, key) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__create_blake3( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__hashing__create_blake3_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__create_chacha20_poly1305( + port_: flutter_rust_bridge::for_generated::MessagePort, + key: Box<[u8]>, + ) { + wire__crate__api__encryption__create_chacha20_poly1305_impl(port_, key) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__create_noop_encryption( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__encryption__create_noop_encryption_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__create_sha3( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__hashing__create_sha3_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__compression__decompress( + port_: flutter_rust_bridge::for_generated::MessagePort, + data: Box<[u8]>, + algorithm: i32, + ) { + wire__crate__api__compression__decompress_impl(port_, data, algorithm) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__decrypt( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ciphertext: Box<[u8]>, + aad: Box<[u8]>, + ) { + wire__crate__api__encryption__decrypt_impl(port_, cipher, ciphertext, aad) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__encrypt( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + plaintext: Box<[u8]>, + aad: Box<[u8]>, + ) { + wire__crate__api__encryption__encrypt_impl(port_, cipher, plaintext, aad) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__encryption_algorithm_id( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__encryption__encryption_algorithm_id_impl(port_, cipher) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__generate_aes256_gcm_key( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__encryption__generate_aes256_gcm_key_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__aes_gcm__generate_aes_key( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__encryption__aes_gcm__generate_aes_key_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__generate_chacha20_poly1305_key( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__encryption__generate_chacha20_poly1305_key_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__encryption__chacha20__generate_chacha_key( + port_: flutter_rust_bridge::for_generated::MessagePort, + ) { + wire__crate__api__encryption__chacha20__generate_chacha_key_impl(port_) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__hasher_algorithm_id( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__hashing__hasher_algorithm_id_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__hasher_finalize( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__hashing__hasher_finalize_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__hasher_reset( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__hashing__hasher_reset_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__hasher_update( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + data: Box<[u8]>, + ) { + wire__crate__api__hashing__hasher_update_impl(port_, handle, data) + } + + #[wasm_bindgen] + pub fn wire__crate__api__kdf__hkdf__hkdf_derive( + ikm: Box<[u8]>, + salt: Option>, + info: Box<[u8]>, + output_len: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__kdf__hkdf__hkdf_derive_impl(ikm, salt, info, output_len) + } + + #[wasm_bindgen] + pub fn wire__crate__api__kdf__hkdf__hkdf_expand( + port_: flutter_rust_bridge::for_generated::MessagePort, + prk: Box<[u8]>, + info: Box<[u8]>, + output_len: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__kdf__hkdf__hkdf_expand_impl(port_, prk, info, output_len) + } + + #[wasm_bindgen] + pub fn wire__crate__api__kdf__hkdf__hkdf_extract( + ikm: Box<[u8]>, + salt: Option>, + ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartDco { + wire__crate__api__kdf__hkdf__hkdf_extract_impl(ikm, salt) + } + + #[wasm_bindgen] + pub fn wire__crate__api__hashing__sha3_hash( + port_: flutter_rust_bridge::for_generated::MessagePort, + data: Box<[u8]>, + ) { + wire__crate__api__hashing__sha3_hash_impl(port_, data) + } + + #[wasm_bindgen] + pub fn wire__crate__api__compression__should_skip_compression( + port_: flutter_rust_bridge::for_generated::MessagePort, + file_path: String, + ) { + wire__crate__api__compression__should_skip_compression_impl(port_, file_path) + } + + #[wasm_bindgen] + pub fn wire__crate__api__streaming__stream_compress_encrypt_file( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + compression: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + input_path: String, + output_path: String, + progress_sink: String, + ) { + wire__crate__api__streaming__stream_compress_encrypt_file_impl( + port_, + cipher, + compression, + input_path, + output_path, + progress_sink, + ) + } + + #[wasm_bindgen] + pub fn wire__crate__api__streaming__stream_decrypt_decompress_file( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + input_path: String, + output_path: String, + progress_sink: String, + ) { + wire__crate__api__streaming__stream_decrypt_decompress_file_impl( + port_, + cipher, + input_path, + output_path, + progress_sink, + ) + } + + #[wasm_bindgen] + pub fn wire__crate__api__streaming__stream_decrypt_file( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + input_path: String, + output_path: String, + progress_sink: String, + ) { + wire__crate__api__streaming__stream_decrypt_file_impl( + port_, + cipher, + input_path, + output_path, + progress_sink, + ) + } + + #[wasm_bindgen] + pub fn wire__crate__api__streaming__stream_encrypt_file( + port_: flutter_rust_bridge::for_generated::MessagePort, + cipher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + input_path: String, + output_path: String, + progress_sink: String, + ) { + wire__crate__api__streaming__stream_encrypt_file_impl( + port_, + cipher, + input_path, + output_path, + progress_sink, + ) + } + + #[wasm_bindgen] + pub fn wire__crate__api__streaming__stream_hash_file( + port_: flutter_rust_bridge::for_generated::MessagePort, + hasher: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + file_path: String, + progress_sink: String, + ) { + wire__crate__api__streaming__stream_hash_file_impl(port_, hasher, file_path, progress_sink) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_capacity( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_capacity_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_close( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_close_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_create( + port_: flutter_rust_bridge::for_generated::MessagePort, + path: String, + key: Box<[u8]>, + algorithm: String, + capacity_bytes: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_create_impl(port_, path, key, algorithm, capacity_bytes) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_defragment( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_defragment_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_delete( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + name: String, + ) { + wire__crate__api__evfs__vault_delete_impl(port_, handle, name) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_health( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_health_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_list( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_list_impl(port_, handle) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_open( + port_: flutter_rust_bridge::for_generated::MessagePort, + path: String, + key: Box<[u8]>, + ) { + wire__crate__api__evfs__vault_open_impl(port_, path, key) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_read( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + name: String, + ) { + wire__crate__api__evfs__vault_read_impl(port_, handle, name) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_read_stream( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + name: String, + verify_checksum: bool, + sink: String, + on_progress: String, + ) { + wire__crate__api__evfs__vault_read_stream_impl( + port_, + handle, + name, + verify_checksum, + sink, + on_progress, + ) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_resize( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + new_capacity: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_resize_impl(port_, handle, new_capacity) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_write( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + name: String, + data: Box<[u8]>, + compression: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + ) { + wire__crate__api__evfs__vault_write_impl(port_, handle, name, data, compression) + } + + #[wasm_bindgen] + pub fn wire__crate__api__evfs__vault_write_file( + port_: flutter_rust_bridge::for_generated::MessagePort, + handle: flutter_rust_bridge::for_generated::wasm_bindgen::JsValue, + name: String, + file_path: String, + on_progress: String, + ) { + wire__crate__api__evfs__vault_write_file_impl(port_, handle, name, file_path, on_progress) + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::increment_strong_count(ptr as _); + } + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerCipherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::decrement_strong_count(ptr as _); + } + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::increment_strong_count(ptr as _); + } + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerHasherHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::decrement_strong_count(ptr as _); + } + } + + #[wasm_bindgen] + pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::increment_strong_count(ptr as _); + } + } + + #[wasm_bindgen] + pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedRustAutoOpaqueInnerVaultHandle( + ptr: *const std::ffi::c_void, + ) { + unsafe { + StdArc::>::decrement_strong_count(ptr as _); + } } } #[cfg(target_family = "wasm")]