@ab-org/predicate-market-sdk 0.0.1

package/dist/modules/marketData.js

@@ -0,0 +1,113 @@
+import { sessionStore } from "@ab-org/sdk-core";
+import { getEnv } from "../utils/env.js";
+const DEFAULT_MERCHANT_BASE_URL = "https://merchant.tomo.services";
+let cachedChains = null;
+/** Fallback when chains API fails (network error, 4xx/5xx, parse error, missing base URL). */
+const MOCK_CHAINS_FALLBACK = [
+    {
+        chain_id: "56",
+        network: "BSC",
+        tokens: [
+            { symbol: "USD1", address: "0x", decimals: 18 },
+            { symbol: "USDT", address: "0x", decimals: 6 },
+            { symbol: "USDC", address: "0x", decimals: 6 },
+        ],
+    },
+    {
+        chain_id: "ETH",
+        network: "Ethereum",
+        tokens: [
+            { symbol: "USDT", address: "0x", decimals: 6 },
+            { symbol: "USDC", address: "0x", decimals: 6 },
+        ],
+    },
+];
+async function fetchChainsFromApi() {
+    if (cachedChains)
+        return cachedChains;
+    try {
+        const CHAINS_API_BASE = getEnv("MERCHANT_BASE_URL") || DEFAULT_MERCHANT_BASE_URL;
+        const res = await fetch(`${CHAINS_API_BASE}/chains`);
+        if (!res.ok)
+            throw new Error(`Chains API error: ${res.status} ${res.statusText}`);
+        const json = (await res.json());
+        const chains = json.data?.chains ?? [];
+        if (chains.length > 0) {
+            cachedChains = chains;
+            return chains;
+        }
+        return MOCK_CHAINS_FALLBACK;
+    }
+    catch {
+        return MOCK_CHAINS_FALLBACK;
+    }
+}
+function chainToChainInfo(chain) {
+    return {
+        id: chain.chain_id,
+        name: chain.network,
+    };
+}
+function deriveTokensFromChains(chains) {
+    const bySymbol = new Map();
+    for (const chain of chains) {
+        for (const t of chain.tokens) {
+            if (!bySymbol.has(t.symbol)) {
+                bySymbol.set(t.symbol, {
+                    symbol: t.symbol,
+                    name: t.symbol,
+                    decimals: t.decimals,
+                });
+            }
+        }
+    }
+    return Array.from(bySymbol.values());
+}
+function computeMockQuote(request) {
+    const isStable = ["USDT", "USDC", "USD1"].includes(request.token);
+    const slippage = isStable ? "0.3" : "1.0";
+    const feeRate = request.direction === "withdraw" ? 0.001 : 0;
+    const amount = Number(request.amount) || 0;
+    const fee = (amount * feeRate).toFixed(2);
+    const estimatedAmount = (amount - Number(fee)).toFixed(6);
+    return {
+        quoteId: `quote-${Date.now()}`,
+        estimatedAmount: amount > 0 ? estimatedAmount : "0",
+        slippage,
+        fee,
+        feeToken: request.token,
+        exchangeRate: "1.0",
+        expiresAt: Date.now() + 30000,
+    };
+}
+/**
+ * Market data provider backed by merchant API.
+ * - getSupportedTokens / getSupportedChains: from GET https://merchant.tomo.services/chains
+ * - getQuote: mock (no quote API yet)
+ * - getDepositAddress: from session (no deposit-address API in this service)
+ */
+export function createMockMarketDataProvider() {
+    return {
+        async getSupportedTokens(_direction) {
+            const chains = await fetchChainsFromApi();
+            const tokens = deriveTokensFromChains(chains);
+            return tokens.length > 0 ? tokens : [];
+        },
+        async getSupportedChains(token, _direction) {
+            const chains = await fetchChainsFromApi();
+            const forToken = chains.filter((c) => c.tokens.some((t) => t.symbol === token));
+            const list = forToken.length > 0 ? forToken : chains;
+            return list.map(chainToChainInfo);
+        },
+        async getQuote(request) {
+            return computeMockQuote(request);
+        },
+        async getDepositAddress(_token, _chain) {
+            const session = sessionStore.getState().session;
+            return {
+                address: session?.address ?? "",
+                minimumDeposit: "15.00",
+            };
+        },
+    };
+}

