@symbiome-forge/cow-sdk-wasm 0.1.0-alpha.1

package/dist/raw/signing-nodejs/cow_sdk_wasm.cjs

@@ -0,0 +1,1078 @@
+/* @ts-self-types="./cow_sdk_wasm.d.ts" */
+
+/**
+ * Initializes the wasm crate's panic hook once.
+ */
+function __cow_sdk_wasm_init() {
+    wasm.__cow_sdk_wasm_init();
+}
+exports.__cow_sdk_wasm_init = __cow_sdk_wasm_init;
+
+/**
+ * Computes the canonical order UID and order digest for an unsigned order.
+ *
+ * The UID combines the EIP-712 order digest, owner address, and validity
+ * timestamp using the same packing rules as the native Rust SDK.
+ *
+ * @param input Unsigned order fields to hash and pack.
+ * @param chainId EVM chain id used for the EIP-712 domain.
+ * @param owner Order owner address included in the UID suffix.
+ * @returns A versioned envelope with `orderUid` and `orderDigest`.
+ * @throws CowError when the order, owner, or chain id is invalid.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @param {string} owner
+ * @returns {WasmEnvelope<GeneratedOrderUidDto>}
+ */
+function computeOrderUid(input, chainId, owner) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.computeOrderUid(retptr, addHeapObject(input), chainId, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.computeOrderUid = computeOrderUid;
+
+/**
+ * Decodes an eth-flow on-chain order lifecycle event log into a typed event.
+ *
+ * Dispatches on the log's topic-0 across the `CoWSwapOnchainOrders`
+ * `OrderPlacement` / `OrderInvalidation` events and the `CoWSwapEthFlow`
+ * `OrderRefund` event. The decode is fail-closed: the topic set and on-chain
+ * signing scheme are validated and every order UID is length-checked, so a
+ * malformed or hostile log returns a typed error rather than panicking.
+ *
+ * @param log Raw log with `topics` (0x-prefixed 32-byte hex, topic-0 first)
+ * and `data` (0x-prefixed hex, `"0x"` when empty).
+ * @returns A versioned envelope containing the decoded eth-flow event.
+ * @throws CowError when the log is malformed or its topic set matches no known
+ * eth-flow lifecycle event.
+ * @param {EventLogInput} log
+ * @returns {WasmEnvelope<EthFlowEventDto>}
+ */
+function decodeEthFlowLog(log) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.decodeEthFlowLog(retptr, addHeapObject(log));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.decodeEthFlowLog = decodeEthFlowLog;
+
+/**
+ * Decodes a `GPv2Settlement` event log into a typed settlement event.
+ *
+ * Dispatches on the log's topic-0 across `Trade`, `Interaction`, `Settlement`,
+ * `OrderInvalidated`, and `PreSignature`. The decode is fail-closed: the topic
+ * set is validated before ABI decoding and every order UID is length-checked,
+ * so a malformed or hostile log returns a typed error rather than panicking.
+ *
+ * @param log Raw log with `topics` (0x-prefixed 32-byte hex, topic-0 first)
+ * and `data` (0x-prefixed hex, `"0x"` when empty).
+ * @returns A versioned envelope containing the decoded settlement event.
+ * @throws CowError when the log is malformed or its topic set matches no known
+ * settlement event.
+ * @param {EventLogInput} log
+ * @returns {WasmEnvelope<SettlementEventDto>}
+ */
+function decodeSettlementLog(log) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.decodeSettlementLog(retptr, addHeapObject(log));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.decodeSettlementLog = decodeSettlementLog;
+
+/**
+ * Returns canonical CoW Protocol deployment addresses for a chain.
+ *
+ * The optional environment selects production or staging deployment data. When
+ * omitted, the helper uses the SDK default environment.
+ *
+ * @param chainId EVM chain id to resolve.
+ * @param env Optional CoW environment name, such as `prod` or `staging`.
+ * @returns Settlement, VaultRelayer, EthFlow, and AllowListAuth addresses.
+ * @throws CowError when the chain or environment is unsupported.
+ * @param {number} chainId
+ * @param {string | null} [env]
+ * @returns {WasmEnvelope<DeploymentAddressesDto>}
+ */
+function deploymentAddresses(chainId, env) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        var ptr0 = isLikeNone(env) ? 0 : passStringToWasm0(env, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len0 = WASM_VECTOR_LEN;
+        wasm.deploymentAddresses(retptr, chainId, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.deploymentAddresses = deploymentAddresses;
+
+/**
+ * Computes the CoW Protocol EIP-712 domain separator for a supported chain.
+ *
+ * Use this helper when a JavaScript host needs to compare the domain hash used
+ * by the Rust SDK with another signing stack. The input is an EVM chain id,
+ * not a CoW environment selector.
+ *
+ * @param chainId EVM chain id supported by the deployment registry.
+ * @returns The `0x`-prefixed 32-byte domain separator.
+ * @throws CowError when the chain is not supported.
+ * @param {number} chainId
+ * @returns {string}
+ */
+function domainSeparator(chainId) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.domainSeparator(retptr, chainId);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.domainSeparator = domainSeparator;
+
+/**
+ * Encodes a CoW EIP-1271 payload from an ECDSA order signature.
+ *
+ * Use this pure helper when a smart-account flow already has the wrapped ECDSA
+ * signature and needs the contract-signature payload bytes expected by CoW
+ * Protocol order submission.
+ *
+ * @param input Unsigned order used to derive the EIP-1271 payload.
+ * @param ecdsaSignature Wrapped ECDSA signature as a `0x`-prefixed string.
+ * @returns A versioned envelope containing the encoded EIP-1271 payload.
+ * @throws CowError when the order or signature is invalid.
+ * @param {OrderInput} input
+ * @param {string} ecdsaSignature
+ * @returns {WasmEnvelope<string>}
+ */
+function eip1271SignaturePayload(input, ecdsaSignature) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(ecdsaSignature, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.eip1271SignaturePayload(retptr, addHeapObject(input), ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.eip1271SignaturePayload = eip1271SignaturePayload;
+
+/**
+ * Builds signer-facing EIP-712 typed data for an unsigned order.
+ *
+ * The returned envelope contains the domain, type map, primary type, and
+ * order message that wallet libraries expect for EIP-712 signing. It is
+ * deterministic for the provided order and chain id.
+ *
+ * @param input Unsigned order fields using the facade order DTO shape.
+ * @param chainId EVM chain id used for the EIP-712 domain.
+ * @returns A versioned envelope containing typed-data DTO fields.
+ * @throws CowError when order parsing or chain validation fails.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @returns {WasmEnvelope<TypedDataEnvelopeDto>}
+ */
+function orderTypedData(input, chainId) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.orderTypedData(retptr, addHeapObject(input), chainId);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return takeObject(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.orderTypedData = orderTypedData;
+
+/**
+ * Signs an order digest through an explicit `eth_sign` callback.
+ *
+ * The SDK computes the canonical order digest, passes the digest as a
+ * `0x`-prefixed string to the callback, normalizes the signature, and returns
+ * an `ethsign` signed-order DTO.
+ *
+ * @param input Unsigned order fields to sign.
+ * @param chainId EVM chain id used for the digest.
+ * @param owner Owner address used in the generated order UID.
+ * @param digestSigner Callback that signs the digest string.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing the signed order.
+ * @throws CowError for invalid input, callback failure, timeout, or cancellation.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @param {string} owner
+ * @param {DigestSignerCallback} digestSigner
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedOrderDto>}
+ */
+function signOrderEthSignDigest(input, chainId, owner, digestSigner, options) {
+    const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signOrderEthSignDigest(addHeapObject(input), chainId, ptr0, len0, addHeapObject(digestSigner), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signOrderEthSignDigest = signOrderEthSignDigest;
+
+/**
+ * Signs an order through a custom EIP-1271 callback.
+ *
+ * Use this method when the JavaScript host owns the smart-account or
+ * account-abstraction client and can return the final contract signature
+ * directly. The SDK still builds typed data and the deterministic order UID.
+ *
+ * @param input Unsigned order to sign.
+ * @param chainId EVM chain id for the EIP-712 domain.
+ * @param owner Smart-account owner address used in the generated order UID.
+ * @param customCallback Callback that returns the final EIP-1271 signature.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing the signed-order DTO.
+ * @throws CowError for invalid input, callback failure, timeout, or cancellation.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @param {string} owner
+ * @param {CustomEip1271Callback} customCallback
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedOrderDto>}
+ */
+function signOrderWithCustomEip1271(input, chainId, owner, customCallback, options) {
+    const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signOrderWithCustomEip1271(addHeapObject(input), chainId, ptr0, len0, addHeapObject(customCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signOrderWithCustomEip1271 = signOrderWithCustomEip1271;
+
+/**
+ * Signs an order through an EIP-1193 request callback.
+ *
+ * The callback receives an `eth_signTypedData_v4` request object with owner
+ * address and serialized typed data. This is the bridge for injected wallets
+ * and wallet-client libraries that expose an EIP-1193-style request function.
+ *
+ * @param input Unsigned order fields to sign.
+ * @param chainId EVM chain id used for the EIP-712 domain.
+ * @param owner Owner address used in the wallet request and order UID.
+ * @param requestCallback Callback that executes the EIP-1193 request.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing the signed order.
+ * @throws CowError for invalid input, wallet failure, timeout, or cancellation.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @param {string} owner
+ * @param {Eip1193RequestCallback} requestCallback
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedOrderDto>}
+ */
+function signOrderWithEip1193(input, chainId, owner, requestCallback, options) {
+    const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signOrderWithEip1193(addHeapObject(input), chainId, ptr0, len0, addHeapObject(requestCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signOrderWithEip1193 = signOrderWithEip1193;
+
+/**
+ * Signs an order through typed-data ECDSA and wraps it as EIP-1271.
+ *
+ * The SDK sends the EIP-712 envelope to the provided typed-data callback,
+ * then converts the returned ECDSA signature into the CoW EIP-1271 payload.
+ * Per-call options may attach cancellation and wallet timeout settings.
+ *
+ * @param input Unsigned order to sign.
+ * @param chainId EVM chain id for the EIP-712 domain.
+ * @param owner Smart-account owner address used in the generated order UID.
+ * @param typedDataSigner Callback that signs the typed-data envelope.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing the signed-order DTO.
+ * @throws CowError for invalid input, callback failure, timeout, or cancellation.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @param {string} owner
+ * @param {TypedDataSignerCallback} typedDataSigner
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedOrderDto>}
+ */
+function signOrderWithEip1271(input, chainId, owner, typedDataSigner, options) {
+    const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signOrderWithEip1271(addHeapObject(input), chainId, ptr0, len0, addHeapObject(typedDataSigner), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signOrderWithEip1271 = signOrderWithEip1271;
+
+/**
+ * Signs an order through a typed-data callback.
+ *
+ * The SDK builds the EIP-712 typed-data envelope, passes it to the callback,
+ * normalizes the returned ECDSA signature, and returns the signed-order DTO
+ * with the canonical order UID and digest.
+ *
+ * @param input Unsigned order fields to sign.
+ * @param chainId EVM chain id used for the EIP-712 domain.
+ * @param owner Owner address used in the generated order UID.
+ * @param typedDataSigner Callback that signs the typed-data envelope.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing the signed order.
+ * @throws CowError for invalid input, callback failure, timeout, or cancellation.
+ * @param {OrderInput} input
+ * @param {number} chainId
+ * @param {string} owner
+ * @param {TypedDataSignerCallback} typedDataSigner
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedOrderDto>}
+ */
+function signOrderWithTypedDataSigner(input, chainId, owner, typedDataSigner, options) {
+    const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signOrderWithTypedDataSigner(addHeapObject(input), chainId, ptr0, len0, addHeapObject(typedDataSigner), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signOrderWithTypedDataSigner = signOrderWithTypedDataSigner;
+
+/**
+ * Returns the EVM chain ids supported by the SDK deployment registry.
+ *
+ * This is a pure helper and does not perform network I/O. The returned list is
+ * suitable for runtime validation, UI selection, or capability checks before a
+ * client is constructed.
+ *
+ * @returns A typed array of supported EVM chain ids.
+ * @returns {Uint32Array}
+ */
+function supportedChainIds() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.supportedChainIds(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var v1 = getArrayU32FromWasm0(r0, r1).slice();
+        wasm.__wbindgen_export4(r0, r1 * 4, 4);
+        return v1;
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+exports.supportedChainIds = supportedChainIds;
+
+/**
+ * Returns the version of the wasm package runtime.
+ *
+ * The value comes from the Rust package metadata used to build the wasm
+ * artifact and can be included in diagnostics or compatibility checks.
+ *
+ * @returns The semantic version string for this wasm build.
+ * @returns {string}
+ */
+function wasmVersion() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.wasmVersion(retptr);
+        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);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+    }
+}
+exports.wasmVersion = wasmVersion;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_Error_fdd633d4bb5dd76a: function(arg0, arg1) {
+            const ret = Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_Number_c4bdf66bb78f7977: function(arg0) {
+            const ret = Number(getObject(arg0));
+            return ret;
+        },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_boolean_get_edaed31a367ce1bd: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_debug_string_8a447059637473e2: function(arg0, arg1) {
+            const ret = debugString(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_in_4990f46af709e33c: function(arg0, arg1) {
+            const ret = getObject(arg0) in getObject(arg1);
+            return ret;
+        },
+        __wbg___wbindgen_is_function_acc5528be2b923f2: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_6d937fbfb6478470: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_0beba4a1980d3eea: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_1fca8072260dd261: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_721f8decd50c87a3: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_loose_eq_4b9aba9e5b3c4582: function(arg0, arg1) {
+            const ret = getObject(arg0) == getObject(arg1);
+            return ret;
+        },
+        __wbg___wbindgen_number_get_1cc01dd708740256: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'number' ? obj : undefined;
+            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
+        __wbg___wbindgen_string_get_71bb4348194e31f0: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_ea4887a5f8f9a9db: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg__wbg_cb_unref_33c39e13d73b25f6: function(arg0) {
+            getObject(arg0)._wbg_cb_unref();
+        },
+        __wbg_aborted_4d4114700dc4c251: function(arg0) {
+            const ret = getObject(arg0).aborted;
+            return ret;
+        },
+        __wbg_addEventListener_ea90bc131475777e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        }, arguments); },
+        __wbg_call_5575218572ead796: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_8e98ed2f3c86c4b5: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).call(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_clearTimeout_3629d6209dfcc46e: function(arg0) {
+            const ret = clearTimeout(takeObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_done_b62d4a7d2286852a: function(arg0) {
+            const ret = getObject(arg0).done;
+            return ret;
+        },
+        __wbg_entries_c261c3fa1f281256: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_get_197a3fe98f169e38: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_9a29be2cb383ed9a: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_dddb90ff5d27a080: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_unchecked_54a4374c38e08460: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
+            const ret = getObject(arg0)[getObject(arg1)];
+            return addHeapObject(ret);
+        },
+        __wbg_instanceof_AbortSignal_4bebac9f7add3026: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof AbortSignal;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_ArrayBuffer_2a7bb09fee70c2da: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ArrayBuffer;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_f080092dc70f5d58: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_isArray_145a34fd0a38d37b: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_isSafeInteger_a3389a198582f5f6: function(arg0) {
+            const ret = Number.isSafeInteger(getObject(arg0));
+            return ret;
+        },
+        __wbg_iterator_cc47ba25a2be735a: function() {
+            const ret = Symbol.iterator;
+            return addHeapObject(ret);
+        },
+        __wbg_length_589238bdcf171f0e: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_c6054974c0a6cdb9: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_new_227d7c05414eb861: function() {
+            const ret = new Error();
+            return addHeapObject(ret);
+        },
+        __wbg_new_2e117a478906f062: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_3444eb7412549f0b: function() {
+            const ret = new Map();
+            return addHeapObject(ret);
+        },
+        __wbg_new_36e147a8ced3c6e0: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_81880fb5002cb255: function(arg0) {
+            const ret = new Uint8Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_f85beb941dc6d8aa: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_1603(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_typed_00a409eb4ec4f2d9: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_1603(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_next_0c4066e251d2eff9: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).next();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_next_402fa10b59ab20c3: function(arg0) {
+            const ret = getObject(arg0).next;
+            return addHeapObject(ret);
+        },
+        __wbg_prototypesetcall_d721637c7ca66eb8: function(arg0, arg1, arg2) {
+            Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_push_f724b5db8acf89d2: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
+        __wbg_queueMicrotask_1c9b3800e321a967: function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        },
+        __wbg_queueMicrotask_311744e534a929a3: function(arg0) {
+            queueMicrotask(getObject(arg0));
+        },
+        __wbg_race_27bed3574f107c6d: function(arg0) {
+            const ret = Promise.race(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_removeEventListener_c6782a9c30557d31: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        }, arguments); },
+        __wbg_resolve_d82363d90af6928a: function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_setTimeout_56bcdccbad22fd44: function() { return handleError(function (arg0, arg1) {
+            const ret = setTimeout(getObject(arg0), arg1);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+        },
+        __wbg_set_9a1d61e17de7054c: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
+            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+        },
+        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
+            const ret = getObject(arg1).stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_ce44e66a4935da8c: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_44f6e0cb5e67cdad: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_168f178805d978fe: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_then_05edfc8a4fea5106: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_then_591b6b3a75ee817a: function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_value_49f783bb59765962: function(arg0) {
+            const ret = getObject(arg0).value;
+            return addHeapObject(ret);
+        },
+        __wbg_warn_cd671287bc02594a: function(arg0) {
+            console.warn(getObject(arg0));
+        },
+        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 135, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_1594);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 113, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_1317);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000003: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000004: function(arg0) {
+            // Cast intrinsic for `I64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000006: function(arg0) {
+            // Cast intrinsic for `U64 -> Externref`.
+            const ret = BigInt.asUintN(64, arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./cow_sdk_wasm_bg.js": import0,
+    };
+}
+
+function __wasm_bindgen_func_elem_1317(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_1317(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_1594(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_1594(retptr, arg0, arg1, addHeapObject(arg2));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        if (r1) {
+            throw takeObject(r0);
+        }
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+function __wasm_bindgen_func_elem_1603(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1603(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_export5(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export3(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_export5(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const wasmPath = `${__dirname}/../signing-bundler/cow_sdk_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
+let wasm = wasmInstance.exports;