@wowok/agent-mcp 2.3.6 → 2.3.8

package/dist/schema/call/bridge-handler.js

@@ -0,0 +1,234 @@
+import { BridgeClient, LocalMark, } from "@wowok/wowok";
+let _bridgeClient = null;
+let _bridgeClientEnv = null;
+function getBridgeClient(env) {
+    const envObj = env || {};
+    const curAccount = envObj?.account;
+    if (_bridgeClient === null || _bridgeClientEnv === null || curAccount !== _bridgeClientEnv?.account) {
+        _bridgeClient = new BridgeClient({ wowEnv: envObj });
+        _bridgeClientEnv = envObj;
+    }
+    return _bridgeClient;
+}
+function getBridgeClientForQuery() {
+    if (_bridgeClient !== null)
+        return _bridgeClient;
+    _bridgeClient = new BridgeClient({});
+    _bridgeClientEnv = {};
+    return _bridgeClient;
+}
+function validateMainnet(env) {
+    const network = env?.network;
+    if (network && network !== "mainnet") {
+        throw new Error(`Bridge only supports WOW mainnet (current network: '${network}'). Only mainnet provides cross-chain functionality.`);
+    }
+}
+async function resolveWowAddress(addrOrName, env) {
+    if (!addrOrName) {
+        const acc = env?.account;
+        return acc;
+    }
+    if (/^0x[0-9a-fA-F]{64}$/.test(addrOrName))
+        return addrOrName;
+    try {
+        const addr = await LocalMark.Instance().get_address(addrOrName);
+        if (addr)
+            return addr;
+        return addrOrName;
+    }
+    catch {
+        return addrOrName;
+    }
+}
+function safeJson(obj) {
+    return JSON.stringify(obj, (_k, v) => typeof v === "bigint" ? v.toString() : v, 2);
+}
+function convertBigInts(obj) {
+    if (typeof obj === "bigint")
+        return obj.toString();
+    if (Array.isArray(obj))
+        return obj.map(convertBigInts);
+    if (obj && typeof obj === "object") {
+        const out = {};
+        for (const k of Object.keys(obj))
+            out[k] = convertBigInts(obj[k]);
+        return out;
+    }
+    return obj;
+}
+function ok(message, result) {
+    const safeResult = convertBigInts(result);
+    const output = { message, result: { type: "data", data: safeResult } };
+    return {
+        content: [
+            { type: "text", text: message },
+            { type: "text", text: safeJson(safeResult) },
+        ],
+        structuredContent: output,
+    };
+}
+function err(message) {
+    const output = { message, result: { type: "error", error: message } };
+    return {
+        content: [{ type: "text", text: message }],
+        structuredContent: output,
+    };
+}
+export async function handleBridgeOperations(args) {
+    if (!args || typeof args !== "object") {
+        return err("Invalid args: expected an object with operation_type");
+    }
+    let validated;
+    try {
+        const { strictParse } = await import("./base.js");
+        validated = strictParse((await import("./bridge.js")).BridgeOperationsSchema, args, "bridge_operations input");
+    }
+    catch (e) {
+        return err(`Parameter validation failed: ${e?.message ?? String(e)}`);
+    }
+    const env = validated.env;
+    try {
+        switch (validated.operation_type) {
+            case "cross_chain_wow_to_evm": {
+                validateMainnet(env);
+                const data = validated.data;
+                const client = getBridgeClient(env);
+                const result = await client.bridgeWowToEvmSimple({
+                    token: data.token,
+                    amount: BigInt(data.amount),
+                    withdrawTo: data.withdrawTo,
+                    waitForFinalization: false,
+                });
+                return ok(`WOW→EVM cross-chain step 1 (deposit) submitted. transferId=${result.transferId}, activeEvmAccount=${result.activeEvmAccount}. ` +
+                    `Next: poll query_transfer_status until bridge signs (~1-5 min), then call claim_wow_to_evm to complete.`, result);
+            }
+            case "cross_chain_evm_to_wow": {
+                validateMainnet(env);
+                const data = validated.data;
+                const recipientWowAddress = await resolveWowAddress(data.recipientWowAddress, env);
+                const client = getBridgeClient(env);
+                const result = await client.bridgeEvmToWowSimple({
+                    token: data.token,
+                    amount: BigInt(data.amount),
+                    recipientWowAddress,
+                    waitForFinalization: false,
+                });
+                return ok(`EVM→WOW cross-chain submitted. transferId=${result.transferId}, activeEvmAccount=${result.activeEvmAccount}. ` +
+                    `Bridge will auto-claim on WOW (~10-20 min). Poll query_transfer_status to monitor progress.`, result);
+            }
+            case "claim_wow_to_evm": {
+                validateMainnet(env);
+                const data = validated.data;
+                const client = getBridgeClient(env);
+                const result = await client.claimWowToEvm(data.transferId);
+                return ok(`WOW→EVM claim (step 2) completed. transferId=${result.transferId}, claimTxHash=${result.claimTxHash}`, result);
+            }
+            case "withdraw": {
+                const data = validated.data;
+                const client = getBridgeClientForQuery();
+                let tokenAddress = data.tokenAddress;
+                if (!tokenAddress && data.token && data.token !== "ETH") {
+                    const cfg = client.config;
+                    const chain = cfg?.evmChains?.find((c) => c.name === (data.network ?? "mainnet"));
+                    const tokenMeta = chain?.tokens?.find((t) => t.symbol === data.token);
+                    tokenAddress = tokenMeta?.evmAddress;
+                    if (!tokenAddress) {
+                        return err(`Cannot resolve ERC20 token address for symbol '${data.token}' on chain '${data.network ?? "mainnet"}'. Please pass tokenAddress explicitly.`);
+                    }
+                }
+                const result = await client.withdrawFromActiveEvmAccount({
+                    to: data.to,
+                    amount: BigInt(data.amount),
+                    tokenAddress,
+                    token: data.token ? data.token : undefined,
+                    network: data.network,
+                });
+                return ok(`Withdrawal submitted. transferId=${result.transferId}, txHash=${result.txHash}`, result);
+            }
+            case "query_active_evm_account": {
+                const data = validated.data ?? {};
+                const client = getBridgeClientForQuery();
+                const result = await client.queryActiveEvmAccount({
+                    network: data.network,
+                    tokens: data.tokens,
+                });
+                return ok(`activeEvmAccount: ${result.address} (${result.chains.length} chain(s))`, result);
+            }
+            case "query_supported_evm_chains": {
+                const client = getBridgeClientForQuery();
+                const result = await client.querySupportedEvmChains();
+                return ok(`${result.length} EVM chain(s) supported: ${result.map(c => `${c.name}(chainId=${c.chainId})`).join(", ")}`, result);
+            }
+            case "query_supported_tokens": {
+                const data = validated.data ?? {};
+                const client = getBridgeClientForQuery();
+                const result = await client.querySupportedTokens({
+                    network: data.network,
+                });
+                const totalTokens = result.reduce((sum, c) => sum + c.tokens.length, 0);
+                return ok(`${result.length} chain(s), ${totalTokens} token entries: ${result.map((c) => `${c.chainName}(${c.tokens.length} tokens)`).join(", ")}`, result);
+            }
+            case "query_transfer_list": {
+                const data = validated.data ?? {};
+                const client = getBridgeClientForQuery();
+                let result = await client.queryTransferList({
+                    onlyActive: data.onlyActive,
+                });
+                if (data.status) {
+                    result = result.filter((r) => r.status === data.status);
+                }
+                if (data.direction) {
+                    result = result.filter((r) => r.direction === data.direction);
+                }
+                if (data.token) {
+                    result = result.filter((r) => r.token === data.token);
+                }
+                if (data.limit && data.limit > 0) {
+                    result = result.slice(0, data.limit);
+                }
+                const active = result.filter(r => r.status !== "success" && r.status !== "failed").length;
+                return ok(`${result.length} transfer record(s) (${active} in progress)${data.status || data.direction || data.token ? " (filtered)" : ""}`, result);
+            }
+            case "query_transfer_status": {
+                const data = validated.data;
+                const client = getBridgeClientForQuery();
+                const refresh = data.refresh !== false;
+                if (refresh) {
+                    try {
+                        await Promise.race([
+                            client.refreshTransferStatus(data.transferId),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error("refresh timeout")), 15_000)),
+                        ]);
+                    }
+                    catch {
+                    }
+                }
+                const result = await client.queryTransferStatus(data.transferId);
+                if (!result) {
+                    return err(`transferId '${data.transferId}' not found. ` +
+                        `Use query_transfer_list to see all valid transferIds. ` +
+                        `Note: transfer history is persisted in cache.db and restored on MCP restart, ` +
+                        `so this transferId may never have been created in this environment.`);
+                }
+                return ok(`Transfer ${data.transferId}: ${result.direction} / ${result.step} / ${result.status}`, result);
+            }
+            case "manage_evm_rpc": {
+                const data = validated.data;
+                const client = getBridgeClientForQuery();
+                const result = await client.manageEvmRpc({
+                    op: data.op,
+                    network: data.network,
+                    rpcUrls: data.rpcUrls,
+                });
+                return ok(`RPC '${data.op}' operation ${result.success ? "succeeded" : "failed"}`, result);
+            }
+            default: {
+                return err(`Unsupported operation_type: ${validated.operation_type}`);
+            }
+        }
+    }
+    catch (e) {
+        const msg = e?.message ?? String(e);
+        return err(`Bridge operation failed: ${msg}`);
+    }
+}