package/dist/modules/withdraw.d.ts

@@ -0,0 +1,31 @@
+import type { ChainInfo, CustodyAdapter, MarketDataProvider, ModalController, QuoteResult, TokenInfo } from "../types.js";
+export interface WithdrawModalConfig {
+    defaultAmount?: string;
+    defaultToken?: string;
+    defaultChain?: string;
+    targetAddress?: string;
+    onStatusChange?: (status: WithdrawStatus) => void;
+}
+export type WithdrawStatus = {
+    phase: "idle";
+} | {
+    phase: "requested";
+    requestId: string;
+} | {
+    phase: "processing";
+    requestId: string;
+} | {
+    phase: "settled";
+    requestId: string;
+    txHash?: string;
+} | {
+    phase: "failed";
+    reason: string;
+};
+export interface WithdrawController extends ModalController<WithdrawModalConfig> {
+    readonly status: WithdrawStatus;
+    fetchTokens(): Promise<TokenInfo[]>;
+    fetchChains(token: string): Promise<ChainInfo[]>;
+    fetchQuote(token: string, chain: string, amount: string): Promise<QuoteResult>;
+}
+export declare const createWithdrawController: (custody: CustodyAdapter, marketData: MarketDataProvider) => WithdrawController;

package/dist/modules/withdraw.js

@@ -0,0 +1,60 @@
+import { sessionStore } from "@ab-org/sdk-core";
+function requireSession() {
+    const session = sessionStore.getState().session;
+    if (!session)
+        throw new Error("Login required");
+    return session;
+}
+export const createWithdrawController = (custody, marketData) => {
+    let status = { phase: "idle" };
+    const update = (next, cb) => {
+        status = next;
+        cb?.(status);
+    };
+    const open = async (config) => {
+        const session = requireSession();
+        const token = config?.defaultToken ?? "USD1";
+        const chain = config?.defaultChain ??
+            session.chainContext?.settlementChain ??
+            session.chain ??
+            "AB_CORE";
+        const targetAddress = config?.targetAddress;
+        if (!targetAddress)
+            throw new Error("targetAddress required for withdraw");
+        try {
+            const { requestId } = await custody.requestWithdraw({
+                amount: config?.defaultAmount ?? "0",
+                token,
+                chain,
+                targetAddress,
+            });
+            update({ phase: "requested", requestId }, config?.onStatusChange);
+            update({ phase: "processing", requestId }, config?.onStatusChange);
+            const { status: finalStatus, txHash } = await custody.getWithdrawStatus(requestId);
+            update(finalStatus === "SETTLED"
+                ? { phase: "settled", requestId, txHash }
+                : { phase: "failed", reason: finalStatus }, config?.onStatusChange);
+        }
+        catch (error) {
+            update({ phase: "failed", reason: error.message }, config?.onStatusChange);
+        }
+    };
+    return {
+        get status() {
+            return status;
+        },
+        open,
+        fetchTokens() {
+            requireSession();
+            return marketData.getSupportedTokens("withdraw");
+        },
+        fetchChains(token) {
+            requireSession();
+            return marketData.getSupportedChains(token, "withdraw");
+        },
+        fetchQuote(token, chain, amount) {
+            requireSession();
+            return marketData.getQuote({ token, chain, amount, direction: "withdraw" });
+        },
+    };
+};

package/dist/modules/withdrawExecutor.d.ts

