@runflame/wallet-wasm 0.0.1-rc.7 → 0.0.1-rc.8

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;
@@ -107,6 +114,8 @@ export interface FlameError extends Error {
     kind:
     | "invalidMnemonic"
     | "invalidSeed"
+    | "invalidKey"
+    | "notPermitted"
     | "invalidAddress"
     | "invalidKeyPath"
     | "invalidBytes"
@@ -120,6 +129,10 @@ export interface FlameError extends Error {
     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;
 }
 
 
@@ -127,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();
@@ -146,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.
@@ -174,8 +208,9 @@ export class Wallet {
      */
     receivingKey(): string;
     /**
-     * The bech32f view key a watch-only wallet is given: it reads every
-     * amount and memo but cannot spend, so store it as a secret.
+     * 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;
 }
@@ -224,7 +259,10 @@ 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;
@@ -279,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;

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}
      */
@@ -231,24 +296,33 @@ export class Wallet {
         }
     }
     /**
-     * The bech32f view key a watch-only wallet is given: it reads every
-     * amount and memo but cannot spend, so store it as a secret.
+     * 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 deferred1_0;
-        let deferred1_1;
+        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);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            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(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
 }

package/flamewallet_wasm_bg.wasm.d.ts

@@ -11,7 +11,10 @@ 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;
@@ -66,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runflame/wallet-wasm",
-  "version": "0.0.1-rc.7",
+  "version": "0.0.1-rc.8",
   "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:f6c82bfb-9c6a-450a-bee9-dda4f09491a9",
+  "serialNumber": "urn:uuid:d458b8c6-abb2-4b2b-ac9d-4da15edf4cef",
   "metadata": {
-    "timestamp": "2026-10-07T17:11:15.624378000Z",
+    "timestamp": "2026-10-08T12:25:09.625584000Z",
     "tools": [
       {
         "vendor": "CycloneDX",