@runflame/wallet-wasm 0.0.1-rc.35 → 0.0.1-rc.37

package/flamewallet_wasm.d.ts

@@ -18,8 +18,10 @@ export interface KeyPath {
 
 export interface IssuedAddress {
     path: KeyPath;
-    /** Tracking address followed by the encryption key: `f1…e1…` / `t1…i1…`. */
-    address: string;
+    /** What a payer is given: the tracking address followed by the encryption key, `f1…e1…` / `t1…i1…`. */
+    receivingAddress: string;
+    /** The receiving address's first half, `f1…` / `t1…`, as `predicateToTrackingAddress` gives it. */
+    trackingAddress: string;
     /** The 32-byte compressed point payments to this address are locked with. */
     predicate: Uint8Array;
 }
@@ -33,7 +35,13 @@ export interface ContractInfo {
 }
 
 export type ContractValue =
-| { kind: "clear"; qty: bigint; flavor: Uint8Array }
+| {
+    kind: "clear";
+    qty: bigint;
+    flavor: Uint8Array;
+    /** Whether `flavor` is `nativeFlavor()`, flames. */
+    isNative: boolean;
+}
 | { kind: "confidential" }
 | { kind: "other" };
 
@@ -62,7 +70,7 @@ export interface TransferOutput {
     qty: bigint;
     /** Absent for flames. */
     flavor?: Uint8Array;
-    /** Sealed into the note for the recipient alone; at most 4006 bytes. */
+    /** Sealed into the note for the recipient alone; at most `memoMaxBytes()`. */
     memo?: Uint8Array;
 }
 
@@ -96,6 +104,8 @@ export interface Transfer {
 /** What `Wallet.openNote` gives: the opening to spend with, and the memo. */
 export interface ReceivedNote {
     opening: Opening;
+    /** Whether `opening.flavor` is `nativeFlavor()`, flames. */
+    isNative: boolean;
     memo: Uint8Array;
 }
 
@@ -215,11 +225,6 @@ export class Wallet {
     viewKey(): string;
 }
 
-/**
- * The predicate a payment to `address` is locked with.
- */
-export function addressToPredicate(address: string, network: Network): Uint8Array;
-
 /**
  * Id, predicate, and a cleartext amount if the contract has one.
  */
@@ -230,32 +235,73 @@ export function decodeContract(bytes: Uint8Array): ContractInfo;
  */
 export function generateMnemonic(wordCount: number): string;
 
+/**
+ * The longest memo, in bytes, one transfer output takes.
+ */
+export function memoMaxBytes(): number;
+
 /**
  * The 64-byte BIP-39 seed of `phrase` under `passphrase` (`""` for none).
  */
 export function mnemonicToSeed(phrase: string, passphrase: string): Uint8Array;
 
+/**
+ * The 32-byte flavor of flames, as `decodeContract` and `openNote` give
+ * a flavor.
+ */
+export function nativeFlavor(): Uint8Array;
+
 /**
  * Whether `opening` opens the confidential contract in `contract`.
  */
 export function openingMatches(contract: Uint8Array, opening: Opening): boolean;
 
+/**
+ * The tracking address, `f1…` / `t1…`, that names a 32-byte predicate:
+ * the first half of every receiving address it locks payments to.
+ */
+export function predicateToTrackingAddress(predicate: Uint8Array, network: Network): string;
+
+/**
+ * The predicate a payment to receiving `address` is locked with.
+ */
+export function receivingAddressToPredicate(address: string, network: Network): Uint8Array;
+
 /**
  * Whether `phrase` is a valid mnemonic in any BIP-39 language.
  */
 export function validateMnemonic(phrase: string): boolean;
 
+/**
+ * Whether `address` is a receiving address, `f1…e1…` / `t1…i1…`, for
+ * `network`. A bad address is `false`; a `network` that is not
+ * `"mainnet"` or `"testnet"` is a caller's bug and throws a `TypeError`.
+ */
+export function validateReceivingAddress(address: string, network: Network): boolean;
+
+/**
+ * Whether `address` is a tracking address, `f1…` / `t1…`, for `network`.
+ * A whole receiving address is not one. A bad `network` throws a
+ * `TypeError`, as in `validateReceivingAddress`.
+ */
+export function validateTrackingAddress(address: string, network: Network): boolean;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_wallet_free: (a: number, b: number) => void;
-    readonly addressToPredicate: (a: number, b: number, c: number, d: number) => void;
     readonly decodeContract: (a: number, b: number, c: number) => void;
     readonly generateMnemonic: (a: number, b: number) => void;
+    readonly memoMaxBytes: () => number;
     readonly mnemonicToSeed: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly nativeFlavor: (a: number) => void;
     readonly openingMatches: (a: number, b: number, c: number, d: number) => void;
+    readonly predicateToTrackingAddress: (a: number, b: number, c: number, d: number) => void;
+    readonly receivingAddressToPredicate: (a: number, b: number, c: number, d: number) => void;
     readonly validateMnemonic: (a: number, b: number) => number;
+    readonly validateReceivingAddress: (a: number, b: number, c: number, d: number) => void;
+    readonly validateTrackingAddress: (a: number, b: number, c: number, d: number) => void;
     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;
@@ -299,6 +345,8 @@ export interface InitOutput {
     readonly ffi_flamewallet_ffi_rust_future_complete_rust_buffer: (a: number, b: bigint, c: number) => void;
     readonly ffi_flamewallet_ffi_rust_future_poll_void: (a: bigint, b: number, c: bigint) => void;
     readonly ffi_flamewallet_ffi_rust_future_complete_void: (a: bigint, b: number) => void;
+    readonly uniffi_flamewallet_ffi_fn_func_native_flavor: (a: number, b: number) => void;
+    readonly uniffi_flamewallet_ffi_checksum_func_native_flavor: () => number;
     readonly uniffi_flamewallet_ffi_fn_func_decode_contract: (a: number, b: number, c: number) => void;
     readonly uniffi_flamewallet_ffi_checksum_func_decode_contract: () => number;
     readonly uniffi_flamewallet_ffi_fn_func_opening_matches: (a: number, b: number, c: number) => number;
@@ -309,8 +357,14 @@ export interface InitOutput {
     readonly uniffi_flamewallet_ffi_checksum_func_validate_mnemonic: () => number;
     readonly uniffi_flamewallet_ffi_fn_func_mnemonic_to_seed: (a: number, b: number, c: number, d: number) => void;
     readonly uniffi_flamewallet_ffi_checksum_func_mnemonic_to_seed: () => number;
-    readonly uniffi_flamewallet_ffi_fn_func_address_to_predicate: (a: number, b: number, c: number, d: number) => void;
-    readonly uniffi_flamewallet_ffi_checksum_func_address_to_predicate: () => number;
+    readonly uniffi_flamewallet_ffi_fn_func_receiving_address_to_predicate: (a: number, b: number, c: number, d: number) => void;
+    readonly uniffi_flamewallet_ffi_checksum_func_receiving_address_to_predicate: () => number;
+    readonly uniffi_flamewallet_ffi_fn_func_predicate_to_tracking_address: (a: number, b: number, c: number, d: number) => void;
+    readonly uniffi_flamewallet_ffi_checksum_func_predicate_to_tracking_address: () => number;
+    readonly uniffi_flamewallet_ffi_fn_func_validate_receiving_address: (a: number, b: number, c: number) => number;
+    readonly uniffi_flamewallet_ffi_checksum_func_validate_receiving_address: () => number;
+    readonly uniffi_flamewallet_ffi_fn_func_validate_tracking_address: (a: number, b: number, c: number) => number;
+    readonly uniffi_flamewallet_ffi_checksum_func_validate_tracking_address: () => number;
     readonly uniffi_flamewallet_ffi_fn_clone_wallet: (a: bigint, b: number) => bigint;
     readonly uniffi_flamewallet_ffi_fn_free_wallet: (a: bigint, b: number) => void;
     readonly uniffi_flamewallet_ffi_fn_constructor_wallet_new: (a: number, b: number, c: number, d: number) => bigint;
@@ -341,6 +395,8 @@ export interface InitOutput {
     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 uniffi_flamewallet_ffi_fn_func_memo_max_bytes: (a: number) => number;
+    readonly uniffi_flamewallet_ffi_checksum_func_memo_max_bytes: () => number;
     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_u32: (a: bigint) => void;

package/flamewallet_wasm.js

@@ -328,33 +328,6 @@ export class Wallet {
 }
 if (Symbol.dispose) Wallet.prototype[Symbol.dispose] = Wallet.prototype.free;
 
-/**
- * The predicate a payment to `address` is locked with.
- * @param {string} address
- * @param {Network} network
- * @returns {Uint8Array}
- */
-export function addressToPredicate(address, network) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-        const len0 = WASM_VECTOR_LEN;
-        wasm.addressToPredicate(retptr, ptr0, len0, addHeapObject(network));
-        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);
-        if (r3) {
-            throw takeObject(r2);
-        }
-        var v2 = getArrayU8FromWasm0(r0, r1).slice();
-        wasm.__wbindgen_export4(r0, r1 * 1, 1);
-        return v2;
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
 /**
  * Id, predicate, and a cleartext amount if the contract has one.
  * @param {Uint8Array} bytes
@@ -408,6 +381,15 @@ export function generateMnemonic(wordCount) {
     }
 }
 
+/**
+ * The longest memo, in bytes, one transfer output takes.
+ * @returns {number}
+ */
+export function memoMaxBytes() {
+    const ret = wasm.memoMaxBytes();
+    return ret >>> 0;
+}
+
 /**
  * The 64-byte BIP-39 seed of `phrase` under `passphrase` (`""` for none).
  * @param {string} phrase
@@ -437,6 +419,25 @@ export function mnemonicToSeed(phrase, passphrase) {
     }
 }
 
+/**
+ * The 32-byte flavor of flames, as `decodeContract` and `openNote` give
+ * a flavor.
+ * @returns {Uint8Array}
+ */
+export function nativeFlavor() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.nativeFlavor(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v1 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Whether `opening` opens the confidential contract in `contract`.
  * @param {Uint8Array} contract
@@ -461,6 +462,67 @@ export function openingMatches(contract, opening) {
     }
 }
 
+/**
+ * The tracking address, `f1…` / `t1…`, that names a 32-byte predicate:
+ * the first half of every receiving address it locks payments to.
+ * @param {Uint8Array} predicate
+ * @param {Network} network
+ * @returns {string}
+ */
+export function predicateToTrackingAddress(predicate, network) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArray8ToWasm0(predicate, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.predicateToTrackingAddress(retptr, ptr0, len0, addHeapObject(network));
+        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 ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * The predicate a payment to receiving `address` is locked with.
+ * @param {string} address
+ * @param {Network} network
+ * @returns {Uint8Array}
+ */
+export function receivingAddressToPredicate(address, network) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.receivingAddressToPredicate(retptr, ptr0, len0, addHeapObject(network));
+        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);
+        if (r3) {
+            throw takeObject(r2);
+        }
+        var v2 = getArrayU8FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 1, 1);
+        return v2;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Whether `phrase` is a valid mnemonic in any BIP-39 language.
  * @param {string} phrase
@@ -472,6 +534,58 @@ export function validateMnemonic(phrase) {
     const ret = wasm.validateMnemonic(ptr0, len0);
     return ret !== 0;
 }
+
+/**
+ * Whether `address` is a receiving address, `f1…e1…` / `t1…i1…`, for
+ * `network`. A bad address is `false`; a `network` that is not
+ * `"mainnet"` or `"testnet"` is a caller's bug and throws a `TypeError`.
+ * @param {string} address
+ * @param {Network} network
+ * @returns {boolean}
+ */
+export function validateReceivingAddress(address, network) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.validateReceivingAddress(retptr, ptr0, len0, addHeapObject(network));
+        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 r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Whether `address` is a tracking address, `f1…` / `t1…`, for `network`.
+ * A whole receiving address is not one. A bad `network` throws a
+ * `TypeError`, as in `validateReceivingAddress`.
+ * @param {string} address
+ * @param {Network} network
+ * @returns {boolean}
+ */
+export function validateTrackingAddress(address, network) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.validateTrackingAddress(retptr, ptr0, len0, addHeapObject(network));
+        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 r0 !== 0;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,

package/flamewallet_wasm_bg.wasm.d.ts

@@ -2,12 +2,17 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_wallet_free: (a: number, b: number) => void;
-export const addressToPredicate: (a: number, b: number, c: number, d: number) => void;
 export const decodeContract: (a: number, b: number, c: number) => void;
 export const generateMnemonic: (a: number, b: number) => void;
+export const memoMaxBytes: () => number;
 export const mnemonicToSeed: (a: number, b: number, c: number, d: number, e: number) => void;
+export const nativeFlavor: (a: number) => void;
 export const openingMatches: (a: number, b: number, c: number, d: number) => void;
+export const predicateToTrackingAddress: (a: number, b: number, c: number, d: number) => void;
+export const receivingAddressToPredicate: (a: number, b: number, c: number, d: number) => void;
 export const validateMnemonic: (a: number, b: number) => number;
+export const validateReceivingAddress: (a: number, b: number, c: number, d: number) => void;
+export const validateTrackingAddress: (a: number, b: number, c: number, d: number) => void;
 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;
@@ -51,6 +56,8 @@ export const ffi_flamewallet_ffi_rust_future_poll_rust_buffer: (a: bigint, b: nu
 export const ffi_flamewallet_ffi_rust_future_complete_rust_buffer: (a: number, b: bigint, c: number) => void;
 export const ffi_flamewallet_ffi_rust_future_poll_void: (a: bigint, b: number, c: bigint) => void;
 export const ffi_flamewallet_ffi_rust_future_complete_void: (a: bigint, b: number) => void;
+export const uniffi_flamewallet_ffi_fn_func_native_flavor: (a: number, b: number) => void;
+export const uniffi_flamewallet_ffi_checksum_func_native_flavor: () => number;
 export const uniffi_flamewallet_ffi_fn_func_decode_contract: (a: number, b: number, c: number) => void;
 export const uniffi_flamewallet_ffi_checksum_func_decode_contract: () => number;
 export const uniffi_flamewallet_ffi_fn_func_opening_matches: (a: number, b: number, c: number) => number;
@@ -61,8 +68,14 @@ export const uniffi_flamewallet_ffi_fn_func_validate_mnemonic: (a: number, b: nu
 export const uniffi_flamewallet_ffi_checksum_func_validate_mnemonic: () => number;
 export const uniffi_flamewallet_ffi_fn_func_mnemonic_to_seed: (a: number, b: number, c: number, d: number) => void;
 export const uniffi_flamewallet_ffi_checksum_func_mnemonic_to_seed: () => number;
-export const uniffi_flamewallet_ffi_fn_func_address_to_predicate: (a: number, b: number, c: number, d: number) => void;
-export const uniffi_flamewallet_ffi_checksum_func_address_to_predicate: () => number;
+export const uniffi_flamewallet_ffi_fn_func_receiving_address_to_predicate: (a: number, b: number, c: number, d: number) => void;
+export const uniffi_flamewallet_ffi_checksum_func_receiving_address_to_predicate: () => number;
+export const uniffi_flamewallet_ffi_fn_func_predicate_to_tracking_address: (a: number, b: number, c: number, d: number) => void;
+export const uniffi_flamewallet_ffi_checksum_func_predicate_to_tracking_address: () => number;
+export const uniffi_flamewallet_ffi_fn_func_validate_receiving_address: (a: number, b: number, c: number) => number;
+export const uniffi_flamewallet_ffi_checksum_func_validate_receiving_address: () => number;
+export const uniffi_flamewallet_ffi_fn_func_validate_tracking_address: (a: number, b: number, c: number) => number;
+export const uniffi_flamewallet_ffi_checksum_func_validate_tracking_address: () => number;
 export const uniffi_flamewallet_ffi_fn_clone_wallet: (a: bigint, b: number) => bigint;
 export const uniffi_flamewallet_ffi_fn_free_wallet: (a: bigint, b: number) => void;
 export const uniffi_flamewallet_ffi_fn_constructor_wallet_new: (a: number, b: number, c: number, d: number) => bigint;
@@ -93,6 +106,8 @@ export const uniffi_flamewallet_ffi_fn_method_wallet_open_note: (a: number, b: b
 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 uniffi_flamewallet_ffi_fn_func_memo_max_bytes: (a: number) => number;
+export const uniffi_flamewallet_ffi_checksum_func_memo_max_bytes: () => number;
 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_u32: (a: bigint) => void;

package/package.json

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

package/sbom.cdx.json

@@ -2,9 +2,9 @@
   "bomFormat": "CycloneDX",
   "specVersion": "1.3",
   "version": 1,
-  "serialNumber": "urn:uuid:0d9150e4-5a33-41ee-9e86-81490c3957ca",
+  "serialNumber": "urn:uuid:f5bd99cf-906d-4cee-ade0-7a12eb515de6",
   "metadata": {
-    "timestamp": "2026-10-20T10:28:49.236559000Z",
+    "timestamp": "2026-10-22T16:31:40.846345000Z",
     "tools": [
       {
         "vendor": "CycloneDX",