@@ -0,0 +1,47 @@
+export interface WithdrawRequest {
+    /** 用户收款地址（目标链） */
+    toAddress: string;
+    /** Human-readable amount, e.g. "100.5" */
+    amount: string;
+    /** 目标链代币 symbol，如 "USDT" */
+    token: string;
+    /** 目标链 chain_id */
+    chain: string;
+}
+export interface WithdrawResult {
+    /** BSC 上转入一次性地址的 funding tx hash */
+    txHash: string;
+    /** 提现订单 ID，用于轮询 getWithdrawOrder(orderId) */
+    orderId: string;
+    /** 广播 funding tx 的链 id，用于构建 explorer 链接 */
+    fundingChainId?: string;
+}
+/**
+ * A function that executes a withdraw operation.
+ * Callers can supply their own implementation to override the default behaviour.
+ */
+export type WithdrawExecutor = (request: WithdrawRequest) => Promise<WithdrawResult>;
+/**
+ * Convert a human-readable decimal string to the smallest unit (wei-equivalent).
+ *
+ * Examples with decimals=18:
+ *   "1"     → 1000000000000000000n
+ *   "0.5"   → 500000000000000000n
+ *   "100.1" → 100100000000000000000n
+ */
+export declare function parseUnits(value: string, decimals: number): bigint;
+export interface BscUsd1WithdrawExecutorOptions {
+    /** 源代币 USD1 合约地址（提现场景下为 BSC 上的 USD1） */
+    tokenAddress?: string;
+    decimals?: number;
+    chainId?: number;
+    /** 系统配置的单笔限额（wei 字符串），若提供则校验 request.amount 不得超过此值 */
+    maxAmountWei?: string;
+}
+/**
+ * Factory that returns a `WithdrawExecutor` implementing the flow in withdraw.md:
+ * 1) Create NATIVE_SWAP order → get one-time wallet address (OTW);
+ * 2) Sign ERC-20 transfer of USD1 on BSC to the OTW (not to user);
+ * 3) Broadcast tx and return { txHash, orderId } for the client to poll getWithdrawOrder(orderId).
+ */
+export declare function createBscUsd1WithdrawExecutor(options?: BscUsd1WithdrawExecutorOptions): WithdrawExecutor;

package/dist/modules/withdrawExecutor.js

