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

package/dist/chunk-IUBVUCWJ.js

@@ -0,0 +1,419 @@
+import { getChainInfo, getFundingTokenAddress, DEFAULT_FUNDING_CHAIN_ID } from './chunk-F2UPP3YC.js';
+import { getChains, createOrder } from './chunk-TPMI3XWV.js';
+import { getEnv } from './chunk-SHLNBZBY.js';
+import { sessionStore, createSessionCapabilityPolicy } from '@ab-org/sdk-core';
+import { 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
+  };
+}
+
+// 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;
+  });
+}
+
+// src/modules/withdrawExecutor.ts
+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 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 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 chainsRes = await getChains();
+    const chains = chainsRes?.chains ?? [];
+    if (isUsdtWithdrawDirect(request.chain, request.tokenAddress, chains)) {
+      return {
+        txRequest: {
+          toAddress: request.toAddress,
+          amount: request.amount,
+          token: request.token,
+          tokenAddress: request.tokenAddress,
+          tokenDecimals: chains.find((c) => c.chain_id === request.chain)?.tokens.find((t) => t.address.toLowerCase() === request.tokenAddress.toLowerCase())?.decimals ?? decimals,
+          chain: request.chain
+        },
+        fundingChainId: request.chain,
+        withdrawMode: "direct"
+      };
+    }
+    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");
+    }
+    const session = sessionStore.getState().session;
+    if (!session) throw new Error("Login required");
+    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");
+    }
+    return {
+      txRequest: {
+        toAddress: oneTimeAddress,
+        amount: request.amount,
+        token: fundingLegTokenSymbol,
+        tokenAddress,
+        tokenDecimals: decimals,
+        chain: fundingChain.chainId
+      },
+      orderId: orderRes.order_id,
+      fundingChainId: fundingChain.chainId,
+      withdrawMode: "cross_chain"
+    };
+  };
+}
+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-JFRRJXOJ.js

