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

package/dist/raw/orderbook-bundler/cow_sdk_wasm_bg.js

@@ -0,0 +1,1636 @@
+/**
+ * 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.
+ */
+export 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;
+
+/**
+ * Initializes the wasm crate's panic hook once.
+ */
+export function __cow_sdk_wasm_init() {
+    wasm.__cow_sdk_wasm_init();
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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>}
+ */
+export 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);
+}
+
+/**
+ * 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}
+ */
+export 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);
+    }
+}
+
+/**
+ * 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}
+ */
+export 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);
+    }
+}
+export function __wbg_Error_fdd633d4bb5dd76a(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+}
+export function __wbg_Number_c4bdf66bb78f7977(arg0) {
+    const ret = Number(getObject(arg0));
+    return ret;
+}
+export function __wbg_String_8564e559799eccda(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);
+}
+export function __wbg___wbindgen_bigint_get_as_i64_d9e915702856f831(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);
+}
+export function __wbg___wbindgen_boolean_get_edaed31a367ce1bd(arg0) {
+    const v = getObject(arg0);
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_debug_string_8a447059637473e2(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);
+}
+export function __wbg___wbindgen_in_4990f46af709e33c(arg0, arg1) {
+    const ret = getObject(arg0) in getObject(arg1);
+    return ret;
+}
+export function __wbg___wbindgen_is_bigint_90b5ccfe67c78460(arg0) {
+    const ret = typeof(getObject(arg0)) === 'bigint';
+    return ret;
+}
+export function __wbg___wbindgen_is_function_acc5528be2b923f2(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+}
+export function __wbg___wbindgen_is_null_6d937fbfb6478470(arg0) {
+    const ret = getObject(arg0) === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_object_0beba4a1980d3eea(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
+export function __wbg___wbindgen_is_string_1fca8072260dd261(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_721f8decd50c87a3(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_eq_4e8c38722cb8ff51(arg0, arg1) {
+    const ret = getObject(arg0) === getObject(arg1);
+    return ret;
+}
+export function __wbg___wbindgen_jsval_loose_eq_4b9aba9e5b3c4582(arg0, arg1) {
+    const ret = getObject(arg0) == getObject(arg1);
+    return ret;
+}
+export function __wbg___wbindgen_number_get_1cc01dd708740256(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);
+}
+export function __wbg___wbindgen_string_get_71bb4348194e31f0(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);
+}
+export function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg__wbg_cb_unref_33c39e13d73b25f6(arg0) {
+    getObject(arg0)._wbg_cb_unref();
+}
+export function __wbg_abort_413b060ce2cedffd(arg0) {
+    getObject(arg0).abort();
+}
+export function __wbg_aborted_4d4114700dc4c251(arg0) {
+    const ret = getObject(arg0).aborted;
+    return ret;
+}
+export function __wbg_addEventListener_ea90bc131475777e() { return handleError(function (arg0, arg1, arg2, arg3) {
+    getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+}, arguments); }
+export function __wbg_call_5575218572ead796() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_call_8e98ed2f3c86c4b5() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_clearTimeout_323d72e2c87b37b4(arg0) {
+    globalThis.clearTimeout(getObject(arg0));
+}
+export function __wbg_clearTimeout_3629d6209dfcc46e(arg0) {
+    const ret = clearTimeout(takeObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_done_b62d4a7d2286852a(arg0) {
+    const ret = getObject(arg0).done;
+    return ret;
+}
+export function __wbg_entries_c261c3fa1f281256(arg0) {
+    const ret = Object.entries(getObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_error_a6fa202b58aa1cd3(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);
+    }
+}
+export function __wbg_get_197a3fe98f169e38(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+}
+export function __wbg_get_9a29be2cb383ed9a() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_get_dddb90ff5d27a080() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_get_unchecked_54a4374c38e08460(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+}
+export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+}
+export function __wbg_instanceof_AbortSignal_4bebac9f7add3026(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof AbortSignal;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_ArrayBuffer_2a7bb09fee70c2da(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Map_afa18d5840c04c15(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_f080092dc70f5d58(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_145a34fd0a38d37b(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+}
+export function __wbg_isSafeInteger_a3389a198582f5f6(arg0) {
+    const ret = Number.isSafeInteger(getObject(arg0));
+    return ret;
+}
+export function __wbg_iterator_cc47ba25a2be735a() {
+    const ret = Symbol.iterator;
+    return addHeapObject(ret);
+}
+export function __wbg_length_589238bdcf171f0e(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+}
+export function __wbg_length_c6054974c0a6cdb9(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+}
+export function __wbg_new_0d0108049d844421() {
+    const ret = new globalThis.AbortController();
+    return addHeapObject(ret);
+}
+export function __wbg_new_227d7c05414eb861() {
+    const ret = new Error();
+    return addHeapObject(ret);
+}
+export function __wbg_new_2e117a478906f062() {
+    const ret = new Object();
+    return addHeapObject(ret);
+}
+export function __wbg_new_3444eb7412549f0b() {
+    const ret = new Map();
+    return addHeapObject(ret);
+}
+export function __wbg_new_36e147a8ced3c6e0() {
+    const ret = new Array();
+    return addHeapObject(ret);
+}
+export function __wbg_new_81880fb5002cb255(arg0) {
+    const ret = new Uint8Array(getObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_new_f85beb941dc6d8aa(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_4110(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return addHeapObject(ret);
+    } finally {
+        state0.a = 0;
+    }
+}
+export function __wbg_new_typed_00a409eb4ec4f2d9(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_4110(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return addHeapObject(ret);
+    } finally {
+        state0.a = 0;
+    }
+}
+export function __wbg_next_0c4066e251d2eff9() { return handleError(function (arg0) {
+    const ret = getObject(arg0).next();
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_next_402fa10b59ab20c3(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+}
+export function __wbg_now_d2e0afbad4edbe82() {
+    const ret = Date.now();
+    return ret;
+}
+export function __wbg_now_e7c6795a7f81e10f(arg0) {
+    const ret = getObject(arg0).now();
+    return ret;
+}
+export function __wbg_performance_3fcf6e32a7e1ed0a(arg0) {
+    const ret = getObject(arg0).performance;
+    return addHeapObject(ret);
+}
+export function __wbg_prototypesetcall_d721637c7ca66eb8(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+}
+export function __wbg_push_f724b5db8acf89d2(arg0, arg1) {
+    const ret = getObject(arg0).push(getObject(arg1));
+    return ret;
+}
+export function __wbg_queueMicrotask_1c9b3800e321a967(arg0) {
+    const ret = getObject(arg0).queueMicrotask;
+    return addHeapObject(ret);
+}
+export function __wbg_queueMicrotask_311744e534a929a3(arg0) {
+    queueMicrotask(getObject(arg0));
+}
+export function __wbg_race_27bed3574f107c6d(arg0) {
+    const ret = Promise.race(getObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_removeEventListener_c6782a9c30557d31() { return handleError(function (arg0, arg1, arg2, arg3) {
+    getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+}, arguments); }
+export function __wbg_resolve_d82363d90af6928a(arg0) {
+    const ret = Promise.resolve(getObject(arg0));
+    return addHeapObject(ret);
+}
+export function __wbg_setTimeout_56bcdccbad22fd44() { return handleError(function (arg0, arg1) {
+    const ret = setTimeout(getObject(arg0), arg1);
+    return addHeapObject(ret);
+}, arguments); }
+export function __wbg_setTimeout_63c2e8b855bb48ad(arg0, arg1) {
+    const ret = globalThis.setTimeout(getObject(arg0), arg1 >>> 0);
+    return addHeapObject(ret);
+}
+export function __wbg_set_4564f7dc44fcb0c9() { return handleError(function (arg0, arg1, arg2) {
+    const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+    return ret;
+}, arguments); }
+export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+}
+export function __wbg_set_9a1d61e17de7054c(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}
+export function __wbg_set_dc601f4a69da0bc2(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+}
+export function __wbg_signal_4c9d3f39f4095986(arg0) {
+    const ret = getObject(arg0).signal;
+    return addHeapObject(ret);
+}
+export function __wbg_stack_3b0d974bbf31e44f(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);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_2fee5048bcca5938() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+export function __wbg_static_accessor_GLOBAL_ce44e66a4935da8c() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+export function __wbg_static_accessor_SELF_44f6e0cb5e67cdad() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+export function __wbg_static_accessor_WINDOW_168f178805d978fe() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+}
+export function __wbg_then_05edfc8a4fea5106(arg0, arg1, arg2) {
+    const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}
+export function __wbg_then_591b6b3a75ee817a(arg0, arg1) {
+    const ret = getObject(arg0).then(getObject(arg1));
+    return addHeapObject(ret);
+}
+export function __wbg_value_49f783bb59765962(arg0) {
+    const ret = getObject(arg0).value;
+    return addHeapObject(ret);
+}
+export function __wbg_warn_cd671287bc02594a(arg0) {
+    console.warn(getObject(arg0));
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 366, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4101);
+    return addHeapObject(ret);
+}
+export function __wbindgen_cast_0000000000000002(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 358, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4021);
+    return addHeapObject(ret);
+}
+export function __wbindgen_cast_0000000000000003(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+}
+export function __wbindgen_cast_0000000000000004(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+}
+export function __wbindgen_cast_0000000000000005(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+}
+export function __wbindgen_cast_0000000000000006(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+}
+export function __wbindgen_object_clone_ref(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+}
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+}
+function __wasm_bindgen_func_elem_4021(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_4021(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_4101(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_4101(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_4110(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_4110(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const OrderBookClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_orderbookclient_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();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = 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;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}