@ab-org/predicate-market-sdk 2.0.0 → 2.0.1-beta.0

package/dist/chunk-66CHMJG7.js

@@ -0,0 +1,527 @@
+import { getChainInfo, getFundingTokenAddress, DEFAULT_FUNDING_CHAIN_ID } from './chunk-F2UPP3YC.js';
+import { getChains, createOrder } from './chunk-TPMI3XWV.js';
+import { tryAutoReconnect } from './chunk-26RFAFJG.js';
+import { getEnv } from './chunk-SHLNBZBY.js';
+import { sessionStore, createSessionCapabilityPolicy } from '@ab-org/sdk-core';
+import { toHex, fromHex, parseGwei, formatUnits } from 'viem';
+
+function requireSession() {
+  const session = sessionStore.getState().session;
+  if (!session) throw new Error("Login required");
+  return session;
+}
+var createDepositController = (custody, marketData) => {
+  let status = { phase: "idle" };
+  const notify = (next, cb) => {
+    status = next;
+    cb?.(status);
+  };
+  const open = async (config) => {
+    const session = requireSession();
+    const chain = config?.preferredChain ?? session.chainContext?.settlementChain ?? session.chain ?? "AB_CORE";
+    const token = config?.preferredToken || getEnv("FUNDING_TOKEN_SYMBOL") || "USDT";
+    try {
+      const { address } = await marketData.getDepositAddress(token, chain);
+      const depositId = `${chain}:${token}:${Date.now()}`;
+      notify({ phase: "address-issued", depositId, address }, config?.onStatusChange);
+      notify({ phase: "confirming", depositId }, config?.onStatusChange);
+      const { status: finalStatus, txHash } = await custody.getDepositStatus(depositId);
+      notify(
+        finalStatus === "SETTLED" ? { phase: "settled", depositId, txHash } : { phase: "failed", reason: finalStatus },
+        config?.onStatusChange
+      );
+    } catch (error) {
+      notify({ phase: "failed", reason: error.message }, config?.onStatusChange);
+    }
+  };
+  return {
+    get status() {
+      return status;
+    },
+    open,
+    fetchTokens() {
+      requireSession();
+      return marketData.getSupportedTokens("deposit");
+    },
+    fetchChains(token) {
+      requireSession();
+      return marketData.getSupportedChains(token, "deposit");
+    },
+    fetchQuote(token, chain, amount) {
+      requireSession();
+      return marketData.getQuote({ token, chain, amount, direction: "deposit" });
+    },
+    fetchDepositAddress(token, chain) {
+      requireSession();
+      return marketData.getDepositAddress(token, chain);
+    }
+  };
+};
+function requireSession2() {
+  const session = sessionStore.getState().session;
+  if (!session) throw new Error("Login required");
+  return session;
+}
+var createWithdrawController = (custody, marketData) => {
+  let status = { phase: "idle" };
+  const update = (next, cb) => {
+    status = next;
+    cb?.(status);
+  };
+  const open = async (config) => {
+    const session = requireSession2();
+    const token = config?.defaultToken || getEnv("FUNDING_TOKEN_SYMBOL") || "USDT";
+    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() {
+      requireSession2();
+      return marketData.getSupportedTokens("withdraw");
+    },
+    fetchChains(token) {
+      requireSession2();
+      return marketData.getSupportedChains(token, "withdraw");
+    },
+    fetchQuote(token, chain, amount) {
+      requireSession2();
+      return marketData.getQuote({ token, chain, amount, direction: "withdraw" });
+    }
+  };
+};
+var cachedChains = null;
+async function fetchChainsFromApi() {
+  if (cachedChains) return cachedChains;
+  try {
+    const { chains } = await getChains();
+    if (chains.length > 0) {
+      cachedChains = chains;
+      return chains;
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+function chainToChainInfo(chain) {
+  return {
+    id: chain.chain_id,
+    name: chain.network
+  };
+}
+function findTokenInChains(chains, chainId, tokenSymbol) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  return chain?.tokens.find((t) => t.symbol === tokenSymbol);
+}
+function formatMinimumDepositDisplay(token, tokenSymbol) {
+  const raw = token.minimum_deposit?.trim();
+  if (raw == null || raw === "") return void 0;
+  try {
+    return `${formatUnits(BigInt(raw), token.decimals)} ${tokenSymbol}`;
+  } catch {
+    return `${raw} ${tokenSymbol}`;
+  }
+}
+function deriveTokensFromChains(chains) {
+  const bySymbol = /* @__PURE__ */ 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 computeDefaultQuote(request) {
+  const isStable = ["USDT", "USDC", "USD1"].includes(request.token);
+  const slippage = isStable ? "0.3" : "1.0";
+  const feeRate = request.direction === "withdraw" ? 1e-3 : 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() + 3e4
+  };
+}
+function createMarketDataProvider() {
+  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 computeDefaultQuote(request);
+    },
+    async getDepositAddress(token, chain) {
+      const session = sessionStore.getState().session;
+      const chains = await fetchChainsFromApi();
+      const meta = findTokenInChains(chains, chain, token);
+      const minimumDeposit = meta != null ? formatMinimumDepositDisplay(meta, token) : void 0;
+      return {
+        address: session?.address ?? "",
+        minimumDeposit
+      };
+    }
+  };
+}
+
+// src/modules/balanceQuery.ts
+var ERC20_BALANCE_OF_SELECTOR = "0x70a08231";
+function padAddress(address) {
+  return address.toLowerCase().replace("0x", "").padStart(64, "0");
+}
+function formatUnits2(value, decimals) {
+  const divisor = 10n ** BigInt(decimals);
+  const intPart = value / divisor;
+  const fracPart = value % divisor;
+  if (fracPart === 0n) return intPart.toString();
+  const fracStr = fracPart.toString().padStart(decimals, "0").replace(/0+$/, "");
+  return `${intPart}.${fracStr}`;
+}
+function formatBalanceDisplay(value, decimals) {
+  const full = formatUnits2(value, decimals);
+  const n = Number(full);
+  return Number.isNaN(n) ? full : n.toFixed(2);
+}
+async function fetchErc20Balance(rpcUrl, tokenAddress, walletAddress) {
+  const data = `${ERC20_BALANCE_OF_SELECTOR}${padAddress(walletAddress)}`;
+  const response = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "eth_call",
+      params: [{ to: tokenAddress, data }, "latest"]
+    })
+  });
+  const json = await response.json();
+  if (json.error) throw new Error(json.error.message ?? "RPC error");
+  return BigInt(json.result ?? "0x0");
+}
+async function fetchFundingTokenBalance(walletAddress, options) {
+  const chain = getChainInfo(options?.chainId);
+  const rpcUrl = options?.rpcUrl ?? chain.rpcUrls[0];
+  const tokenAddress = options?.tokenAddress ?? getFundingTokenAddress(options?.chainId);
+  const decimals = options?.decimals ?? chain.nativeCurrencyDecimals;
+  const FUNDING_TOKEN_SYMBOL = getEnv("FUNDING_TOKEN_SYMBOL");
+  const displaySymbol = options?.displaySymbol ?? (FUNDING_TOKEN_SYMBOL || "Funding");
+  const raw = await fetchErc20Balance(rpcUrl, tokenAddress, walletAddress);
+  return {
+    raw,
+    formatted: formatBalanceDisplay(raw, decimals),
+    symbol: displaySymbol
+  };
+}
+var MAX_WITHDRAW_GAS_LIMIT = 500000n;
+var ERC20_TRANSFER_SELECTOR = "0xa9059cbb";
+function padHex256(value) {
+  return value.toString(16).padStart(64, "0");
+}
+function padAddress2(address) {
+  return address.toLowerCase().replace("0x", "").padStart(64, "0");
+}
+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}${padAddress2(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 ensureFundingEvmChain(provider, chainId) {
+  const hex = `0x${chainId.toString(16)}`;
+  try {
+    await provider.request({ method: "wallet_switchEthereumChain", params: [{ chainId: hex }] });
+  } catch {
+  }
+}
+function getDstTokenAddress(chains, chainId, tokenSymbol) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  return chain?.tokens.find((t) => t.symbol === tokenSymbol)?.address;
+}
+function createFundingWithdrawExecutor(options) {
+  const fundingChain = getChainInfo(options?.chainId);
+  const chainIdNum = Number(fundingChain.chainId);
+  const rpcUrl = options?.rpcUrl ?? fundingChain.rpcUrls[0];
+  const tokenAddress = options?.tokenAddress ?? getFundingTokenAddress(options?.chainId);
+  const decimals = options?.decimals ?? fundingChain.nativeCurrencyDecimals;
+  const maxAmountWei = options?.maxAmountWei;
+  const fundingLegTokenSymbol = options?.fundingLegTokenSymbol || getEnv("FUNDING_TOKEN_SYMBOL") || "USDT";
+  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}`);
+    }
+    const sourceTokenSymbol = fundingLegTokenSymbol;
+    const orderRes = await createOrder({
+      intent_id: `withdraw-${Date.now()}`,
+      order_type: "NATIVE_SWAP",
+      order_payload: {
+        chain_id: fundingChain.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: fundingChain.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 ensureFundingEvmChain(provider, chainIdNum);
+    const data = encodeTransferData(oneTimeAddress, amountWei);
+    const nonce = await requestHexQuantity(
+      provider,
+      rpcUrl,
+      "eth_getTransactionCount",
+      [session.address, "latest"]
+    );
+    const tx = {
+      from: session.address,
+      to: tokenAddress,
+      value: "0x0",
+      nonce,
+      data,
+      chainId: toHex(chainIdNum)
+    };
+    const estimatedGasHex = await requestHexQuantity(
+      provider,
+      rpcUrl,
+      "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(rpcUrl, "eth_sendRawTransaction", [signedTx]);
+    }
+    return { txHash, orderId: orderRes.order_id, fundingChainId: fundingChain.chainId };
+  };
+}
+
+// src/modules/withdrawDirect.ts
+function isUsdtWithdrawDirect(chainId, tokenAddress, chains) {
+  if (chainId !== String(DEFAULT_FUNDING_CHAIN_ID)) return false;
+  const addr = tokenAddress.trim();
+  if (!addr) return false;
+  const chain = chains.find((c) => c.chain_id === chainId);
+  const token = chain?.tokens.find((t) => t.address.toLowerCase() === addr.toLowerCase());
+  return token?.is_usd_stable === true;
+}
+function findTokenDataFromChains(chains, chainId, opts) {
+  const chain = chains.find((c) => c.chain_id === chainId);
+  if (!chain?.tokens.length) return void 0;
+  const sym = opts.symbol.trim();
+  const addr = opts.tokenAddress?.trim().toLowerCase();
+  return chain.tokens.find((t) => {
+    if (addr && t.address.toLowerCase() === addr) return true;
+    if (sym.length > 0 && t.symbol === sym) return true;
+    return false;
+  });
+}
+var createPolicy = (overrides, options) => createSessionCapabilityPolicy({
+  appId: options?.appId,
+  origin: options?.origin,
+  expiresAt: options?.expiresAt,
+  ...overrides
+});
+var withActionMetadata = (action, policy) => ({
+  ...policy,
+  metadata: {
+    ...policy.metadata ?? {},
+    action
+  }
+});
+var 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
+      )
+    );
+  }
+});
+
+export { createDepositController, createFundingWithdrawExecutor, createMarketDataProvider, createPredicateMarketPolicyAdapter, createWithdrawController, fetchErc20Balance, fetchFundingTokenBalance, findTokenDataFromChains, isUsdtWithdrawDirect, parseUnits };

package/dist/chunk-6YQEHB6P.js

@@ -0,0 +1,14 @@
+import { getEnv, getChainInfo } from './chunk-YX56ZGDB.js';
+
+// ../sign_in_sdk/src/config.ts
+var stage = getEnv("STAGE") || "dev";
+var clientIds = {
+  google: getEnv("GOOGLE_CLIENT_ID"),
+  x: getEnv("X_CLIENT_ID")
+};
+var chainConfig = {
+  chainType: "evm",
+  chainId: getChainInfo().chainId
+};
+
+export { chainConfig, clientIds, stage };

package/dist/chunk-C5BV2OG7.js

@@ -0,0 +1,6 @@
+// src/core.ts
+function tryAutoReconnect() {
+  return import('./autoReconnect-6YV7YSSL.js').then(({ tryAutoReconnect: reconnect }) => reconnect());
+}
+
+export { tryAutoReconnect };

package/dist/chunk-F2UPP3YC.js

@@ -0,0 +1,88 @@
+import { getEnv } from './chunk-SHLNBZBY.js';
+
+// src/constants/chains.ts
+var TENDERLY_BSC_3131 = {
+  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",
+  defaultFundingTokenAddress: "0x55d398326f99059fF775485246999027B3197955"
+};
+var BSC_MAINNET_56 = {
+  chainId: "56",
+  name: "BSC",
+  chainName: "BNB Smart Chain",
+  nativeCurrencyName: "BNB",
+  nativeCurrencySymbol: "BNB",
+  nativeCurrencyDecimals: 18,
+  rpcUrls: ["https://bsc-dataseed.binance.org", "https://bsc-dataseed1.defibit.io"],
+  blockExplorerUrl: "https://bscscan.com",
+  platformType: "EVM",
+  icon: "https://static.tomo.inc/token/bsc_new.svg",
+  defaultFundingTokenAddress: "0x55d398326f99059fF775485246999027B3197955"
+};
+var CHAIN_REGISTRY = {
+  [TENDERLY_BSC_3131.chainId]: TENDERLY_BSC_3131,
+  [BSC_MAINNET_56.chainId]: BSC_MAINNET_56
+};
+var DEFAULT_FUNDING_CHAIN_ID = getEnv("FUNDING_CHAIN_ID") || "3131";
+function normalizeFundingChainId(chainId) {
+  if (chainId === void 0 || chainId === null) return DEFAULT_FUNDING_CHAIN_ID;
+  const normalized = String(chainId).trim();
+  return normalized === "" ? DEFAULT_FUNDING_CHAIN_ID : normalized;
+}
+function getChainInfo(chainId) {
+  const id = normalizeFundingChainId(chainId);
+  const info = CHAIN_REGISTRY[id];
+  if (!info) {
+    throw new Error(
+      `Unsupported funding chainId "${id}". Supported: ${Object.keys(CHAIN_REGISTRY).sort().join(", ")}`
+    );
+  }
+  return info;
+}
+function pickEnvFundingTokenAddress() {
+  const candidates = [["NEXT_PUBLIC_FUNDING_TOKEN_ADDRESS", "FUNDING_TOKEN_ADDRESS"]];
+  const processEnv = globalThis.process?.env;
+  if (processEnv) {
+    for (const [pub, priv] of candidates) {
+      const publicValue = processEnv[pub];
+      const privateValue = processEnv[priv];
+      if (publicValue != null && publicValue !== "") return publicValue;
+      if (privateValue != null && privateValue !== "") return privateValue;
+    }
+  }
+  try {
+    const metaEnv = import.meta.env;
+    if (metaEnv) {
+      for (const [pub, priv] of candidates) {
+        const publicValue = metaEnv[pub];
+        const privateValue = metaEnv[priv];
+        if (publicValue != null && publicValue !== "") return publicValue;
+        if (privateValue != null && privateValue !== "") return privateValue;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getFundingTokenAddress(chainId) {
+  const fromEnv = pickEnvFundingTokenAddress();
+  if (fromEnv && /^0x[0-9a-fA-F]{40}$/.test(fromEnv)) return fromEnv;
+  return getChainInfo(chainId).defaultFundingTokenAddress;
+}
+var DEFAULT_FUNDING_TOKEN_ADDRESS = getFundingTokenAddress(DEFAULT_FUNDING_CHAIN_ID);
+var ClientIds = {
+  google: getEnv("GOOGLE_CLIENT_ID"),
+  x: getEnv("X_CLIENT_ID")
+};
+
+export { ClientIds, DEFAULT_FUNDING_CHAIN_ID, DEFAULT_FUNDING_TOKEN_ADDRESS, getChainInfo, getFundingTokenAddress };