@breeztech/breez-sdk-spark 0.6.5 → 0.7.0-dev1

package/deno/breez_sdk_spark_wasm.js

@@ -205,11 +205,11 @@ function debugString(val) {
     return className;
 }
 /**
- * @param {Network} network
- * @returns {Config}
+ * @param {ConnectRequest} request
+ * @returns {Promise<BreezSdk>}
  */
-export function defaultConfig(network) {
-    const ret = wasm.defaultConfig(network);
+export function connect(request) {
+    const ret = wasm.connect(request);
     return ret;
 }
 
@@ -226,11 +226,24 @@ export function initLogging(logger, filter) {
 }
 
 /**
- * @param {ConnectRequest} request
+ * @param {Config} config
+ * @param {ExternalSigner} signer
+ * @param {string} storage_dir
  * @returns {Promise<BreezSdk>}
  */
-export function connect(request) {
-    const ret = wasm.connect(request);
+export function connectWithSigner(config, signer, storage_dir) {
+    const ptr0 = passStringToWasm0(storage_dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.connectWithSigner(config, signer, ptr0, len0);
+    return ret;
+}
+
+/**
+ * @param {Network} network
+ * @returns {Config}
+ */
+export function defaultConfig(network) {
+    const ret = wasm.defaultConfig(network);
     return ret;
 }
 
@@ -239,6 +252,34 @@ function takeFromExternrefTable0(idx) {
     wasm.__externref_table_dealloc(idx);
     return value;
 }
+/**
+ * Creates a default external signer from a mnemonic phrase.
+ *
+ * This creates a signer that can be used with `connectWithSigner` or `SdkBuilder.newWithSigner`.
+ * @param {string} mnemonic
+ * @param {string | null | undefined} passphrase
+ * @param {Network} network
+ * @param {KeySetConfig | null} [key_set_config]
+ * @returns {DefaultSigner}
+ */
+export function defaultExternalSigner(mnemonic, passphrase, network, key_set_config) {
+    const ptr0 = passStringToWasm0(mnemonic, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(passphrase) ? 0 : passStringToWasm0(passphrase, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.defaultExternalSigner(ptr0, len0, ptr1, len1, network, isLikeNone(key_set_config) ? 0 : addToExternrefTable0(key_set_config));
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return DefaultSigner.__wrap(ret[0]);
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
  * Entry point invoked by JavaScript in a worker.
  * @param {number} ptr
@@ -250,16 +291,16 @@ export function task_worker_entry_point(ptr) {
     }
 }
 
-function __wbg_adapter_58(arg0, arg1) {
+function __wbg_adapter_64(arg0, arg1) {
     wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdf0ebd5238280272(arg0, arg1);
 }
 
-function __wbg_adapter_61(arg0, arg1, arg2) {
-    wasm.closure996_externref_shim(arg0, arg1, arg2);
+function __wbg_adapter_67(arg0, arg1, arg2) {
+    wasm.closure1047_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_282(arg0, arg1, arg2, arg3) {
-    wasm.closure564_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_349(arg0, arg1, arg2, arg3) {
+    wasm.closure632_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 const __wbindgen_enum_ReadableStreamType = ["bytes"];
@@ -519,6 +560,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_registerLightningAddress(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {FetchTokenConversionLimitsRequest} request
+     * @returns {Promise<FetchTokenConversionLimitsResponse>}
+     */
+    fetchTokenConversionLimits(request) {
+        const ret = wasm.breezsdk_fetchTokenConversionLimits(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @returns {OptimizationProgress}
      */
@@ -562,6 +611,219 @@ export class BreezSdk {
     }
 }
 
+const DefaultSignerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_defaultsigner_free(ptr >>> 0, 1));
+/**
+ * A default signer implementation that wraps the core SDK's ExternalSigner.
+ * This is returned by `defaultExternalSigner` and can be passed to `connectWithSigner`.
+ */
+export class DefaultSigner {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DefaultSigner.prototype);
+        obj.__wbg_ptr = ptr;
+        DefaultSignerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DefaultSignerFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_defaultsigner_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} message
+     * @param {string} path
+     * @returns {Promise<EcdsaSignatureBytes>}
+     */
+    signEcdsa(message, path) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsigner_signEcdsa(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {ExternalSignFrostRequest} request
+     * @returns {Promise<ExternalFrostSignatureShare>}
+     */
+    signFrost(request) {
+        const ret = wasm.defaultsigner_signFrost(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} message
+     * @param {string} path
+     * @returns {Promise<Uint8Array>}
+     */
+    eciesDecrypt(message, path) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsigner_eciesDecrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} message
+     * @param {string} path
+     * @returns {Promise<Uint8Array>}
+     */
+    eciesEncrypt(message, path) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsigner_eciesEncrypt(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {ExternalAggregateFrostRequest} request
+     * @returns {Promise<ExternalFrostSignature>}
+     */
+    aggregateFrost(request) {
+        const ret = wasm.defaultsigner_aggregateFrost(this.__wbg_ptr, request);
+        return ret;
+    }
+    /**
+     * @param {string} path
+     * @returns {Promise<PublicKeyBytes>}
+     */
+    derivePublicKey(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsigner_derivePublicKey(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} hash
+     * @param {string} path
+     * @returns {Promise<SchnorrSignatureBytes>}
+     */
+    signHashSchnorr(hash, path) {
+        const ptr0 = passArray8ToWasm0(hash, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsigner_signHashSchnorr(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @returns {Promise<ExternalPrivateKeySource>}
+     */
+    generateRandomKey() {
+        const ret = wasm.defaultsigner_generateRandomKey(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {PublicKeyBytes}
+     */
+    identityPublicKey() {
+        const ret = wasm.defaultsigner_identityPublicKey(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {ExternalPrivateKeySource} signing_key
+     * @param {ExternalPrivateKeySource} new_signing_key
+     * @returns {Promise<ExternalPrivateKeySource>}
+     */
+    subtractPrivateKeys(signing_key, new_signing_key) {
+        const ret = wasm.defaultsigner_subtractPrivateKeys(this.__wbg_ptr, signing_key, new_signing_key);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} message
+     * @param {string} path
+     * @returns {Promise<RecoverableEcdsaSignatureBytes>}
+     */
+    signEcdsaRecoverable(message, path) {
+        const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.defaultsigner_signEcdsaRecoverable(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {ExternalTreeNodeId} id
+     * @returns {Promise<PublicKeyBytes>}
+     */
+    getPublicKeyForNode(id) {
+        const ret = wasm.defaultsigner_getPublicKeyForNode(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * @param {ExternalSecretToSplit} secret
+     * @param {number} threshold
+     * @param {number} num_shares
+     * @returns {Promise<ExternalVerifiableSecretShare[]>}
+     */
+    splitSecretWithProofs(secret, threshold, num_shares) {
+        const ret = wasm.defaultsigner_splitSecretWithProofs(this.__wbg_ptr, secret, threshold, num_shares);
+        return ret;
+    }
+    /**
+     * @param {number} index
+     * @returns {Promise<PublicKeyBytes>}
+     */
+    getStaticDepositPublicKey(index) {
+        const ret = wasm.defaultsigner_getStaticDepositPublicKey(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @param {number} index
+     * @returns {Promise<PrivateKeyBytes>}
+     */
+    getStaticDepositPrivateKey(index) {
+        const ret = wasm.defaultsigner_getStaticDepositPrivateKey(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @param {ExternalEncryptedPrivateKey} private_key
+     * @param {PublicKeyBytes} receiver_public_key
+     * @returns {Promise<Uint8Array>}
+     */
+    encryptPrivateKeyForReceiver(private_key, receiver_public_key) {
+        const ret = wasm.defaultsigner_encryptPrivateKeyForReceiver(this.__wbg_ptr, private_key, receiver_public_key);
+        return ret;
+    }
+    /**
+     * @returns {Promise<ExternalFrostCommitments>}
+     */
+    generateFrostSigningCommitments() {
+        const ret = wasm.defaultsigner_generateFrostSigningCommitments(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} index
+     * @returns {Promise<ExternalPrivateKeySource>}
+     */
+    getStaticDepositPrivateKeySource(index) {
+        const ret = wasm.defaultsigner_getStaticDepositPrivateKeySource(this.__wbg_ptr, index);
+        return ret;
+    }
+    /**
+     * @param {ExternalPrivateKeySource} private_key
+     * @returns {Promise<PublicKeyBytes>}
+     */
+    getPublicKeyFromPrivateKeySource(private_key) {
+        const ret = wasm.defaultsigner_getPublicKeyFromPrivateKeySource(this.__wbg_ptr, private_key);
+        return ret;
+    }
+}
+
 const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
@@ -714,14 +976,12 @@ export class SdkBuilder {
         wasm.__wbg_sdkbuilder_free(ptr, 0);
     }
     /**
-     * @param {KeySetType} key_set_type
-     * @param {boolean} use_address_index
-     * @param {number | null} [account_number]
+     * @param {KeySetConfig} config
      * @returns {SdkBuilder}
      */
-    withKeySet(key_set_type, use_address_index, account_number) {
+    withKeySet(config) {
         const ptr = this.__destroy_into_raw();
-        const ret = wasm.sdkbuilder_withKeySet(ptr, key_set_type, use_address_index, isLikeNone(account_number) ? 0x100000001 : (account_number) >>> 0);
+        const ret = wasm.sdkbuilder_withKeySet(ptr, config);
         return SdkBuilder.__wrap(ret);
     }
     /**
@@ -733,6 +993,15 @@ export class SdkBuilder {
         const ret = wasm.sdkbuilder_withStorage(ptr, storage);
         return SdkBuilder.__wrap(ret);
     }
+    /**
+     * @param {Config} config
+     * @param {ExternalSigner} signer
+     * @returns {SdkBuilder}
+     */
+    static newWithSigner(config, signer) {
+        const ret = wasm.sdkbuilder_newWithSigner(config, signer);
+        return SdkBuilder.__wrap(ret);
+    }
     /**
      * @param {FiatService} fiat_service
      * @returns {SdkBuilder}
@@ -920,6 +1189,10 @@ const imports = {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments) },
+        __wbg_aggregateFrost_053f2d54394422d5: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.aggregateFrost(arg1);
+            return ret;
+        }, arguments) },
         __wbg_append_8c7dd8d641a5f01b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments) },
@@ -1052,10 +1325,54 @@ const imports = {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments) },
+        __wbg_derivePublicKey_736fb57b6852f201: function() { return handleError(function (arg0, arg1, arg2) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg1;
+                deferred0_1 = arg2;
+                const ret = arg0.derivePublicKey(getStringFromWasm0(arg1, arg2));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        }, arguments) },
         __wbg_done_769e5ede4b31c67b: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
+        __wbg_eciesDecrypt_4edc97146456d67b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+                wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+                deferred1_0 = arg3;
+                deferred1_1 = arg4;
+                const ret = arg0.eciesDecrypt(v0, getStringFromWasm0(arg3, arg4));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments) },
+        __wbg_eciesEncrypt_040d338cf1cb289f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+                wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+                deferred1_0 = arg3;
+                deferred1_1 = arg4;
+                const ret = arg0.eciesEncrypt(v0, getStringFromWasm0(arg3, arg4));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments) },
+        __wbg_encryptPrivateKeyForReceiver_6e87a5befdd3ee82: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.encryptPrivateKeyForReceiver(arg1, arg2);
+            return ret;
+        }, arguments) },
         __wbg_enqueue_bb16ba72f537dc9e: function() { return handleError(function (arg0, arg1) {
             arg0.enqueue(arg1);
         }, arguments) },
@@ -1090,6 +1407,14 @@ const imports = {
             const ret = fetch(arg0);
             return ret;
         },
+        __wbg_generateFrostSigningCommitments_3473ea4923985769: function() { return handleError(function (arg0) {
+            const ret = arg0.generateFrostSigningCommitments();
+            return ret;
+        }, arguments) },
+        __wbg_generateRandomKey_48fd8bb84246b45f: function() { return handleError(function (arg0) {
+            const ret = arg0.generateRandomKey();
+            return ret;
+        }, arguments) },
         __wbg_getAddressUtxos_328ceb8b4a63a6da: function() { return handleError(function (arg0, arg1, arg2) {
             let deferred0_0;
             let deferred0_1;
@@ -1138,6 +1463,14 @@ const imports = {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments) },
+        __wbg_getPublicKeyForNode_5ddb3378904e4ad4: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.getPublicKeyForNode(arg1);
+            return ret;
+        }, arguments) },
+        __wbg_getPublicKeyFromPrivateKeySource_1ef953e0c8c04628: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.getPublicKeyFromPrivateKeySource(arg1);
+            return ret;
+        }, arguments) },
         __wbg_getRandomValues_b8f5dbd5f3995a9e: function() { return handleError(function (arg0, arg1) {
             arg0.getRandomValues(arg1);
         }, arguments) },
@@ -1160,6 +1493,18 @@ const imports = {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
             }
         }, arguments) },
+        __wbg_getStaticDepositPrivateKeySource_7b2991ed6d3d4711: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.getStaticDepositPrivateKeySource(arg1 >>> 0);
+            return ret;
+        }, arguments) },
+        __wbg_getStaticDepositPrivateKey_c4cc635b7e2348a8: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.getStaticDepositPrivateKey(arg1 >>> 0);
+            return ret;
+        }, arguments) },
+        __wbg_getStaticDepositPublicKey_86535a86c4cf3d04: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.getStaticDepositPublicKey(arg1 >>> 0);
+            return ret;
+        }, arguments) },
         __wbg_getTransactionHex_973b8d0555c60f99: function() { return handleError(function (arg0, arg1, arg2) {
             let deferred0_0;
             let deferred0_1;
@@ -1212,6 +1557,10 @@ const imports = {
             const ret = arg0.headers;
             return ret;
         },
+        __wbg_identityPublicKey_c8b35005055a3df0: function() { return handleError(function (arg0) {
+            const ret = arg0.identityPublicKey();
+            return ret;
+        }, arguments) },
         __wbg_insertPayment_2afe3300c5f86ccf: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.insertPayment(arg1);
             return ret;
@@ -1354,7 +1703,7 @@ const imports = {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wbg_adapter_282(a, state0.b, arg0, arg1);
+                        return __wbg_adapter_349(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -1588,10 +1937,60 @@ const imports = {
         __wbg_setsignal_75b21ef3a81de905: function(arg0, arg1) {
             arg0.signal = arg1;
         },
+        __wbg_signEcdsaRecoverable_673b67f4f9ec42e7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+                wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+                deferred1_0 = arg3;
+                deferred1_1 = arg4;
+                const ret = arg0.signEcdsaRecoverable(v0, getStringFromWasm0(arg3, arg4));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments) },
+        __wbg_signEcdsa_b0be26cee51844bc: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+                wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+                deferred1_0 = arg3;
+                deferred1_1 = arg4;
+                const ret = arg0.signEcdsa(v0, getStringFromWasm0(arg3, arg4));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments) },
+        __wbg_signFrost_06ac652135c4e862: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.signFrost(arg1);
+            return ret;
+        }, arguments) },
+        __wbg_signHashSchnorr_390c51f0bbb70a7a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            let deferred1_0;
+            let deferred1_1;
+            try {
+                var v0 = getArrayU8FromWasm0(arg1, arg2).slice();
+                wasm.__wbindgen_free(arg1, arg2 * 1, 1);
+                deferred1_0 = arg3;
+                deferred1_1 = arg4;
+                const ret = arg0.signHashSchnorr(v0, getStringFromWasm0(arg3, arg4));
+                return ret;
+            } finally {
+                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+            }
+        }, arguments) },
         __wbg_signal_aaf9ad74119f20a4: function(arg0) {
             const ret = arg0.signal;
             return ret;
         },
+        __wbg_splitSecretWithProofs_1aba146de2c5eb0a: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.splitSecretWithProofs(arg1, arg2 >>> 0, arg3 >>> 0);
+            return ret;
+        }, arguments) },
         __wbg_static_accessor_GLOBAL_88a902d13a557d07: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1620,6 +2019,10 @@ const imports = {
             const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
+        __wbg_subtractPrivateKeys_8b281bbbac58f672: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.subtractPrivateKeys(arg1, arg2);
+            return ret;
+        }, arguments) },
         __wbg_syncAddOutgoingChange_9d94d35ba215d3c9: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.syncAddOutgoingChange(arg1);
             return ret;
@@ -1709,6 +2112,13 @@ const imports = {
             const ret = arg0.view;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbindgen_array_new: function() {
+            const ret = [];
+            return ret;
+        },
+        __wbindgen_array_push: function(arg0, arg1) {
+            arg0.push(arg1);
+        },
         __wbindgen_as_number: function(arg0) {
             const ret = +arg0;
             return ret;
@@ -1745,12 +2155,12 @@ const imports = {
             const ret = false;
             return ret;
         },
-        __wbindgen_closure_wrapper11838: function(arg0, arg1, arg2) {
-            const ret = makeMutClosure(arg0, arg1, 997, __wbg_adapter_61);
+        __wbindgen_closure_wrapper11146: function(arg0, arg1, arg2) {
+            const ret = makeMutClosure(arg0, arg1, 812, __wbg_adapter_64);
             return ret;
         },
-        __wbindgen_closure_wrapper9899: function(arg0, arg1, arg2) {
-            const ret = makeMutClosure(arg0, arg1, 759, __wbg_adapter_58);
+        __wbindgen_closure_wrapper13052: function(arg0, arg1, arg2) {
+            const ret = makeMutClosure(arg0, arg1, 1048, __wbg_adapter_67);
             return ret;
         },
         __wbindgen_debug_string: function(arg0, arg1) {
@@ -1844,6 +2254,12 @@ const imports = {
         __wbindgen_throw: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbindgen_uint8_array_new: function(arg0, arg1) {
+            var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
+            wasm.__wbindgen_free(arg0, arg1 * 1, 1);
+            const ret = v0;
+            return ret;
+        },
     },
 
 };

package/deno/breez_sdk_spark_wasm_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_breezsdk_free: (a: number, b: number) => void;
+export const __wbg_defaultsigner_free: (a: number, b: number) => void;
 export const __wbg_sdkbuilder_free: (a: number, b: number) => void;
 export const __wbg_tokenissuer_free: (a: number, b: number) => void;
 export const breezsdk_addEventListener: (a: number, b: any) => any;
@@ -12,6 +13,7 @@ export const breezsdk_claimDeposit: (a: number, b: any) => any;
 export const breezsdk_claimHtlcPayment: (a: number, b: any) => any;
 export const breezsdk_deleteLightningAddress: (a: number) => any;
 export const breezsdk_disconnect: (a: number) => any;
+export const breezsdk_fetchTokenConversionLimits: (a: number, b: any) => any;
 export const breezsdk_getInfo: (a: number, b: any) => any;
 export const breezsdk_getLeafOptimizationProgress: (a: number) => any;
 export const breezsdk_getLightningAddress: (a: number) => any;
@@ -39,14 +41,36 @@ export const breezsdk_startLeafOptimization: (a: number) => void;
 export const breezsdk_syncWallet: (a: number, b: any) => any;
 export const breezsdk_updateUserSettings: (a: number, b: any) => any;
 export const connect: (a: any) => any;
+export const connectWithSigner: (a: any, b: any, c: number, d: number) => any;
 export const defaultConfig: (a: any) => any;
+export const defaultExternalSigner: (a: number, b: number, c: number, d: number, e: any, f: number) => [number, number, number];
+export const defaultsigner_aggregateFrost: (a: number, b: any) => any;
+export const defaultsigner_derivePublicKey: (a: number, b: number, c: number) => any;
+export const defaultsigner_eciesDecrypt: (a: number, b: number, c: number, d: number, e: number) => any;
+export const defaultsigner_eciesEncrypt: (a: number, b: number, c: number, d: number, e: number) => any;
+export const defaultsigner_encryptPrivateKeyForReceiver: (a: number, b: any, c: any) => any;
+export const defaultsigner_generateFrostSigningCommitments: (a: number) => any;
+export const defaultsigner_generateRandomKey: (a: number) => any;
+export const defaultsigner_getPublicKeyForNode: (a: number, b: any) => any;
+export const defaultsigner_getPublicKeyFromPrivateKeySource: (a: number, b: any) => any;
+export const defaultsigner_getStaticDepositPrivateKey: (a: number, b: number) => any;
+export const defaultsigner_getStaticDepositPrivateKeySource: (a: number, b: number) => any;
+export const defaultsigner_getStaticDepositPublicKey: (a: number, b: number) => any;
+export const defaultsigner_identityPublicKey: (a: number) => [number, number, number];
+export const defaultsigner_signEcdsa: (a: number, b: number, c: number, d: number, e: number) => any;
+export const defaultsigner_signEcdsaRecoverable: (a: number, b: number, c: number, d: number, e: number) => any;
+export const defaultsigner_signFrost: (a: number, b: any) => any;
+export const defaultsigner_signHashSchnorr: (a: number, b: number, c: number, d: number, e: number) => any;
+export const defaultsigner_splitSecretWithProofs: (a: number, b: any, c: number, d: number) => any;
+export const defaultsigner_subtractPrivateKeys: (a: number, b: any, c: any) => any;
 export const initLogging: (a: any, b: number, c: number) => any;
 export const sdkbuilder_build: (a: number) => any;
 export const sdkbuilder_new: (a: any, b: any) => number;
+export const sdkbuilder_newWithSigner: (a: any, b: any) => number;
 export const sdkbuilder_withChainService: (a: number, b: any) => number;
 export const sdkbuilder_withDefaultStorage: (a: number, b: number, c: number) => any;
 export const sdkbuilder_withFiatService: (a: number, b: any) => number;
-export const sdkbuilder_withKeySet: (a: number, b: any, c: number, d: number) => number;
+export const sdkbuilder_withKeySet: (a: number, b: any) => number;
 export const sdkbuilder_withLnurlClient: (a: number, b: any) => number;
 export const sdkbuilder_withPaymentObserver: (a: number, b: any) => number;
 export const sdkbuilder_withRestChainService: (a: number, b: number, c: number, d: any, e: number) => number;
@@ -86,6 +110,6 @@ export const __externref_drop_slice: (a: number, b: number) => void;
 export const __wbindgen_export_7: WebAssembly.Table;
 export const __externref_table_dealloc: (a: number) => void;
 export const _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hdf0ebd5238280272: (a: number, b: number) => void;
-export const closure996_externref_shim: (a: number, b: number, c: any) => void;
-export const closure564_externref_shim: (a: number, b: number, c: any, d: any) => void;
+export const closure1047_externref_shim: (a: number, b: number, c: any) => void;
+export const closure632_externref_shim: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_start: () => void;