@runflame/wallet-wasm 0.0.1-rc.0 → 0.0.1-rc.10

package/flamewallet_wasm.d.ts

@@ -3,6 +3,13 @@
 /** Which network addresses are encoded for: `f1…` or `tf1…`. */
 export type Network = "mainnet" | "testnet";
 
+/**
+ * What a `Wallet` was built from, and so what it can do: `spend` (seed or
+ * mnemonic) finds, opens and spends; `view` (view key) finds and opens;
+ * `receive` (receiving key) only finds.
+ */
+export type WalletKind = "spend" | "view" | "receive";
+
 /** `m/35263'/network'/0'/branch/index`; branch 0 is receiving, 1 is change. */
 export interface KeyPath {
     branch: number;
@@ -50,10 +57,13 @@ export interface TransferInput {
 }
 
 export interface TransferOutput {
-    predicate: Uint8Array;
+    /** The recipient's bech32f address, for the wallet's network. */
+    address: string;
     qty: bigint;
     /** Absent for flames. */
     flavor?: Uint8Array;
+    /** Sealed into the note for the recipient alone; at most 4006 bytes. */
+    memo?: Uint8Array;
 }
 
 export interface TransferRequest {
@@ -70,8 +80,8 @@ export interface CreatedOutput {
     contractId: Uint8Array;
     /** Its published bytes, as an indexer serves them once confirmed. */
     contract: Uint8Array;
-    /** The only record the output can be spent from. */
-    opening: Opening;
+    /** The encrypted note that follows it on chain; `Wallet.openNote` reads it. */
+    note: Uint8Array;
 }
 
 export interface Transfer {
@@ -79,25 +89,50 @@ export interface Transfer {
     txid: Uint8Array;
     /** `BlockTx::to_bytes`: what a node's `submit_tx` takes. */
     blockTx: Uint8Array;
+    /** In published order, not request order: match each by its predicate. */
     outputs: CreatedOutput[];
 }
 
+/** What `Wallet.openNote` gives: the opening to spend with, and the memo. */
+export interface ReceivedNote {
+    opening: Opening;
+    memo: Uint8Array;
+}
+
+/** Why a note did not open; `docs/payments.md` "Receiving" says what to do. */
+export type NoteFailure =
+| "missing"
+| "malformed"
+| "unknownVersion"
+| "undecryptable"
+| "openingMismatch"
+| "notConfidential";
+
 /** What every call throws. Fields beyond `kind` depend on it. */
 export interface FlameError extends Error {
     name: "FlameError";
     kind:
     | "invalidMnemonic"
     | "invalidSeed"
+    | "invalidKey"
+    | "notPermitted"
     | "invalidAddress"
     | "invalidKeyPath"
     | "invalidBytes"
     | "keyMismatch"
+    | "note"
     | "transfer";
     reason?: string;
     /** For `invalidBytes`: contract, proof, predicate, flavor or blinding. */
     what?: string;
     /** For `keyMismatch`: the input's position. */
     input?: number;
+    /** For `note`: how it failed. */
+    failure?: NoteFailure;
+    /** For `notPermitted`: the wallet that refused. */
+    wallet?: WalletKind;
+    /** For `notPermitted`: the least kind of wallet that could. */
+    needs?: WalletKind;
 }
 
 
@@ -105,7 +140,10 @@ export interface FlameError extends Error {
 /**
  * One account, `m/35263'/network'/0'`. Its keys live in this module's
  * memory until `free()` — or `using` — drops the handle, which zeroizes
- * them; nothing a caller receives is key material.
+ * them. Two calls hand key material to JavaScript, where nothing can wipe
+ * it, so keep what they return as secret as the wallet: `viewKey()` reads
+ * every amount and memo, and `receivingKey()` links every address.
+ * Neither can spend.
  */
 export class Wallet {
     private constructor();
@@ -124,11 +162,29 @@ export class Wallet {
      * seeing the seed.
      */
     static fromMnemonic(phrase: string, passphrase: string, network: Network, nextIndex: number): Wallet;
+    /**
+     * A receive wallet from its bech32f receiving key, as `receivingKey`
+     * gives it. It issues addresses and finds payments; `viewKey`,
+     * `openNote` and `buildTransfer` throw `notPermitted`. Only the key
+     * `receivingKey` exports will do, as with `fromViewKey`.
+     */
+    static fromReceivingKey(receivingKey: string, network: Network, nextIndex: number): Wallet;
     /**
      * The account below a 64-byte seed, with `nextIndex` receiving
      * addresses already issued; a new wallet passes 0.
      */
     static fromSeed(seed: Uint8Array, network: Network, nextIndex: number): Wallet;
+    /**
+     * A view wallet from its bech32f view key, as `viewKey` gives it.
+     * Everything works except `buildTransfer`, which throws
+     * `notPermitted`. Only the key `viewKey` exports will do: a key from
+     * another node is accepted and silently owns nothing.
+     */
+    static fromViewKey(viewKey: string, network: Network, nextIndex: number): Wallet;
+    /**
+     * What this wallet was built from: `spend`, `view` or `receive`.
+     */
+    kind(): WalletKind;
     network(): Network;
     /**
      * Issues the next receiving address and advances the counter.
@@ -138,6 +194,11 @@ export class Wallet {
      * The next receiving index not yet issued: what an app stores.
      */
     nextIndex(): number;
+    /**
+     * Opens the note a scan served with `contract` (`undefined` if none),
+     * with the key at `path`, as `owns` found it.
+     */
+    openNote(contract: Uint8Array, note: Uint8Array | null | undefined, path: KeyPath): ReceivedNote;
     /**
      * Which path below `nextIndex + gap` owns `predicate`, if any.
      */
@@ -146,6 +207,12 @@ export class Wallet {
      * The bech32f receiving key an indexer is given.
      */
     receivingKey(): string;
+    /**
+     * The bech32f view key a view wallet is built from: it reads every
+     * amount and memo but cannot spend, so store it as a secret. A
+     * receive wallet throws `notPermitted`.
+     */
+    viewKey(): string;
 }
 
 /**
@@ -192,12 +259,17 @@ export interface InitOutput {
     readonly wallet_address: (a: number, b: number, c: number) => void;
     readonly wallet_buildTransfer: (a: number, b: number, c: number) => void;
     readonly wallet_fromMnemonic: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly wallet_fromReceivingKey: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly wallet_fromSeed: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wallet_fromViewKey: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly wallet_kind: (a: number) => number;
     readonly wallet_network: (a: number, b: number) => void;
     readonly wallet_nextAddress: (a: number, b: number) => void;
     readonly wallet_nextIndex: (a: number) => number;
+    readonly wallet_openNote: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly wallet_owns: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly wallet_receivingKey: (a: number, b: number) => void;
+    readonly wallet_viewKey: (a: number, b: number) => void;
     readonly ffi_flamewallet_ffi_uniffi_contract_version: () => number;
     readonly ffi_flamewallet_ffi_rustbuffer_alloc: (a: number, b: bigint, c: number) => void;
     readonly ffi_flamewallet_ffi_rustbuffer_from_bytes: (a: number, b: number, c: number) => void;
@@ -245,6 +317,12 @@ export interface InitOutput {
     readonly uniffi_flamewallet_ffi_checksum_constructor_wallet_new: () => number;
     readonly uniffi_flamewallet_ffi_fn_constructor_wallet_from_mnemonic: (a: number, b: number, c: number, d: number, e: number) => bigint;
     readonly uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic: () => number;
+    readonly uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key: (a: number, b: number, c: number, d: number) => bigint;
+    readonly uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key: () => number;
+    readonly uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key: (a: number, b: number, c: number, d: number) => bigint;
+    readonly uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key: () => number;
+    readonly uniffi_flamewallet_ffi_fn_method_wallet_kind: (a: number, b: bigint, c: number) => void;
+    readonly uniffi_flamewallet_ffi_checksum_method_wallet_kind: () => number;
     readonly uniffi_flamewallet_ffi_fn_method_wallet_network: (a: number, b: bigint, c: number) => void;
     readonly uniffi_flamewallet_ffi_checksum_method_wallet_network: () => number;
     readonly uniffi_flamewallet_ffi_fn_method_wallet_address: (a: number, b: bigint, c: number, d: number) => void;
@@ -257,32 +335,36 @@ export interface InitOutput {
     readonly uniffi_flamewallet_ffi_checksum_method_wallet_owns: () => number;
     readonly uniffi_flamewallet_ffi_fn_method_wallet_receiving_key: (a: number, b: bigint, c: number) => void;
     readonly uniffi_flamewallet_ffi_checksum_method_wallet_receiving_key: () => number;
+    readonly uniffi_flamewallet_ffi_fn_method_wallet_view_key: (a: number, b: bigint, c: number) => void;
+    readonly uniffi_flamewallet_ffi_checksum_method_wallet_view_key: () => number;
+    readonly uniffi_flamewallet_ffi_fn_method_wallet_open_note: (a: number, b: bigint, c: number, d: number, e: number, f: number) => void;
+    readonly uniffi_flamewallet_ffi_checksum_method_wallet_open_note: () => number;
     readonly uniffi_flamewallet_ffi_fn_method_wallet_build_transfer: (a: number, b: bigint, c: number, d: number) => void;
     readonly uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer: () => number;
-    readonly ffi_flamewallet_ffi_rust_future_free_u16: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_cancel_u16: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_free_u32: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_complete_u32: (a: bigint, b: number) => number;
-    readonly ffi_flamewallet_ffi_rust_future_cancel_u32: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_free_i64: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_cancel_i64: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_free_rust_buffer: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_cancel_rust_buffer: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_free_i32: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_cancel_i32: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_free_i64: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_cancel_i64: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_free_u64: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_complete_u64: (a: bigint, b: number) => bigint;
     readonly ffi_flamewallet_ffi_rust_future_cancel_u64: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_free_u8: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_cancel_u8: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_free_void: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_cancel_void: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_free_i16: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_cancel_i16: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_free_u32: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_cancel_u32: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_free_f64: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_cancel_f64: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_free_i8: (a: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_cancel_i8: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_free_i16: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_cancel_i16: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_free_u8: (a: bigint) => void;
-    readonly ffi_flamewallet_ffi_rust_future_cancel_u8: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_free_i32: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_complete_u32: (a: bigint, b: number) => number;
+    readonly ffi_flamewallet_ffi_rust_future_cancel_i32: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_free_u16: (a: bigint) => void;
+    readonly ffi_flamewallet_ffi_rust_future_cancel_u16: (a: bigint) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/flamewallet_wasm.js

@@ -3,7 +3,10 @@
 /**
  * One account, `m/35263'/network'/0'`. Its keys live in this module's
  * memory until `free()` — or `using` — drops the handle, which zeroizes
- * them; nothing a caller receives is key material.
+ * them. Two calls hand key material to JavaScript, where nothing can wipe
+ * it, so keep what they return as secret as the wallet: `viewKey()` reads
+ * every amount and memo, and `receivingKey()` links every address.
+ * Neither can spend.
  */
 export class Wallet {
     static __wrap(ptr) {
@@ -90,6 +93,33 @@ export class Wallet {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * A receive wallet from its bech32f receiving key, as `receivingKey`
+     * gives it. It issues addresses and finds payments; `viewKey`,
+     * `openNote` and `buildTransfer` throw `notPermitted`. Only the key
+     * `receivingKey` exports will do, as with `fromViewKey`.
+     * @param {string} receivingKey
+     * @param {Network} network
+     * @param {number} nextIndex
+     * @returns {Wallet}
+     */
+    static fromReceivingKey(receivingKey, network, nextIndex) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(receivingKey, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wallet_fromReceivingKey(retptr, ptr0, len0, addHeapObject(network), nextIndex);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Wallet.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The account below a 64-byte seed, with `nextIndex` receiving
      * addresses already issued; a new wallet passes 0.
@@ -115,6 +145,41 @@ export class Wallet {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * A view wallet from its bech32f view key, as `viewKey` gives it.
+     * Everything works except `buildTransfer`, which throws
+     * `notPermitted`. Only the key `viewKey` exports will do: a key from
+     * another node is accepted and silently owns nothing.
+     * @param {string} viewKey
+     * @param {Network} network
+     * @param {number} nextIndex
+     * @returns {Wallet}
+     */
+    static fromViewKey(viewKey, network, nextIndex) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(viewKey, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.wallet_fromViewKey(retptr, ptr0, len0, addHeapObject(network), nextIndex);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Wallet.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * What this wallet was built from: `spend`, `view` or `receive`.
+     * @returns {WalletKind}
+     */
+    kind() {
+        const ret = wasm.wallet_kind(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @returns {Network}
      */
@@ -160,6 +225,33 @@ export class Wallet {
         const ret = wasm.wallet_nextIndex(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Opens the note a scan served with `contract` (`undefined` if none),
+     * with the key at `path`, as `owns` found it.
+     * @param {Uint8Array} contract
+     * @param {Uint8Array | null | undefined} note
+     * @param {KeyPath} path
+     * @returns {ReceivedNote}
+     */
+    openNote(contract, note, path) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(contract, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(note) ? 0 : passArray8ToWasm0(note, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.wallet_openNote(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, addHeapObject(path));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Which path below `nextIndex + gap` owns `predicate`, if any.
      * @param {Uint8Array} predicate
@@ -203,6 +295,36 @@ export class Wallet {
             wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * The bech32f view key a view wallet is built from: it reads every
+     * amount and memo but cannot spend, so store it as a secret. A
+     * receive wallet throws `notPermitted`.
+     * @returns {string}
+     */
+    viewKey() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wallet_viewKey(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr1 = r0;
+            var len1 = r1;
+            if (r3) {
+                ptr1 = 0; len1 = 0;
+                throw takeObject(r2);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
 }
 if (Symbol.dispose) Wallet.prototype[Symbol.dispose] = Wallet.prototype.free;
 

package/flamewallet_wasm_bg.wasm.d.ts

@@ -11,12 +11,17 @@ export const validateMnemonic: (a: number, b: number) => number;
 export const wallet_address: (a: number, b: number, c: number) => void;
 export const wallet_buildTransfer: (a: number, b: number, c: number) => void;
 export const wallet_fromMnemonic: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const wallet_fromReceivingKey: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wallet_fromSeed: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wallet_fromViewKey: (a: number, b: number, c: number, d: number, e: number) => void;
+export const wallet_kind: (a: number) => number;
 export const wallet_network: (a: number, b: number) => void;
 export const wallet_nextAddress: (a: number, b: number) => void;
 export const wallet_nextIndex: (a: number) => number;
+export const wallet_openNote: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const wallet_owns: (a: number, b: number, c: number, d: number, e: number) => void;
 export const wallet_receivingKey: (a: number, b: number) => void;
+export const wallet_viewKey: (a: number, b: number) => void;
 export const ffi_flamewallet_ffi_uniffi_contract_version: () => number;
 export const ffi_flamewallet_ffi_rustbuffer_alloc: (a: number, b: bigint, c: number) => void;
 export const ffi_flamewallet_ffi_rustbuffer_from_bytes: (a: number, b: number, c: number) => void;
@@ -64,6 +69,12 @@ export const uniffi_flamewallet_ffi_fn_constructor_wallet_new: (a: number, b: nu
 export const uniffi_flamewallet_ffi_checksum_constructor_wallet_new: () => number;
 export const uniffi_flamewallet_ffi_fn_constructor_wallet_from_mnemonic: (a: number, b: number, c: number, d: number, e: number) => bigint;
 export const uniffi_flamewallet_ffi_checksum_constructor_wallet_from_mnemonic: () => number;
+export const uniffi_flamewallet_ffi_fn_constructor_wallet_from_view_key: (a: number, b: number, c: number, d: number) => bigint;
+export const uniffi_flamewallet_ffi_checksum_constructor_wallet_from_view_key: () => number;
+export const uniffi_flamewallet_ffi_fn_constructor_wallet_from_receiving_key: (a: number, b: number, c: number, d: number) => bigint;
+export const uniffi_flamewallet_ffi_checksum_constructor_wallet_from_receiving_key: () => number;
+export const uniffi_flamewallet_ffi_fn_method_wallet_kind: (a: number, b: bigint, c: number) => void;
+export const uniffi_flamewallet_ffi_checksum_method_wallet_kind: () => number;
 export const uniffi_flamewallet_ffi_fn_method_wallet_network: (a: number, b: bigint, c: number) => void;
 export const uniffi_flamewallet_ffi_checksum_method_wallet_network: () => number;
 export const uniffi_flamewallet_ffi_fn_method_wallet_address: (a: number, b: bigint, c: number, d: number) => void;
@@ -76,32 +87,36 @@ export const uniffi_flamewallet_ffi_fn_method_wallet_owns: (a: number, b: bigint
 export const uniffi_flamewallet_ffi_checksum_method_wallet_owns: () => number;
 export const uniffi_flamewallet_ffi_fn_method_wallet_receiving_key: (a: number, b: bigint, c: number) => void;
 export const uniffi_flamewallet_ffi_checksum_method_wallet_receiving_key: () => number;
+export const uniffi_flamewallet_ffi_fn_method_wallet_view_key: (a: number, b: bigint, c: number) => void;
+export const uniffi_flamewallet_ffi_checksum_method_wallet_view_key: () => number;
+export const uniffi_flamewallet_ffi_fn_method_wallet_open_note: (a: number, b: bigint, c: number, d: number, e: number, f: number) => void;
+export const uniffi_flamewallet_ffi_checksum_method_wallet_open_note: () => number;
 export const uniffi_flamewallet_ffi_fn_method_wallet_build_transfer: (a: number, b: bigint, c: number, d: number) => void;
 export const uniffi_flamewallet_ffi_checksum_method_wallet_build_transfer: () => number;
-export const ffi_flamewallet_ffi_rust_future_free_u16: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_cancel_u16: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_free_u32: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_complete_u32: (a: bigint, b: number) => number;
-export const ffi_flamewallet_ffi_rust_future_cancel_u32: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_free_i64: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_cancel_i64: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_free_rust_buffer: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_cancel_rust_buffer: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_free_i32: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_cancel_i32: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_free_i64: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_cancel_i64: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_free_u64: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_complete_u64: (a: bigint, b: number) => bigint;
 export const ffi_flamewallet_ffi_rust_future_cancel_u64: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_free_u8: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_cancel_u8: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_free_void: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_cancel_void: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_free_i16: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_cancel_i16: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_free_u32: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_cancel_u32: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_free_f64: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_cancel_f64: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_free_i8: (a: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_cancel_i8: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_free_i16: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_cancel_i16: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_free_u8: (a: bigint) => void;
-export const ffi_flamewallet_ffi_rust_future_cancel_u8: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_free_i32: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_complete_u32: (a: bigint, b: number) => number;
+export const ffi_flamewallet_ffi_rust_future_cancel_i32: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_free_u16: (a: bigint) => void;
+export const ffi_flamewallet_ffi_rust_future_cancel_u16: (a: bigint) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runflame/wallet-wasm",
-  "version": "0.0.1-rc.0",
+  "version": "0.0.1-rc.10",
   "description": "Flame wallet keys and confidential transfers, compiled to WebAssembly",
   "license": "Apache-2.0",
   "repository": {