@stableops/wallet-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,655 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EvmWalletChainConfigs: () => EvmWalletChainConfigs,
+  StableOpsWalletError: () => StableOpsWalletError,
+  encodeErc20Transfer: () => encodeErc20Transfer,
+  getInjectedEthereumProvider: () => getInjectedEthereumProvider,
+  getInjectedSolanaProvider: () => getInjectedSolanaProvider,
+  getInjectedTronProvider: () => getInjectedTronProvider,
+  getInjectedWalletProviders: () => getInjectedWalletProviders,
+  parseTokenAmount: () => parseTokenAmount,
+  selectWalletPaymentInstruction: () => selectWalletPaymentInstruction,
+  sendOrderWalletPayment: () => sendOrderWalletPayment,
+  sendWalletPayment: () => sendWalletPayment
+});
+module.exports = __toCommonJS(index_exports);
+var solanaWeb3Promise;
+async function loadSolanaWeb3() {
+  if (!solanaWeb3Promise) {
+    solanaWeb3Promise = import("@solana/web3.js").catch((err) => {
+      solanaWeb3Promise = void 0;
+      throw new StableOpsWalletError(
+        "Solana \u652F\u4ED8\u9700\u8981\u53EF\u9009\u4F9D\u8D56 @solana/web3.js\uFF0C\u8BF7\u5148\u5B89\u88C5\uFF1Anpm install @solana/web3.js",
+        "solana_dependency_missing",
+        { cause: err }
+      );
+    });
+  }
+  return solanaWeb3Promise;
+}
+var WALLET_TOKEN_CONTRACTS = [
+  {
+    chain: "ethereum",
+    asset: "USDC",
+    address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    decimals: 6
+  },
+  {
+    chain: "ethereum",
+    asset: "USDT",
+    address: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    decimals: 6
+  },
+  {
+    chain: "base",
+    asset: "USDC",
+    address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    decimals: 6
+  },
+  {
+    chain: "base-sepolia",
+    asset: "USDC",
+    address: "0x036cbd53842c5426634e7929541ec2318f3dcf7e",
+    decimals: 6
+  },
+  {
+    chain: "arbitrum",
+    asset: "USDC",
+    address: "0xaf88d065e77cc2239327c5edb3a432268e5831",
+    decimals: 6
+  },
+  {
+    chain: "polygon",
+    asset: "USDC",
+    address: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
+    decimals: 6
+  },
+  {
+    chain: "tron",
+    asset: "USDT",
+    address: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+    decimals: 6
+  },
+  {
+    chain: "solana",
+    asset: "USDC",
+    address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    decimals: 6
+  },
+  {
+    chain: "solana",
+    asset: "USDT",
+    address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    decimals: 6
+  },
+  {
+    chain: "ethereum-sepolia",
+    asset: "USDC",
+    address: "0x1c7d4b196cb0c7b01d743fbc6116a902379c7238",
+    decimals: 6
+  },
+  {
+    chain: "arbitrum-sepolia",
+    asset: "USDC",
+    address: "0x75faf114eafb1bdbe2f0316df893fd58ce46aa4d",
+    decimals: 6
+  },
+  {
+    chain: "polygon-amoy",
+    asset: "USDC",
+    address: "0x41e94eb019c0762f9bfcf9fb1e58725bfb0e7582",
+    decimals: 6
+  },
+  {
+    chain: "solana-devnet",
+    asset: "USDC",
+    address: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+    decimals: 6
+  },
+  {
+    chain: "tron-nile",
+    asset: "USDT",
+    address: "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf",
+    decimals: 6
+  }
+];
+var EVM_WALLET_CHAINS = [
+  "ethereum",
+  "base",
+  "base-sepolia",
+  "arbitrum",
+  "polygon",
+  "ethereum-sepolia",
+  "arbitrum-sepolia",
+  "polygon-amoy"
+];
+var TRON_WALLET_CHAINS = ["tron", "tron-nile"];
+var SOLANA_WALLET_CHAINS = ["solana", "solana-devnet"];
+var ERC20_TRANSFER_SELECTOR = "a9059cbb";
+var SOLANA_MAINNET_RPC_URL = "https://api.mainnet-beta.solana.com";
+var SOLANA_TOKEN_PROGRAM_ID_BASE58 = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var SOLANA_ASSOCIATED_TOKEN_PROGRAM_ID_BASE58 = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+var SOLANA_TRANSFER_CHECKED_INSTRUCTION = 12;
+var SOLANA_CREATE_ASSOCIATED_TOKEN_ACCOUNT_IDEMPOTENT_INSTRUCTION = 1;
+var StableOpsWalletError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "StableOpsWalletError";
+  }
+  code;
+  details;
+};
+var EvmWalletChainConfigs = {
+  ethereum: {
+    chainId: "ethereum",
+    eip155ChainId: 1,
+    chainName: "Ethereum Mainnet",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: ["https://cloudflare-eth.com"],
+    blockExplorerUrls: ["https://etherscan.io"]
+  },
+  base: {
+    chainId: "base",
+    eip155ChainId: 8453,
+    chainName: "Base",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: ["https://mainnet.base.org"],
+    blockExplorerUrls: ["https://basescan.org"]
+  },
+  "base-sepolia": {
+    chainId: "base-sepolia",
+    eip155ChainId: 84532,
+    chainName: "Base Sepolia",
+    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: ["https://sepolia.base.org"],
+    blockExplorerUrls: ["https://sepolia.basescan.org"]
+  },
+  arbitrum: {
+    chainId: "arbitrum",
+    eip155ChainId: 42161,
+    chainName: "Arbitrum One",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: ["https://arb1.arbitrum.io/rpc"],
+    blockExplorerUrls: ["https://arbiscan.io"]
+  },
+  polygon: {
+    chainId: "polygon",
+    eip155ChainId: 137,
+    chainName: "Polygon",
+    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
+    rpcUrls: ["https://polygon-rpc.com"],
+    blockExplorerUrls: ["https://polygonscan.com"]
+  },
+  "ethereum-sepolia": {
+    chainId: "ethereum-sepolia",
+    eip155ChainId: 11155111,
+    chainName: "Sepolia",
+    nativeCurrency: { name: "Sepolia Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: ["https://ethereum-sepolia-rpc.publicnode.com"],
+    blockExplorerUrls: ["https://sepolia.etherscan.io"]
+  },
+  "arbitrum-sepolia": {
+    chainId: "arbitrum-sepolia",
+    eip155ChainId: 421614,
+    chainName: "Arbitrum Sepolia",
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+    rpcUrls: ["https://sepolia-rollup.arbitrum.io/rpc"],
+    blockExplorerUrls: ["https://sepolia.arbiscan.io"]
+  },
+  "polygon-amoy": {
+    chainId: "polygon-amoy",
+    eip155ChainId: 80002,
+    chainName: "Polygon Amoy",
+    nativeCurrency: { name: "POL", symbol: "POL", decimals: 18 },
+    rpcUrls: ["https://rpc-amoy.polygon.technology"],
+    blockExplorerUrls: ["https://amoy.polygonscan.com"]
+  }
+};
+function getInjectedEthereumProvider() {
+  const maybeGlobal = globalThis;
+  return maybeGlobal.ethereum;
+}
+function getInjectedTronProvider() {
+  const maybeGlobal = globalThis;
+  if (!maybeGlobal.tronWeb) return void 0;
+  return { tronLink: maybeGlobal.tronLink, tronWeb: maybeGlobal.tronWeb };
+}
+function getInjectedSolanaProvider() {
+  const maybeGlobal = globalThis;
+  return maybeGlobal.phantom?.solana ?? maybeGlobal.solana;
+}
+function getInjectedWalletProviders() {
+  const providers = {};
+  const evmProvider = getInjectedEthereumProvider();
+  if (evmProvider) {
+    for (const chain of EVM_WALLET_CHAINS) providers[chain] = evmProvider;
+  }
+  const tronProvider = getInjectedTronProvider();
+  if (tronProvider) {
+    for (const chain of TRON_WALLET_CHAINS) providers[chain] = tronProvider;
+  }
+  const solanaProvider = getInjectedSolanaProvider();
+  if (solanaProvider) {
+    for (const chain of SOLANA_WALLET_CHAINS) providers[chain] = solanaProvider;
+  }
+  return providers;
+}
+function selectWalletPaymentInstruction(instructions, providers, preferredChains = []) {
+  if (instructions.length === 0) {
+    throw new StableOpsWalletError("\u8BA2\u5355\u8FD8\u6CA1\u6709\u53EF\u652F\u4ED8\u7684\u94FE\u4E0A\u6536\u6B3E\u6307\u4EE4", "payment_instruction_not_found");
+  }
+  const preferred = preferredChains.map((chain) => instructions.find((instruction) => instruction.chain === chain)).filter((instruction) => Boolean(instruction));
+  const candidates = [...preferred, ...instructions.filter((instruction) => !preferred.includes(instruction))];
+  for (const instruction of candidates) {
+    const provider = providers[instruction.chain];
+    if (provider) return { instruction, provider };
+  }
+  throw new StableOpsWalletError("\u672A\u627E\u5230\u8BA2\u5355\u5019\u9009\u94FE\u5BF9\u5E94\u7684\u94B1\u5305 provider", "wallet_provider_not_found", {
+    chains: instructions.map((instruction) => instruction.chain)
+  });
+}
+async function sendOrderWalletPayment(input) {
+  const selected = selectWalletPaymentInstruction(
+    input.order.paymentInstructions,
+    input.providers,
+    input.preferredChains
+  );
+  return sendWalletPayment({
+    ...input,
+    provider: selected.provider,
+    instruction: selected.instruction,
+    amount: input.order.amount
+  });
+}
+async function sendWalletPayment(input) {
+  const instruction = requireInstruction(input.instruction);
+  const token = findWalletTokenContract(instruction.chain, instruction.asset);
+  if (!token) {
+    throw new StableOpsWalletError("\u672A\u627E\u5230\u8BE5\u94FE\u4E0E\u8D44\u4EA7\u7684\u9ED8\u8BA4\u4EE3\u5E01\u5408\u7EA6", "token_contract_not_found", {
+      chain: instruction.chain,
+      asset: instruction.asset
+    });
+  }
+  if (isEvmWalletChain(instruction.chain)) {
+    return sendEvmWalletPayment(input, { ...instruction, chain: instruction.chain }, token);
+  }
+  if (isTronWalletChain(instruction.chain)) {
+    return sendTronWalletPayment(input, instruction, token);
+  }
+  if (isSolanaWalletChain(instruction.chain)) {
+    return sendSolanaWalletPayment(input, instruction, token);
+  }
+  throw new StableOpsWalletError("\u5F53\u524D\u94B1\u5305 SDK \u4E0D\u652F\u6301\u8BE5\u94FE", "unsupported_chain", { chain: instruction.chain });
+}
+function encodeErc20Transfer(toAddress, amountUnits) {
+  const normalizedTo = normalizeEvmAddress(toAddress);
+  if (amountUnits < 0n) {
+    throw new StableOpsWalletError("\u8F6C\u8D26\u91D1\u989D\u4E0D\u80FD\u4E3A\u8D1F\u6570", "invalid_amount", { amountUnits: amountUnits.toString() });
+  }
+  return `0x${ERC20_TRANSFER_SELECTOR}${padHex(normalizedTo.slice(2))}${padHex(amountUnits.toString(16))}`;
+}
+function parseTokenAmount(amount, decimals) {
+  if (!Number.isInteger(decimals) || decimals < 0) {
+    throw new StableOpsWalletError("\u4EE3\u5E01\u7CBE\u5EA6\u914D\u7F6E\u65E0\u6548", "invalid_decimals", { decimals });
+  }
+  const trimmed = amount.trim();
+  const match = /^(\d+)(?:\.(\d+))?$/u.exec(trimmed);
+  if (!match) {
+    throw new StableOpsWalletError("\u8F6C\u8D26\u91D1\u989D\u683C\u5F0F\u65E0\u6548", "invalid_amount", { amount });
+  }
+  const whole = match[1];
+  const fraction = match[2] ?? "";
+  if (fraction.length > decimals) {
+    throw new StableOpsWalletError("\u8F6C\u8D26\u91D1\u989D\u5C0F\u6570\u4F4D\u8D85\u8FC7\u4EE3\u5E01\u7CBE\u5EA6", "amount_precision_exceeded", {
+      amount,
+      decimals
+    });
+  }
+  const units = BigInt(whole) * 10n ** BigInt(decimals) + BigInt(fraction.padEnd(decimals, "0") || "0");
+  if (units <= 0n) {
+    throw new StableOpsWalletError("\u8F6C\u8D26\u91D1\u989D\u5FC5\u987B\u5927\u4E8E 0", "invalid_amount", { amount });
+  }
+  return units;
+}
+async function sendEvmWalletPayment(input, instruction, token) {
+  const provider = input.provider;
+  if (!isEip1193Provider(provider)) {
+    throw new StableOpsWalletError("EVM \u652F\u4ED8\u9700\u8981 EIP-1193 \u94B1\u5305 provider", "wallet_provider_mismatch");
+  }
+  const config = resolveChainConfig(instruction.chain, input.chainConfigs);
+  const fromAddress = normalizeEvmAddress(input.fromAddress ?? await requestFirstEvmAccount(provider));
+  await ensureEvmChain(provider, config);
+  const amountUnits = parseTokenAmount(input.amount, token.decimals);
+  const txHash = await provider.request({
+    method: "eth_sendTransaction",
+    params: [
+      {
+        from: fromAddress,
+        to: token.address,
+        value: "0x0",
+        data: encodeErc20Transfer(instruction.address, amountUnits)
+      }
+    ]
+  });
+  return buildSentPayment(txHash, instruction, token, fromAddress, input.amount, amountUnits);
+}
+async function sendTronWalletPayment(input, instruction, token) {
+  const tronWeb = getTronWeb(input.provider);
+  const accountRequester = getTronAccountRequester(input.provider);
+  if (accountRequester) {
+    await accountRequester({ method: "tron_requestAccounts" });
+  }
+  const fromAddress = normalizeTronAddress(input.fromAddress ?? tronWeb.defaultAddress?.base58);
+  const toAddress = normalizeTronAddress(instruction.address);
+  const amountUnits = parseTokenAmount(input.amount, token.decimals);
+  const built = await tronWeb.transactionBuilder.triggerSmartContract(
+    token.address,
+    "transfer(address,uint256)",
+    { feeLimit: 1e8 },
+    [
+      { type: "address", value: toAddress },
+      { type: "uint256", value: amountUnits.toString() }
+    ],
+    fromAddress
+  );
+  if (!built.transaction) {
+    throw new StableOpsWalletError("TRON \u94B1\u5305\u672A\u80FD\u521B\u5EFA TRC-20 \u8F6C\u8D26\u4EA4\u6613", "tron_transaction_build_failed", built);
+  }
+  const signed = await tronWeb.trx.sign(built.transaction);
+  const sent = await tronWeb.trx.sendRawTransaction(signed);
+  const txHash = sent.txid ?? sent.transaction?.txID ?? getTronSignedTransactionId(signed);
+  if (!txHash) {
+    throw new StableOpsWalletError("TRON \u94B1\u5305\u672A\u8FD4\u56DE\u4EA4\u6613\u54C8\u5E0C", "wallet_transaction_hash_not_found", sent);
+  }
+  return buildSentPayment(txHash, instruction, token, fromAddress, input.amount, amountUnits);
+}
+async function sendSolanaWalletPayment(input, instruction, token) {
+  const web3 = await loadSolanaWeb3();
+  const provider = input.provider;
+  const payer = publicKeyFromString(web3, input.fromAddress ?? await requestSolanaPublicKey(provider));
+  const recipient = publicKeyFromString(web3, instruction.address);
+  const mint = publicKeyFromString(web3, token.address);
+  const amountUnits = parseTokenAmount(input.amount, token.decimals);
+  const connection = input.solanaConnection ?? new web3.Connection(input.solanaRpcUrl ?? SOLANA_MAINNET_RPC_URL, "confirmed");
+  const tokenProgramId = new web3.PublicKey(SOLANA_TOKEN_PROGRAM_ID_BASE58);
+  const associatedTokenProgramId = new web3.PublicKey(SOLANA_ASSOCIATED_TOKEN_PROGRAM_ID_BASE58);
+  const sourceTokenAccount = findAssociatedTokenAddress(web3, payer, mint, tokenProgramId, associatedTokenProgramId);
+  const destinationTokenAccount = findAssociatedTokenAddress(web3, recipient, mint, tokenProgramId, associatedTokenProgramId);
+  const latest = await connection.getLatestBlockhash();
+  const transaction = new web3.Transaction({
+    feePayer: payer,
+    recentBlockhash: latest.blockhash
+  });
+  transaction.add(
+    createAssociatedTokenAccountIdempotentInstruction(
+      web3,
+      payer,
+      destinationTokenAccount,
+      recipient,
+      mint,
+      tokenProgramId,
+      associatedTokenProgramId
+    )
+  );
+  transaction.add(
+    createSplTokenTransferCheckedInstruction(
+      web3,
+      sourceTokenAccount,
+      mint,
+      destinationTokenAccount,
+      payer,
+      amountUnits,
+      token.decimals,
+      tokenProgramId
+    )
+  );
+  const txHash = await sendSolanaTransaction(provider, connection, transaction);
+  return buildSentPayment(txHash, instruction, token, payer.toBase58(), input.amount, amountUnits);
+}
+function buildSentPayment(txHash, instruction, token, fromAddress, amount, amountUnits) {
+  return {
+    txHash,
+    chain: instruction.chain,
+    asset: instruction.asset,
+    fromAddress,
+    toAddress: instruction.address,
+    tokenContract: token.address,
+    amount,
+    amountUnits: amountUnits.toString()
+  };
+}
+function isEvmWalletChain(chain) {
+  return EVM_WALLET_CHAINS.includes(chain);
+}
+function isTronWalletChain(chain) {
+  return TRON_WALLET_CHAINS.includes(chain);
+}
+function isSolanaWalletChain(chain) {
+  return SOLANA_WALLET_CHAINS.includes(chain);
+}
+function findWalletTokenContract(chain, asset) {
+  return WALLET_TOKEN_CONTRACTS.find((entry) => entry.chain === chain && entry.asset === asset);
+}
+function isEip1193Provider(provider) {
+  return typeof provider.request === "function";
+}
+async function requestFirstEvmAccount(provider) {
+  const accounts = await provider.request({ method: "eth_requestAccounts" });
+  const first = accounts[0];
+  if (!first) {
+    throw new StableOpsWalletError("\u94B1\u5305\u672A\u8FD4\u56DE\u53EF\u7528\u8D26\u6237", "wallet_account_not_found");
+  }
+  return first;
+}
+async function ensureEvmChain(provider, config) {
+  try {
+    await provider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: toHexChainId(config.eip155ChainId) }]
+    });
+  } catch (err) {
+    if (!isUnknownChainError(err)) throw err;
+    await provider.request({ method: "wallet_addEthereumChain", params: [toWalletAddChainParams(config)] });
+    await provider.request({
+      method: "wallet_switchEthereumChain",
+      params: [{ chainId: toHexChainId(config.eip155ChainId) }]
+    });
+  }
+}
+function requireInstruction(instruction) {
+  if (!instruction) {
+    throw new StableOpsWalletError("\u8BA2\u5355\u8FD8\u6CA1\u6709\u53EF\u652F\u4ED8\u7684\u94FE\u4E0A\u6536\u6B3E\u6307\u4EE4", "payment_instruction_not_found");
+  }
+  return instruction;
+}
+function resolveChainConfig(chain, overrides) {
+  const config = overrides?.[chain] ?? EvmWalletChainConfigs[chain];
+  if (!config) {
+    throw new StableOpsWalletError("\u672A\u627E\u5230\u94B1\u5305\u5207\u94FE\u914D\u7F6E", "chain_config_not_found", { chain });
+  }
+  return config;
+}
+function toWalletAddChainParams(config) {
+  return {
+    chainId: toHexChainId(config.eip155ChainId),
+    chainName: config.chainName,
+    nativeCurrency: config.nativeCurrency,
+    rpcUrls: config.rpcUrls,
+    blockExplorerUrls: config.blockExplorerUrls
+  };
+}
+function toHexChainId(chainId) {
+  return `0x${chainId.toString(16)}`;
+}
+function isUnknownChainError(err) {
+  if (typeof err !== "object" || err === null) return false;
+  const code = Number(err.code);
+  if (code === 4902) return true;
+  const data = err.data;
+  if (typeof data !== "object" || data === null) return false;
+  const originalError = data.originalError;
+  if (typeof originalError !== "object" || originalError === null) return false;
+  return Number(originalError.code) === 4902;
+}
+function getTronWeb(provider) {
+  const tronWeb = provider.tronWeb ?? provider;
+  if (!tronWeb || typeof tronWeb.transactionBuilder?.triggerSmartContract !== "function" || typeof tronWeb.trx?.sign !== "function" || typeof tronWeb.trx?.sendRawTransaction !== "function") {
+    throw new StableOpsWalletError("TRON \u652F\u4ED8\u9700\u8981 TronLink / TronWeb \u94B1\u5305 provider", "wallet_provider_mismatch");
+  }
+  return tronWeb;
+}
+function getTronAccountRequester(provider) {
+  const wrapper = provider;
+  return wrapper.tronLink?.request?.bind(wrapper.tronLink) ?? wrapper.request?.bind(wrapper);
+}
+function getTronSignedTransactionId(signed) {
+  if (typeof signed !== "object" || signed === null) return void 0;
+  return signed.txID;
+}
+async function requestSolanaPublicKey(provider) {
+  const existing = solanaPublicKeyToString(provider.publicKey);
+  if (existing) return existing;
+  const connected = await provider.connect?.();
+  const connectedKey = connected ? solanaPublicKeyToString(connected.publicKey) : void 0;
+  const providerKey = solanaPublicKeyToString(provider.publicKey);
+  const publicKey = connectedKey ?? providerKey;
+  if (!publicKey) {
+    throw new StableOpsWalletError("Solana \u94B1\u5305\u672A\u8FD4\u56DE\u53EF\u7528\u8D26\u6237", "wallet_account_not_found");
+  }
+  return publicKey;
+}
+async function sendSolanaTransaction(provider, connection, transaction) {
+  if (typeof provider.signAndSendTransaction === "function") {
+    const result = await provider.signAndSendTransaction(transaction);
+    const signature = typeof result === "string" ? result : result.signature;
+    if (!signature) {
+      throw new StableOpsWalletError("Solana \u94B1\u5305\u672A\u8FD4\u56DE\u4EA4\u6613\u7B7E\u540D", "wallet_transaction_hash_not_found", result);
+    }
+    return signature;
+  }
+  if (typeof provider.signTransaction !== "function") {
+    throw new StableOpsWalletError("Solana \u652F\u4ED8\u9700\u8981\u94B1\u5305\u652F\u6301 signAndSendTransaction \u6216 signTransaction", "wallet_provider_mismatch");
+  }
+  const signed = await provider.signTransaction(transaction);
+  return connection.sendRawTransaction(signed.serialize());
+}
+function solanaPublicKeyToString(publicKey) {
+  if (!publicKey) return void 0;
+  if (typeof publicKey === "string") return publicKey;
+  return publicKey.toBase58();
+}
+function publicKeyFromString(web3, address) {
+  try {
+    return new web3.PublicKey(address);
+  } catch (err) {
+    throw new StableOpsWalletError("Solana \u5730\u5740\u683C\u5F0F\u65E0\u6548", "invalid_solana_address", { address, cause: err });
+  }
+}
+function findAssociatedTokenAddress(web3, owner, mint, tokenProgramId, associatedTokenProgramId) {
+  return web3.PublicKey.findProgramAddressSync(
+    [owner.toBuffer(), tokenProgramId.toBuffer(), mint.toBuffer()],
+    associatedTokenProgramId
+  )[0];
+}
+function createAssociatedTokenAccountIdempotentInstruction(web3, payer, associatedToken, owner, mint, tokenProgramId, associatedTokenProgramId) {
+  return new web3.TransactionInstruction({
+    programId: associatedTokenProgramId,
+    keys: [
+      { pubkey: payer, isSigner: true, isWritable: true },
+      { pubkey: associatedToken, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: false, isWritable: false },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: web3.SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramId, isSigner: false, isWritable: false }
+    ],
+    data: new Uint8Array([SOLANA_CREATE_ASSOCIATED_TOKEN_ACCOUNT_IDEMPOTENT_INSTRUCTION])
+  });
+}
+function createSplTokenTransferCheckedInstruction(web3, source, mint, destination, owner, amountUnits, decimals, tokenProgramId) {
+  const data = new Uint8Array(10);
+  data[0] = SOLANA_TRANSFER_CHECKED_INSTRUCTION;
+  writeBigUInt64LE(data, amountUnits, 1);
+  data[9] = decimals;
+  return new web3.TransactionInstruction({
+    programId: tokenProgramId,
+    keys: [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: mint, isSigner: false, isWritable: false },
+      { pubkey: destination, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: true, isWritable: false }
+    ],
+    data
+  });
+}
+function writeBigUInt64LE(bytes, value, offset) {
+  if (value > 0xffffffffffffffffn) {
+    throw new StableOpsWalletError("\u8F6C\u8D26\u91D1\u989D\u8D85\u51FA u64 \u8303\u56F4", "invalid_amount", { amountUnits: value.toString() });
+  }
+  let remaining = value;
+  for (let index = 0; index < 8; index++) {
+    bytes[offset + index] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+}
+function normalizeEvmAddress(address) {
+  if (!/^0x[0-9a-fA-F]{40}$/u.test(address)) {
+    throw new StableOpsWalletError("EVM \u5730\u5740\u683C\u5F0F\u65E0\u6548", "invalid_evm_address", { address });
+  }
+  return address.toLowerCase();
+}
+function normalizeTronAddress(address) {
+  if (!address || !/^T[1-9A-HJ-NP-Za-km-z]{33}$/u.test(address)) {
+    throw new StableOpsWalletError("TRON \u5730\u5740\u683C\u5F0F\u65E0\u6548", "invalid_tron_address", { address });
+  }
+  return address;
+}
+function padHex(hex) {
+  return hex.padStart(64, "0");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EvmWalletChainConfigs,
+  StableOpsWalletError,
+  encodeErc20Transfer,
+  getInjectedEthereumProvider,
+  getInjectedSolanaProvider,
+  getInjectedTronProvider,
+  getInjectedWalletProviders,
+  parseTokenAmount,
+  selectWalletPaymentInstruction,
+  sendOrderWalletPayment,
+  sendWalletPayment
+});
+//# sourceMappingURL=index.js.map