@@ -0,0 +1,208 @@
+import { sessionStore } from "@ab-org/sdk-core";
+import { tryAutoReconnect } from "../auth/autoReconnect.js";
+import { getChains, createOrder } from "./api.js";
+import { fromHex, parseGwei, toHex } from "viem";
+import { testBsc, BSC_USD1_ADDRESS } from "../constants/chains.js";
+const MAX_WITHDRAW_GAS_LIMIT = 500000n;
+const BSC_RPC_URL = testBsc.rpcUrls[0];
+/* ─── Internal helpers ────────────────────────── */
+const ERC20_TRANSFER_SELECTOR = "0xa9059cbb";
+const USD1_DECIMALS = testBsc.nativeCurrencyDecimals;
+function padHex256(value) {
+    return value.toString(16).padStart(64, "0");
+}
+function padAddress(address) {
+    return address.toLowerCase().replace("0x", "").padStart(64, "0");
+}
+/**
+ * Convert a human-readable decimal string to the smallest unit (wei-equivalent).
+ *
+ * Examples with decimals=18:
+ *   "1"     → 1000000000000000000n
+ *   "0.5"   → 500000000000000000n
+ *   "100.1" → 100100000000000000000n
+ */
+export function parseUnits(value, decimals) {
+    if (!value || value === "0")
+        return 0n;
+    const [intPart = "0", fracPart = ""] = value.split(".");
+    const padded = fracPart.padEnd(decimals, "0").slice(0, decimals);
+    return BigInt(intPart) * 10n ** BigInt(decimals) + BigInt(padded);
+}
+function encodeTransferData(to, amountWei) {
+    return `${ERC20_TRANSFER_SELECTOR}${padAddress(to)}${padHex256(amountWei)}`;
+}
+function isUnsupportedMethodError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /unsupported rpc method|unsupported method|method not found|does not support/i.test(message);
+}
+function toHexQuantity(value) {
+    if (typeof value === "string") {
+        if (/^0x[0-9a-fA-F]+$/.test(value)) {
+            return value;
+        }
+        if (/^\d+$/.test(value)) {
+            return toHex(BigInt(value));
+        }
+    }
+    if (typeof value === "number") {
+        return toHex(BigInt(value));
+    }
+    if (typeof value === "bigint") {
+        return toHex(value);
+    }
+    throw new Error(`Invalid EVM quantity: ${String(value)}`);
+}
+async function callRpc(rpcUrl, method, params) {
+    const response = await fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: Date.now(),
+            method,
+            params,
+        }),
+    });
+    const json = (await response.json());
+    if (!response.ok || json.error) {
+        throw new Error(json.error?.message ?? `${method} failed`);
+    }
+    return json.result;
+}
+async function requestHexQuantity(provider, rpcUrl, method, params) {
+    try {
+        const result = await provider.request({ method, params });
+        return toHexQuantity(result);
+    }
+    catch (error) {
+        if (!isUnsupportedMethodError(error)) {
+            throw error;
+        }
+        return toHexQuantity(await callRpc(rpcUrl, method, params));
+    }
+}
+async function ensureBscChain(provider, chainId) {
+    const hex = `0x${chainId.toString(16)}`;
+    try {
+        await provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: hex }] });
+    }
+    catch {
+        // Ignored – the wallet may already be on BSC or may not support switching.
+    }
+}
+function getDstTokenAddress(chains, chainId, tokenSymbol) {
+    const chain = chains.find((c) => c.chain_id === chainId);
+    return chain?.tokens.find((t) => t.symbol === tokenSymbol)?.address;
+}
+/**
+ * Factory that returns a `WithdrawExecutor` implementing the flow in withdraw.md:
+ * 1) Create NATIVE_SWAP order → get one-time wallet address (OTW);
+ * 2) Sign ERC-20 transfer of USD1 on BSC to the OTW (not to user);
+ * 3) Broadcast tx and return { txHash, orderId } for the client to poll getWithdrawOrder(orderId).
+ */
+export function createBscUsd1WithdrawExecutor(options) {
+    const tokenAddress = options?.tokenAddress ?? BSC_USD1_ADDRESS;
+    const decimals = options?.decimals ?? USD1_DECIMALS;
+    const maxAmountWei = options?.maxAmountWei;
+    const chainId = options?.chainId ?? Number(testBsc.chainId);
+    return async (request) => {
+        const amountWei = parseUnits(request.amount, decimals);
+        const amountWeiStr = amountWei.toString();
+        if (maxAmountWei != null && amountWei > BigInt(maxAmountWei)) {
+            throw new Error("Withdraw amount exceeds the single-transaction limit");
+        }
+        let session = sessionStore.getState().session;
+        if (!session)
+            throw new Error("Login required");
+        let { provider } = session;
+        try {
+            await provider.request({ method: "eth_chainId", params: [] });
+        }
+        catch (err) {
+            const msg = err.message ?? "";
+            if (msg.includes("restored from cache") || msg.includes("Reconnect your wallet")) {
+                const reconnected = await tryAutoReconnect();
+                if (reconnected) {
+                    session = reconnected;
+                    provider = reconnected.provider;
+                }
+                else {
+                    sessionStore.clearSession();
+                    throw new Error("Session expired. Please sign in again.");
+                }
+            }
+        }
+        const chainsRes = await getChains();
+        const chains = chainsRes?.chains ?? [];
+        const dstTokenAddress = getDstTokenAddress(chains, request.chain, request.token);
+        if (!dstTokenAddress) {
+            throw new Error(`Unsupported token ${request.token} on chain ${request.chain}`);
+        }
+        // 校验规则：源代币或目标代币中必须有一个是 USD1。提现场景下源代币（token_address）为 USD1；token_amount 已按 maxAmountWei 做单笔限额校验
+        const sourceTokenSymbol = "USD1";
+        const orderRes = await createOrder({
+            intent_id: `withdraw-${Date.now()}`,
+            order_type: "NATIVE_SWAP",
+            order_payload: {
+                chain_id: String(chainId),
+                token_address: tokenAddress,
+                token_amount: amountWeiStr,
+                dst_chain_id: request.chain,
+                dst_token_address: dstTokenAddress,
+                recipient: request.toAddress,
+            },
+            payment_pairs: [
+                {
+                    token_symbol: sourceTokenSymbol,
+                    token_amount: amountWeiStr,
+                    token_address: tokenAddress,
+                    user_address: session.address,
+                    chain_id: String(chainId),
+                },
+            ],
+        });
+        const oneTimeAddress = orderRes.payment_sessions?.[0]?.one_time_wallet_address;
+        if (!oneTimeAddress) {
+            throw new Error("Order created but no one-time wallet address returned");
+        }
+        await ensureBscChain(provider, chainId);
+        const data = encodeTransferData(oneTimeAddress, amountWei);
+        const nonce = await requestHexQuantity(provider, BSC_RPC_URL, "eth_getTransactionCount", [session.address, "latest"]);
+        const tx = {
+            from: session.address,
+            to: tokenAddress,
+            value: "0x0",
+            nonce,
+            data,
+            chainId: toHex(chainId),
+        };
+        const estimatedGasHex = await requestHexQuantity(provider, BSC_RPC_URL, "eth_estimateGas", [tx]);
+        const estimatedGas = fromHex(estimatedGasHex, "bigint");
+        const gas = toHex(estimatedGas > MAX_WITHDRAW_GAS_LIMIT ? MAX_WITHDRAW_GAS_LIMIT : estimatedGas);
+        const transaction = {
+            ...tx,
+            gas,
+            maxFeePerGas: toHex(parseGwei("5")),
+            maxPriorityFeePerGas: toHex(parseGwei("1")),
+        };
+        let txHash;
+        try {
+            txHash = await provider.request({
+                method: "eth_sendTransaction",
+                params: [transaction],
+            });
+        }
+        catch (error) {
+            if (!isUnsupportedMethodError(error)) {
+                throw error;
+            }
+            const signedTx = await provider.request({
+                method: "eth_signTransaction",
+                params: [transaction],
+            });
+            txHash = await callRpc(BSC_RPC_URL, "eth_sendRawTransaction", [signedTx]);
+        }
+        return { txHash, orderId: orderRes.order_id, fundingChainId: String(chainId) };
+    };
+}

