@aptos-labs/cross-chain-core 4.23.1

package/dist/index.mjs

@@ -0,0 +1,957 @@
+// src/CrossChainCore.ts
+import { Network as Network3 } from "@aptos-labs/ts-sdk";
+
+// src/providers/wormhole/wormhole.ts
+import {
+  chainToPlatform,
+  routes,
+  Wormhole,
+  wormhole,
+  TransferState
+} from "@wormhole-foundation/sdk";
+import { Network, sleep as sleep2 } from "@aptos-labs/ts-sdk";
+import aptos from "@wormhole-foundation/sdk/aptos";
+import solana from "@wormhole-foundation/sdk/solana";
+import evm from "@wormhole-foundation/sdk/evm";
+
+// src/utils/logger.ts
+var logger = {
+  log: (...args) => {
+    if (process.env.NODE_ENV === "development") {
+      console.log(...args);
+    }
+  },
+  warn: (...args) => {
+    if (process.env.NODE_ENV === "development") {
+      console.warn(...args);
+    }
+  },
+  error: (...args) => {
+    if (process.env.NODE_ENV === "development") {
+      console.error(...args);
+    }
+  }
+};
+
+// src/providers/wormhole/signers/AptosLocalSigner.ts
+import {
+  Aptos,
+  AptosConfig,
+  Network as AptosNetwork
+} from "@aptos-labs/ts-sdk";
+var AptosLocalSigner = class {
+  constructor(chain, options, wallet, feePayerAccount) {
+    this._chain = chain;
+    this._options = options;
+    this._wallet = wallet;
+    this._sponsorAccount = feePayerAccount;
+    this._claimedTransactionHashes = "";
+  }
+  chain() {
+    return this._chain;
+  }
+  address() {
+    return this._wallet.accountAddress.toString();
+  }
+  claimedTransactionHashes() {
+    return this._claimedTransactionHashes;
+  }
+  async signAndSend(txs) {
+    const txHashes = [];
+    for (const tx of txs) {
+      const txId = await signAndSendTransaction(
+        tx,
+        this._wallet,
+        this._sponsorAccount
+      );
+      txHashes.push(txId);
+      this._claimedTransactionHashes = txId;
+    }
+    return txHashes;
+  }
+};
+async function signAndSendTransaction(request, wallet, sponsorAccount) {
+  if (!wallet) {
+    throw new Error("Wallet is undefined");
+  }
+  const payload = request.transaction;
+  payload.functionArguments = payload.functionArguments.map((a) => {
+    if (a instanceof Uint8Array) {
+      return Array.from(a);
+    } else if (typeof a === "bigint") {
+      return a.toString();
+    } else {
+      return a;
+    }
+  });
+  const aptosConfig = new AptosConfig({
+    network: AptosNetwork.TESTNET
+  });
+  const aptos2 = new Aptos(aptosConfig);
+  const txnToSign = await aptos2.transaction.build.simple({
+    data: payload,
+    sender: wallet.accountAddress.toString(),
+    withFeePayer: sponsorAccount ? true : false
+  });
+  const senderAuthenticator = await aptos2.transaction.sign({
+    signer: wallet,
+    transaction: txnToSign
+  });
+  const txnToSubmit = {
+    transaction: txnToSign,
+    senderAuthenticator
+  };
+  if (sponsorAccount) {
+    if (typeof sponsorAccount === "string") {
+    } else {
+      const feePayerSignerAuthenticator = aptos2.transaction.signAsFeePayer({
+        signer: sponsorAccount,
+        transaction: txnToSign
+      });
+      txnToSubmit.feePayerAuthenticator = feePayerSignerAuthenticator;
+    }
+  }
+  const response = await aptos2.transaction.submit.simple(txnToSubmit);
+  const tx = await aptos2.waitForTransaction({
+    transactionHash: response.hash
+  });
+  return tx.hash;
+}
+
+// src/providers/wormhole/signers/SolanaSigner.ts
+import {
+  ComputeBudgetProgram,
+  LAMPORTS_PER_SOL
+} from "@solana/web3.js";
+import {
+  determinePriorityFee,
+  determinePriorityFeeTritonOne
+} from "@wormhole-foundation/sdk-solana";
+import { Connection } from "@solana/web3.js";
+import { SolanaDerivedWallet } from "@aptos-labs/derived-wallet-solana";
+async function signAndSendTransaction2(request, wallet, options, crossChainCore) {
+  var _a, _b, _c, _d;
+  if (!wallet || !(wallet instanceof SolanaDerivedWallet)) {
+    throw new Error("Invalid wallet type or missing Solana wallet").message;
+  }
+  const commitment = (_a = options == null ? void 0 : options.commitment) != null ? _a : "finalized";
+  const connection = new Connection(
+    (_d = (_c = (_b = crossChainCore == null ? void 0 : crossChainCore._dappConfig) == null ? void 0 : _b.solanaConfig) == null ? void 0 : _c.rpc) != null ? _d : "https://api.devnet.solana.com"
+  );
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash(commitment);
+  const transaction = request.transaction.transaction;
+  const unsignedTx = await setPriorityFeeInstructions(
+    connection,
+    blockhash,
+    lastValidBlockHeight,
+    request,
+    crossChainCore
+  );
+  let confirmTransactionPromise = null;
+  let confirmedTx = null;
+  let txSendAttempts = 1;
+  let signature = "";
+  if (!wallet.solanaWallet.signTransaction) {
+    throw new Error("Wallet does not support signing transactions").message;
+  }
+  const tx = await wallet.solanaWallet.signTransaction(unsignedTx);
+  if (!tx)
+    throw new Error("Failed to sign transaction").message;
+  const serializedTx = tx.serialize();
+  const sendOptions = {
+    skipPreflight: true,
+    maxRetries: 0,
+    preFlightCommitment: commitment
+  };
+  signature = await connection.sendRawTransaction(serializedTx, sendOptions);
+  confirmTransactionPromise = connection.confirmTransaction(
+    {
+      signature,
+      blockhash,
+      lastValidBlockHeight
+    },
+    commitment
+  );
+  const txRetryInterval = 5e3;
+  while (!confirmedTx) {
+    confirmedTx = await Promise.race([
+      confirmTransactionPromise,
+      new Promise(
+        (resolve) => setTimeout(() => {
+          resolve(null);
+        }, txRetryInterval)
+      )
+    ]);
+    if (confirmedTx) {
+      break;
+    }
+    console.log(
+      `Tx not confirmed after ${txRetryInterval * txSendAttempts++}ms, resending`
+    );
+    try {
+      await connection.sendRawTransaction(serializedTx, sendOptions);
+    } catch (e) {
+      console.error("Failed to resend transaction:", e);
+    }
+  }
+  if (confirmedTx.value.err) {
+    let errorMessage = `Transaction failed: ${confirmedTx.value.err}`;
+    if (typeof confirmedTx.value.err === "object") {
+      try {
+        errorMessage = `Transaction failed: ${JSON.stringify(
+          confirmedTx.value.err,
+          (_key, value) => typeof value === "bigint" ? value.toString() : value
+        )}`;
+      } catch (e) {
+        errorMessage = `Transaction failed: Unknown error`;
+      }
+    }
+    throw new Error(`Transaction failed: ${errorMessage}`).message;
+  }
+  return signature;
+}
+async function setPriorityFeeInstructions(connection, blockhash, lastValidBlockHeight, request, crossChainCore) {
+  const unsignedTx = request.transaction.transaction;
+  const computeBudgetIxFilter = (ix) => ix.programId.toString() !== "ComputeBudget111111111111111111111111111111";
+  unsignedTx.recentBlockhash = blockhash;
+  unsignedTx.lastValidBlockHeight = lastValidBlockHeight;
+  unsignedTx.instructions = unsignedTx.instructions.filter(
+    computeBudgetIxFilter
+  );
+  unsignedTx.add(
+    ...await createPriorityFeeInstructions(
+      connection,
+      unsignedTx,
+      crossChainCore
+    )
+  );
+  if (request.transaction.signers) {
+    unsignedTx.partialSign(...request.transaction.signers);
+  }
+  return unsignedTx;
+}
+async function createPriorityFeeInstructions(connection, transaction, crossChainCore) {
+  var _a, _b, _c;
+  let unitsUsed = 2e5;
+  let simulationAttempts = 0;
+  simulationLoop:
+    while (true) {
+      const response = await connection.simulateTransaction(
+        transaction
+      );
+      if (response.value.err) {
+        if (checkKnownSimulationError(response.value)) {
+          if (simulationAttempts < 5) {
+            simulationAttempts++;
+            await sleep(1e3);
+            continue simulationLoop;
+          }
+        } else if (simulationAttempts < 3) {
+          simulationAttempts++;
+          await sleep(1e3);
+          continue simulationLoop;
+        }
+        throw new Error(
+          `Simulation failed: ${JSON.stringify(response.value.err)}
+Logs:
+${(response.value.logs || []).join("\n  ")}`
+        ).message;
+      } else {
+        if (response.value.unitsConsumed) {
+          unitsUsed = response.value.unitsConsumed;
+        }
+        break;
+      }
+    }
+  const unitBudget = Math.floor(unitsUsed * 1.2);
+  const instructions = [];
+  instructions.push(
+    ComputeBudgetProgram.setComputeUnitLimit({
+      units: unitBudget
+    })
+  );
+  const {
+    percentile = 0.9,
+    percentileMultiple = 1,
+    min = 1e5,
+    max = 1e8
+  } = (_c = (_b = (_a = crossChainCore == null ? void 0 : crossChainCore._dappConfig) == null ? void 0 : _a.solanaConfig) == null ? void 0 : _b.priorityFeeConfig) != null ? _c : {};
+  const calculateFee = async (rpcProvider2) => {
+    if (rpcProvider2 === "triton") {
+      try {
+        const fee2 = await determinePriorityFeeTritonOne(
+          connection,
+          transaction,
+          percentile,
+          percentileMultiple,
+          min,
+          max
+        );
+        return {
+          fee: fee2,
+          methodUsed: "triton"
+        };
+      } catch (e) {
+        console.warn(`Failed to determine priority fee using Triton RPC:`, e);
+      }
+    }
+    try {
+      const fee2 = await determinePriorityFee(
+        connection,
+        transaction,
+        percentile,
+        percentileMultiple,
+        min,
+        max
+      );
+      return {
+        fee: fee2,
+        methodUsed: "default"
+      };
+    } catch (e) {
+      console.warn(`Failed to determine priority fee using Triton RPC:`, e);
+      return {
+        fee: min,
+        methodUsed: "minimum"
+      };
+    }
+  };
+  const rpcProvider = determineRpcProvider(connection.rpcEndpoint);
+  const { fee, methodUsed } = await calculateFee(rpcProvider);
+  const maxFeeInSol = fee / 1e6 / LAMPORTS_PER_SOL * unitBudget;
+  console.table({
+    "RPC Provider": rpcProvider,
+    "Method used": methodUsed,
+    "Percentile used": percentile,
+    "Multiple used": percentileMultiple,
+    "Compute budget": unitBudget,
+    "Priority fee": fee,
+    "Max fee in SOL": maxFeeInSol
+  });
+  instructions.push(
+    ComputeBudgetProgram.setComputeUnitPrice({ microLamports: fee })
+  );
+  return instructions;
+}
+function checkKnownSimulationError(response) {
+  const errors = {};
+  if (response.err === "BlockhashNotFound") {
+    errors["BlockhashNotFound"] = "Blockhash not found during simulation. Trying again.";
+  }
+  if (response.logs) {
+    for (const line of response.logs) {
+      if (line.includes("SlippageToleranceExceeded")) {
+        errors["SlippageToleranceExceeded"] = "Slippage failure during simulation. Trying again.";
+      }
+      if (line.includes("RequireGteViolated")) {
+        errors["RequireGteViolated"] = "Swap instruction failure during simulation. Trying again.";
+      }
+    }
+  }
+  if (isEmptyObject(errors)) {
+    return false;
+  }
+  console.table(errors);
+  return true;
+}
+async function sleep(timeout) {
+  return new Promise((resolve) => setTimeout(resolve, timeout));
+}
+var isEmptyObject = (value) => {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  for (const key in value) {
+    if (value.hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+};
+function determineRpcProvider(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    const hostname = url.hostname;
+    if (hostname === "rpcpool.com") {
+      return "triton";
+    } else if (hostname === "helius-rpc.com") {
+      return "helius";
+    } else if (hostname === "rpc.ankr.com") {
+      return "ankr";
+    } else {
+      return "unknown";
+    }
+  } catch (e) {
+    return "unknown";
+  }
+}
+
+// src/providers/wormhole/signers/EthereumSigner.ts
+import { ethers, getBigInt } from "ethers";
+async function signAndSendTransaction3(request, wallet, chainName, options) {
+  if (!wallet) {
+    throw new Error("wallet.sendTransaction is undefined").message;
+  }
+  const chainId = await wallet.eip1193Provider.request({
+    method: "eth_chainId"
+  });
+  const actualChainId = parseInt(chainId, 16);
+  if (!actualChainId)
+    throw new Error("No signer found for chain" + chainName).message;
+  const expectedChainId = request.transaction.chainId ? getBigInt(request.transaction.chainId) : void 0;
+  if (!actualChainId || !expectedChainId || BigInt(actualChainId) !== expectedChainId) {
+    throw new Error(
+      `Signer is not connected to the right chain. Expected ${expectedChainId}, got ${actualChainId}`
+    ).message;
+  }
+  const provider = new ethers.BrowserProvider(
+    wallet.eip1193Provider
+  );
+  const signer = await provider.getSigner();
+  const response = await signer.sendTransaction(request.transaction);
+  const receipt = await response.wait();
+  return (receipt == null ? void 0 : receipt.hash) || "";
+}
+
+// src/providers/wormhole/signers/Signer.ts
+var Signer = class {
+  constructor(chain, address, options, wallet, crossChainCore) {
+    this._chain = chain;
+    this._address = address;
+    this._options = options;
+    this._wallet = wallet;
+    this._crossChainCore = crossChainCore;
+  }
+  chain() {
+    return this._chain.displayName;
+  }
+  address() {
+    return this._address;
+  }
+  async signAndSend(txs) {
+    const txHashes = [];
+    for (const tx of txs) {
+      const txId = await signAndSendTransaction4(
+        this._chain,
+        tx,
+        this._wallet,
+        this._options,
+        this._crossChainCore
+      );
+      txHashes.push(txId);
+    }
+    return txHashes;
+  }
+};
+var signAndSendTransaction4 = async (chain, request, wallet, options = {}, crossChainCore) => {
+  if (!wallet) {
+    throw new Error("wallet is undefined");
+  }
+  if (chain.context === "Solana") {
+    const signature = await signAndSendTransaction2(
+      request,
+      wallet,
+      options,
+      crossChainCore
+    );
+    return signature;
+  } else if (chain.context === "Ethereum") {
+    const tx = await signAndSendTransaction3(
+      request,
+      wallet,
+      chain.displayName,
+      options
+    );
+    return tx;
+  } else {
+    throw new Error(`Unsupported chain: ${chain}`);
+  }
+};
+
+// src/providers/wormhole/wormhole.ts
+var WormholeProvider = class {
+  constructor(core) {
+    this.crossChainCore = core;
+  }
+  get wormholeContext() {
+    return this._wormholeContext;
+  }
+  async setWormholeContext(sourceChain) {
+    var _a;
+    const dappNetwork = (_a = this.crossChainCore._dappConfig) == null ? void 0 : _a.aptosNetwork;
+    if (dappNetwork === Network.DEVNET) {
+      throw new Error("Devnet is not supported on Wormhole");
+    }
+    if (!sourceChain) {
+      throw new Error("Origin chain not selected");
+    }
+    const isMainnet = dappNetwork === Network.MAINNET;
+    const platforms = [aptos, solana, evm];
+    const wh = await wormhole(isMainnet ? "Mainnet" : "Testnet", platforms);
+    this._wormholeContext = wh;
+  }
+  async getRoute(sourceChain) {
+    if (!this._wormholeContext) {
+      throw new Error("Wormhole context not initialized");
+    }
+    const { sourceToken, destToken } = this.getTokenInfo(sourceChain);
+    const sourceContext = this._wormholeContext.getPlatform(chainToPlatform(sourceChain)).getChain(sourceChain);
+    logger.log("sourceContext", sourceContext);
+    const destContext = this._wormholeContext.getPlatform(chainToPlatform("Aptos")).getChain("Aptos");
+    logger.log("destContext", destContext);
+    const request = await routes.RouteTransferRequest.create(
+      this._wormholeContext,
+      {
+        source: sourceToken,
+        destination: destToken
+      },
+      sourceContext,
+      destContext
+    );
+    const resolver = this._wormholeContext.resolver([
+      routes.CCTPRoute
+    ]);
+    const route = await resolver.findRoutes(request);
+    const cctpRoute = route[0];
+    this.wormholeRoute = cctpRoute;
+    this.wormholeRequest = request;
+    return { route: cctpRoute, request };
+  }
+  async getQuote(input) {
+    const { amount, sourceChain } = input;
+    if (!this._wormholeContext) {
+      await this.setWormholeContext(sourceChain);
+    }
+    const { route, request } = await this.getRoute(sourceChain);
+    const transferParams = {
+      amount,
+      options: { nativeGas: 0 }
+    };
+    const validated = await route.validate(request, transferParams);
+    if (!validated.valid) {
+      logger.log("invalid", validated.valid);
+      throw new Error(`Invalid quote: ${validated.error}`).message;
+    }
+    const quote = await route.quote(request, validated.params);
+    if (!quote.success) {
+      logger.log("quote failed", quote.success);
+      throw new Error(`Invalid quote: ${quote.error}`).message;
+    }
+    this.wormholeQuote = quote;
+    logger.log("quote", quote);
+    return quote;
+  }
+  async submitCCTPTransfer(input) {
+    var _a;
+    const { sourceChain, wallet, destinationAddress } = input;
+    if (!this._wormholeContext) {
+      await this.setWormholeContext(sourceChain);
+    }
+    if (!this.wormholeRoute || !this.wormholeRequest || !this.wormholeQuote) {
+      throw new Error("Wormhole route, request, or quote not initialized");
+    }
+    let signerAddress;
+    const chainContext = this.getChainConfig(sourceChain).context;
+    if (chainContext === "Solana") {
+      signerAddress = ((_a = wallet.solanaWallet.publicKey) == null ? void 0 : _a.toBase58()) || "";
+    } else {
+      [signerAddress] = await wallet.eip1193Provider.request({
+        method: "eth_requestAccounts"
+      });
+    }
+    logger.log("signerAddress", signerAddress);
+    const signer = new Signer(
+      this.getChainConfig(sourceChain),
+      signerAddress,
+      {},
+      wallet
+    );
+    let receipt = await this.wormholeRoute.initiate(
+      this.wormholeRequest,
+      signer,
+      this.wormholeQuote,
+      Wormhole.chainAddress("Aptos", destinationAddress.toString())
+    );
+    const originChainTxnId = "originTxs" in receipt ? receipt.originTxs[receipt.originTxs.length - 1].txid : void 0;
+    return { originChainTxnId: originChainTxnId || "", receipt };
+  }
+  async claimCCTPTransfer(input) {
+    let { receipt, mainSigner, sponsorAccount } = input;
+    if (!this.wormholeRoute) {
+      throw new Error("Wormhole route not initialized");
+    }
+    logger.log("mainSigner", mainSigner.accountAddress.toString());
+    let retries = 0;
+    const maxRetries = 5;
+    const baseDelay = 1e3;
+    while (retries < maxRetries) {
+      try {
+        for await (receipt of this.wormholeRoute.track(receipt, 120 * 1e3)) {
+          if (receipt.state >= TransferState.SourceInitiated) {
+            logger.log("Receipt is on track ", receipt);
+            try {
+              const signer = new AptosLocalSigner(
+                "Aptos",
+                {},
+                mainSigner,
+                sponsorAccount ? sponsorAccount : void 0
+              );
+              if (routes.isManual(this.wormholeRoute)) {
+                const circleAttestationReceipt = await this.wormholeRoute.complete(signer, receipt);
+                logger.log("Claim receipt: ", circleAttestationReceipt);
+                const destinationChainTxnId = signer.claimedTransactionHashes();
+                return { destinationChainTxnId };
+              } else {
+                return { destinationChainTxnId: "" };
+              }
+            } catch (e) {
+              console.error("Failed to claim", e);
+              return { destinationChainTxnId: "" };
+            }
+          }
+        }
+      } catch (e) {
+        console.error(
+          `Error tracking transfer (attempt ${retries + 1} / ${maxRetries}):`,
+          e
+        );
+        const delay = baseDelay * Math.pow(2, retries);
+        await sleep2(delay);
+        retries++;
+      }
+    }
+    return { destinationChainTxnId: "" };
+  }
+  async initiateCCTPTransfer(input) {
+    var _a;
+    if (((_a = this.crossChainCore._dappConfig) == null ? void 0 : _a.aptosNetwork) === Network.DEVNET) {
+      throw new Error("Devnet is not supported on Wormhole");
+    }
+    if (input.amount) {
+      await this.getQuote({
+        amount: input.amount,
+        sourceChain: input.sourceChain
+      });
+    }
+    let { originChainTxnId, receipt } = await this.submitCCTPTransfer(input);
+    const { destinationChainTxnId } = await this.claimCCTPTransfer({
+      receipt,
+      mainSigner: input.mainSigner,
+      sponsorAccount: input.sponsorAccount
+    });
+    return { originChainTxnId, destinationChainTxnId };
+  }
+  getChainConfig(chain) {
+    const chainConfig = this.crossChainCore.CHAINS[chain];
+    if (!chainConfig) {
+      throw new Error(`Chain config not found for chain: ${chain}`);
+    }
+    return chainConfig;
+  }
+  getTokenInfo(sourceChain) {
+    const sourceToken = Wormhole.tokenId(
+      this.crossChainCore.TOKENS[sourceChain].tokenId.chain,
+      this.crossChainCore.TOKENS[sourceChain].tokenId.address
+    );
+    const destToken = Wormhole.tokenId(
+      this.crossChainCore.APTOS_TOKEN.tokenId.chain,
+      this.crossChainCore.APTOS_TOKEN.tokenId.address
+    );
+    return { sourceToken, destToken };
+  }
+};
+
+// src/config/types.ts
+var Context = /* @__PURE__ */ ((Context2) => {
+  Context2["ETH"] = "Ethereum";
+  Context2["SOLANA"] = "Solana";
+  Context2["APTOS"] = "Aptos";
+  return Context2;
+})(Context || {});
+
+// src/config/testnet/chains.ts
+var testnetChains = {
+  Sepolia: {
+    key: "Sepolia",
+    id: 10002,
+    context: "Ethereum" /* ETH */,
+    finalityThreshold: 0,
+    displayName: "Sepolia",
+    explorerUrl: "https://sepolia.etherscan.io/",
+    explorerName: "Etherscan",
+    gasToken: "ETHsepolia",
+    chainId: 11155111,
+    icon: "Ethereum",
+    maxBlockSearch: 2e3,
+    symbol: "ETH",
+    defaultRpc: "https://eth-sepolia.public.blastapi.io",
+    wrappedGasToken: "0xeef12A83EE5b7161D3873317c8E0E7B76e0B5D9c"
+  },
+  Solana: {
+    key: "Solana",
+    id: 1,
+    context: "Solana" /* SOLANA */,
+    finalityThreshold: 32,
+    displayName: "Solana",
+    explorerUrl: "https://explorer.solana.com/",
+    explorerName: "Solana Explorer",
+    gasToken: "SOL",
+    chainId: 0,
+    icon: "Solana",
+    maxBlockSearch: 2e3,
+    symbol: "SOL",
+    defaultRpc: "https://api.devnet.solana.com",
+    wrappedGasToken: "So11111111111111111111111111111111111111112"
+  }
+};
+var AptosTestnetChain = {
+  key: "Aptos",
+  id: 22,
+  context: "Aptos" /* APTOS */,
+  finalityThreshold: 0,
+  displayName: "Aptos",
+  explorerUrl: "https://explorer.aptoslabs.com?network=testnet",
+  explorerName: "Aptos Explorer",
+  gasToken: "APT",
+  chainId: 0,
+  icon: "Aptos",
+  maxBlockSearch: 0,
+  symbol: "APT",
+  sdkName: "Aptos"
+};
+
+// src/config/testnet/tokens.ts
+var testnetTokens = {
+  Sepolia: {
+    symbol: "USDC",
+    icon: "USDC",
+    decimals: 6,
+    tokenId: {
+      chain: "Sepolia",
+      address: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
+    }
+  },
+  Solana: {
+    symbol: "USDC",
+    tokenId: {
+      chain: "Solana",
+      address: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
+    },
+    icon: "USDC",
+    decimals: 6
+  }
+};
+var AptosTestnetUSDCToken = {
+  symbol: "USDC",
+  decimals: 6,
+  tokenId: {
+    chain: "Aptos",
+    address: "0x69091fbab5f7d635ee7ac5098cf0c1efbe31d68fec0f2cd565e8d168daf52832"
+  },
+  icon: "USDC"
+};
+
+// src/config/mainnet/chains.ts
+var mainnetChains = {
+  Ethereum: {
+    key: "Ethereum",
+    id: 2,
+    context: "Ethereum" /* ETH */,
+    finalityThreshold: 64,
+    displayName: "Ethereum",
+    explorerUrl: "https://etherscan.io/",
+    explorerName: "Etherscan",
+    gasToken: "ETH",
+    chainId: 1,
+    icon: "Ethereum",
+    maxBlockSearch: 2e3,
+    symbol: "ETH",
+    defaultRpc: "https://rpc.ankr.com/eth"
+  },
+  Solana: {
+    key: "Solana",
+    id: 1,
+    context: "Solana" /* SOLANA */,
+    finalityThreshold: 32,
+    displayName: "Solana",
+    explorerUrl: "https://explorer.solana.com/",
+    explorerName: "Solana Explorer",
+    gasToken: "SOL",
+    chainId: 0,
+    icon: "Solana",
+    maxBlockSearch: 2e3,
+    symbol: "SOL",
+    defaultRpc: "https://solana-mainnet.rpc.extrnode.com"
+  }
+};
+var AptosMainnetChain = {
+  key: "Aptos",
+  id: 22,
+  context: "Aptos",
+  finalityThreshold: 0,
+  displayName: "Aptos",
+  explorerUrl: "https://explorer.aptoslabs.com/",
+  explorerName: "Aptos Explorer",
+  gasToken: "APT",
+  chainId: 0,
+  icon: "Aptos",
+  maxBlockSearch: 0,
+  symbol: "APT"
+};
+
+// src/config/mainnet/tokens.ts
+var mainnetTokens = {
+  Ethereum: {
+    symbol: "USDC",
+    tokenId: {
+      chain: "Ethereum",
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+    },
+    icon: "USDC",
+    decimals: 6
+  },
+  Solana: {
+    symbol: "USDC",
+    tokenId: {
+      chain: "Solana",
+      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+    },
+    icon: "USDC",
+    decimals: 6
+  }
+};
+var AptosMainnetUSDCToken = {
+  symbol: "USDC",
+  tokenId: {
+    chain: "Aptos",
+    address: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b"
+  },
+  icon: "USDC",
+  decimals: 6
+};
+
+// src/utils/getUsdcBalance.ts
+import { Aptos as Aptos2, AptosConfig as AptosConfig2, Network as Network2 } from "@aptos-labs/ts-sdk";
+import { Connection as Connection2, PublicKey } from "@solana/web3.js";
+import { ethers as ethers2, JsonRpcProvider } from "ethers";
+var getSolanaWalletUSDCBalance = async (walletAddress, aptosNetwork, rpc) => {
+  var _a;
+  const address = new PublicKey(walletAddress);
+  const tokenAddress = aptosNetwork === Network2.MAINNET ? mainnetTokens["Solana"].tokenId.address : testnetTokens["Solana"].tokenId.address;
+  const connection = new Connection2(rpc);
+  const splToken = await connection.getTokenAccountsByOwner(address, {
+    mint: new PublicKey(tokenAddress)
+  });
+  const checkAddress = splToken.value.length > 0 ? splToken.value[0].pubkey : address;
+  const balance = await connection.getTokenAccountBalance(checkAddress);
+  console.log("balance", balance);
+  return (_a = balance.value.uiAmountString) != null ? _a : (Number(balance.value.amount) / 10 ** balance.value.decimals).toString();
+};
+var getEthereumWalletUSDCBalance = async (walletAddress, aptosNetwork, rpc) => {
+  const token = aptosNetwork === Network2.MAINNET ? mainnetTokens["Ethereum"] : testnetTokens["Sepolia"];
+  const tokenAddress = token.tokenId.address;
+  const connection = new JsonRpcProvider(rpc);
+  const abi = ["function balanceOf(address owner) view returns (uint256)"];
+  const contract = new ethers2.Contract(tokenAddress, abi, connection);
+  const balance = await contract.balanceOf(walletAddress);
+  return ethers2.formatUnits(balance, token.decimals).toString();
+};
+var getAptosWalletUSDCBalance = async (walletAddress, aptosNetwork) => {
+  const token = aptosNetwork === Network2.MAINNET ? AptosMainnetUSDCToken : AptosTestnetUSDCToken;
+  const tokenAddress = token.tokenId.address;
+  const aptosConfig = new AptosConfig2({ network: aptosNetwork });
+  const connection = new Aptos2(aptosConfig);
+  const response = await connection.getCurrentFungibleAssetBalances({
+    options: {
+      where: {
+        owner_address: { _eq: walletAddress },
+        asset_type: { _eq: tokenAddress }
+      }
+    }
+  });
+  const balance = (Number(response[0].amount) / 10 ** token.decimals).toString();
+  return balance;
+};
+
+// src/CrossChainCore.ts
+import { NetworkToChainId, NetworkToNodeAPI } from "@aptos-labs/ts-sdk";
+var CrossChainCore = class {
+  constructor(args) {
+    this._dappConfig = {
+      aptosNetwork: Network3.TESTNET
+    };
+    this.CHAINS = testnetChains;
+    this.TOKENS = testnetTokens;
+    this.APTOS_TOKEN = AptosTestnetUSDCToken;
+    var _a;
+    this._dappConfig = args.dappConfig;
+    if (((_a = args.dappConfig) == null ? void 0 : _a.aptosNetwork) === Network3.MAINNET) {
+      this.CHAINS = mainnetChains;
+      this.TOKENS = mainnetTokens;
+      this.APTOS_TOKEN = AptosMainnetUSDCToken;
+    } else {
+      this.CHAINS = testnetChains;
+      this.TOKENS = testnetTokens;
+      this.APTOS_TOKEN = AptosTestnetUSDCToken;
+    }
+  }
+  getProvider(providerType) {
+    switch (providerType) {
+      case "Wormhole":
+        return new WormholeProvider(this);
+      default:
+        throw new Error(`Unknown provider: ${providerType}`);
+    }
+  }
+  async getWalletUSDCBalance(walletAddress, sourceChain) {
+    var _a, _b, _c;
+    if (sourceChain === "Aptos") {
+      return await getAptosWalletUSDCBalance(
+        walletAddress,
+        this._dappConfig.aptosNetwork
+      );
+    }
+    if (!this.CHAINS[sourceChain]) {
+      throw new Error(`Unsupported chain: ${sourceChain}`);
+    }
+    switch (sourceChain) {
+      case "Solana":
+        return await getSolanaWalletUSDCBalance(
+          walletAddress,
+          this._dappConfig.aptosNetwork,
+          (_c = (_b = (_a = this._dappConfig) == null ? void 0 : _a.solanaConfig) == null ? void 0 : _b.rpc) != null ? _c : this.CHAINS[sourceChain].defaultRpc
+        );
+      case "Ethereum":
+      case "Sepolia":
+        return await getEthereumWalletUSDCBalance(
+          walletAddress,
+          this._dappConfig.aptosNetwork,
+          this.CHAINS[sourceChain].defaultRpc
+        );
+      default:
+        throw new Error(`Unsupported chain: ${sourceChain}`);
+    }
+  }
+};
+
+// src/index.ts
+import { Network as Network4 } from "@aptos-labs/ts-sdk";
+export {
+  AptosLocalSigner,
+  AptosMainnetChain,
+  AptosMainnetUSDCToken,
+  AptosTestnetChain,
+  AptosTestnetUSDCToken,
+  Context,
+  CrossChainCore,
+  Network4 as Network,
+  NetworkToChainId,
+  NetworkToNodeAPI,
+  WormholeProvider,
+  mainnetChains,
+  mainnetTokens,
+  signAndSendTransaction,
+  testnetChains,
+  testnetTokens
+};
+//# sourceMappingURL=index.mjs.map