@@ -0,0 +1,149 @@
+import { getOptionalEnv, setMerchantBaseUrl } from './chunk-SHLNBZBY.js';
+import { getSDKConfig, initSDK } from './chunk-WHTI52FI.js';
+import axios from 'axios';
+
+// src/auth/bundledConfig.ts
+function getBundledAuthConfig() {
+  const relayOrigin = getOptionalEnv("RELAY_ORIGIN");
+  const cubeEnv = getOptionalEnv("CUBE_SIGNER_ENV");
+  const cubeOrgId = getOptionalEnv("CUBE_SIGNER_ORG_ID");
+  return {
+    googleClientId: getOptionalEnv("GOOGLE_CLIENT_ID"),
+    twitterClientId: getOptionalEnv("X_CLIENT_ID"),
+    twitterRedirectUri: relayOrigin ? `${relayOrigin}/auth/twitter-callback` : void 0,
+    cubeSigner: cubeEnv && cubeOrgId ? {
+      env: cubeEnv,
+      orgId: cubeOrgId
+    } : void 0
+  };
+}
+function resolveSignerApiRoot(env) {
+  if (!env) return "https://gamma.signer.cubist.dev";
+  if (/^https?:\/\//.test(env)) return env.replace(/\/$/, "");
+  if (env === "gamma" || env === "dev") return "https://gamma.signer.cubist.dev";
+  if (env === "prod") return "https://prod.signer.cubist.dev";
+  return "https://gamma.signer.cubist.dev";
+}
+async function sha256Hex(input) {
+  const g = globalThis;
+  try {
+    if (g.crypto?.subtle) {
+      const enc = new TextEncoder();
+      const buf = await g.crypto.subtle.digest("SHA-256", enc.encode(input));
+      const bytes = new Uint8Array(buf);
+      return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+  } catch {
+  }
+  try {
+    const { createHash } = await import('crypto');
+    return createHash("sha256").update(input).digest("hex");
+  } catch {
+    throw new Error("SHA-256 not available in this runtime");
+  }
+}
+function pickStageSalt() {
+  const stage = getOptionalEnv("STAGE") ?? "dev";
+  if (stage === "prod" || stage === "pre") return "xnPWRJT5XG2WyevuydMjMpZq";
+  return "dev@tomo";
+}
+async function defaultRegisterUser(oidcToken) {
+  const env = getOptionalEnv("CUBE_SIGNER_ENV") ?? "gamma";
+  const orgId = getOptionalEnv("CUBE_SIGNER_ORG_ID") ?? "";
+  const registerApi = getOptionalEnv("CUBE_REG") ?? "";
+  if (!orgId) throw new Error("CUBE_SIGNER_ORG_ID is not set");
+  if (!registerApi) throw new Error("CUBE_REG is not set");
+  const root = resolveSignerApiRoot(env);
+  const proveUrl = `${root}/v0/org/${encodeURIComponent(orgId)}/identity/prove/oidc`;
+  const proveRes = await axios.post(proveUrl, void 0, {
+    headers: { Authorization: oidcToken },
+    timeout: 2e4
+  });
+  const proof = proveRes.data ?? {};
+  const identity_proof = {
+    id: proof?.user_info?.user_id,
+    aud: proof?.aud,
+    email: proof?.email,
+    username: proof?.preferred_username,
+    identity: { iss: proof?.identity?.iss, sub: proof?.identity?.sub },
+    exp_epoch: proof?.exp_epoch
+  };
+  const timestamp = Date.now().toString();
+  const sigPayload = JSON.stringify({ iss: identity_proof.identity.iss, sub: identity_proof.identity.sub, timestamp });
+  const signature = await sha256Hex(sigPayload + pickStageSalt());
+  const regRes = await axios.post(
+    registerApi,
+    { identity_proof, timestamp, signature },
+    { headers: { "Content-Type": "application/json" }, timeout: 2e4 }
+  );
+  const body = regRes.data ?? {};
+  if (typeof body.code !== "undefined" && body.code !== 0) {
+    throw new Error(`User register failed: ${body?.message || body?.error || body.code}`);
+  }
+}
+
+// src/auth/config.ts
+function getFixedAuthConfig() {
+  const bundled = getBundledAuthConfig();
+  const envGoogle = getOptionalEnv("GOOGLE_CLIENT_ID");
+  const envTwitter = getOptionalEnv("X_CLIENT_ID");
+  const relayOrigin = getOptionalEnv("RELAY_ORIGIN");
+  const envRedirect = relayOrigin ? `${relayOrigin}/auth/twitter-callback` : void 0;
+  const cubeEnv = getOptionalEnv("CUBE_SIGNER_ENV");
+  const cubeOrgId = getOptionalEnv("CUBE_SIGNER_ORG_ID");
+  const cubeSignerFromEnv = cubeEnv && cubeOrgId ? { env: cubeEnv, orgId: cubeOrgId } : void 0;
+  return {
+    googleClientId: envGoogle || bundled.googleClientId,
+    twitterClientId: envTwitter || bundled.twitterClientId,
+    twitterRedirectUri: envRedirect || bundled.twitterRedirectUri,
+    cubeSigner: cubeSignerFromEnv ?? bundled.cubeSigner
+  };
+}
+function scheduleAutoReconnect() {
+  if (typeof window === "undefined") return;
+  void import('./autoReconnect-IFPVI2XU.js').then(({ tryAutoReconnect }) => tryAutoReconnect()).catch(() => {
+  });
+}
+function initSDK2(config = {}) {
+  const { merchantBaseUrl, registerUser, ...rest } = config;
+  const fixed = getFixedAuthConfig();
+  const prev = getSDKConfig();
+  const merged = {
+    ...prev,
+    ...fixed,
+    ...rest,
+    cubeSigner: rest.cubeSigner ?? fixed.cubeSigner ?? prev.cubeSigner
+  };
+  if (registerUser != null && merged.cubeSigner) {
+    merged.cubeSigner = {
+      ...merged.cubeSigner,
+      oidcLoginHooks: {
+        ...merged.cubeSigner.oidcLoginHooks,
+        registerUser
+      }
+    };
+  }
+  if (registerUser == null && merged.cubeSigner) {
+    const hasCubeReg = Boolean(getOptionalEnv("CUBE_REG"));
+    const alreadyHas = Boolean(merged.cubeSigner.oidcLoginHooks?.registerUser);
+    if (hasCubeReg && alreadyHas == false) {
+      merged.cubeSigner = {
+        ...merged.cubeSigner,
+        oidcLoginHooks: {
+          ...merged.cubeSigner.oidcLoginHooks,
+          registerUser: defaultRegisterUser
+        }
+      };
+    }
+  }
+  if (merchantBaseUrl) {
+    setMerchantBaseUrl(merchantBaseUrl);
+  }
+  initSDK(merged);
+  scheduleAutoReconnect();
+}
+function getSDKConfig2() {
+  return getSDKConfig();
+}
+
+export { getFixedAuthConfig, getSDKConfig2 as getSDKConfig, initSDK2 as initSDK };

package/dist/chunk-LOJTP47I.js

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

package/dist/chunk-SHLNBZBY.js

@@ -0,0 +1,72 @@
+// src/utils/env.ts
+function pick(...candidates) {
+  for (const candidate of candidates) {
+    if (candidate != null && candidate !== "") return candidate;
+  }
+  return void 0;
+}
+function nextPublicProcessEnvKey(logicalKey) {
+  return `NEXT_PUBLIC_${logicalKey}`;
+}
+function readProcessEnvStatic(key) {
+  if (typeof process === "undefined" || !process.env) return void 0;
+  switch (key) {
+    case "STAGE":
+      return pick(process.env.NEXT_PUBLIC_STAGE, process.env.STAGE);
+    case "GOOGLE_CLIENT_ID":
+      return pick(process.env.NEXT_PUBLIC_GOOGLE_CLIENT_ID, process.env.GOOGLE_CLIENT_ID);
+    case "X_CLIENT_ID":
+      return pick(process.env.NEXT_PUBLIC_X_CLIENT_ID, process.env.X_CLIENT_ID);
+    case "MERCHANT_BASE_URL":
+      return pick(process.env.NEXT_PUBLIC_MERCHANT_BASE_URL, process.env.MERCHANT_BASE_URL);
+    case "CUBE_SIGNER_ENV":
+      return pick(process.env.NEXT_PUBLIC_CUBE_SIGNER_ENV, process.env.CUBE_SIGNER_ENV);
+    case "CUBE_SIGNER_ORG_ID":
+      return pick(process.env.NEXT_PUBLIC_CUBE_SIGNER_ORG_ID, process.env.CUBE_SIGNER_ORG_ID);
+    case "CUBE_REG":
+      return pick(process.env.NEXT_PUBLIC_CUBE_REG, process.env.CUBE_REG);
+    case "RELAY_ORIGIN":
+      return pick(process.env.NEXT_PUBLIC_RELAY_ORIGIN, process.env.RELAY_ORIGIN);
+    case "FUNDING_TOKEN_SYMBOL":
+      return pick(process.env.NEXT_PUBLIC_FUNDING_TOKEN_SYMBOL, process.env.FUNDING_TOKEN_SYMBOL) || "USDT";
+    default:
+      return void 0;
+  }
+}
+function readEnv(key) {
+  const staticVal = readProcessEnvStatic(key);
+  if (staticVal != null && staticVal !== "") return staticVal;
+  const globalEnv = globalThis.process?.env;
+  if (globalEnv) {
+    const pub = nextPublicProcessEnvKey(key);
+    const val = globalEnv[key] ?? globalEnv[pub];
+    if (val != null && val !== "") return val;
+  }
+  try {
+    const metaEnv = import.meta.env;
+    if (metaEnv) {
+      const pub = nextPublicProcessEnvKey(key);
+      const val = metaEnv[key] ?? metaEnv[pub];
+      if (val != null && val !== "") return val;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getOptionalEnv(key) {
+  return readEnv(key);
+}
+function getEnv(key) {
+  return readEnv(key) ?? "";
+}
+
+// src/modules/apiConfig.ts
+var configuredMerchantBaseUrl;
+function setMerchantBaseUrl(baseUrl) {
+  configuredMerchantBaseUrl = baseUrl && baseUrl.trim() !== "" ? baseUrl : void 0;
+}
+function getMerchantBaseUrl() {
+  return configuredMerchantBaseUrl ?? getOptionalEnv("MERCHANT_BASE_URL");
+}
+
+export { getEnv, getMerchantBaseUrl, getOptionalEnv, setMerchantBaseUrl };