@xian-tech/client 0.1.0

package/README.md

@@ -0,0 +1,16 @@
+# @xian-tech/client
+
+This package owns the typed Xian client surface for JS / TS consumers.
+
+It includes:
+
+- HTTP and ABCI query helpers
+- transaction payload building, signing, and broadcast helpers
+- Ed25519 signing primitives for tests and local development
+- websocket subscriptions for dashboard state and event streams
+
+It does not own:
+
+- browser wallet discovery
+- wallet-provider event contracts
+- framework-specific bindings

package/dist/client.d.ts

@@ -0,0 +1,75 @@
+import { WatchApi } from "./watch";
+import type { BroadcastMode, BroadcastTxOptions, BuildTxRequest, ContractSendOptions, EstimateStampsOptions, EstimateStampsResult, SimulateRequest, TokenApproveOptions, TokenTransferOptions, TransactionReceipt, TransactionSubmission, WaitForTxOptions, XianClientOptions, XianSignedTransaction, XianSigner, XianUnsignedTransaction } from "./types";
+export declare class XianClient {
+    readonly rpcUrl: string;
+    readonly dashboardUrl?: string;
+    readonly watch: WatchApi;
+    private readonly fetchFn;
+    private chainIdCache?;
+    constructor(options: XianClientOptions);
+    private requestJson;
+    private abciQuery;
+    private decodeAbciValue;
+    private normalizeTxLookup;
+    private decodeTxRecord;
+    getGenesis(): Promise<Record<string, unknown>>;
+    getChainId(): Promise<string>;
+    getStatus(): Promise<Record<string, unknown>>;
+    getBlock(height: number | string): Promise<Record<string, unknown>>;
+    getTx(txHash: string): Promise<TransactionReceipt>;
+    getNonce(address: string): Promise<number | bigint>;
+    getState(contract: string, variable: string, keys?: string[]): Promise<unknown>;
+    getBalance(address: string, options?: {
+        contract?: string;
+    }): Promise<unknown>;
+    getTokenMetadata(contract: string): Promise<{
+        contract: string;
+        name: string | null;
+        symbol: string | null;
+        logoUrl: string | null;
+    }>;
+    getStampRate(): Promise<number | bigint | null>;
+    getContract(contract: string): Promise<string | null>;
+    getContractCode(contract: string): Promise<string | null>;
+    simulate(request: SimulateRequest): Promise<Record<string, unknown>>;
+    call(request: SimulateRequest): Promise<unknown>;
+    estimateStamps(request: SimulateRequest, options?: EstimateStampsOptions): Promise<EstimateStampsResult>;
+    buildTx(request: BuildTxRequest): Promise<XianUnsignedTransaction>;
+    signTx(tx: XianUnsignedTransaction, signer: XianSigner): Promise<XianSignedTransaction>;
+    broadcastTx(tx: XianSignedTransaction, options?: BroadcastTxOptions): Promise<TransactionSubmission>;
+    waitForTx(txHash: string, options?: WaitForTxOptions): Promise<TransactionReceipt>;
+    sendTx(request: BuildTxRequest & {
+        signer: XianSigner;
+        mode?: BroadcastMode;
+        waitForTx?: boolean;
+        timeoutMs?: number;
+        pollIntervalMs?: number;
+    }): Promise<TransactionSubmission>;
+    contract(name: string): ContractClient;
+    token(name?: string): TokenClient;
+}
+export declare class ContractClient {
+    private readonly client;
+    private readonly contractName;
+    constructor(client: XianClient, contractName: string);
+    call(functionName: string, kwargs: Record<string, unknown>, sender?: string): Promise<unknown>;
+    send(functionName: string, kwargs: Record<string, unknown>, options: ContractSendOptions & {
+        signer: XianSigner;
+    }): Promise<TransactionSubmission>;
+}
+export declare class TokenClient {
+    private readonly client;
+    private readonly tokenName;
+    constructor(client: XianClient, tokenName: string);
+    balanceOf(address: string): Promise<unknown>;
+    metadata(): Promise<{
+        contract: string;
+        name: string | null;
+        symbol: string | null;
+        logoUrl: string | null;
+    }>;
+    allowance(owner: string, spender: string): Promise<unknown>;
+    transfer(options: TokenTransferOptions): Promise<TransactionSubmission>;
+    approve(options: TokenApproveOptions): Promise<TransactionSubmission>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -0,0 +1,580 @@
+import { base64ToUtf8, bytesToHex, canonicalizeRuntime, decodeRuntime, encodeRuntime, parseXianNumber, sortKeysDeep, utf8ToBytes } from "./encoding";
+import { isValidEd25519Signature } from "./ed25519";
+import { AbciError, RpcError, SimulationError, TransactionError, TransportError, TxTimeoutError } from "./errors";
+import { WatchApi } from "./watch";
+const EMPTY_ABCI_VALUE = "AA==";
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_POLL_INTERVAL_MS = 500;
+const DEFAULT_STAMP_MARGIN = 0.2;
+const DEFAULT_MIN_STAMP_HEADROOM = 5_000;
+function stripTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isIdentifier(value) {
+    return /^[a-zA-Z][a-zA-Z0-9_]*$/.test(value);
+}
+function isNonNegativeInteger(value) {
+    if (typeof value === "bigint") {
+        return value >= 0n;
+    }
+    return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isHexKey(value) {
+    return /^[a-fA-F0-9]{64}$/.test(value);
+}
+function readErrorMessage(value) {
+    const data = value.data;
+    if (typeof data === "string" && data.length > 0) {
+        return data;
+    }
+    const message = value.message;
+    if (typeof message === "string" && message.length > 0) {
+        return message;
+    }
+    return "RPC error";
+}
+function asRecord(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new TransportError("expected object response");
+    }
+    return value;
+}
+function parseJsonResult(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function normalizeMaybeNumber(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    if (/^-?\d+$/.test(value)) {
+        return parseXianNumber(value);
+    }
+    return value;
+}
+function normalizeMaybeString(value) {
+    if (value == null) {
+        return null;
+    }
+    return typeof value === "string" ? value : String(value);
+}
+function isPendingLookupReceipt(receipt) {
+    return !receipt.success && receipt.txHash == null && receipt.transaction == null;
+}
+function validatePayload(payload) {
+    const keys = Object.keys(payload).sort();
+    const expected = ["chain_id", "contract", "function", "kwargs", "nonce", "sender", "stamps_supplied"];
+    if (keys.join(",") !== expected.join(",")) {
+        throw new TransactionError("payload must contain the canonical Xian transaction keys");
+    }
+    if (!isHexKey(payload.sender)) {
+        throw new TransactionError("sender must be a 32-byte hex public key");
+    }
+    if (!isIdentifier(payload.contract)) {
+        throw new TransactionError("contract must be a valid identifier");
+    }
+    if (!isIdentifier(payload.function)) {
+        throw new TransactionError("function must be a valid identifier");
+    }
+    if (!isNonNegativeInteger(payload.nonce)) {
+        throw new TransactionError("nonce must be a non-negative integer");
+    }
+    if (!isNonNegativeInteger(payload.stamps_supplied)) {
+        throw new TransactionError("stamps_supplied must be a non-negative integer");
+    }
+    for (const key of Object.keys(payload.kwargs)) {
+        if (!isIdentifier(key)) {
+            throw new TransactionError("kwargs keys must be valid identifiers");
+        }
+    }
+}
+export class XianClient {
+    rpcUrl;
+    dashboardUrl;
+    watch;
+    fetchFn;
+    chainIdCache;
+    constructor(options) {
+        this.rpcUrl = stripTrailingSlash(options.rpcUrl);
+        this.dashboardUrl = options.dashboardUrl
+            ? stripTrailingSlash(options.dashboardUrl)
+            : undefined;
+        this.chainIdCache = options.chainId;
+        this.fetchFn = options.fetchFn ?? globalThis.fetch.bind(globalThis);
+        this.watch = new WatchApi({
+            dashboardUrl: this.dashboardUrl,
+            webSocketFactory: options.webSocketFactory
+        });
+    }
+    async requestJson(method, url) {
+        let response;
+        try {
+            response = await this.fetchFn(url, { method });
+        }
+        catch (error) {
+            throw new TransportError(`request failed for ${url}`, { cause: error });
+        }
+        if (!response.ok) {
+            throw new TransportError(`${method} ${url} returned ${response.status}`);
+        }
+        try {
+            return asRecord(await response.json());
+        }
+        catch (error) {
+            throw new TransportError(`invalid JSON response from ${url}`, { cause: error });
+        }
+    }
+    async abciQuery(path) {
+        const url = new URL(`${this.rpcUrl}/abci_query`);
+        url.searchParams.set("path", `"${path}"`);
+        const data = await this.requestJson("POST", url.toString());
+        if ("error" in data) {
+            throw new RpcError(readErrorMessage(asRecord(data.error)), data.error);
+        }
+        const response = asRecord(asRecord(data.result).response);
+        const code = response.code;
+        if (typeof code === "number" && code !== 0) {
+            throw new AbciError(String(response.log ?? "ABCI query failed"), {
+                path,
+                response
+            });
+        }
+        return data;
+    }
+    decodeAbciValue(value) {
+        if (value == null || value === EMPTY_ABCI_VALUE) {
+            return null;
+        }
+        const decodedUtf8 = base64ToUtf8(String(value));
+        const decoded = decodeRuntime(decodedUtf8);
+        if (decoded == null) {
+            return normalizeMaybeNumber(decodedUtf8);
+        }
+        return normalizeMaybeNumber(decoded);
+    }
+    normalizeTxLookup(data) {
+        const result = asRecord(data.result ?? {});
+        const txResult = asRecord(result.tx_result ?? {});
+        const execution = txResult.data == null ? undefined : parseJsonResult(base64ToUtf8(String(txResult.data)));
+        const transaction = result.tx == null ? undefined : this.decodeTxRecord(String(result.tx));
+        if ("error" in data) {
+            return {
+                success: false,
+                message: readErrorMessage(asRecord(data.error)),
+                response: data
+            };
+        }
+        const code = txResult.code;
+        const success = typeof code === "number" ? code === 0 : false;
+        const txHash = typeof result.hash === "string" ? result.hash : undefined;
+        return {
+            success,
+            txHash,
+            message: success ? undefined : execution ?? txResult.log ?? "Transaction failed",
+            response: data,
+            transaction,
+            execution
+        };
+    }
+    decodeTxRecord(value) {
+        const hexPayload = base64ToUtf8(value);
+        const decoded = decodeRuntime(hexPayload);
+        if (decoded != null) {
+            return decoded;
+        }
+        return decodeRuntime(hexToUtf8(hexPayload));
+    }
+    async getGenesis() {
+        return this.requestJson("GET", `${this.rpcUrl}/genesis`);
+    }
+    async getChainId() {
+        if (this.chainIdCache) {
+            return this.chainIdCache;
+        }
+        const genesis = await this.getGenesis();
+        const chainId = asRecord(asRecord(genesis.result).genesis).chain_id;
+        if (typeof chainId !== "string" || chainId.length === 0) {
+            throw new RpcError("genesis response did not include chain_id", genesis);
+        }
+        this.chainIdCache = chainId;
+        return chainId;
+    }
+    async getStatus() {
+        return this.requestJson("GET", `${this.rpcUrl}/status`);
+    }
+    async getBlock(height) {
+        return this.requestJson("GET", `${this.rpcUrl}/block?height=${height}`);
+    }
+    async getTx(txHash) {
+        const data = await this.requestJson("GET", `${this.rpcUrl}/tx?hash=0x${txHash}`);
+        return this.normalizeTxLookup(data);
+    }
+    async getNonce(address) {
+        const data = await this.abciQuery(`/get_next_nonce/${address}`);
+        const value = asRecord(asRecord(data.result).response).value;
+        if (value == null || value === EMPTY_ABCI_VALUE) {
+            return 0;
+        }
+        return parseXianNumber(base64ToUtf8(String(value)));
+    }
+    async getState(contract, variable, keys = []) {
+        const suffix = keys.length > 0 ? `:${keys.join(":")}` : "";
+        const data = await this.abciQuery(`/get/${contract}.${variable}${suffix}`);
+        return this.decodeAbciValue(asRecord(asRecord(data.result).response).value);
+    }
+    async getBalance(address, options) {
+        const contract = options?.contract ?? "currency";
+        try {
+            const simulation = await this.simulate({
+                sender: address,
+                contract,
+                function: "balance_of",
+                kwargs: { address }
+            });
+            return normalizeMaybeNumber(simulation.result);
+        }
+        catch {
+            return this.getState(contract, "balances", [address]);
+        }
+    }
+    async getTokenMetadata(contract) {
+        if (contract === "currency") {
+            return {
+                contract,
+                name: "Xian",
+                symbol: "Xian",
+                logoUrl: null
+            };
+        }
+        const [name, symbol, logoUrl] = await Promise.all([
+            this.getState(contract, "metadata", ["token_name"]),
+            this.getState(contract, "metadata", ["token_symbol"]),
+            this.getState(contract, "metadata", ["token_logo_url"])
+        ]);
+        return {
+            contract,
+            name: normalizeMaybeString(name),
+            symbol: normalizeMaybeString(symbol),
+            logoUrl: normalizeMaybeString(logoUrl)
+        };
+    }
+    async getStampRate() {
+        const value = await this.getState("stamp_cost", "S", ["value"]);
+        if (value == null) {
+            return null;
+        }
+        if (typeof value === "number" || typeof value === "bigint") {
+            return value;
+        }
+        return parseXianNumber(String(value));
+    }
+    async getContract(contract) {
+        const data = await this.abciQuery(`/contract/${contract}`);
+        const value = asRecord(asRecord(data.result).response).value;
+        if (value == null || value === EMPTY_ABCI_VALUE) {
+            return null;
+        }
+        return base64ToUtf8(String(value));
+    }
+    async getContractCode(contract) {
+        const data = await this.abciQuery(`/contract_code/${contract}`);
+        const value = asRecord(asRecord(data.result).response).value;
+        if (value == null || value === EMPTY_ABCI_VALUE) {
+            return null;
+        }
+        return base64ToUtf8(String(value));
+    }
+    async simulate(request) {
+        const payload = sortKeysDeep({
+            contract: request.contract,
+            function: request.function,
+            kwargs: request.kwargs,
+            sender: request.sender
+        });
+        const encoded = bytesToHex(utf8ToBytes(encodeRuntime(payload)));
+        const data = await this.abciQuery(`/simulate_tx/${encoded}`);
+        const response = asRecord(asRecord(data.result).response);
+        if (response.code != null && response.code !== 0) {
+            throw new SimulationError(String(response.log ?? "simulation failed"), response);
+        }
+        const rawValue = response.value;
+        const decoded = rawValue == null ? null : decodeRuntime(base64ToUtf8(String(rawValue)));
+        if (decoded == null) {
+            throw new SimulationError("simulation response did not decode to JSON", response);
+        }
+        return decoded;
+    }
+    async call(request) {
+        const simulation = await this.simulate(request);
+        const status = simulation.status;
+        if (status != null && status !== 0) {
+            throw new SimulationError(String(simulation.result ?? "Simulation failed"), simulation);
+        }
+        return simulation.result;
+    }
+    async estimateStamps(request, options) {
+        const simulation = await this.simulate(request);
+        const rawStamps = simulation.stamps_used;
+        const estimated = typeof rawStamps === "number"
+            ? rawStamps
+            : Number.parseInt(String(rawStamps ?? "0"), 10);
+        const stampMargin = options?.stampMargin ?? DEFAULT_STAMP_MARGIN;
+        const minStampHeadroom = options?.minStampHeadroom ?? DEFAULT_MIN_STAMP_HEADROOM;
+        const proportional = Math.ceil(estimated * stampMargin);
+        const suggested = estimated + Math.max(proportional, minStampHeadroom);
+        return {
+            estimated,
+            suggested,
+            simulation
+        };
+    }
+    async buildTx(request) {
+        const chainId = request.chainId ?? (await this.getChainId());
+        const nonce = request.nonce ?? (await this.getNonce(request.sender));
+        let stampsSupplied = request.stampsSupplied ?? request.stamps;
+        if (stampsSupplied == null) {
+            const estimate = await this.estimateStamps({
+                sender: request.sender,
+                contract: request.contract,
+                function: request.function,
+                kwargs: request.kwargs
+            });
+            stampsSupplied = estimate.suggested;
+        }
+        const payload = sortKeysDeep({
+            chain_id: chainId,
+            contract: request.contract,
+            function: request.function,
+            kwargs: request.kwargs,
+            nonce,
+            sender: request.sender,
+            stamps_supplied: stampsSupplied
+        });
+        validatePayload(payload);
+        return { payload };
+    }
+    async signTx(tx, signer) {
+        validatePayload(tx.payload);
+        const signerAddress = typeof signer.getAddress === "function" ? await signer.getAddress() : undefined;
+        if (signerAddress && signerAddress !== tx.payload.sender) {
+            throw new TransactionError("signer address does not match payload sender");
+        }
+        const signature = await signer.signMessage(canonicalizeRuntime(tx.payload));
+        if (!isValidEd25519Signature(signature)) {
+            throw new TransactionError("signer returned an invalid Ed25519 signature");
+        }
+        return sortKeysDeep({
+            metadata: { signature },
+            payload: tx.payload
+        });
+    }
+    async broadcastTx(tx, options) {
+        validatePayload(tx.payload);
+        const mode = options?.mode ?? "checktx";
+        if (!["async", "checktx", "commit"].includes(mode)) {
+            throw new TransactionError("mode must be one of: async, checktx, commit");
+        }
+        const endpoint = mode === "async"
+            ? "broadcast_tx_async"
+            : mode === "commit"
+                ? "broadcast_tx_commit"
+                : "broadcast_tx_sync";
+        const encodedTx = bytesToHex(utf8ToBytes(encodeRuntime(sortKeysDeep(tx))));
+        const url = new URL(`${this.rpcUrl}/${endpoint}`);
+        url.searchParams.set("tx", `"${encodedTx}"`);
+        const data = await this.requestJson("POST", url.toString());
+        const response = asRecord(data.result ?? {});
+        const txHash = typeof response.hash === "string" ? response.hash : undefined;
+        const submission = {
+            submitted: !("error" in data),
+            accepted: null,
+            finalized: false,
+            txHash,
+            message: "error" in data ? readErrorMessage(asRecord(data.error)) : undefined,
+            mode,
+            nonce: tx.payload.nonce,
+            stampsSupplied: tx.payload.stamps_supplied,
+            response: data
+        };
+        if ("error" in data) {
+            return submission;
+        }
+        if (mode === "commit") {
+            const checkTx = asRecord(response.check_tx ?? {});
+            const deliverTx = asRecord(response.deliver_tx ?? response.tx_result ?? {});
+            submission.accepted = checkTx.code === 0;
+            submission.finalized = submission.accepted && deliverTx.code === 0 && String(response.height ?? "0") !== "0";
+            submission.message = submission.accepted
+                ? submission.finalized
+                    ? undefined
+                    : deliverTx.log ?? "transaction was not finalized"
+                : checkTx.log ?? "CheckTx failed";
+            return submission;
+        }
+        if (mode === "async") {
+            if (options?.waitForTx && submission.txHash) {
+                submission.receipt = await this.waitForTx(submission.txHash, options);
+                submission.finalized = true;
+            }
+            return submission;
+        }
+        submission.accepted = response.code === 0;
+        submission.message = submission.accepted ? undefined : response.log ?? "CheckTx failed";
+        if (submission.accepted && options?.waitForTx && submission.txHash) {
+            submission.receipt = await this.waitForTx(submission.txHash, options);
+            submission.finalized = true;
+        }
+        return submission;
+    }
+    async waitForTx(txHash, options) {
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const pollIntervalMs = options?.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+        const deadline = Date.now() + timeoutMs;
+        let lastError;
+        while (Date.now() < deadline) {
+            try {
+                const receipt = await this.getTx(txHash);
+                if (!isPendingLookupReceipt(receipt)) {
+                    return receipt;
+                }
+            }
+            catch (error) {
+                lastError = error;
+            }
+            await sleep(pollIntervalMs);
+        }
+        throw new TxTimeoutError(`timed out waiting for transaction ${txHash}`, {
+            cause: lastError
+        });
+    }
+    async sendTx(request) {
+        const tx = await this.buildTx(request);
+        const signedTx = await this.signTx(tx, request.signer);
+        return this.broadcastTx(signedTx, {
+            mode: request.mode,
+            waitForTx: request.waitForTx,
+            timeoutMs: request.timeoutMs,
+            pollIntervalMs: request.pollIntervalMs
+        });
+    }
+    contract(name) {
+        return new ContractClient(this, name);
+    }
+    token(name = "currency") {
+        return new TokenClient(this, name);
+    }
+}
+function hexToUtf8(value) {
+    const out = new Uint8Array(value.length / 2);
+    for (let index = 0; index < value.length; index += 2) {
+        out[index / 2] = Number.parseInt(value.slice(index, index + 2), 16);
+    }
+    return new TextDecoder().decode(out);
+}
+export class ContractClient {
+    client;
+    contractName;
+    constructor(client, contractName) {
+        this.client = client;
+        this.contractName = contractName;
+    }
+    async call(functionName, kwargs, sender = "0".repeat(64)) {
+        return this.client.call({
+            sender,
+            contract: this.contractName,
+            function: functionName,
+            kwargs
+        });
+    }
+    async send(functionName, kwargs, options) {
+        if (typeof options.signer.getAddress !== "function") {
+            throw new TransactionError("signer.getAddress() is required for contract sends");
+        }
+        const sender = await options.signer.getAddress();
+        return this.client.sendTx({
+            sender,
+            contract: this.contractName,
+            function: functionName,
+            kwargs,
+            signer: options.signer,
+            mode: options.mode,
+            waitForTx: options.waitForTx,
+            timeoutMs: options.timeoutMs,
+            pollIntervalMs: options.pollIntervalMs,
+            stamps: options.stamps,
+            nonce: options.nonce,
+            chainId: options.chainId
+        });
+    }
+}
+export class TokenClient {
+    client;
+    tokenName;
+    constructor(client, tokenName) {
+        this.client = client;
+        this.tokenName = tokenName;
+    }
+    balanceOf(address) {
+        return this.client.getBalance(address, { contract: this.tokenName });
+    }
+    metadata() {
+        return this.client.getTokenMetadata(this.tokenName);
+    }
+    allowance(owner, spender) {
+        return this.client.getState(this.tokenName, "approvals", [owner, spender]);
+    }
+    async transfer(options) {
+        if (typeof options.signer.getAddress !== "function") {
+            throw new TransactionError("signer.getAddress() is required for token transfer");
+        }
+        const sender = await options.signer.getAddress();
+        return this.client.sendTx({
+            sender,
+            contract: this.tokenName,
+            function: "transfer",
+            kwargs: {
+                to: options.to,
+                amount: options.amount
+            },
+            signer: options.signer,
+            mode: options.mode,
+            waitForTx: options.waitForTx,
+            timeoutMs: options.timeoutMs,
+            pollIntervalMs: options.pollIntervalMs,
+            stamps: options.stamps,
+            nonce: options.nonce,
+            chainId: options.chainId
+        });
+    }
+    async approve(options) {
+        if (typeof options.signer.getAddress !== "function") {
+            throw new TransactionError("signer.getAddress() is required for token approve");
+        }
+        const sender = await options.signer.getAddress();
+        return this.client.sendTx({
+            sender,
+            contract: this.tokenName,
+            function: "approve",
+            kwargs: {
+                to: options.spender,
+                amount: options.amount
+            },
+            signer: options.signer,
+            mode: options.mode,
+            waitForTx: options.waitForTx,
+            timeoutMs: options.timeoutMs,
+            pollIntervalMs: options.pollIntervalMs,
+            stamps: options.stamps,
+            nonce: options.nonce,
+            chainId: options.chainId
+        });
+    }
+}
+//# sourceMappingURL=client.js.map