@ab-org/predicate-market-sdk 0.0.1 → 0.1.0

package/README.md

@@ -3,7 +3,7 @@
 Prediction-market specific helpers built on top of `@ab-org/sdk-core`.
 
 ## Key features
-- Built-in wallet connection modal (social + plugin wallets)
+- Built-in wallet connection modal (social via **OIDC relay** + `WalletAccount`, injected wallets via `WalletConnector` — **no FedCM** in `SignInModal` for Google/X)
 - Connection state via `createWalletConnectController()` and `createAccountController()` from `@ab-org/sdk-core`
 - Unified smart-wallet session metadata with capability policy support
 - High-level execution helpers via `createWalletExecutionController()`
@@ -29,10 +29,13 @@ import {
 import {
   createDepositController,
   createWithdrawController,
-  createMockMarketDataProvider,
+  createMarketDataProvider,
   createPredicateMarketPolicyAdapter,
+  type CustodyAdapter,
 } from "@ab-org/predicate-market-sdk";
 
+declare const custodyAdapter: CustodyAdapter;
+
 const connector = new WalletConnector([
   new MetaMaskProvider(),
   // new CubistSocialProvider(cubistClient)
@@ -43,7 +46,7 @@ const account = createAccountController();
 const execution = createWalletExecutionController();
 
 // Use the mock provider until real backend endpoints are ready
-const marketData = createMockMarketDataProvider();
+const marketData = createMarketDataProvider();
 
 const deposit = createDepositController(custodyAdapter, marketData);
 const withdraw = createWithdrawController(custodyAdapter, marketData);
@@ -62,13 +65,15 @@ const policy = createPredicateMarketPolicyAdapter({
 
 ## Configure SignInModal
 
-The SDK ships with **bundled auth config** (Google client id, Twitter client id, CubeSigner env/org) so you can call `initSDK` with only `signIn` (and optionally `twitterRedirectUri` for your origin). Override via env (`NEXT_PUBLIC_*`) or by passing options to `initSDK`.
+The SDK ships with **bundled auth config** (Google client id, Twitter client id, CubeSigner env/org) so you can call `initSDK` with only `signIn`. Override via env (`NEXT_PUBLIC_*`) or by passing options to `initSDK`.
+
+**Google / X in `SignInModal`** use the SDK's **bundled OIDC relay auth**: a **popup** opens your **`NEXT_PUBLIC_RELAY_ORIGIN`** routes **`/relay/google`** and **`/relay/x`**, then the SDK's built-in **WalletAccount** bridge turns the returned OIDC token into the session provider.
 
 ```tsx
 import { initSDK, SignInModal } from "@ab-org/predicate-market-sdk";
 
 initSDK({
-  // optional: override redirect for Twitter (origin-dependent)
+  // Optional: only used by other Twitter flows; SignInModal X login uses /relay/x on RELAY_ORIGIN
   twitterRedirectUri: typeof window !== "undefined" ? `${window.location.origin}/auth/twitter-callback` : undefined,
   signIn: {
     socialProviders: [
@@ -88,6 +93,17 @@ initSDK({
 ```
 
 Rules:
+- **`NEXT_PUBLIC_RELAY_ORIGIN`** (or `RELAY_ORIGIN`) must match where you serve **`/relay/google`** and **`/relay/x`**
+
+### Funding chain & funding token (withdraw / balance)
+
+- **`getChainInfo(chainId?)`** — resolves RPC, explorer metadata, native currency fields, and **`defaultFundingTokenAddress`** (per-chain default ERC-20 for the funding leg). If **`chainId`** is omitted or empty, defaults to **`3131`** (Tenderly BSC vnet). Built-in ids are **`3131`** and **`56`** (BSC mainnet); unknown ids throw.
+- **`getFundingTokenAddress(chainId?)`** — same optional **`chainId`** as **`getChainInfo`**. If **`NEXT_PUBLIC_FUNDING_TOKEN_ADDRESS`** / **`FUNDING_TOKEN_ADDRESS`** or legacy **`NEXT_PUBLIC_BSC_USD1_ADDRESS`** / **`BSC_USD1_ADDRESS`** is set (checksummed `0x` + 40 hex), that value overrides defaults for **all** chains; otherwise returns **`getChainInfo(chainId).defaultFundingTokenAddress`**.
+- **`DEFAULT_FUNDING_TOKEN_ADDRESS`** — shorthand for **`getChainInfo().defaultFundingTokenAddress`** (default funding chain **`3131`**).
+- **`fetchFundingTokenBalance(address, { chainId, rpcUrl?, tokenAddress?, decimals?, displaySymbol? })`** — uses **`getChainInfo(chainId)`** for RPC when **`rpcUrl`** is omitted, **`getFundingTokenAddress(chainId)`** when **`tokenAddress`** is omitted, and **`decimals`** default **`chain.nativeCurrencyDecimals`** when omitted (override if your funding token uses different decimals). 
+- **`createFundingWithdrawExecutor({ chainId?, rpcUrl?, tokenAddress?, … })`** — uses the same **`chainId`** for **`getChainInfo`**, default token address (**`getFundingTokenAddress(chainId)`**), and order payload (default **`3131`** when **`chainId`** omitted).
+
+**Type note:** **`EvmChainInfo`** includes **`defaultFundingTokenAddress`**. If you construct chain objects manually in TypeScript, add that field or use **`getChainInfo`** instead of literals.
 - `socialProviders: undefined` uses built-in defaults (`google`, `x`)
 - `socialProviders: []` hides all social buttons
 - known social ids like `google` and `x` automatically reuse built-in icons unless you override `icon`
@@ -96,6 +112,8 @@ Rules:
 - known wallet ids automatically reuse built-in metadata like `installUrl` and detected `installed` state unless you override them
 - component props still override `initSDK({ signIn })` on a per-modal basis
 
+The package still **exports** `signInWithGoogle` (Google Identity Services, optional FedCM) for **custom** integrations; the built-in **`SignInModal`** does **not** use it for Google.
+
 ## Address & balance
 ```tsx
 if (!account.isConnected) return <p>Please connect wallet</p>;
@@ -141,7 +159,7 @@ const quote  = await withdraw.fetchQuote("USDT", "ETH", "200");
 
 ### Implementing a real `MarketDataProvider`
 
-Replace `createMockMarketDataProvider()` with your own implementation:
+Replace `createMarketDataProvider()` with your own implementation:
 
 ```ts
 import type { MarketDataProvider } from "@ab-org/predicate-market-sdk";
@@ -243,4 +261,4 @@ These policies can be passed into your smart-wallet authorization flow so app ac
 >
   Withdraw
 </button>
-```
+```

package/dist/auth/oidcRelay.d.ts

@@ -0,0 +1,11 @@
+export type OidcRelayStage = "dev" | "prod";
+interface CreateOidcRelayAuthOptions {
+    stage: OidcRelayStage;
+    googleClientId: string;
+    xClientId: string;
+}
+export declare function createOidcRelayAuth({ stage, googleClientId, xClientId, }: CreateOidcRelayAuthOptions): {
+    loginByGoogle(): Promise<string>;
+    loginByX(): Promise<string>;
+};
+export {};

package/dist/auth/oidcRelay.js

@@ -0,0 +1,107 @@
+import { getEnv } from "../utils/env.js";
+function getRelayOrigin() {
+    if (typeof window === "undefined") {
+        throw new Error("OIDC relay requires a browser environment");
+    }
+    if (window.location.hostname === "localhost") {
+        return window.location.origin;
+    }
+    const relayOrigin = getEnv("RELAY_ORIGIN");
+    if (!relayOrigin) {
+        throw new Error("RELAY_ORIGIN is not configured");
+    }
+    return relayOrigin;
+}
+function openRelayWindow(url, name) {
+    const width = 420;
+    const height = 640;
+    const top = (window.innerHeight - height) / 2 + window.screenY;
+    const left = (window.innerWidth - width) / 2 + window.screenX;
+    return window.open(url, name, `dialog=yes,top=${top}px,left=${left}px,width=${width}px,height=${height}px`);
+}
+function waitForOidcToken(popup, relayOrigin, timeoutMs = 120000) {
+    return new Promise((resolve, reject) => {
+        if (!popup) {
+            reject(new Error("Failed to open login popup"));
+            return;
+        }
+        let settled = false;
+        const cleanup = () => {
+            clearTimeout(timeout);
+            clearInterval(closedCheck);
+            window.removeEventListener("message", onMessage);
+        };
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            fn();
+        };
+        const timeout = window.setTimeout(() => {
+            try {
+                popup.close();
+            }
+            catch {
+                // Ignore popup close errors on timeout.
+            }
+            finish(() => reject(new Error("Login timeout")));
+        }, timeoutMs);
+        const onMessage = (event) => {
+            if (event.origin !== relayOrigin)
+                return;
+            if (event.data?.action !== "login")
+                return;
+            const payload = (event.data?.data ?? {});
+            if (payload.error) {
+                try {
+                    popup.close();
+                }
+                catch {
+                    // Ignore popup close errors after relay failure.
+                }
+                finish(() => reject(new Error(String(payload.error))));
+                return;
+            }
+            if (payload.oidcToken) {
+                try {
+                    popup.close();
+                }
+                catch {
+                    // Ignore popup close errors after success.
+                }
+                finish(() => resolve(payload.oidcToken));
+            }
+        };
+        const closedCheck = window.setInterval(() => {
+            if (popup.closed) {
+                finish(() => reject(new Error("Login cancelled by user")));
+            }
+        }, 400);
+        window.addEventListener("message", onMessage);
+    });
+}
+export function createOidcRelayAuth({ stage, googleClientId, xClientId, }) {
+    const relayOrigin = getRelayOrigin();
+    const buildUrl = (provider, clientId) => {
+        const target = window.location.origin;
+        const params = new URLSearchParams({
+            target,
+            stage,
+            eventId: Date.now().toString(),
+            action: "login",
+            clientId,
+        });
+        return `${relayOrigin}/relay/${provider}?${params.toString()}`;
+    };
+    return {
+        async loginByGoogle() {
+            const popup = openRelayWindow(buildUrl("google", googleClientId), "Google login");
+            return waitForOidcToken(popup, relayOrigin);
+        },
+        async loginByX() {
+            const popup = openRelayWindow(buildUrl("x", xClientId), "X login");
+            return waitForOidcToken(popup, relayOrigin);
+        },
+    };
+}

package/dist/auth/walletAccount.d.ts

@@ -0,0 +1,20 @@
+import { type CubeSignerConfig, type CubeSignerSession, type WalletAuthSource, type WalletProvider, type WalletProviderRequest, type WalletSession } from "@ab-org/sdk-core";
+export declare class EmbeddedWalletAccountProvider implements WalletProvider {
+    private readonly provider;
+    constructor(provider: WalletProvider);
+    request<T = unknown>(payload: WalletProviderRequest): Promise<T>;
+    disconnect(): Promise<void>;
+    eth_accounts(): Promise<string[]>;
+    eth_chainId(): Promise<string>;
+}
+export default class WalletAccount {
+    private static instance;
+    private static instanceToken;
+    private static walletSession;
+    private static cubeSignerSession;
+    static clearInstance(): void;
+    static getWalletSession(): WalletSession | null;
+    static getCubeSignerSession(): CubeSignerSession | null;
+    static getInstance(oidcToken: string, authSource: WalletAuthSource, cubeSignerConfig: CubeSignerConfig): Promise<EmbeddedWalletAccountProvider>;
+}
+export declare function clearSocialAccountInstance(): void;

package/dist/auth/walletAccount.js

@@ -0,0 +1,267 @@
+import { EvmSigner } from "@cubist-labs/cubesigner-sdk";
+import { CubeSignerAuth, createChainContext, createSessionCapabilityPolicy, } from "@ab-org/sdk-core";
+const cubistCapabilities = [
+    "eth_accounts",
+    "eth_requestAccounts",
+    "eth_chainId",
+    "eth_signTransaction",
+    "personal_sign",
+    "eth_signTypedData_v4",
+    "wallet_disconnect",
+];
+const evmChainIdMap = {
+    ETH: 1,
+    BSC: 56,
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const toBigIntQuantity = (value) => {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value < 0) {
+            throw new Error(`Invalid EVM quantity number: ${value}`);
+        }
+        return BigInt(value);
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error("EVM quantity cannot be empty");
+    }
+    if (/^0x[0-9a-fA-F]+$/.test(trimmed) || /^\d+$/.test(trimmed)) {
+        return BigInt(trimmed);
+    }
+    throw new Error(`Invalid EVM quantity string: ${value}`);
+};
+const toHexQuantity = (value) => {
+    if (value === undefined)
+        return undefined;
+    return `0x${toBigIntQuantity(value).toString(16)}`;
+};
+const normalizeAccessList = (accessList) => {
+    if (!accessList)
+        return undefined;
+    return accessList.map((item) => ({
+        address: item.address,
+        storageKeys: item.storageKeys,
+    }));
+};
+const textEncoder = new TextEncoder();
+const resolveTransactionType = (transaction) => {
+    if (transaction.type !== undefined) {
+        const normalized = toHexQuantity(transaction.type);
+        if (normalized === "0x0" || normalized === "0x1" || normalized === "0x2") {
+            return normalized;
+        }
+        throw new Error(`Unsupported EVM transaction type for Cubist: ${normalized}`);
+    }
+    if (transaction.maxFeePerGas !== undefined || transaction.maxPriorityFeePerGas !== undefined) {
+        return "0x2";
+    }
+    if (transaction.accessList?.length) {
+        return "0x1";
+    }
+    return "0x0";
+};
+const toCubistSignRequest = (address, chain, transaction) => {
+    const resolvedChainId = (transaction.chainId !== undefined ? Number(toBigIntQuantity(transaction.chainId)) : undefined) ??
+        evmChainIdMap[chain];
+    if (!resolvedChainId) {
+        throw new Error("Cubist signing requires an EVM chainId");
+    }
+    const type = resolveTransactionType(transaction);
+    const commonFields = {
+        from: transaction.from ?? address,
+        to: transaction.to,
+        data: transaction.data,
+        gas: toHexQuantity(transaction.gas),
+        nonce: toHexQuantity(transaction.nonce),
+        value: toHexQuantity(transaction.value),
+    };
+    const accessList = normalizeAccessList(transaction.accessList);
+    const tx = type === "0x2"
+        ? {
+            ...commonFields,
+            type,
+            ...(accessList ? { accessList } : {}),
+            maxFeePerGas: toHexQuantity(transaction.maxFeePerGas),
+            maxPriorityFeePerGas: toHexQuantity(transaction.maxPriorityFeePerGas),
+        }
+        : type === "0x1"
+            ? {
+                ...commonFields,
+                type,
+                ...(accessList ? { accessList } : {}),
+                gasPrice: toHexQuantity(transaction.gasPrice),
+            }
+            : {
+                ...commonFields,
+                type,
+                gasPrice: toHexQuantity(transaction.gasPrice),
+            };
+    return {
+        chain_id: resolvedChainId,
+        tx,
+    };
+};
+const getTransactionParam = (params) => {
+    const candidate = params?.[0];
+    if (!isRecord(candidate)) {
+        throw new Error("eth_signTransaction requires a transaction object");
+    }
+    return candidate;
+};
+const toHexBytes = (value) => {
+    if (/^0x[0-9a-fA-F]*$/.test(value))
+        return value;
+    return `0x${Array.from(textEncoder.encode(value))
+        .map((byte) => byte.toString(16).padStart(2, "0"))
+        .join("")}`;
+};
+const getMessageParam = (address, params) => {
+    const [first, second] = params ?? [];
+    if (typeof second === "string" && second.toLowerCase() === address.toLowerCase()) {
+        return String(first ?? "");
+    }
+    if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
+        return String(second ?? "");
+    }
+    return String(first ?? "");
+};
+const getTypedDataParam = (address, params) => {
+    const [first, second] = params ?? [];
+    if (typeof first === "string" && first.toLowerCase() === address.toLowerCase()) {
+        return typeof second === "string"
+            ? JSON.parse(second)
+            : (second ?? {});
+    }
+    return typeof second === "string"
+        ? JSON.parse(second)
+        : (second ?? first ?? {});
+};
+function createEmbeddedProvider({ session, address, chain, }) {
+    const signer = new EvmSigner(address, session.client);
+    return {
+        async request(payload) {
+            switch (payload.method) {
+                case "eth_accounts":
+                case "eth_requestAccounts":
+                    return [address];
+                case "eth_chainId": {
+                    const chainId = evmChainIdMap[chain];
+                    if (!chainId) {
+                        throw new Error(`CubistProvider: chain ${chain} does not expose an EVM chainId`);
+                    }
+                    return `0x${chainId.toString(16)}`;
+                }
+                case "eth_signTransaction": {
+                    const transaction = getTransactionParam(payload.params);
+                    const signRequest = toCubistSignRequest(address, chain, transaction);
+                    return (await signer.signTransaction(signRequest));
+                }
+                case "personal_sign": {
+                    const message = getMessageParam(address, payload.params);
+                    return (await signer.signEip191({ data: toHexBytes(message) }));
+                }
+                case "eth_signTypedData_v4": {
+                    const typedData = getTypedDataParam(address, payload.params);
+                    const domain = typedData.domain;
+                    const chainId = domain?.chainId !== undefined
+                        ? Number(toBigIntQuantity(domain.chainId))
+                        : evmChainIdMap[chain];
+                    if (!chainId) {
+                        throw new Error("CubistProvider: typed data signing requires an EVM chainId");
+                    }
+                    return (await signer.signEip712({
+                        chain_id: chainId,
+                        typed_data: typedData,
+                    }));
+                }
+                default:
+                    throw new Error(`CubistProvider: unsupported RPC method "${payload.method}"`);
+            }
+        },
+        async disconnect() {
+            await session.client.revokeSession();
+        },
+    };
+}
+export class EmbeddedWalletAccountProvider {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    async request(payload) {
+        return this.provider.request(payload);
+    }
+    async disconnect() {
+        await this.provider.disconnect();
+    }
+    async eth_accounts() {
+        return this.request({ method: "eth_accounts" });
+    }
+    async eth_chainId() {
+        return this.request({ method: "eth_chainId" });
+    }
+}
+class WalletAccount {
+    static clearInstance() {
+        WalletAccount.instance = null;
+        WalletAccount.instanceToken = null;
+        WalletAccount.walletSession = null;
+        WalletAccount.cubeSignerSession = null;
+    }
+    static getWalletSession() {
+        return WalletAccount.walletSession;
+    }
+    static getCubeSignerSession() {
+        return WalletAccount.cubeSignerSession;
+    }
+    static async getInstance(oidcToken, authSource, cubeSignerConfig) {
+        if (WalletAccount.instance && WalletAccount.instanceToken === oidcToken) {
+            return WalletAccount.instance;
+        }
+        WalletAccount.clearInstance();
+        const auth = new CubeSignerAuth(cubeSignerConfig);
+        const cubeSignerSession = await auth.loginWithGoogle(oidcToken);
+        const keys = await cubeSignerSession.client.sessionKeys();
+        const evmKey = keys.find((key) => key.cached.key_type === "SecpEthAddr");
+        if (!evmKey) {
+            throw new Error("No EVM key found in CubeSigner session");
+        }
+        const address = evmKey.materialId;
+        const chain = "BSC";
+        const provider = createEmbeddedProvider({
+            session: cubeSignerSession,
+            address,
+            chain,
+        });
+        const wrappedProvider = new EmbeddedWalletAccountProvider(provider);
+        const capabilityPolicy = auth.defaultSessionPolicy
+            ? createSessionCapabilityPolicy(auth.defaultSessionPolicy)
+            : undefined;
+        WalletAccount.instance = wrappedProvider;
+        WalletAccount.instanceToken = oidcToken;
+        WalletAccount.cubeSignerSession = cubeSignerSession;
+        WalletAccount.walletSession = {
+            address,
+            chain,
+            provider: wrappedProvider,
+            walletType: "social",
+            authSource,
+            sessionId: `${authSource}:${address.toLowerCase()}`,
+            expiresAt: capabilityPolicy?.expiresAt,
+            capabilities: [...cubistCapabilities],
+            sessionData: cubeSignerSession.sessionData,
+            chainContext: createChainContext(chain),
+            capabilityPolicy,
+        };
+        return wrappedProvider;
+    }
+}
+WalletAccount.instance = null;
+WalletAccount.instanceToken = null;
+WalletAccount.walletSession = null;
+WalletAccount.cubeSignerSession = null;
+export default WalletAccount;
+export function clearSocialAccountInstance() {
+    WalletAccount.clearInstance();
+}

package/dist/constants/chains.d.ts

@@ -1,22 +1,2 @@
-export declare const testBsc: {
-    readonly chainId: "3131";
-    readonly name: "BSC_TENDERLY";
-    readonly chainName: "BSC_TENDERLY";
-    readonly nativeCurrencyName: "BSC";
-    readonly nativeCurrencySymbol: "BSC";
-    readonly nativeCurrencyDecimals: 18;
-    readonly rpcUrls: readonly ["https://virtual.binance.eu.rpc.tenderly.co/e643ea28-32eb-4fb9-8116-90be24f7defa"];
-    readonly blockExplorerUrl: "https://dashboard.tenderly.co/explorer/vnet/6593bc72-f548-497d-bff9-5be061436a48";
-    readonly platformType: "EVM";
-    readonly icon: "https://static.tomo.inc/token/bsc_new.svg";
-    readonly supportSwap: true;
-    readonly supportGift: true;
-    readonly supportHistory: true;
-};
-export declare const clientIds: {
-    readonly google: string;
-    readonly x: string;
-    readonly sdk: "MfLzAb2ItdDR3RZfE33ueqUhRf3mo1w0tBzLfExvLG72oUzvI6mgACtq19v6Vz7cmHVsfMBpbmr1fFU09sn30wbD";
-};
-export declare const BSC_USD1_ADDRESS = "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d";
-export declare const BSC_USD1_PLATFORM_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
+export { ClientIds, DEFAULT_FUNDING_CHAIN_ID, DEFAULT_FUNDING_TOKEN_ADDRESS, getFundingTokenAddress, getChainInfo, type EvmChainInfo, } from "@ab-org/wallet-utils";
+/** Demo / docs placeholder platform contract; replace in production. */

package/dist/constants/chains.js

@@ -1,23 +1,3 @@
-import { getEnv } from "../utils/env.js";
-export const testBsc = {
-    chainId: "3131",
-    name: "BSC_TENDERLY",
-    chainName: "BSC_TENDERLY",
-    nativeCurrencyName: "BSC",
-    nativeCurrencySymbol: "BSC",
-    nativeCurrencyDecimals: 18,
-    rpcUrls: ["https://virtual.binance.eu.rpc.tenderly.co/e643ea28-32eb-4fb9-8116-90be24f7defa"],
-    blockExplorerUrl: "https://dashboard.tenderly.co/explorer/vnet/6593bc72-f548-497d-bff9-5be061436a48",
-    platformType: "EVM",
-    icon: "https://static.tomo.inc/token/bsc_new.svg",
-    supportSwap: true,
-    supportGift: true,
-    supportHistory: true,
-};
-export const clientIds = {
-    google: getEnv("GOOGLE_CLIENT_ID"),
-    x: getEnv("X_CLIENT_ID"),
-    sdk: "MfLzAb2ItdDR3RZfE33ueqUhRf3mo1w0tBzLfExvLG72oUzvI6mgACtq19v6Vz7cmHVsfMBpbmr1fFU09sn30wbD",
-};
-export const BSC_USD1_ADDRESS = "0x8d0D000Ee44948FC98c9B98A4FA4921476f08B0d";
-export const BSC_USD1_PLATFORM_CONTRACT_ADDRESS = "0x1234567890123456789012345678901234567890";
+export { ClientIds, DEFAULT_FUNDING_CHAIN_ID, DEFAULT_FUNDING_TOKEN_ADDRESS, getFundingTokenAddress, getChainInfo, } from "@ab-org/wallet-utils";
+/** Demo / docs placeholder platform contract; replace in production. */
+// export const FUNDING_TOKEN_PLATFORM_CONTRACT_ADDRESS ="0x1234567890123456789012345678901234567890";

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export * from "./modules/withdraw.js";
 export * from "./modules/marketData.js";
 export * from "./modules/balanceQuery.js";
 export * from "./modules/withdrawExecutor.js";
+export * from "./modules/api.js";
+export * from "./modules/withdrawDirect.js";
 export * from "./policyAdapter.js";
 export * from "./ui/SignInModal.js";
 export * from "./ui/signInTypes.js";
@@ -17,3 +19,4 @@ export * from "./ui/WithdrawModal.js";
 export * from "./ui/components/DropdownField.js";
 export * from "./ui/components/DepositDetailsPanel.js";
 export * from "./walletUtils.js";
+export * from "./constants/chains.js";

package/dist/index.js

@@ -8,6 +8,8 @@ export * from "./modules/withdraw.js";
 export * from "./modules/marketData.js";
 export * from "./modules/balanceQuery.js";
 export * from "./modules/withdrawExecutor.js";
+export * from "./modules/api.js";
+export * from "./modules/withdrawDirect.js";
 export * from "./policyAdapter.js";
 export * from "./ui/SignInModal.js";
 export * from "./ui/signInTypes.js";
@@ -17,3 +19,5 @@ export * from "./ui/WithdrawModal.js";
 export * from "./ui/components/DropdownField.js";
 export * from "./ui/components/DepositDetailsPanel.js";
 export * from "./walletUtils.js";
+// Re-export funding chain helpers so apps can import from package root
+export * from "./constants/chains.js";

package/dist/modules/api.d.ts

@@ -1,5 +1,5 @@
 /**
- * Merchant API client (BaseUrl: https://merchant.tomo.services)
+ * Merchant API client
  * 基于 axios 封装，类型与文档一致。
  */
 import { type AxiosInstance } from "axios";
@@ -14,6 +14,10 @@ export interface TokenData {
     symbol: string;
     address: string;
     decimals: number;
+    /** 最小充值量（最小单位字符串，如 `"15000000"`） */
+    minimum_deposit?: string;
+    /** 是否为 USD 类稳定币 */
+    is_usd_stable?: boolean;
 }
 export interface ChainData {
     chain_id: string;
@@ -33,12 +37,12 @@ export interface PlatformRegisterResponseData {
     chain_id: string;
 }
 export type QuoteDirection = "deposit" | "withdraw";
-export interface QuoteRequest {
+interface QuoteRequest {
     direction: QuoteDirection;
     chain_id: string;
     token_address: string;
     token_amount?: string;
-    usd1_amount?: string;
+    dst_token_amount?: string;
 }
 export interface QuoteResponseData {
     token_address: string;
@@ -47,7 +51,7 @@ export interface QuoteResponseData {
     rate: string;
     chain_id: number;
     deposit_address?: string;
-    usd1_amount?: string;
+    dst_token_amount?: string;
     token_amount?: string;
     expires_at?: string;
 }
@@ -58,7 +62,7 @@ export interface DepositOrderResponseData {
     source_chain_id: string;
     token_address: string;
     token_amount?: string;
-    usd1_amount?: string;
+    dst_token_amount?: string;
     deposit_address?: string;
     source_tx_hash?: string;
     created_at?: string;
@@ -70,7 +74,7 @@ export interface WithdrawOrderResponseData {
     status: WithdrawOrderStatus;
     one_time_address?: string;
     chain_id: string;
-    usd1_amount: string;
+    dst_token_amount: string;
     /** Fee (e.g. "0.01 USD1"); only present if backend includes it in GET /api/v1/orders/withdraw/:id. UI falls back to feeDisplay prop or "—". */
     fee?: string;
     target_chain_id: string;
@@ -123,7 +127,7 @@ export interface CreateOrderResponseData {
     payment_sessions: PaymentSessionResponseData[];
 }
 /**
- * 配置 Merchant API 的 baseURL（可选，默认 https://merchant.tomo.services）
+ * 配置 Merchant API 的 baseURL
  */
 export declare function configureMerchantApi(): void;
 /**
@@ -142,3 +146,4 @@ export declare function getDepositOrder(orderId: string): Promise<DepositOrderRe
 export declare function getWithdrawOrder(orderId: string): Promise<WithdrawOrderResponseData>;
 /** POST /order - 创建 NATIVE_SWAP 提现订单 */
 export declare function createOrder(body: CreateOrderRequest): Promise<CreateOrderResponseData>;
+export {};