@breeztech/breez-sdk-spark 0.19.0 → 0.20.0-dev1

package/deno/breez_sdk_spark_wasm.js

@@ -35,6 +35,16 @@ export class BitcoinChainServiceHandle {
         const ret = wasm.bitcoinchainservicehandle_broadcastTransaction(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @param {string} address
+     * @returns {Promise<any>}
+     */
+    getAddressTxos(address) {
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.bitcoinchainservicehandle_getAddressTxos(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
     /**
      * @param {string} address
      * @returns {Promise<any>}
@@ -45,6 +55,17 @@ export class BitcoinChainServiceHandle {
         const ret = wasm.bitcoinchainservicehandle_getAddressUtxos(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @param {string} txid
+     * @param {number} vout
+     * @returns {Promise<any>}
+     */
+    getOutspend(txid, vout) {
+        const ptr0 = passStringToWasm0(txid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.bitcoinchainservicehandle_getOutspend(this.__wbg_ptr, ptr0, len0, vout);
+        return ret;
+    }
     /**
      * @param {string} txid
      * @returns {Promise<any>}
@@ -368,6 +389,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_prepareSendPayment(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {PrepareUnilateralExitRequest} request
+     * @returns {Promise<PrepareUnilateralExitResponse>}
+     */
+    prepareUnilateralExit(request) {
+        const ret = wasm.breezsdk_prepareUnilateralExit(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {PublishSignedLnurlPayPackageRequest} request
      * @returns {Promise<PublishSignedLnurlPayResponse>}
@@ -408,7 +437,7 @@ export class BreezSdk {
         return ret;
     }
     /**
-     * @returns {Promise<void>}
+     * @returns {Promise<RefundPendingConversionsResponse>}
      */
     refundPendingConversions() {
         const ret = wasm.breezsdk_refundPendingConversions(this.__wbg_ptr);
@@ -464,6 +493,15 @@ export class BreezSdk {
         const ret = wasm.breezsdk_syncWallet(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {UnilateralExitRequest} request
+     * @param {CpfpSigner} signer
+     * @returns {Promise<UnilateralExitResponse>}
+     */
+    unilateralExit(request, signer) {
+        const ret = wasm.breezsdk_unilateralExit(this.__wbg_ptr, request, signer);
+        return ret;
+    }
     /**
      * @param {UnregisterWebhookRequest} request
      * @returns {Promise<void>}
@@ -491,6 +529,39 @@ export class BreezSdk {
 }
 if (Symbol.dispose) BreezSdk.prototype[Symbol.dispose] = BreezSdk.prototype.free;
 
+/**
+ * A CPFP signer matching the `CpfpSigner` TypeScript interface.
+ */
+export class DefaultCpfpSigner {
+    static __wrap(ptr) {
+        const obj = Object.create(DefaultCpfpSigner.prototype);
+        obj.__wbg_ptr = ptr;
+        DefaultCpfpSignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DefaultCpfpSignerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_defaultcpfpsigner_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} psbt_bytes
+     * @returns {Promise<Uint8Array>}
+     */
+    signPsbt(psbt_bytes) {
+        const ptr0 = passArray8ToWasm0(psbt_bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultcpfpsigner_signPsbt(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) DefaultCpfpSigner.prototype[Symbol.dispose] = DefaultCpfpSigner.prototype.free;
+
 /**
  * A JS handle to a backend's own session store (from `defaultSessionStore`),
  * exposing the same `getSession` / `setSession` interface. Wrap it in a JS
@@ -880,6 +951,17 @@ export class ExternalSparkSignerHandle {
         const ret = wasm.externalsparksignerhandle_signFrost(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @param {ExternalTreeNodeId} leaf_id
+     * @param {Uint8Array} sighash
+     * @returns {Promise<SchnorrSignatureBytes>}
+     */
+    signLeafRefundSpend(leaf_id, sighash) {
+        const ptr0 = passArray8ToWasm0(sighash, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.externalsparksignerhandle_signLeafRefundSpend(this.__wbg_ptr, leaf_id, ptr0, len0);
+        return ret;
+    }
     /**
      * @param {Uint8Array} message
      * @returns {Promise<EcdsaSignatureBytes>}
@@ -1053,6 +1135,23 @@ export class PasskeyClient {
         const ret = wasm.passkeyclient_checkAvailability(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Single-CTA onboarding: silent sign-in that falls through to
+     * registration when no credential exists on the device. Pins
+     * immediate mediation, so on web only use it where the browser
+     * advertises it (`supportsImmediateMediation`); otherwise the silent
+     * probe degrades to the standard picker and a dismiss does not fall
+     * through to register, so
+     * present an explicit create / sign-in choice instead. Called without
+     * a `label`, the response `labels` lists a returning user's wallets
+     * for a picker.
+     * @param {ConnectWithPasskeyRequest} request
+     * @returns {Promise<ConnectWithPasskeyResponse>}
+     */
+    connectWithPasskey(request) {
+        const ret = wasm.passkeyclient_connectWithPasskey(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * Label sub-object. List / publish labels for this passkey's identity.
      * @returns {PasskeyLabels}
@@ -1101,6 +1200,18 @@ export class PasskeyClient {
         const ret = wasm.passkeyclient_signIn(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * Whether this browser advertises WebAuthn immediate mediation: the
+     * silent single-CTA probe (a no-credential sign-in fast-fails with no
+     * UI) works here, so a web host can pick single- vs two-button
+     * onboarding. Web-only and WASM-only: native does the silent probe
+     * inherently, so there is nothing to query off-web.
+     * @returns {Promise<boolean>}
+     */
+    supportsImmediateMediation() {
+        const ret = wasm.passkeyclient_supportsImmediateMediation(this.__wbg_ptr);
+        return ret;
+    }
 }
 if (Symbol.dispose) PasskeyClient.prototype[Symbol.dispose] = PasskeyClient.prototype.free;
 
@@ -1765,6 +1876,21 @@ export function postgresStorage(config) {
     return WasmStorageConfig.__wrap(ret);
 }
 
+/**
+ * Creates a default CPFP signer backed by a single private key.
+ * @param {Uint8Array} secret_key_bytes
+ * @returns {DefaultCpfpSigner}
+ */
+export function singleKeyCpfpSigner(secret_key_bytes) {
+    const ptr0 = passArray8ToWasm0(secret_key_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.singleKeyCpfpSigner(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return DefaultCpfpSigner.__wrap(ret[0]);
+}
+
 /**
  * Runs automatically when the wasm module is instantiated. Installs the
  * panic hook so Rust panics surface as readable `console.error` output
@@ -2300,6 +2426,18 @@ function __wbg_get_imports() {
             const ret = Array.from(arg0);
             return ret;
         },
+        __wbg_getAddressTxos_3ca1c4b39dd84911: function() { return handleError(function (arg0, arg1, arg2) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.getAddressTxos(getStringFromWasm0(arg1, arg2));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_getAddressUtxos_9526b6d8078b867e: function() { return handleError(function (arg0, arg1, arg2) {
             let deferred0_0;
             let deferred0_1;
@@ -2365,6 +2503,18 @@ function __wbg_get_imports() {
             const ret = arg0.getLeaves();
             return ret;
         }, arguments); },
+        __wbg_getOutspend_4b3c117972515790: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.getOutspend(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments); },
         __wbg_getPaymentById_6d677ada5879df99: function() { return handleError(function (arg0, arg1, arg2) {
             let deferred0_0;
             let deferred0_1;
@@ -3194,12 +3344,24 @@ function __wbg_get_imports() {
                 wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         }, arguments); },
+        __wbg_signLeafRefundSpend_dc0eea305a0dde9c: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            var v0 = getArrayU8FromWasm0(arg2, arg3).slice();
+            wasm.__wbindgen_free(arg2, arg3 * 1, 1);
+            const ret = arg0.signLeafRefundSpend(arg1, v0);
+            return ret;
+        }, arguments); },
         __wbg_signMessage_80ec0b0dfc7f00ee: function() { return handleError(function (arg0, arg1, arg2) {
             var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
             wasm.__wbindgen_free(arg1, arg2 * 1, 1);
             const ret = arg0.signMessage(v0);
             return ret;
         }, arguments); },
+        __wbg_signPsbt_625c8cbdec488cc6: function() { return handleError(function (arg0, arg1, arg2) {
+            var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+            wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+            const ret = arg0.signPsbt(v0);
+            return ret;
+        }, arguments); },
         __wbg_signSparkInvoice_cca6c7f35b5e85d2: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.signSparkInvoice(arg1);
             return ret;
@@ -3255,6 +3417,10 @@ function __wbg_get_imports() {
             const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
+        __wbg_supportsImmediateMediation_a50b46b1cdfacd3d: function() { return handleError(function (arg0) {
+            const ret = arg0.supportsImmediateMediation();
+            return ret;
+        }, arguments); },
         __wbg_syncAddOutgoingChange_69db2a1430cbd55a: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.syncAddOutgoingChange(arg1);
             return ret;
@@ -3407,62 +3573,62 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h21f6855640435575);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 230, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 230, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_2);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 230, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_3);
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 230, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_4);
             return ret;
         },
         __wbindgen_cast_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 230, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_5);
             return ret;
         },
         __wbindgen_cast_0000000000000007: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("SessionStore")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("SessionStore")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h21f6855640435575_6);
             return ret;
         },
         __wbindgen_cast_0000000000000008: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h21f6855640435575_7);
             return ret;
         },
         __wbindgen_cast_0000000000000009: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h21f6855640435575_8);
             return ret;
         },
         __wbindgen_cast_000000000000000a: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 17, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h21f6855640435575_9);
             return ret;
         },
         __wbindgen_cast_000000000000000b: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 394, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h1d6669a7b693932a);
             return ret;
         },
         __wbindgen_cast_000000000000000c: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 421, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 425, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h0fa3f876e31d2a3e);
             return ret;
         },
@@ -3647,6 +3813,9 @@ const BitcoinChainServiceHandleFinalization = (typeof FinalizationRegistry === '
 const BreezSdkFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_breezsdk_free(ptr, 1));
+const DefaultCpfpSignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_defaultcpfpsigner_free(ptr, 1));
 const DefaultSessionStoreFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_defaultsessionstore_free(ptr, 1));

package/deno/breez_sdk_spark_wasm_bg.wasm.d.ts

@@ -3,6 +3,7 @@
 export const memory: WebAssembly.Memory;
 export const __wbg_bitcoinchainservicehandle_free: (a: number, b: number) => void;
 export const __wbg_breezsdk_free: (a: number, b: number) => void;
+export const __wbg_defaultcpfpsigner_free: (a: number, b: number) => void;
 export const __wbg_externalsigners_free: (a: number, b: number) => void;
 export const __wbg_passkeyclient_free: (a: number, b: number) => void;
 export const __wbg_passkeylabels_free: (a: number, b: number) => void;
@@ -11,7 +12,9 @@ export const __wbg_tokenissuer_free: (a: number, b: number) => void;
 export const __wbg_wasmsdkcontext_free: (a: number, b: number) => void;
 export const __wbg_wasmstorageconfig_free: (a: number, b: number) => void;
 export const bitcoinchainservicehandle_broadcastTransaction: (a: number, b: number, c: number) => any;
+export const bitcoinchainservicehandle_getAddressTxos: (a: number, b: number, c: number) => any;
 export const bitcoinchainservicehandle_getAddressUtxos: (a: number, b: number, c: number) => any;
+export const bitcoinchainservicehandle_getOutspend: (a: number, b: number, c: number, d: number) => any;
 export const bitcoinchainservicehandle_getTransactionHex: (a: number, b: number, c: number) => any;
 export const bitcoinchainservicehandle_getTransactionStatus: (a: number, b: number, c: number) => any;
 export const bitcoinchainservicehandle_recommendedFees: (a: number) => any;
@@ -50,6 +53,7 @@ export const breezsdk_optimizeLeaves: (a: number, b: any) => any;
 export const breezsdk_parse: (a: number, b: number, c: number) => any;
 export const breezsdk_prepareLnurlPay: (a: number, b: any) => any;
 export const breezsdk_prepareSendPayment: (a: number, b: any) => any;
+export const breezsdk_prepareUnilateralExit: (a: number, b: any) => any;
 export const breezsdk_publishSignedLnurlPayPackage: (a: number, b: any) => any;
 export const breezsdk_publishSignedTransferPackage: (a: number, b: any) => any;
 export const breezsdk_receivePayment: (a: number, b: any) => any;
@@ -62,6 +66,7 @@ export const breezsdk_removeEventListener: (a: number, b: number, c: number) =>
 export const breezsdk_sendPayment: (a: number, b: any) => any;
 export const breezsdk_signMessage: (a: number, b: any) => any;
 export const breezsdk_syncWallet: (a: number, b: any) => any;
+export const breezsdk_unilateralExit: (a: number, b: any, c: any) => any;
 export const breezsdk_unregisterWebhook: (a: number, b: any) => any;
 export const breezsdk_updateContact: (a: number, b: any) => any;
 export const breezsdk_updateUserSettings: (a: number, b: any) => any;
@@ -77,6 +82,7 @@ export const defaultPostgresStorageConfig: (a: number, b: number) => any;
 export const defaultServerConfig: (a: any) => any;
 export const defaultSessionStore: (a: number, b: any, c: number, d: number) => any;
 export const defaultStorage: (a: number, b: number) => number;
+export const defaultcpfpsigner_signPsbt: (a: number, b: number, c: number) => any;
 export const defaultsessionstore_getSession: (a: number, b: number, c: number) => any;
 export const defaultsessionstore_setSession: (a: number, b: number, c: number, d: any) => any;
 export const externalbreezsignerhandle_decryptEcies: (a: number, b: number, c: number, d: number, e: number) => any;
@@ -103,6 +109,7 @@ export const externalsparksignerhandle_prepareTokenTransaction: (a: number, b: a
 export const externalsparksignerhandle_prepareTransfer: (a: number, b: any) => any;
 export const externalsparksignerhandle_signAuthenticationChallenge: (a: number, b: number, c: number) => any;
 export const externalsparksignerhandle_signFrost: (a: number, b: number, c: number) => any;
+export const externalsparksignerhandle_signLeafRefundSpend: (a: number, b: any, c: number, d: number) => any;
 export const externalsparksignerhandle_signMessage: (a: number, b: number, c: number) => any;
 export const externalsparksignerhandle_signSparkInvoice: (a: number, b: any) => any;
 export const externalsparksignerhandle_signStaticDepositRefund: (a: number, b: any) => any;
@@ -113,10 +120,12 @@ export const mysqlStorage: (a: any) => number;
 export const newRestChainService: (a: number, b: number, c: any, d: any, e: number) => any;
 export const newSharedSdkContext: (a: any) => any;
 export const passkeyclient_checkAvailability: (a: number) => any;
+export const passkeyclient_connectWithPasskey: (a: number, b: any) => any;
 export const passkeyclient_labels: (a: number) => number;
 export const passkeyclient_new: (a: any, b: number, c: number, d: number) => number;
 export const passkeyclient_register: (a: number, b: any) => any;
 export const passkeyclient_signIn: (a: number, b: any) => any;
+export const passkeyclient_supportsImmediateMediation: (a: number) => any;
 export const passkeylabels_list: (a: number) => any;
 export const passkeylabels_store: (a: number, b: number, c: number) => any;
 export const postgresStorage: (a: any) => number;
@@ -137,6 +146,7 @@ export const sdkbuilder_withSessionStore: (a: number, b: any) => number;
 export const sdkbuilder_withSharedContext: (a: number, b: number) => number;
 export const sdkbuilder_withStorage: (a: number, b: any) => number;
 export const sdkbuilder_withStorageBackend: (a: number, b: number) => number;
+export const singleKeyCpfpSigner: (a: number, b: number) => [number, number, number];
 export const start: () => void;
 export const tokenissuer_burnIssuerToken: (a: number, b: any) => any;
 export const tokenissuer_createIssuerToken: (a: number, b: any) => any;

package/itest/.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.env

package/itest/helpers/assert.test.js

@@ -0,0 +1,70 @@
+'use strict'
+
+// Pure tests for the tolerant JSON evaluator; no network. Mirrors the unit
+// tests in crates/breez-sdk/cli/tests/harness/assert.rs.
+
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const { checkMatcher, extractJsonDocs, interpolate, lookupPath } = require('./scenario')
+
+test('extracts pretty and inline docs and skips noise', () => {
+  const chunk = 'Breez SDK: noise\n{\n  "a": 1\n}\nError: nope\n{"b": 2}\nEvent: {"c": 3}\n'
+  assert.deepEqual(extractJsonDocs(chunk), [{ a: 1 }, { b: 2 }])
+})
+
+test('path matches across casings', () => {
+  const rust = { payment_request: { amount_msat: 5 } }
+  const wasm = { paymentRequest: { amountMsat: 5 } }
+  for (const doc of [rust, wasm]) {
+    assert.equal(lookupPath(doc, 'payment_request.amount_msat'), 5)
+  }
+})
+
+test('path bridges enum tags', () => {
+  const rust = { Bolt11Invoice: { amount_msat: 7 } }
+  const wasm = { type: 'bolt11Invoice', amountMsat: 7 }
+  for (const doc of [rust, wasm]) {
+    assert.equal(lookupPath(doc, 'bolt11_invoice.amount_msat'), 7)
+  }
+})
+
+test('empty path addresses the document', () => {
+  assert.deepEqual(lookupPath({}, ''), {})
+  checkMatcher({}, lookupPath({}, ''))
+})
+
+test('path indexes arrays', () => {
+  const doc = { payments: [{ id: 'x' }, { id: 'y' }] }
+  assert.equal(lookupPath(doc, 'payments.1.id'), 'y')
+  assert.equal(lookupPath(doc, 'payments.2.id'), undefined)
+})
+
+test('equality tolerates case and bigint strings', () => {
+  checkMatcher('completed', 'Completed')
+  checkMatcher('1000', 1000)
+  checkMatcher(1000, '1000')
+  assert.throws(() => checkMatcher('completed', 'failed'))
+  assert.throws(() => checkMatcher('completed', undefined))
+})
+
+test('gte accepts numbers and numeric strings', () => {
+  checkMatcher({ gte: 10 }, 11)
+  checkMatcher({ gte: 10 }, '10')
+  assert.throws(() => checkMatcher({ gte: 10 }, 9))
+  assert.throws(() => checkMatcher({ gte: 10 }, 'abc'))
+  assert.throws(() => checkMatcher({ gte: 10 }, undefined))
+})
+
+test('exists checks presence and null', () => {
+  checkMatcher({ exists: true }, 'x')
+  checkMatcher({ exists: false }, undefined)
+  checkMatcher({ exists: false }, null)
+  assert.throws(() => checkMatcher({ exists: true }, null))
+  assert.throws(() => checkMatcher({ exists: true }, undefined))
+})
+
+test('interpolation substitutes known vars and rejects unknown', () => {
+  assert.equal(interpolate('pay -r ${addr} -a 5', { addr: 'spark1x' }), 'pay -r spark1x -a 5')
+  assert.throws(() => interpolate('${missing}', {}))
+})

package/itest/helpers/faucet.js

@@ -0,0 +1,68 @@
+'use strict'
+
+// Minimal client for the Lightspark regtest faucet, mirroring the Rust
+// harness (crates/breez-sdk/cli/tests/harness/faucet.rs).
+
+const DEFAULT_URL = 'https://api.lightspark.com/graphql/spark/rc'
+const MAX_RETRIES = 3
+
+/**
+ * Fund a regtest bitcoin address, returning the funding txid. Retries with
+ * exponential backoff. Reads FAUCET_URL, FAUCET_USERNAME, and
+ * FAUCET_PASSWORD from the environment.
+ *
+ * @param {string} address
+ * @param {number} amountSats
+ * @returns {Promise<string>}
+ */
+async function fundAddress(address, amountSats) {
+  let lastError
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    if (attempt > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 2 ** attempt * 1000))
+    }
+    try {
+      return await tryFundAddress(address, amountSats)
+    } catch (e) {
+      lastError = e
+    }
+  }
+  throw lastError
+}
+
+async function tryFundAddress(address, amountSats) {
+  const url = process.env.FAUCET_URL || DEFAULT_URL
+  const headers = { 'Content-Type': 'application/json' }
+  const { FAUCET_USERNAME, FAUCET_PASSWORD } = process.env
+  if (FAUCET_USERNAME && FAUCET_PASSWORD) {
+    const credentials = Buffer.from(`${FAUCET_USERNAME}:${FAUCET_PASSWORD}`).toString('base64')
+    headers.Authorization = `Basic ${credentials}`
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({
+      operationName: 'RequestRegtestFunds',
+      variables: { amount_sats: amountSats, address },
+      query:
+        'mutation RequestRegtestFunds($address: String!, $amount_sats: Long!) { ' +
+        'request_regtest_funds(input: {address: $address, amount_sats: $amount_sats}) ' +
+        '{ transaction_hash}}'
+    })
+  })
+  const body = await response.text()
+  if (!response.ok) {
+    throw new Error(`faucet request failed with status ${response.status}: ${body}`)
+  }
+  const parsed = JSON.parse(body)
+  if (parsed.errors && parsed.errors.length > 0) {
+    throw new Error(`faucet returned errors: ${parsed.errors.map((e) => e.message).join(', ')}`)
+  }
+  if (!parsed.data) {
+    throw new Error(`faucet response has no data: ${body}`)
+  }
+  return parsed.data.request_regtest_funds.transaction_hash
+}
+
+module.exports = { fundAddress }