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

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

@@ -0,0 +1,2330 @@
+/* @ts-self-types="./cow_sdk_wasm.d.ts" */
+
+/**
+ * IPFS app-data client backed by an explicitly configured HTTP transport.
+ *
+ * Construct this client when JavaScript needs to fetch app-data documents by
+ * CID or app-data hash while preserving SDK retry, timeout, and cancellation
+ * behavior.
+ */
+class IpfsClient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IpfsClientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ipfsclient_free(ptr, 0);
+    }
+    /**
+     * Fetches and parses an app-data document by CID.
+     *
+     * The CID is resolved through the configured gateway and transport. The
+     * returned document is normalized into the SDK app-data DTO shape.
+     *
+     * @param cid Canonical IPFS CID for the app-data document.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the app-data document.
+     * @throws CowError for invalid CID, transport failure, timeout, or parse failure.
+     * @param {string} cid
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<AppDataDocDto>}
+     */
+    fetchAppDataFromCid(cid, options) {
+        const ptr0 = passStringToWasm0(cid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ipfsclient_fetchAppDataFromCid(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches and parses an app-data document by app-data hash.
+     *
+     * The helper converts the app-data hash to the canonical CID before
+     * fetching through the configured gateway.
+     *
+     * @param appDataHex App-data hash as a `0x`-prefixed hex string.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the app-data document.
+     * @throws CowError for invalid hash, transport failure, timeout, or parse failure.
+     * @param {string} appDataHex
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<AppDataDocDto>}
+     */
+    fetchAppDataFromHex(appDataHex, options) {
+        const ptr0 = passStringToWasm0(appDataHex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ipfsclient_fetchAppDataFromHex(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Creates an IPFS app-data client from a single config object.
+     *
+     * The config must include `transport`. Optional `ipfsUri` overrides the
+     * default gateway base, while timeout, signal, and policy fields become
+     * defaults for method calls.
+     *
+     * @param config IPFS client configuration.
+     * @throws CowError when transport, policy, timeout, or gateway config is invalid.
+     * @param {IpfsClientConfig} config
+     */
+    constructor(config) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ipfsclient_new(retptr, addHeapObject(config));
+            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);
+            }
+            this.__wbg_ptr = r0;
+            IpfsClientFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) IpfsClient.prototype[Symbol.dispose] = IpfsClient.prototype.free;
+exports.IpfsClient = IpfsClient;
+
+/**
+ * Orderbook client backed by an explicitly configured HTTP transport.
+ *
+ * Construct this client when JavaScript needs direct access to quote,
+ * submission, lookup, trade, native-price, app-data, and cancellation orderbook
+ * endpoints. The client owns one callback registration and releases raw wasm
+ * resources through the facade `dispose()` method.
+ */
+class OrderBookClient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OrderBookClientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_orderbookclient_free(ptr, 0);
+    }
+    /**
+     * Submits signed off-chain order cancellations.
+     *
+     * Build the signed cancellation payload with one of the cancellation
+     * signing helpers, then submit it through the same orderbook runtime
+     * configuration used for order operations.
+     *
+     * @param signed Signed cancellation payload.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing `{ cancelled: true }` on success.
+     * @throws CowError for invalid UID, signature, transport failure, or timeout.
+     * @param {SignedCancellationsInput} signed
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<{ cancelled: true }>}
+     */
+    cancelOrders(signed, options) {
+        const ret = wasm.orderbookclient_cancelOrders(this.__wbg_ptr, addHeapObject(signed), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches the full app-data document registered for an app-data hash.
+     *
+     * Use this to retrieve the canonical app-data payload the orderbook holds
+     * for a given hash, for example to display or re-verify a document
+     * referenced by an order.
+     *
+     * @param appDataHash App-data hash as a `0x`-prefixed 32-byte hex string.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the app-data document.
+     * @throws CowError for an invalid hash, transport failure, or timeout.
+     * @param {string} appDataHash
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<AppDataObjectDto>}
+     */
+    getAppData(appDataHash, options) {
+        const ptr0 = passStringToWasm0(appDataHash, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getAppData(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches a token's native price from the orderbook API.
+     *
+     * The token must be an EVM address. The returned value follows the
+     * orderbook native-price response shape.
+     *
+     * @param token Token address to price.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing native price data.
+     * @throws CowError for invalid token address, transport failure, or timeout.
+     * @param {string} token
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<NativePriceResponseDto>}
+     */
+    getNativePrice(token, options) {
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getNativePrice(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches one order by its canonical order UID.
+     *
+     * The UID must be the full 56-byte CoW order UID encoded as a `0x`-prefixed
+     * string. The response is returned in the orderbook wire DTO shape.
+     *
+     * @param orderUid Full order UID to look up.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the order response.
+     * @throws CowError for invalid UID, not-found responses, transport failure, or timeout.
+     * @param {string} orderUid
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<OrderDto>}
+     */
+    getOrder(orderUid, options) {
+        const ptr0 = passStringToWasm0(orderUid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getOrder(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches the live competition status for one order.
+     *
+     * Returns the order's status in the current or most recent solver
+     * competition, including any per-solver executed amounts the service
+     * reports. The UID must be the full 56-byte CoW order UID.
+     *
+     * @param orderUid Full order UID to look up.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the competition status.
+     * @throws CowError for invalid UID, not-found responses, transport failure, or timeout.
+     * @param {string} orderUid
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<CompetitionOrderStatusDto>}
+     */
+    getOrderCompetitionStatus(orderUid, options) {
+        const ptr0 = passStringToWasm0(orderUid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getOrderCompetitionStatus(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Builds the public order-details URL for a UID without any network call.
+     *
+     * @param orderUid Full order UID to link to.
+     * @returns A versioned envelope containing the order-details URL.
+     * @throws CowError for an invalid UID or an unresolved base URL.
+     * @param {string} orderUid
+     * @returns {WasmEnvelope<string>}
+     */
+    getOrderLink(orderUid) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(orderUid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.orderbookclient_getOrderLink(retptr, this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * Fetches an order by UID, falling back across environments on a 404.
+     *
+     * @param orderUid Full order UID to look up.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the order response.
+     * @throws CowError for invalid UID, not-found responses, transport failure, or timeout.
+     * @param {string} orderUid
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<OrderDto>}
+     */
+    getOrderMultiEnv(orderUid, options) {
+        const ptr0 = passStringToWasm0(orderUid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getOrderMultiEnv(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches orders owned by an address with optional pagination.
+     *
+     * The owner address is validated before the request is dispatched. The
+     * response preserves the typed orderbook order shape.
+     *
+     * @param owner Owner address to query.
+     * @param pagination Optional offset and limit.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing matching orders.
+     * @throws CowError for invalid owner, transport failure, timeout, or cancellation.
+     * @param {string} owner
+     * @param {PaginationOptions | null} [pagination]
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<OrderDto[]>}
+     */
+    getOrders(owner, pagination, options) {
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getOrders(this.__wbg_ptr, ptr0, len0, isLikeNone(pagination) ? 0 : addHeapObject(pagination), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches a price quote from the orderbook API.
+     *
+     * The request is converted to the typed orderbook quote request and sent
+     * through the configured transport. Per-call options can override the
+     * constructor timeout or attach an `AbortSignal`.
+     *
+     * @param request Quote request DTO.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the quote response.
+     * @throws CowError for invalid input, transport failure, timeout, or cancellation.
+     * @param {OrderQuoteRequestInput} request
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<OrderQuoteResponseDto>}
+     */
+    getQuote(request, options) {
+        const ret = wasm.orderbookclient_getQuote(this.__wbg_ptr, addHeapObject(request), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches the total accumulated surplus for an account.
+     *
+     * Returns the lifetime surplus the protocol has captured for the owner
+     * across its settled orders, in the upstream decimal-string wire shape.
+     *
+     * @param owner Owner address to query.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the total-surplus response.
+     * @throws CowError for invalid owner, transport failure, or timeout.
+     * @param {string} owner
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<TotalSurplusDto>}
+     */
+    getTotalSurplus(owner, options) {
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getTotalSurplus(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches trades for exactly one owner address or order UID.
+     *
+     * The query must set one of `owner` or `orderUid`, not both. Optional
+     * pagination fields are forwarded to the orderbook request.
+     *
+     * @param query Trade query DTO.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing matching trades.
+     * @throws CowError when the query is ambiguous or transport fails.
+     * @param {TradesQueryInput} query
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<TradeDto[]>}
+     */
+    getTrades(query, options) {
+        const ret = wasm.orderbookclient_getTrades(this.__wbg_ptr, addHeapObject(query), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches the orders contained in a settlement transaction.
+     *
+     * @param txHash Settlement transaction hash.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the settled orders.
+     * @throws CowError for an invalid hash, transport failure, timeout, or cancellation.
+     * @param {string} txHash
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<OrderDto[]>}
+     */
+    getTxOrders(txHash, options) {
+        const ptr0 = passStringToWasm0(txHash, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_getTxOrders(this.__wbg_ptr, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches the orderbook service version string.
+     *
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the service version string.
+     * @throws CowError for transport failure, timeout, or cancellation.
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<string>}
+     */
+    getVersion(options) {
+        const ret = wasm.orderbookclient_getVersion(this.__wbg_ptr, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Creates an orderbook client from a single config object.
+     *
+     * The config must include `chainId` and `transport`. The optional
+     * `timeoutMs`, `signal`, and `transportPolicy` fields become defaults for
+     * calls made through this client unless a method call overrides them.
+     *
+     * @param config Orderbook client configuration.
+     * @throws CowError when the chain, environment, transport, or policy is invalid.
+     * @param {OrderBookClientConfig} config
+     */
+    constructor(config) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.orderbookclient_new(retptr, addHeapObject(config));
+            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);
+            }
+            this.__wbg_ptr = r0;
+            OrderBookClientFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Submits a signed order to the orderbook.
+     *
+     * The signed DTO normally comes from a signing helper in the same package.
+     * The SDK reconstructs the typed order creation payload and returns the
+     * order UID assigned by the orderbook service.
+     *
+     * @param signed Signed order DTO including typed data, signature, owner, and scheme.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the submitted order UID.
+     * @throws CowError for invalid signatures, transport failure, timeout, or rejection.
+     * @param {SignedOrderDto} signed
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<string>}
+     */
+    sendOrder(signed, options) {
+        const ret = wasm.orderbookclient_sendOrder(this.__wbg_ptr, addHeapObject(signed), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Submits a raw order-creation payload to the orderbook.
+     *
+     * Use this method when the host already has a complete orderbook
+     * `OrderCreation` shape and does not need the facade to reconstruct it
+     * from a signed-order DTO.
+     *
+     * @param input Raw order-creation DTO.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the submitted order UID.
+     * @throws CowError for malformed input, transport failure, timeout, or rejection.
+     * @param {OrderCreationInput} input
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<string>}
+     */
+    sendOrderCreation(input, options) {
+        const ret = wasm.orderbookclient_sendOrderCreation(this.__wbg_ptr, addHeapObject(input), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Uploads the full app-data JSON for a content-addressed app-data hash.
+     *
+     * The SDK enforces the content-addressed-write invariant: the keccak-256
+     * digest of `fullAppData` must equal `appDataHash`, or the call rejects
+     * before any network request. Serialize `fullAppData` with the canonical
+     * app-data writer so the digest matches.
+     *
+     * @param appDataHash App-data hash as a `0x`-prefixed 32-byte hex string.
+     * @param fullAppData Canonically serialized app-data JSON payload.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing `{ uploaded: true }` on success.
+     * @throws CowError for a hash mismatch, invalid hash, transport failure, or timeout.
+     * @param {string} appDataHash
+     * @param {string} fullAppData
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<{ uploaded: true }>}
+     */
+    uploadAppData(appDataHash, fullAppData, options) {
+        const ptr0 = passStringToWasm0(appDataHash, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(fullAppData, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.orderbookclient_uploadAppData(this.__wbg_ptr, ptr0, len0, ptr1, len1, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) OrderBookClient.prototype[Symbol.dispose] = OrderBookClient.prototype.free;
+exports.OrderBookClient = OrderBookClient;
+
+/**
+ * Read-only subgraph client backed by an explicitly configured transport.
+ *
+ * Construct this client when JavaScript needs protocol totals, recent volume,
+ * or custom GraphQL query execution through the same transport and policy
+ * model as the orderbook clients.
+ */
+class SubgraphClient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SubgraphClientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_subgraphclient_free(ptr, 0);
+    }
+    /**
+     * Fetches recent daily volume rows.
+     *
+     * The `days` value controls how many recent daily buckets the subgraph
+     * query requests.
+     *
+     * @param days Number of daily buckets to fetch.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing daily volume rows.
+     * @throws CowError for invalid query shape, transport failure, or timeout.
+     * @param {number} days
+     * @param {SdkClientOptions | null} [options]
+     * @returns {Promise<any>}
+     */
+    getLastDaysVolume(days, options) {
+        const ret = wasm.subgraphclient_getLastDaysVolume(this.__wbg_ptr, days, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches recent hourly volume rows.
+     *
+     * The `hours` value controls how many recent hourly buckets the subgraph
+     * query requests.
+     *
+     * @param hours Number of hourly buckets to fetch.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing hourly volume rows.
+     * @throws CowError for invalid query shape, transport failure, or timeout.
+     * @param {number} hours
+     * @param {SdkClientOptions | null} [options]
+     * @returns {Promise<any>}
+     */
+    getLastHoursVolume(hours, options) {
+        const ret = wasm.subgraphclient_getLastHoursVolume(this.__wbg_ptr, hours, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches aggregate protocol totals from the subgraph.
+     *
+     * The request uses the client's configured chain, API key, transport, and
+     * transport policy.
+     *
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing aggregate totals.
+     * @throws CowError for transport, cancellation, timeout, or subgraph errors.
+     * @param {SdkClientOptions | null} [options]
+     * @returns {Promise<any>}
+     */
+    getTotals(options) {
+        const ret = wasm.subgraphclient_getTotals(this.__wbg_ptr, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Creates a subgraph client from a single config object.
+     *
+     * The config must include `chainId`, `apiKey`, and `transport`. Optional
+     * timeout, signal, and policy fields become client defaults for later
+     * method calls.
+     *
+     * @param config Subgraph client configuration.
+     * @throws CowError when the chain, API key, transport, or policy is invalid.
+     * @param {SubgraphClientConfig} config
+     */
+    constructor(config) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.subgraphclient_new(retptr, addHeapObject(config));
+            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);
+            }
+            this.__wbg_ptr = r0;
+            SubgraphClientFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Runs a caller-provided GraphQL query against the configured subgraph.
+     *
+     * Use this method when the built-in totals or volume helpers are too
+     * narrow. Variables and operation name are forwarded when present.
+     *
+     * @param request GraphQL query, variables, and optional operation name.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the JSON GraphQL response.
+     * @throws CowError for transport, timeout, cancellation, or GraphQL errors.
+     * @param {SubgraphQueryInput} request
+     * @param {SdkClientOptions | null} [options]
+     * @returns {Promise<any>}
+     */
+    runQuery(request, options) {
+        const ret = wasm.subgraphclient_runQuery(this.__wbg_ptr, addHeapObject(request), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) SubgraphClient.prototype[Symbol.dispose] = SubgraphClient.prototype.free;
+exports.SubgraphClient = SubgraphClient;
+
+/**
+ * High-level trading client backed by an explicitly configured orderbook.
+ *
+ * Construct this client when JavaScript needs quote, sign, post, allowance,
+ * and native-sell helper workflows rather than direct orderbook calls. The
+ * client keeps app-code, chain, environment, transport, and policy defaults.
+ */
+class TradingClient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TradingClientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_tradingclient_free(ptr, 0);
+    }
+    /**
+     * Builds the ERC-20 approval transaction for the CoW Protocol vault relayer.
+     *
+     * The SDK encodes the unsigned `approve` transaction; the JavaScript host
+     * owns submission through its own wallet. This completes the
+     * read-allowance-then-approve path alongside `getCowProtocolAllowance`.
+     *
+     * @param params Approval parameters DTO (token, amount, optional vault-relayer override).
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the unsigned approval transaction request.
+     * @throws CowError when the token, amount, or vault-relayer override is invalid.
+     * @param {ApprovalParametersInput} params
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<TransactionRequestDto>}
+     */
+    buildApprovalTx(params, options) {
+        const ret = wasm.tradingclient_buildApprovalTx(this.__wbg_ptr, addHeapObject(params), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Builds the transaction for a native-currency sell order.
+     *
+     * The helper validates that the order sells the native-token sentinel,
+     * resolves the EthFlow deployment, and returns a transaction request for
+     * the host wallet to submit.
+     *
+     * @param order Unsigned native-sell order DTO.
+     * @param quoteId Quote identifier returned by the orderbook.
+     * @param from Transaction sender address.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing order UID and transaction request.
+     * @throws CowError when the order, chain, deployment, or sender is invalid.
+     * @param {OrderInput} order
+     * @param {number} quoteId
+     * @param {string} from
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<BuiltSellNativeCurrencyTxDto>}
+     */
+    buildSellNativeCurrencyTx(order, quoteId, from, options) {
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tradingclient_buildSellNativeCurrencyTx(this.__wbg_ptr, addHeapObject(order), quoteId, ptr0, len0, isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Reads CoW Protocol allowance through a read-only contract callback.
+     *
+     * The SDK builds the contract call while the JavaScript host performs the
+     * actual chain read. Use this when a TypeScript runtime owns the RPC
+     * provider.
+     *
+     * @param params Allowance parameters DTO.
+     * @param readContractCallback Callback that executes the read-only call.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing the allowance amount string.
+     * @throws CowError for invalid parameters, callback failure, timeout, or cancellation.
+     * @param {AllowanceParametersInput} params
+     * @param {ContractReadCallback} readContractCallback
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<string>}
+     */
+    getCowProtocolAllowance(params, readContractCallback, options) {
+        const ret = wasm.tradingclient_getCowProtocolAllowance(this.__wbg_ptr, addHeapObject(params), addHeapObject(readContractCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fetches a quote without signing or submitting an order.
+     *
+     * Use this method when a host wants to preview the quote response before
+     * asking a wallet to sign or before constructing a post request.
+     *
+     * @param params Swap parameters DTO.
+     * @param options Optional per-call cancellation and timeout settings.
+     * @returns A versioned envelope containing quote results.
+     * @throws CowError for invalid parameters, transport failure, timeout, or cancellation.
+     * @param {SwapParametersInput} params
+     * @param {SdkClientOptions | null} [options]
+     * @returns {WasmEnvelope<QuoteResultsDto>}
+     */
+    getQuote(params, options) {
+        const ret = wasm.tradingclient_getQuote(this.__wbg_ptr, addHeapObject(params), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Creates a trading client from a single config object.
+     *
+     * The config must include `chainId`, `appCode`, and `transport`. Optional
+     * environment, API key, timeout, signal, and transport policy fields become
+     * defaults for all trading methods.
+     *
+     * @param config Trading client configuration.
+     * @throws CowError when chain, app-code, environment, transport, or policy validation fails.
+     * @param {TradingClientConfig} config
+     */
+    constructor(config) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.tradingclient_new(retptr, addHeapObject(config));
+            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);
+            }
+            this.__wbg_ptr = r0;
+            TradingClientFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Signs and posts a limit order through a typed-data callback.
+     *
+     * This helper follows the native limit-order trading path and lets the SDK
+     * build, sign, and submit the order using the configured orderbook.
+     *
+     * @param params Limit-order parameters DTO.
+     * @param owner Owner address to bind to the order when absent from params.
+     * @param signerCallback Callback that signs the typed-data envelope.
+     * @param options Optional cancellation, timeout, and wallet timeout settings.
+     * @returns A versioned envelope containing order posting output.
+     * @throws CowError for invalid input, wallet failure, timeout, or rejection.
+     * @param {LimitTradeParametersInput} params
+     * @param {string} owner
+     * @param {TypedDataSignerCallback} signerCallback
+     * @param {SigningOptions | null} [options]
+     * @returns {WasmEnvelope<OrderPostingResultDto>}
+     */
+    postLimitOrder(params, owner, signerCallback, options) {
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tradingclient_postLimitOrder(this.__wbg_ptr, addHeapObject(params), ptr0, len0, addHeapObject(signerCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Quotes, signs, and posts a swap order through a typed-data callback.
+     *
+     * The SDK fetches a quote, builds the order to sign, invokes the callback
+     * with the EIP-712 envelope, posts the signed order, and returns posting
+     * output from the trading workflow.
+     *
+     * @param params Swap parameters DTO.
+     * @param owner Owner address to bind to the order.
+     * @param signerCallback Callback that signs the typed-data envelope.
+     * @param options Optional cancellation, timeout, and wallet timeout settings.
+     * @returns A versioned envelope containing order posting output.
+     * @throws CowError for invalid input, quote failure, wallet failure, timeout, or rejection.
+     * @param {SwapParametersInput} params
+     * @param {string} owner
+     * @param {TypedDataSignerCallback} signerCallback
+     * @param {SigningOptions | null} [options]
+     * @returns {WasmEnvelope<OrderPostingResultDto>}
+     */
+    postSwapOrder(params, owner, signerCallback, options) {
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tradingclient_postSwapOrder(this.__wbg_ptr, addHeapObject(params), ptr0, len0, addHeapObject(signerCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Signs and posts a previously quoted swap order.
+     *
+     * Use this method when a host has already called `getQuote` and wants to
+     * reuse that quote result for posting without requesting a new quote.
+     *
+     * @param quoteResults Quote result DTO returned by `getQuote`.
+     * @param owner Owner address to bind to the order.
+     * @param signerCallback Callback that signs the typed-data envelope.
+     * @param options Optional cancellation, timeout, and wallet timeout settings.
+     * @returns A versioned envelope containing order posting output.
+     * @throws CowError for invalid quote data, wallet failure, timeout, or rejection.
+     * @param {QuoteResultsDto} quoteResults
+     * @param {string} owner
+     * @param {TypedDataSignerCallback} signerCallback
+     * @param {SigningOptions | null} [options]
+     * @returns {WasmEnvelope<OrderPostingResultDto>}
+     */
+    postSwapOrderFromQuote(quoteResults, owner, signerCallback, options) {
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tradingclient_postSwapOrderFromQuote(this.__wbg_ptr, addHeapObject(quoteResults), ptr0, len0, addHeapObject(signerCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Quotes and posts a swap order with a custom EIP-1271 signature callback.
+     *
+     * Use this method when a smart-account runtime owns final contract
+     * signature production. The SDK still quotes the swap, builds typed data,
+     * posts the signed order, and returns posting output.
+     *
+     * @param params Swap parameters DTO.
+     * @param owner Smart-account owner address.
+     * @param customCallback Callback that returns the final EIP-1271 signature.
+     * @param options Optional cancellation, timeout, and wallet timeout settings.
+     * @returns A versioned envelope containing order posting output.
+     * @throws CowError for invalid input, quote failure, callback failure, timeout, or rejection.
+     * @param {SwapParametersInput} params
+     * @param {string} owner
+     * @param {CustomEip1271Callback} customCallback
+     * @param {SigningOptions | null} [options]
+     * @returns {WasmEnvelope<OrderPostingResultDto>}
+     */
+    postSwapOrderWithEip1271(params, owner, customCallback, options) {
+        const ptr0 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.tradingclient_postSwapOrderWithEip1271(this.__wbg_ptr, addHeapObject(params), ptr0, len0, addHeapObject(customCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) TradingClient.prototype[Symbol.dispose] = TradingClient.prototype.free;
+exports.TradingClient = TradingClient;
+
+/**
+ * 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;
+
+/**
+ * Builds a normalized app-data document without deriving storage metadata.
+ *
+ * This helper is useful when a host wants to inspect or modify the canonical
+ * document shape before separately deriving app-data information.
+ *
+ * @param doc App-data document input accepted by the SDK schema.
+ * @returns A versioned envelope containing the normalized document.
+ * @throws CowError when the input cannot be normalized.
+ * @param {AppDataDocInput} doc
+ * @returns {WasmEnvelope<AppDataDocDto>}
+ */
+function appDataDoc(doc) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.appDataDoc(retptr, addHeapObject(doc));
+        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.appDataDoc = appDataDoc;
+
+/**
+ * Converts a `0x`-prefixed app-data hash into the canonical IPFS CID.
+ *
+ * The conversion is pure and uses the same app-data multicodec and multihash
+ * rules as the Rust app-data crate.
+ *
+ * @param appDataHex App-data hash as a `0x`-prefixed hex string.
+ * @returns A versioned envelope containing the CID string.
+ * @throws CowError when the hash is malformed.
+ * @param {string} appDataHex
+ * @returns {WasmEnvelope<string>}
+ */
+function appDataHexToCid(appDataHex) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(appDataHex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.appDataHexToCid(retptr, 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.appDataHexToCid = appDataHexToCid;
+
+/**
+ * Builds app-data content and returns its deterministic hash and CID.
+ *
+ * Use this when a JavaScript host wants the SDK to construct the canonical
+ * document and expose the values needed for order submission and storage.
+ *
+ * @param doc App-data document input accepted by the SDK schema.
+ * @returns A versioned envelope containing document, hash, CID, and hex data.
+ * @throws CowError when the document cannot be normalized or hashed.
+ * @param {AppDataDocInput} doc
+ * @returns {WasmEnvelope<AppDataInfoDto>}
+ */
+function appDataInfo(doc) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.appDataInfo(retptr, addHeapObject(doc));
+        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.appDataInfo = appDataInfo;
+
+/**
+ * Builds a settlement cancellation transaction for an order UID.
+ *
+ * The returned transaction request targets the Settlement contract and encodes
+ * `invalidateOrder(bytes)`. The host wallet remains responsible for submitting
+ * and observing the transaction.
+ *
+ * @param params Order UID, chain, environment, and optional deployment override.
+ * @returns A versioned envelope containing the transaction request DTO.
+ * @throws CowError when the chain, deployment, or order UID is invalid.
+ * @param {OrderTraderParametersInput} params
+ * @returns {WasmEnvelope<TransactionRequestDto>}
+ */
+function buildCancelOrderTx(params) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.buildCancelOrderTx(retptr, addHeapObject(params));
+        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.buildCancelOrderTx = buildCancelOrderTx;
+
+/**
+ * Builds a settlement pre-sign transaction for an order UID.
+ *
+ * The returned transaction request targets the Settlement contract and encodes
+ * `setPreSignature(bytes,bool)` with the order UID and `true` flag. The host
+ * wallet remains responsible for transaction submission.
+ *
+ * @param params Order UID, chain, environment, and optional deployment override.
+ * @returns A versioned envelope containing the transaction request DTO.
+ * @throws CowError when the chain, deployment, or order UID is invalid.
+ * @param {OrderTraderParametersInput} params
+ * @returns {WasmEnvelope<TransactionRequestDto>}
+ */
+function buildPresignTx(params) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.buildPresignTx(retptr, addHeapObject(params));
+        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.buildPresignTx = buildPresignTx;
+
+/**
+ * Converts a canonical IPFS CID into a `0x`-prefixed app-data hash.
+ *
+ * Use this helper when an order or metadata path starts from a CID but the
+ * orderbook request needs the app-data hash form.
+ *
+ * @param cid Canonical CID string for an app-data document.
+ * @returns A versioned envelope containing the `0x`-prefixed hash.
+ * @throws CowError when the CID does not match the supported app-data shape.
+ * @param {string} cid
+ * @returns {WasmEnvelope<string>}
+ */
+function cidToAppDataHex(cid) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(cid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.cidToAppDataHex(retptr, 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.cidToAppDataHex = cidToAppDataHex;
+
+/**
+ * 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 a cancellation digest through an explicit `eth_sign` callback.
+ *
+ * The SDK computes the canonical cancellation digest for the provided UIDs and
+ * passes it to the digest signer callback as a `0x`-prefixed string.
+ *
+ * @param orderUids One or more full order UIDs to cancel.
+ * @param chainId EVM chain id used for the cancellation digest.
+ * @param digestSigner Callback that signs the digest string.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing signed cancellations.
+ * @throws CowError for empty input, invalid UID, callback failure, or timeout.
+ * @param {string[]} orderUids
+ * @param {number} chainId
+ * @param {DigestSignerCallback} digestSigner
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedCancellationsInput>}
+ */
+function signCancellationEthSignDigest(orderUids, chainId, digestSigner, options) {
+    const ptr0 = passArrayJsValueToWasm0(orderUids, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signCancellationEthSignDigest(ptr0, len0, chainId, addHeapObject(digestSigner), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signCancellationEthSignDigest = signCancellationEthSignDigest;
+
+/**
+ * Signs cancellation typed data through an EIP-1193 callback.
+ *
+ * The callback receives an `eth_signTypedData_v4` request object. Use this
+ * helper when an injected wallet or wallet client owns typed-data signing.
+ *
+ * @param orderUids One or more full order UIDs to cancel.
+ * @param chainId EVM chain id used for the cancellation domain.
+ * @param owner Owner address included in the EIP-1193 request parameters.
+ * @param requestCallback Callback that executes the EIP-1193 request.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing signed cancellations.
+ * @throws CowError for invalid input, wallet failure, timeout, or cancellation.
+ * @param {string[]} orderUids
+ * @param {number} chainId
+ * @param {string} owner
+ * @param {Eip1193RequestCallback} requestCallback
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedCancellationsInput>}
+ */
+function signCancellationWithEip1193(orderUids, chainId, owner, requestCallback, options) {
+    const ptr0 = passArrayJsValueToWasm0(orderUids, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(owner, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.signCancellationWithEip1193(ptr0, len0, chainId, ptr1, len1, addHeapObject(requestCallback), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signCancellationWithEip1193 = signCancellationWithEip1193;
+
+/**
+ * Signs cancellation typed data through a typed-data callback.
+ *
+ * The SDK builds the batch cancellation EIP-712 payload for the provided order
+ * UIDs and asks the callback to sign it. The response can be submitted through
+ * `OrderBookClient.cancelOrders`.
+ *
+ * @param orderUids One or more full order UIDs to cancel.
+ * @param chainId EVM chain id used for the cancellation domain.
+ * @param typedDataSigner Callback that signs the typed-data envelope.
+ * @param options Optional cancellation, timeout, and wallet timeout settings.
+ * @returns A versioned envelope containing signed cancellations.
+ * @throws CowError for empty input, invalid UID, callback failure, or timeout.
+ * @param {string[]} orderUids
+ * @param {number} chainId
+ * @param {TypedDataSignerCallback} typedDataSigner
+ * @param {SigningOptions | null} [options]
+ * @returns {WasmEnvelope<SignedCancellationsInput>}
+ */
+function signCancellationWithTypedDataSigner(orderUids, chainId, typedDataSigner, options) {
+    const ptr0 = passArrayJsValueToWasm0(orderUids, wasm.__wbindgen_export);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.signCancellationWithTypedDataSigner(ptr0, len0, chainId, addHeapObject(typedDataSigner), isLikeNone(options) ? 0 : addHeapObject(options));
+    return takeObject(ret);
+}
+exports.signCancellationWithTypedDataSigner = signCancellationWithTypedDataSigner;
+
+/**
+ * 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;
+
+/**
+ * Validates an app-data document against the typed metadata contract.
+ *
+ * Validation is local and deterministic. The result reports whether the
+ * document conforms and includes validation details without uploading data.
+ *
+ * @param doc App-data document input to validate.
+ * @returns A versioned envelope containing the validation result.
+ * @throws CowError when the input cannot be converted into a document.
+ * @param {AppDataDocInput} doc
+ * @returns {WasmEnvelope<ValidationResultDto>}
+ */
+function validateAppDataDoc(doc) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.validateAppDataDoc(retptr, addHeapObject(doc));
+        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.validateAppDataDoc = validateAppDataDoc;
+
+/**
+ * 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_bigint_get_as_i64_d9e915702856f831: function(arg0, arg1) {
+            const v = getObject(arg1);
+            const ret = typeof(v) === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), 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_bigint_90b5ccfe67c78460: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'bigint';
+            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_eq_4e8c38722cb8ff51: function(arg0, arg1) {
+            const ret = getObject(arg0) === getObject(arg1);
+            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_abort_413b060ce2cedffd: function(arg0) {
+            getObject(arg0).abort();
+        },
+        __wbg_abort_6e6ea7d259504afc: function(arg0) {
+            getObject(arg0).abort();
+        },
+        __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_323d72e2c87b37b4: function(arg0) {
+            globalThis.clearTimeout(getObject(arg0));
+        },
+        __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_from_50138b2ca136f50c: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __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_headers_d9123c649c85d441: function(arg0) {
+            const ret = getObject(arg0).headers;
+            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_Map_afa18d5840c04c15: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Object_60be3eaa7a661141: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Object;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Response_79948c98d1d2ba75: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Response;
+            } 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_0d0108049d844421: function() {
+            const ret = new globalThis.AbortController();
+            return addHeapObject(ret);
+        },
+        __wbg_new_10e2f2ad134f940f: function() { return handleError(function () {
+            const ret = new Headers();
+            return addHeapObject(ret);
+        }, arguments); },
+        __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_51233fa2a760b272: function() { return handleError(function () {
+            const ret = new AbortController();
+            return addHeapObject(ret);
+        }, arguments); },
+        __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_6489(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_6489(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_with_str_and_init_5b299538bdeeec64: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __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_now_d2e0afbad4edbe82: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_now_e7c6795a7f81e10f: function(arg0) {
+            const ret = getObject(arg0).now();
+            return ret;
+        },
+        __wbg_performance_3fcf6e32a7e1ed0a: function(arg0) {
+            const ret = getObject(arg0).performance;
+            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_setTimeout_63c2e8b855bb48ad: function(arg0, arg1) {
+            const ret = globalThis.setTimeout(getObject(arg0), arg1 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_set_1c87dcfd4a93c514: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_set_4564f7dc44fcb0c9: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return 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_body_97c25d1c0051cb04: function(arg0, arg1) {
+            getObject(arg0).body = getObject(arg1);
+        },
+        __wbg_set_dc601f4a69da0bc2: function(arg0, arg1, arg2) {
+            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+        },
+        __wbg_set_headers_6751c09a8e579ff7: function(arg0, arg1) {
+            getObject(arg0).headers = getObject(arg1);
+        },
+        __wbg_set_method_1120482abe0934aa: function(arg0, arg1, arg2) {
+            getObject(arg0).method = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_signal_4a69430cb12800f3: function(arg0, arg1) {
+            getObject(arg0).signal = getObject(arg1);
+        },
+        __wbg_signal_4c9d3f39f4095986: function(arg0) {
+            const ret = getObject(arg0).signal;
+            return addHeapObject(ret);
+        },
+        __wbg_signal_4d9d567be73ea52c: function(arg0) {
+            const ret = getObject(arg0).signal;
+            return addHeapObject(ret);
+        },
+        __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_status_0053aa6239760447: function(arg0) {
+            const ret = getObject(arg0).status;
+            return ret;
+        },
+        __wbg_text_68ea00f7126f2706: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).text();
+            return addHeapObject(ret);
+        }, arguments); },
+        __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: 635, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6480);
+            return addHeapObject(ret);
+        },
+        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 627, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6400);
+            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_6400(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_6400(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_6480(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_6480(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_6489(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_6489(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const IpfsClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ipfsclient_free(ptr, 1));
+const OrderBookClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orderbookclient_free(ptr, 1));
+const SubgraphClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_subgraphclient_free(ptr, 1));
+const TradingClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_tradingclient_free(ptr, 1));
+
+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 passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+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}/../default-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;