package/dist/policyAdapter.d.ts

@@ -0,0 +1,11 @@
+import { type SessionCapabilityPolicy, type SupportedChain, type SupportedToken, type WalletCapability } from "@ab-org/sdk-core";
+export interface PredicateMarketPolicyAdapterOptions {
+    appId?: string;
+    origin?: string;
+    expiresAt?: number;
+}
+export declare const createPredicateMarketPolicyAdapter: (options?: PredicateMarketPolicyAdapterOptions) => {
+    deposit(token: SupportedToken, chain: SupportedChain, maxAmount?: string): SessionCapabilityPolicy;
+    withdraw(token: SupportedToken, chain: SupportedChain, maxAmount?: string): SessionCapabilityPolicy;
+    trade(chain: SupportedChain, capabilities?: WalletCapability[]): SessionCapabilityPolicy;
+};

package/dist/policyAdapter.js

@@ -0,0 +1,38 @@
+import { createSessionCapabilityPolicy, } from "@ab-org/sdk-core";
+const createPolicy = (overrides, options) => createSessionCapabilityPolicy({
+    appId: options?.appId,
+    origin: options?.origin,
+    expiresAt: options?.expiresAt,
+    ...overrides,
+});
+const withActionMetadata = (action, policy) => ({
+    ...policy,
+    metadata: {
+        ...(policy.metadata ?? {}),
+        action,
+    },
+});
+export const createPredicateMarketPolicyAdapter = (options) => ({
+    deposit(token, chain, maxAmount) {
+        return withActionMetadata("deposit", createPolicy({
+            methods: ["eth_sendTransaction"],
+            chains: [chain],
+            tokens: [token],
+            maxAmount,
+        }, options));
+    },
+    withdraw(token, chain, maxAmount) {
+        return withActionMetadata("withdraw", createPolicy({
+            methods: ["eth_sendTransaction"],
+            chains: [chain],
+            tokens: [token],
+            maxAmount,
+        }, options));
+    },
+    trade(chain, capabilities = ["eth_sendTransaction"]) {
+        return withActionMetadata("trade", createPolicy({
+            methods: capabilities,
+            chains: [chain],
+        }, options));
+    },
+});

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+export interface CustodyAdapter {
+    getDepositStatus(depositId: string): Promise<{
+        status: string;
+        txHash?: string;
+    }>;
+    requestWithdraw(params: {
+        amount: string;
+        token: string;
+        chain: string;
+        targetAddress: string;
+    }): Promise<{
+        requestId: string;
+    }>;
+    getWithdrawStatus(requestId: string): Promise<{
+        status: string;
+        txHash?: string;
+        etaSeconds?: number;
+    }>;
+}
+export interface ModalController<TConfig> {
+    open(config?: TConfig): void;
+}
+export interface TokenInfo {
+    symbol: string;
+    name: string;
+    decimals: number;
+    iconUrl?: string;
+    minAmount?: string;
+    maxAmount?: string;
+}
+export interface ChainInfo {
+    id: string;
+    name: string;
+    iconUrl?: string;
+    confirmations?: number;
+    estimatedTime?: string;
+}
+export interface QuoteRequest {
+    token: string;
+    chain: string;
+    amount: string;
+    direction: "deposit" | "withdraw";
+}
+export interface QuoteResult {
+    quoteId: string;
+    estimatedAmount: string;
+    slippage: string;
+    fee: string;
+    feeToken: string;
+    exchangeRate: string;
+    expiresAt: number;
+}
+export interface DepositAddressResult {
+    address: string;
+    minimumDeposit?: string;
+}
+export interface MarketDataProvider {
+    getSupportedTokens(direction: "deposit" | "withdraw"): Promise<TokenInfo[]>;
+    getSupportedChains(token: string, direction: "deposit" | "withdraw"): Promise<ChainInfo[]>;
+    getQuote(request: QuoteRequest): Promise<QuoteResult>;
+    getDepositAddress(token: string, chain: string): Promise<DepositAddressResult>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/DepositModal.d.ts

@@ -0,0 +1,36 @@
+import { type ReactNode } from "react";
+import { type SelectOption } from "./components/DropdownField.js";
+export interface DepositModalProps {
+    /** Pre-selected token id. */
+    token?: string;
+    /** Pre-selected chain id. */
+    chain?: string;
+    /** Available tokens (when not provided, fetched from getChains). */
+    tokenOptions?: SelectOption[];
+    /** Available chains (when not provided, derived from getChains by token). */
+    chainOptions?: SelectOption[];
+    /** Deposit address，必须由调用方传入；在已选 token+chain 时若未传入合法值将抛错。 */
+    depositAddress?: string;
+    /** e.g. "0.01 USDT" */
+    minimumDeposit?: string;
+    /** Icon rendered at the center of the QR code. */
+    qrCenterIcon?: ReactNode;
+    /** Extra icons shown on the Transfer Crypto row. */
+    cryptoIcons?: ReactNode;
+    /** Deposit amount for quote (optional; when set, quote is fetched and shown). */
+    depositAmount?: string;
+    /** Called for toast messages (copy, quote expired, wait for balance, transfer confirmed). */
+    onShowToast?: (message: string) => void;
+    /** When set, show "Transfer confirmed" toast and explorer link. */
+    txHash?: string;
+    /** Build explorer URL for tx; e.g. (chainId, txHash) => `https://bscscan.com/tx/${txHash}` */
+    explorerTxUrl?: (chainId: string, txHash: string) => string;
+    onTokenSelect?: (id: string) => void;
+    onChainSelect?: (id: string) => void;
+    onCopyAddress?: () => void;
+    onBuyCrypto?: () => void;
+    onSignIn?: () => void;
+    onBack?: () => void;
+    onClose?: () => void;
+}
+export declare const DepositModal: ({ token, chain, tokenOptions: tokenOptionsProp, chainOptions: chainOptionsProp, depositAddress, minimumDeposit, qrCenterIcon, cryptoIcons, depositAmount, onShowToast, txHash, explorerTxUrl, onTokenSelect, onChainSelect, onCopyAddress, onBuyCrypto, onSignIn, onBack, onClose, }: DepositModalProps) => import("react/jsx-runtime.js").JSX.Element;