@1llet.xyz/erc4337-gasless-sdk 0.4.70 → 0.4.72

package/dist/index.mjs

@@ -1,10 +1,10 @@
-import { monad, unichain, arbitrum, polygon, bsc, avalanche, optimism, gnosis, baseSepolia, base, optimismSepolia, worldchain } from 'viem/chains';
+import { parseAbi, createPublicClient, http, encodeFunctionData, createWalletClient, decodeErrorResult, getAddress, parseUnits, formatUnits, erc20Abi as erc20Abi$1, encodeAbiParameters, keccak256, maxUint256, padHex, toHex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { monad, unichain, arbitrum, polygon, bsc, avalanche, optimism, gnosis, baseSepolia, base, optimismSepolia, mainnet, worldchain } from 'viem/chains';
 import * as StellarSdk from 'stellar-sdk';
 import { Networks } from 'stellar-sdk';
 import axios from 'axios';
-import { parseAbi, createPublicClient, http, encodeFunctionData, createWalletClient, decodeErrorResult, encodeAbiParameters, keccak256, maxUint256, padHex } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { OpenAPI, OneClickService, QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
+import { OpenAPI, QuoteRequest, OneClickService } from '@defuse-protocol/one-click-sdk-typescript';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -16,6 +16,858 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/constants.ts
+var factoryAbi, entryPointAbi, smartAccountAbi, erc20Abi;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    factoryAbi = [
+      {
+        inputs: [
+          { name: "owner", type: "address" },
+          { name: "salt", type: "uint256" }
+        ],
+        name: "getAccountAddress",
+        outputs: [{ name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "owner", type: "address" },
+          { name: "salt", type: "uint256" }
+        ],
+        name: "isAccountDeployed",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "owner", type: "address" },
+          { name: "salt", type: "uint256" }
+        ],
+        name: "createAccount",
+        outputs: [{ name: "account", type: "address" }],
+        stateMutability: "nonpayable",
+        type: "function"
+      }
+    ];
+    entryPointAbi = [
+      {
+        inputs: [
+          { name: "sender", type: "address" },
+          { name: "key", type: "uint192" }
+        ],
+        name: "getNonce",
+        outputs: [{ name: "nonce", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+    smartAccountAbi = [
+      {
+        inputs: [
+          { name: "target", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "data", type: "bytes" }
+        ],
+        name: "execute",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "targets", type: "address[]" },
+          { name: "values", type: "uint256[]" },
+          { name: "datas", type: "bytes[]" }
+        ],
+        name: "executeBatch",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function"
+      }
+    ];
+    erc20Abi = [
+      {
+        inputs: [{ name: "account", type: "address" }],
+        name: "balanceOf",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "to", type: "address" },
+          { name: "amount", type: "uint256" }
+        ],
+        name: "transfer",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "spender", type: "address" },
+          { name: "amount", type: "uint256" }
+        ],
+        name: "approve",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "owner", type: "address" },
+          { name: "spender", type: "address" }
+        ],
+        name: "allowance",
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function"
+      },
+      {
+        inputs: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "amount", type: "uint256" }
+        ],
+        name: "transferFrom",
+        outputs: [{ name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function"
+      },
+      {
+        inputs: [],
+        name: "decimals",
+        outputs: [{ name: "", type: "uint8" }],
+        stateMutability: "view",
+        type: "function"
+      }
+    ];
+  }
+});
+
+// src/BundlerClient.ts
+var BundlerClient;
+var init_BundlerClient = __esm({
+  "src/BundlerClient.ts"() {
+    BundlerClient = class {
+      constructor(config, entryPointAddress) {
+        this.bundlerUrl = config.bundlerUrl;
+        this.entryPointAddress = entryPointAddress;
+      }
+      async call(method, params) {
+        const response = await fetch(this.bundlerUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method,
+            params
+          })
+        });
+        const result = await response.json();
+        if (result.error) {
+          throw new Error(result.error.message);
+        }
+        return result.result;
+      }
+      async estimateGas(userOp) {
+        const result = await this.call("eth_estimateUserOperationGas", [
+          {
+            sender: userOp.sender,
+            nonce: userOp.nonce ? "0x" + userOp.nonce.toString(16) : "0x0",
+            initCode: userOp.initCode || "0x",
+            callData: userOp.callData || "0x",
+            paymasterAndData: userOp.paymasterAndData || "0x",
+            signature: "0x"
+          },
+          this.entryPointAddress
+        ]);
+        console.log("DEBUG: estimateGas result:", result);
+        return {
+          callGasLimit: result.callGasLimit,
+          verificationGasLimit: result.verificationGasLimit,
+          preVerificationGas: result.preVerificationGas,
+          maxFeePerGas: result.maxFeePerGas,
+          maxPriorityFeePerGas: result.maxPriorityFeePerGas,
+          paymasterAndData: result.paymasterAndData
+        };
+      }
+      async sendUserOperation(userOp) {
+        return await this.call("eth_sendUserOperation", [
+          {
+            sender: userOp.sender,
+            nonce: "0x" + userOp.nonce.toString(16),
+            initCode: userOp.initCode,
+            callData: userOp.callData,
+            callGasLimit: "0x" + userOp.callGasLimit.toString(16),
+            verificationGasLimit: "0x" + userOp.verificationGasLimit.toString(16),
+            preVerificationGas: "0x" + userOp.preVerificationGas.toString(16),
+            maxFeePerGas: "0x" + userOp.maxFeePerGas.toString(16),
+            maxPriorityFeePerGas: "0x" + userOp.maxPriorityFeePerGas.toString(16),
+            paymasterAndData: userOp.paymasterAndData,
+            signature: userOp.signature
+          },
+          this.entryPointAddress
+        ]);
+      }
+      async waitForUserOperation(userOpHash, timeout = 6e4) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+          const result = await this.call("eth_getUserOperationReceipt", [userOpHash]);
+          if (result) {
+            return result;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 2e3));
+        }
+        throw new Error("Timeout waiting for UserOperation");
+      }
+      async requestApprovalSupport(token, owner, spender, amount) {
+        return await this.call("pm_requestApprovalSupport", [
+          token,
+          owner,
+          spender,
+          amount.toString()
+        ]);
+      }
+      async scheduleUserOp(userOp, condition) {
+        return await this.call("bundler_scheduleUserOp", [
+          {
+            sender: userOp.sender,
+            nonce: "0x" + userOp.nonce.toString(16),
+            initCode: userOp.initCode,
+            callData: userOp.callData,
+            callGasLimit: "0x" + userOp.callGasLimit.toString(16),
+            verificationGasLimit: "0x" + userOp.verificationGasLimit.toString(16),
+            preVerificationGas: "0x" + userOp.preVerificationGas.toString(16),
+            maxFeePerGas: "0x" + userOp.maxFeePerGas.toString(16),
+            maxPriorityFeePerGas: "0x" + userOp.maxPriorityFeePerGas.toString(16),
+            paymasterAndData: userOp.paymasterAndData,
+            signature: userOp.signature
+          },
+          condition
+        ]);
+      }
+    };
+  }
+});
+var TokenService;
+var init_TokenService = __esm({
+  "src/TokenService.ts"() {
+    init_constants();
+    TokenService = class {
+      constructor(chainConfig, publicClient) {
+        this.tokens = /* @__PURE__ */ new Map();
+        this.publicClient = publicClient;
+        chainConfig.tokens.forEach((token) => {
+          this.tokens.set(token.symbol.toUpperCase(), token);
+        });
+      }
+      /**
+       * Resolve token address from symbol or return address if provided
+       */
+      getTokenAddress(token) {
+        if (token.startsWith("0x")) return token;
+        const info = this.tokens.get(token.toUpperCase());
+        if (!info) throw new Error(`Token ${token} not found in chain config`);
+        return info.address;
+      }
+      /**
+       * Get balance of a token for an account
+       */
+      async getBalance(token, account) {
+        const address = this.getTokenAddress(token);
+        if (address === "0x0000000000000000000000000000000000000000") {
+          return await this.publicClient.getBalance({ address: account });
+        }
+        return await this.publicClient.readContract({
+          address,
+          abi: erc20Abi,
+          functionName: "balanceOf",
+          args: [account]
+        });
+      }
+      /**
+       * Get allowance (ERC-20 only)
+       */
+      async getAllowance(token, owner, spender) {
+        const address = this.getTokenAddress(token);
+        if (address === "0x0000000000000000000000000000000000000000") {
+          return 0n;
+        }
+        return await this.publicClient.readContract({
+          address,
+          abi: erc20Abi,
+          functionName: "allowance",
+          args: [owner, spender]
+        });
+      }
+      /**
+       * Encode transfer data
+       */
+      encodeTransfer(recipient, amount) {
+        return encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "transfer",
+          args: [recipient, amount]
+        });
+      }
+      /**
+       * Encode transferFrom data
+       */
+      encodeTransferFrom(sender, recipient, amount) {
+        return encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "transferFrom",
+          args: [sender, recipient, amount]
+        });
+      }
+      /**
+       * Encode approve data
+       */
+      encodeApprove(spender, amount) {
+        return encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [spender, amount]
+        });
+      }
+    };
+  }
+});
+var UserOpBuilder;
+var init_UserOpBuilder = __esm({
+  "src/UserOpBuilder.ts"() {
+    init_constants();
+    UserOpBuilder = class {
+      constructor(chainConfig, bundlerClient, publicClient) {
+        this.chainConfig = chainConfig;
+        this.bundlerClient = bundlerClient;
+        this.publicClient = publicClient;
+        this.entryPointAddress = chainConfig.entryPointAddress;
+        this.factoryAddress = chainConfig.factoryAddress;
+      }
+      async getNonce(smartAccountAddress) {
+        return await this.publicClient.readContract({
+          address: this.entryPointAddress,
+          abi: entryPointAbi,
+          functionName: "getNonce",
+          args: [smartAccountAddress, 0n]
+        });
+      }
+      buildInitCode(owner) {
+        const createAccountData = encodeFunctionData({
+          abi: factoryAbi,
+          functionName: "createAccount",
+          args: [owner, 0n]
+        });
+        return `${this.factoryAddress}${createAccountData.slice(2)}`;
+      }
+      async isAccountDeployed(smartAccountAddress) {
+        const code = await this.publicClient.getCode({
+          address: smartAccountAddress
+        });
+        return code !== void 0 && code !== "0x";
+      }
+      async buildUserOperationBatch(owner, smartAccountAddress, transactions) {
+        const isDeployed = await this.isAccountDeployed(smartAccountAddress);
+        const initCode = isDeployed ? "0x" : this.buildInitCode(owner);
+        const targets = transactions.map((tx) => tx.target);
+        const values = transactions.map((tx) => tx.value);
+        const datas = transactions.map((tx) => tx.data);
+        const callData = encodeFunctionData({
+          abi: smartAccountAbi,
+          functionName: "executeBatch",
+          args: [targets, values, datas]
+        });
+        const nonce = await this.getNonce(smartAccountAddress);
+        const partialOp = {
+          sender: smartAccountAddress,
+          nonce,
+          initCode,
+          callData,
+          paymasterAndData: this.chainConfig.paymasterAddress || "0x"
+        };
+        const gasEstimate = await this.bundlerClient.estimateGas(partialOp);
+        return {
+          ...partialOp,
+          callGasLimit: BigInt(gasEstimate.callGasLimit),
+          verificationGasLimit: BigInt(gasEstimate.verificationGasLimit),
+          preVerificationGas: BigInt(gasEstimate.preVerificationGas),
+          maxFeePerGas: BigInt(gasEstimate.maxFeePerGas),
+          maxPriorityFeePerGas: BigInt(gasEstimate.maxPriorityFeePerGas),
+          paymasterAndData: gasEstimate.paymasterAndData || partialOp.paymasterAndData,
+          signature: "0x"
+        };
+      }
+      async buildDeployUserOp(owner, smartAccountAddress) {
+        const isDeployed = await this.isAccountDeployed(smartAccountAddress);
+        if (isDeployed) throw new Error("Account already deployed");
+        const initCode = this.buildInitCode(owner);
+        const callData = "0x";
+        const nonce = await this.getNonce(smartAccountAddress);
+        const partialOp = {
+          sender: smartAccountAddress,
+          nonce,
+          initCode,
+          callData,
+          paymasterAndData: this.chainConfig.paymasterAddress || "0x"
+        };
+        const gasEstimate = await this.bundlerClient.estimateGas(partialOp);
+        return {
+          ...partialOp,
+          callGasLimit: BigInt(gasEstimate.callGasLimit),
+          verificationGasLimit: BigInt(gasEstimate.verificationGasLimit),
+          preVerificationGas: BigInt(gasEstimate.preVerificationGas),
+          maxFeePerGas: BigInt(gasEstimate.maxFeePerGas),
+          maxPriorityFeePerGas: BigInt(gasEstimate.maxPriorityFeePerGas),
+          paymasterAndData: gasEstimate.paymasterAndData || partialOp.paymasterAndData,
+          signature: "0x"
+        };
+      }
+      getUserOpHash(userOp) {
+        const packed = encodeAbiParameters(
+          [
+            { type: "address" },
+            { type: "uint256" },
+            { type: "bytes32" },
+            { type: "bytes32" },
+            { type: "uint256" },
+            { type: "uint256" },
+            { type: "uint256" },
+            { type: "uint256" },
+            { type: "uint256" },
+            { type: "bytes32" }
+          ],
+          [
+            userOp.sender,
+            userOp.nonce,
+            keccak256(userOp.initCode),
+            keccak256(userOp.callData),
+            userOp.callGasLimit,
+            userOp.verificationGasLimit,
+            userOp.preVerificationGas,
+            userOp.maxFeePerGas,
+            userOp.maxPriorityFeePerGas,
+            keccak256(userOp.paymasterAndData)
+          ]
+        );
+        const packedHash = keccak256(packed);
+        return keccak256(
+          encodeAbiParameters(
+            [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
+            [packedHash, this.entryPointAddress, BigInt(this.chainConfig.chain.id)]
+          )
+        );
+      }
+    };
+  }
+});
+var AccountAbstraction;
+var init_AccountAbstraction = __esm({
+  "src/AccountAbstraction.ts"() {
+    init_constants();
+    init_BundlerClient();
+    init_TokenService();
+    init_UserOpBuilder();
+    AccountAbstraction = class {
+      constructor(chainConfig) {
+        this.owner = null;
+        this.smartAccountAddress = null;
+        this.walletClient = null;
+        this.chainConfig = chainConfig;
+        if (!chainConfig.entryPointAddress) throw new Error("EntryPoint address required");
+        this.entryPointAddress = chainConfig.entryPointAddress;
+        if (!chainConfig.factoryAddress) throw new Error("Factory address required");
+        this.factoryAddress = chainConfig.factoryAddress;
+        const rpcUrl = chainConfig.rpcUrl || chainConfig.chain.rpcUrls.default.http[0];
+        this.publicClient = createPublicClient({
+          chain: chainConfig.chain,
+          transport: http(rpcUrl)
+        });
+        this.bundlerClient = new BundlerClient(chainConfig, this.entryPointAddress);
+        this.tokenService = new TokenService(chainConfig, this.publicClient);
+        this.userOpBuilder = new UserOpBuilder(chainConfig, this.bundlerClient, this.publicClient);
+      }
+      getBundlerClient() {
+        return this.bundlerClient;
+      }
+      getChainId() {
+        return this.chainConfig.chain.id;
+      }
+      getPublicClient() {
+        return this.publicClient;
+      }
+      async buildUserOperation(transaction) {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        return this.userOpBuilder.buildUserOperationBatch(this.owner, this.smartAccountAddress, [transaction]);
+      }
+      async buildBatchUserOperation(transactions) {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        return this.userOpBuilder.buildUserOperationBatch(this.owner, this.smartAccountAddress, transactions);
+      }
+      async connect(signer) {
+        if (typeof signer === "string") {
+          const account = privateKeyToAccount(signer);
+          this.owner = account.address;
+          const rpcUrl = this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0];
+          this.walletClient = createWalletClient({
+            account,
+            chain: this.chainConfig.chain,
+            transport: http(rpcUrl)
+          });
+        } else if (signer && typeof signer === "object") {
+          this.walletClient = signer;
+          if (!this.walletClient.account) throw new Error("WalletClient must have an account");
+          this.owner = this.walletClient.account.address;
+        } else {
+          if (typeof window === "undefined" || !window.ethereum) {
+            throw new Error("MetaMask is not installed and no private key provided");
+          }
+          const accounts = await window.ethereum.request({
+            method: "eth_requestAccounts"
+          });
+          if (!accounts || accounts.length === 0) throw new Error("No accounts found");
+          const chainId = await window.ethereum.request({
+            method: "eth_chainId"
+          });
+          const targetChainId = this.chainConfig.chain.id;
+          if (parseInt(chainId, 16) !== targetChainId) {
+            try {
+              await window.ethereum.request({
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId: "0x" + targetChainId.toString(16) }]
+              });
+            } catch (switchError) {
+              const error = switchError;
+              if (error.code === 4902) {
+                await window.ethereum.request({
+                  method: "wallet_addEthereumChain",
+                  params: [
+                    {
+                      chainId: "0x" + targetChainId.toString(16),
+                      chainName: this.chainConfig.chain.name,
+                      nativeCurrency: this.chainConfig.chain.nativeCurrency,
+                      rpcUrls: [this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0]],
+                      blockExplorerUrls: this.chainConfig.chain.blockExplorers?.default?.url ? [this.chainConfig.chain.blockExplorers.default.url] : []
+                    }
+                  ]
+                });
+              } else {
+                throw switchError;
+              }
+            }
+          }
+          this.owner = accounts[0];
+        }
+        this.smartAccountAddress = await this.getSmartAccountAddress(this.owner);
+        return {
+          owner: this.owner,
+          smartAccount: this.smartAccountAddress
+        };
+      }
+      // --- Account Management ---
+      async isAccountDeployed() {
+        if (!this.smartAccountAddress) return false;
+        const code = await this.publicClient.getBytecode({ address: this.smartAccountAddress });
+        return code !== void 0;
+      }
+      async deployAccount() {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        return this.sendTransaction({
+          target: this.smartAccountAddress,
+          value: 0n,
+          data: "0x"
+        });
+      }
+      /**
+       * Get the Smart Account address for an owner
+       */
+      async getSmartAccountAddress(owner) {
+        try {
+          const address = await this.publicClient.readContract({
+            address: this.factoryAddress,
+            abi: factoryAbi,
+            functionName: "getAccountAddress",
+            args: [owner, 0n]
+          });
+          return address;
+        } catch (e) {
+          try {
+            const { result } = await this.publicClient.simulateContract({
+              address: this.factoryAddress,
+              abi: factoryAbi,
+              functionName: "createAccount",
+              args: [owner, 0n],
+              account: "0x0000000000000000000000000000000000000000"
+              // Zero address or random for simulation
+            });
+            return result;
+          } catch (inner) {
+            throw e;
+          }
+        }
+      }
+      // --- Token Methods (Delegated) ---
+      getTokenAddress(token) {
+        return this.tokenService.getTokenAddress(token);
+      }
+      async getBalance(token) {
+        if (!this.smartAccountAddress) throw new Error("Not connected");
+        return this.tokenService.getBalance(token, this.smartAccountAddress);
+      }
+      async getEoaBalance(token) {
+        if (!this.owner) throw new Error("Not connected");
+        return this.tokenService.getBalance(token, this.owner);
+      }
+      async getAllowance(token = "USDC") {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        return this.tokenService.getAllowance(token, this.owner, this.smartAccountAddress);
+      }
+      /**
+       * Get comprehensive state of the account for a specific token
+       * Useful for UI initialization
+       */
+      async getAccountState(token) {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        const tokenAddress = this.getTokenAddress(token);
+        const isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
+        const [balance, eoaBalance, allowance, isDeployed] = await Promise.all([
+          this.getBalance(token),
+          this.getEoaBalance(token),
+          isNative ? 0n : this.getAllowance(token).catch(() => 0n),
+          // Handle native/error gracefully
+          this.isAccountDeployed()
+        ]);
+        return {
+          owner: this.owner,
+          smartAccount: this.smartAccountAddress,
+          balance,
+          eoaBalance,
+          allowance,
+          isDeployed
+        };
+      }
+      // --- Transactions ---
+      async sendTransaction(tx) {
+        return this.sendBatchTransaction([tx]);
+      }
+      async sendBatchTransaction(txs) {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        const transactions = txs.map((tx) => ({
+          target: tx.target,
+          value: tx.value ?? 0n,
+          data: tx.data ?? "0x"
+        }));
+        try {
+          const userOp = await this.userOpBuilder.buildUserOperationBatch(
+            this.owner,
+            this.smartAccountAddress,
+            transactions
+          );
+          const signed = await this.signUserOperation(userOp);
+          const hash = await this.sendUserOperation(signed);
+          return await this.waitForUserOperation(hash);
+        } catch (error) {
+          throw this.decodeError(error);
+        }
+      }
+      async deposit(amount) {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        if (this.walletClient) {
+          return await this.walletClient.sendTransaction({
+            account: this.walletClient.account,
+            to: this.smartAccountAddress,
+            value: amount,
+            chain: this.chainConfig.chain
+          });
+        }
+        return await window.ethereum.request({
+          method: "eth_sendTransaction",
+          params: [{
+            from: this.owner,
+            to: this.smartAccountAddress,
+            value: "0x" + amount.toString(16)
+          }]
+        });
+      }
+      /**
+       * Smart Transfer: Automatically chooses best method (SA vs EOA) based on balances.
+       * Supports strict fee handling.
+       */
+      async smartTransfer(token, recipient, amount, fee) {
+        if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+        const tokenAddress = this.getTokenAddress(token);
+        const isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
+        const [saBal, eoaBal, allowance] = await Promise.all([
+          this.getBalance(token),
+          this.getEoaBalance(token),
+          isNative ? 0n : this.getAllowance(token).catch(() => 0n)
+        ]);
+        const totalNeeded = amount + (fee?.amount || 0n);
+        if (saBal >= totalNeeded) {
+          const txs = [];
+          if (isNative) {
+            txs.push({ target: recipient, value: amount, data: "0x" });
+          } else {
+            txs.push({ target: tokenAddress, value: 0n, data: this.tokenService.encodeTransfer(recipient, amount) });
+          }
+          if (fee && fee.amount > 0n) {
+            if (isNative) {
+              txs.push({ target: fee.recipient, value: fee.amount, data: "0x" });
+            } else {
+              txs.push({ target: tokenAddress, value: 0n, data: this.tokenService.encodeTransfer(fee.recipient, fee.amount) });
+            }
+          }
+          console.log("SmartTransfer: Using Smart Account");
+          return this.sendBatchTransaction(txs);
+        }
+        if (eoaBal >= totalNeeded) {
+          if (isNative) {
+            console.log("SmartTransfer: Using EOA (Native)");
+            if (this.walletClient) {
+              const hash2 = await this.walletClient.sendTransaction({
+                account: this.walletClient.account,
+                to: recipient,
+                value: amount,
+                chain: this.chainConfig.chain
+              });
+              return { receipt: { transactionHash: hash2 } };
+            }
+            const hash = await window.ethereum.request({
+              method: "eth_sendTransaction",
+              params: [{ from: this.owner, to: recipient, value: "0x" + amount.toString(16) }]
+            });
+            return { receipt: { transactionHash: hash } };
+          } else {
+            console.log("SmartTransfer: Using EOA (Pull)");
+            if (allowance < totalNeeded) {
+              throw new Error(`Approval required. Please approve ${token} usage.`);
+            }
+            const txs = [];
+            txs.push({
+              target: tokenAddress,
+              value: 0n,
+              data: this.tokenService.encodeTransferFrom(this.owner, recipient, amount)
+            });
+            if (fee && fee.amount > 0n) {
+              txs.push({
+                target: tokenAddress,
+                value: 0n,
+                data: this.tokenService.encodeTransferFrom(this.owner, fee.recipient, fee.amount)
+              });
+            }
+            return this.sendBatchTransaction(txs);
+          }
+        }
+        throw new Error(`Insufficient funds.`);
+      }
+      async transfer(token, recipient, amount) {
+        const tokenAddress = this.getTokenAddress(token);
+        if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+          return this.sendTransaction({
+            target: recipient,
+            value: amount,
+            data: "0x"
+          });
+        }
+        const data = this.tokenService.encodeTransfer(recipient, amount);
+        return this.sendTransaction({
+          target: tokenAddress,
+          value: 0n,
+          data
+        });
+      }
+      /**
+       * Approve a token for the Smart Account
+       */
+      async approveToken(token, spender, amount = 115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
+        if (!this.owner) throw new Error("Not connected");
+        const support = await this.requestApprovalSupport(token, spender, amount);
+        if (support.type === "approve") {
+          const data = this.tokenService.encodeApprove(spender, amount);
+          if (this.walletClient) {
+            return await this.walletClient.sendTransaction({
+              account: this.walletClient.account,
+              to: token,
+              data,
+              chain: this.chainConfig.chain
+            });
+          }
+          return await window.ethereum.request({
+            method: "eth_sendTransaction",
+            params: [{
+              from: this.owner,
+              to: token,
+              data
+            }]
+          });
+        }
+        if (support.type === "permit") throw new Error("Permit not yet supported");
+        return "NOT_NEEDED";
+      }
+      // --- Core Bridge to Bundler/UserOp ---
+      async signUserOperation(userOp) {
+        if (!this.owner) throw new Error("Not connected");
+        const userOpHash = this.userOpBuilder.getUserOpHash(userOp);
+        let signature;
+        if (this.walletClient) {
+          signature = await this.walletClient.signMessage({
+            account: this.walletClient.account,
+            message: { raw: userOpHash }
+            // Sign hash directly
+          });
+        } else {
+          signature = await window.ethereum.request({
+            method: "personal_sign",
+            params: [userOpHash, this.owner]
+          });
+        }
+        return { ...userOp, signature };
+      }
+      async sendUserOperation(userOp) {
+        return this.bundlerClient.sendUserOperation(userOp);
+      }
+      async waitForUserOperation(hash, timeout = 6e4) {
+        return this.bundlerClient.waitForUserOperation(hash, timeout);
+      }
+      // Internal but exposed via BundlerClient originally
+      async requestApprovalSupport(token, spender, amount) {
+        if (!this.owner) throw new Error("Not connected");
+        return this.bundlerClient.requestApprovalSupport(token, this.owner, spender, amount);
+      }
+      // Error Decoding (Private)
+      decodeError(error) {
+        const msg = error?.message || "";
+        const hexMatch = msg.match(/(0x[0-9a-fA-F]+)/);
+        if (hexMatch) {
+          try {
+            const decoded = decodeErrorResult({
+              abi: [{ inputs: [{ name: "message", type: "string" }], name: "Error", type: "error" }],
+              data: hexMatch[0]
+            });
+            if (decoded.errorName === "Error") return new Error(`Smart Account Error: ${decoded.args[0]}`);
+          } catch (e) {
+          }
+        }
+        if (msg.includes("AA21")) return new Error("Smart Account: Native transfer failed (ETH missing?)");
+        if (msg.includes("AA25")) return new Error("Smart Account: Invalid account nonce");
+        return error instanceof Error ? error : new Error(String(error));
+      }
+      // Getters
+      getOwner() {
+        return this.owner;
+      }
+      getSmartAccount() {
+        return this.smartAccountAddress;
+      }
+    };
+  }
+});
+
 // src/constants/bundler.ts
 var DEFAULT_BUNDLER_URL, BUNDLER_URL;
 var init_bundler = __esm({
@@ -48,7 +900,7 @@ var init_Base = __esm({
         chain: base,
         rpcUrl: "https://base-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
         supports7702: true,
-        erc4337: false,
+        erc4337: true,
         bundlerUrl: `${BUNDLER_URL}/rpc?chain=base`,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
         factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
@@ -86,103 +938,74 @@ var init_Base = __esm({
     };
   }
 });
-var GNOSIS;
-var init_Gnosis = __esm({
-  "src/chains/Evm/Gnosis.ts"() {
+var AVALANCHE;
+var init_Avalanche = __esm({
+  "src/chains/Evm/Avalanche.ts"() {
     init_bundler();
-    GNOSIS = {
+    AVALANCHE = {
       assets: [
         {
           name: "USDC",
           decimals: 6,
-          address: "0x2a22f9c3b484c3629090FeED35F17Ff8F88f76F0",
-          coingeckoId: "usd-coin"
-        },
-        {
-          name: "USDT",
-          decimals: 6,
-          address: "0x4ECaBa5870353805a9F068101A40E0f32ed605C6",
-          coingeckoId: "tether"
-        },
-        {
-          name: "EURe",
-          decimals: 18,
-          address: "0x420CA0f9B9b604cE0fd9C18EF134C705e5Fa3430",
-          coingeckoId: "monerium-eur-money"
-        },
-        {
-          name: "GNO",
-          decimals: 18,
-          address: "0x9C58BAcC331c9aa871AFD802DB6379a98e80CEdb",
-          coingeckoId: "gnosis"
+          address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+          coingeckoId: "usd-coin",
+          supportsStargate: true
         },
         {
-          name: "WETH",
+          name: "AVAX",
           decimals: 18,
-          address: "0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1",
-          coingeckoId: "ethereum"
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "avalanche-2"
         },
         {
-          name: "XDAI",
-          decimals: 18,
-          address: "0x0000000000000000000000000000000000000000",
-          coingeckoId: "xdai"
+          name: "USDT",
+          decimals: 6,
+          address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+          coingeckoId: "tether"
         }
       ],
       evm: {
-        chain: gnosis,
-        rpcUrl: gnosis.rpcUrls.default.http[0],
-        supports7702: true,
-        erc4337: true,
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=gnosis`,
+        chain: avalanche,
+        rpcUrl: avalanche.rpcUrls.default.http[0],
+        supports7702: false,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=avalanche`,
+        erc4337: false,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0xC8a2Fb1f2E686417A131E09be3320cb5431CcD90",
-        paymasterAddress: "0x4C36C70d68a7c26326711e8268bb163E3784fA96"
+        factoryAddress: "0x5D1D71FE2De5D1C52c7c11311332eC7f0CBf88aF",
+        paymasterAddress: "0x6c0de464F2203FE089FF719Acf425dFfE6ac1EE5"
       },
       crossChainInformation: {
         circleInformation: {
-          supportCirclePaymaster: false,
-          aproxFromFee: 0,
+          supportCirclePaymaster: true,
           cCTPInformation: {
-            supportCCTP: false,
-            domain: 0
-          }
+            supportCCTP: true,
+            domain: 1
+          },
+          aproxFromFee: 0
         },
         nearIntentInformation: {
           support: true,
           assetsId: [
             {
-              assetId: "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
+              assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
               name: "USDC",
               decimals: 6
             },
             {
-              assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
-              name: "USDT",
-              decimals: 6
-            },
-            {
-              assetId: "nep141:gnosis-0x420ca0f9b9b604ce0fd9c18ef134c705e5fa3430.omft.near",
-              name: "EURe",
-              decimals: 18
-            },
-            {
-              assetId: "nep141:gnosis-0x9c58bacc331c9aa871afd802db6379a98e80cedb.omft.near",
-              name: "GNO",
-              decimals: 18
-            },
-            {
-              assetId: "nep141:gnosis-0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1.omft.near",
-              name: "WETH",
+              assetId: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
+              name: "AVAX",
               decimals: 18
             },
             {
-              assetId: "nep141:gnosis.omft.near",
-              name: "XDAI",
-              decimals: 18
+              assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
+              name: "USDT",
+              decimals: 6
             }
           ],
           needMemo: false
+        },
+        stargateInformation: {
+          support: true
         }
       }
     };
@@ -221,7 +1044,7 @@ var init_Optimism = __esm({
       ],
       evm: {
         chain: optimism,
-        rpcUrl: "https://opt-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
+        rpcUrl: "https://mainnet.optimism.io",
         supports7702: false,
         erc4337: false,
         bundlerUrl: `${BUNDLER_URL}/rpc?chain=optimism`,
@@ -268,74 +1091,103 @@ var init_Optimism = __esm({
     };
   }
 });
-var AVALANCHE;
-var init_Avalanche = __esm({
-  "src/chains/Evm/Avalanche.ts"() {
+var GNOSIS;
+var init_Gnosis = __esm({
+  "src/chains/Evm/Gnosis.ts"() {
     init_bundler();
-    AVALANCHE = {
+    GNOSIS = {
       assets: [
         {
           name: "USDC",
           decimals: 6,
-          address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-          coingeckoId: "usd-coin",
-          supportsStargate: true
-        },
-        {
-          name: "AVAX",
-          decimals: 18,
-          address: "0x0000000000000000000000000000000000000000",
-          coingeckoId: "avalanche-2"
+          address: "0x2a22f9c3b484c3629090FeED35F17Ff8F88f76F0",
+          coingeckoId: "usd-coin"
         },
         {
           name: "USDT",
           decimals: 6,
-          address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+          address: "0x4ECaBa5870353805a9F068101A40E0f32ed605C6",
           coingeckoId: "tether"
+        },
+        {
+          name: "EURe",
+          decimals: 18,
+          address: "0x420CA0f9B9b604cE0fd9C18EF134C705e5Fa3430",
+          coingeckoId: "monerium-eur-money"
+        },
+        {
+          name: "GNO",
+          decimals: 18,
+          address: "0x9C58BAcC331c9aa871AFD802DB6379a98e80CEdb",
+          coingeckoId: "gnosis"
+        },
+        {
+          name: "WETH",
+          decimals: 18,
+          address: "0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1",
+          coingeckoId: "ethereum"
+        },
+        {
+          name: "XDAI",
+          decimals: 18,
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "xdai"
         }
       ],
       evm: {
-        chain: avalanche,
-        rpcUrl: avalanche.rpcUrls.default.http[0],
-        supports7702: false,
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=avalanche`,
-        erc4337: false,
+        chain: gnosis,
+        rpcUrl: gnosis.rpcUrls.default.http[0],
+        supports7702: true,
+        erc4337: true,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=gnosis`,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0x5D1D71FE2De5D1C52c7c11311332eC7f0CBf88aF",
-        paymasterAddress: "0x6c0de464F2203FE089FF719Acf425dFfE6ac1EE5"
+        factoryAddress: "0xC8a2Fb1f2E686417A131E09be3320cb5431CcD90",
+        paymasterAddress: "0x4C36C70d68a7c26326711e8268bb163E3784fA96"
       },
       crossChainInformation: {
         circleInformation: {
-          supportCirclePaymaster: true,
+          supportCirclePaymaster: false,
+          aproxFromFee: 0,
           cCTPInformation: {
-            supportCCTP: true,
-            domain: 1
-          },
-          aproxFromFee: 0
+            supportCCTP: false,
+            domain: 0
+          }
         },
         nearIntentInformation: {
           support: true,
           assetsId: [
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
+              assetId: "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
               name: "USDC",
               decimals: 6
             },
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
-              name: "AVAX",
+              assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
+              name: "USDT",
+              decimals: 6
+            },
+            {
+              assetId: "nep141:gnosis-0x420ca0f9b9b604ce0fd9c18ef134c705e5fa3430.omft.near",
+              name: "EURe",
               decimals: 18
             },
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
-              name: "USDT",
-              decimals: 6
+              assetId: "nep141:gnosis-0x9c58bacc331c9aa871afd802db6379a98e80cedb.omft.near",
+              name: "GNO",
+              decimals: 18
+            },
+            {
+              assetId: "nep141:gnosis-0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1.omft.near",
+              name: "WETH",
+              decimals: 18
+            },
+            {
+              assetId: "nep141:gnosis.omft.near",
+              name: "XDAI",
+              decimals: 18
             }
           ],
           needMemo: false
-        },
-        stargateInformation: {
-          support: true
         }
       }
     };
@@ -835,6 +1687,17 @@ var init_facilitator = __esm({
       return isDev ? PlatformFees.DEV : PlatformFees.DEFAULT;
     };
     FACILITATOR_NETWORKS = {
+      Ethereum: {
+        chainId: mainnet.id,
+        chain: mainnet,
+        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 0,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: mainnet.rpcUrls.default.http[0]
+      },
       Base: {
         chainId: 8453,
         chain: base,
@@ -1103,6 +1966,68 @@ var init_WorldChain = __esm({
     };
   }
 });
+var ETHEREUM;
+var init_Ethereum = __esm({
+  "src/chains/Evm/Ethereum.ts"() {
+    init_bundler();
+    ETHEREUM = {
+      assets: [
+        {
+          name: "USDC",
+          decimals: 6,
+          address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+          coingeckoId: "usd-coin",
+          supportsStargate: true
+        },
+        {
+          name: "ETH",
+          decimals: 18,
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "ethereum"
+        }
+      ],
+      evm: {
+        chain: mainnet,
+        rpcUrl: mainnet.rpcUrls.default.http[0],
+        supports7702: true,
+        erc4337: true,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=ethereum`,
+        entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+        factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
+        paymasterAddress: "0x1e13Eb16C565E3f3FDe49A011755e50410bb1F95"
+      },
+      crossChainInformation: {
+        circleInformation: {
+          supportCirclePaymaster: true,
+          cCTPInformation: {
+            supportCCTP: true,
+            domain: 0
+          },
+          aproxFromFee: 0
+        },
+        nearIntentInformation: {
+          support: true,
+          assetsId: [
+            {
+              assetId: "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near",
+              name: "USDC",
+              decimals: 6
+            },
+            {
+              assetId: "nep141:eth.omft.near",
+              name: "ETH",
+              decimals: 18
+            }
+          ],
+          needMemo: false
+        },
+        stargateInformation: {
+          support: false
+        }
+      }
+    };
+  }
+});
 
 // src/chains/index.ts
 var init_chains = __esm({
@@ -1118,6 +2043,7 @@ var init_chains = __esm({
     init_Monad();
     init_Binance();
     init_Gnosis();
+    init_Ethereum();
   }
 });
 
@@ -1137,7 +2063,8 @@ var init_chainsInformation = __esm({
       Stellar: STELLAR,
       Monad,
       BNB,
-      Gnosis: GNOSIS
+      Gnosis: GNOSIS,
+      Ethereum: ETHEREUM
     };
   }
 });
@@ -1447,6 +2374,14 @@ var init_cctp2 = __esm({
     };
   }
 });
+
+// src/services/near.ts
+var near_exports = {};
+__export(near_exports, {
+  NearStrategy: () => NearStrategy,
+  getNearQuote: () => getNearQuote,
+  getNearSimulation: () => getNearSimulation
+});
 async function getNearQuote(sourceChain, destChain, amount, destToken, sourceToken, recipient, senderAddress, options) {
   const sourceConfig = NETWORKS[sourceChain];
   const destConfig = NETWORKS[destChain];
@@ -1650,15 +2585,15 @@ var init_near = __esm({
               return { success: false, errorReason: `Stellar Verification Failed: ${e.message}` };
             }
           }
-          const { createPublicClient: createPublicClient4, http: http4 } = await import('viem');
+          const { createPublicClient: createPublicClient5, http: http5 } = await import('viem');
           const { FACILITATOR_NETWORKS: FACILITATOR_NETWORKS2 } = await Promise.resolve().then(() => (init_facilitator(), facilitator_exports));
           const networkConfig = FACILITATOR_NETWORKS2[sourceChain];
           if (!networkConfig) {
             return { success: false, errorReason: `Unsupported source chain for verification: ${sourceChain}` };
           }
-          const publicClient = createPublicClient4({
+          const publicClient = createPublicClient5({
             chain: networkConfig.chain,
-            transport: http4(networkConfig.rpcUrl)
+            transport: http5(networkConfig.rpcUrl)
           });
           try {
             console.log(`[NearStrategy] Waiting for receipt...`);
@@ -1859,6 +2794,7 @@ var init_stargate = __esm({
             success: true,
             transactionHash: "PENDING_USER_SIGNATURE",
             netAmount: amount,
+            estimatedReceived: selectedQuote.dstAmount,
             data: {
               strategy: "Stargate",
               quote: selectedQuote,
@@ -1875,11 +2811,306 @@ var init_stargate = __esm({
             }
           };
         } catch (e) {
-          console.error("[StargateStrategy] Execution Error:", e);
-          return { success: false, errorReason: e.message };
+          console.error("[StargateStrategy] Execution Error:", e);
+          return { success: false, errorReason: e.message };
+        }
+      }
+    };
+  }
+});
+var STACKS_BRIDGE_ADDRESS_ETH, stacksBridgeAbi, StacksStrategy;
+var init_stacks = __esm({
+  "src/services/stacks.ts"() {
+    init_chainsInformation();
+    STACKS_BRIDGE_ADDRESS_ETH = "0x8888888199b2Df864bf678259607d6D5EBb4e3Ce";
+    stacksBridgeAbi = [
+      {
+        "inputs": [
+          { "internalType": "uint256", "name": "value", "type": "uint256" },
+          { "internalType": "uint32", "name": "remoteDomain", "type": "uint32" },
+          { "internalType": "bytes32", "name": "remoteRecipient", "type": "bytes32" },
+          { "internalType": "address", "name": "localToken", "type": "address" },
+          { "internalType": "uint256", "name": "maxFee", "type": "uint256" }
+        ],
+        "name": "depositToRemote",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+      }
+    ];
+    StacksStrategy = class {
+      constructor() {
+        this.name = "Stacks";
+      }
+      canHandle(context) {
+        return context.sourceChain === "Ethereum" && context.destChain === "Stacks";
+      }
+      async execute(context) {
+        const { amount, recipient, facilitatorPrivateKey, sourceChain } = context;
+        if (sourceChain !== "Ethereum") {
+          return { success: false, errorReason: "Stacks Strategy only supports financing from Ethereum" };
+        }
+        if (!facilitatorPrivateKey) {
+          return { success: false, errorReason: "Private Key required for Stacks Bridge execution" };
+        }
+        const networkConfig = NETWORKS[sourceChain];
+        if (!networkConfig || !networkConfig.evm) {
+          return { success: false, errorReason: `Unsupported chain or missing EVM config: ${sourceChain}` };
+        }
+        try {
+          const account = privateKeyToAccount(facilitatorPrivateKey);
+          const client = createWalletClient({
+            account,
+            chain: networkConfig.evm.chain,
+            transport: http(networkConfig.evm.rpcUrl)
+          });
+          const publicClient = createPublicClient({
+            chain: networkConfig.evm.chain,
+            transport: http(networkConfig.evm.rpcUrl)
+          });
+          const usdcAddress = getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+          const amountBigInt = parseUnits(amount, 6);
+          const allowance = await publicClient.readContract({
+            address: usdcAddress,
+            abi: erc20Abi$1,
+            functionName: "allowance",
+            args: [account.address, STACKS_BRIDGE_ADDRESS_ETH]
+          });
+          if (allowance < amountBigInt) {
+            console.log("[Stacks] Approving bridge...");
+            const approveHash = await client.writeContract({
+              address: usdcAddress,
+              abi: erc20Abi$1,
+              functionName: "approve",
+              args: [STACKS_BRIDGE_ADDRESS_ETH, amountBigInt],
+              chain: networkConfig.evm.chain
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveHash });
+            console.log("[Stacks] Approved.");
+          }
+          const REMOTE_DOMAIN_STACKS = 10003;
+          let recipientBytes32;
+          if (recipient.startsWith("0x")) {
+            recipientBytes32 = padHex(recipient, { size: 32 });
+          } else {
+            try {
+              recipientBytes32 = padHex(toHex(recipient), { size: 32 });
+            } catch (e) {
+              throw new Error("Invalid Stacks Recipient Format. Must be Hex or convertible.");
+            }
+          }
+          console.log(`[Stacks] Depositing ${amount} USDC to ${recipient} (Domain ${REMOTE_DOMAIN_STACKS})...`);
+          const hash = await client.writeContract({
+            address: STACKS_BRIDGE_ADDRESS_ETH,
+            abi: stacksBridgeAbi,
+            functionName: "depositToRemote",
+            args: [
+              amountBigInt,
+              REMOTE_DOMAIN_STACKS,
+              recipientBytes32,
+              usdcAddress,
+              0n
+              // maxFee (0 for now, or estimated)
+            ],
+            chain: networkConfig.evm.chain
+          });
+          console.log(`[Stacks] Deposit Tx: ${hash}`);
+          const receipt = await publicClient.waitForTransactionReceipt({ hash });
+          if (receipt.status === "success") {
+            return {
+              success: true,
+              transactionHash: hash,
+              netAmount: amountBigInt.toString()
+            };
+          } else {
+            return {
+              success: false,
+              transactionHash: hash,
+              errorReason: "Stacks Deposit Transaction Reverted"
+            };
+          }
+        } catch (error) {
+          return {
+            success: false,
+            errorReason: error instanceof Error ? error.message : "Using Stacks Bridge failed"
+          };
+        }
+      }
+    };
+  }
+});
+
+// src/services/Router.ts
+var RouterService;
+var init_Router = __esm({
+  "src/services/Router.ts"() {
+    RouterService = class {
+      /**
+       * Orchestrates a Multi-Hop transfer by signing ALL UserOps upfront (Reverse Order),
+       * and then executing them sequentially (Forward Order) with polling support.
+       * 
+       * @param steps Array of MultiHopStep ordered by execution (Source -> Intermediate -> Dest)
+       * @param onLog Optional callback for logging progress
+       */
+      async executeMultiHop(steps, onLog = console.log) {
+        onLog("[Router] Orchestrating Multi-Hop Sequence...");
+        const signedOps = [];
+        onLog("[Router] Phase 1: Preparation & Upfront Signing (Reverse Order)...");
+        for (let i = steps.length - 1; i >= 0; i--) {
+          const step = steps[i];
+          onLog(`[Router] Preparing Step ${i + 1}: ${step.description}...`);
+          try {
+            const userOp = await step.buildUserOp();
+            onLog(`[Router] Please sign Step ${i + 1} (${step.description})...`);
+            const signedOp = await step.aa.signUserOperation(userOp);
+            signedOps.unshift({ stepIndex: i, signedOp });
+            onLog(`[Router] Step ${i + 1} Signed Successfully.`);
+          } catch (err) {
+            onLog(`[Router] Error preparing Step ${i + 1}: ${err.message}`);
+            throw err;
+          }
+        }
+        onLog("[Router] Phase 2: Sequential Execution (Forward Order)...");
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          const signedOp = signedOps[i].signedOp;
+          if (step.waitCondition) {
+            onLog(`[Router] Step ${i + 1} requires waiting (e.g. for funds)...`);
+            const success = await this.pollCondition(step.waitCondition, onLog);
+            if (!success) throw new Error(`Timeout waiting for condition at Step ${i + 1}`);
+          }
+          onLog(`[Router] Executing Step ${i + 1}...`);
+          try {
+            const hash = await step.aa.sendUserOperation(signedOp);
+            onLog(`[Router] Step ${i + 1} Sent! Hash: ${hash}`);
+            onLog(`[Router] Waiting for Step ${i + 1} confirmation...`);
+            const receipt = await step.aa.waitForUserOperation(hash);
+            if (!receipt.success) {
+              throw new Error(`Step ${i + 1} Failed on-chain!`);
+            }
+            onLog(`[Router] Step ${i + 1} Confirmed.`);
+          } catch (err) {
+            onLog(`[Router] Execution Failed at Step ${i + 1}: ${err.message}`);
+            throw err;
+          }
+        }
+        onLog("[Router] Multi-Hop Sequence Completed Successfully! \u{1F680}");
+        return true;
+      }
+      async pollCondition(condition, onLog) {
+        const timeout = 6e4 * 10;
+        const interval = 5e3;
+        let elapsed = 0;
+        while (elapsed < timeout) {
+          try {
+            const passed = await condition();
+            if (passed) return true;
+          } catch (e) {
+            onLog(`[Router] Polling check failed (retrying): ${e.message}`);
+          }
+          await new Promise((r) => setTimeout(r, interval));
+          elapsed += interval;
+          if (elapsed % 2e4 === 0) onLog(`[Router] Still waiting... (${Math.floor(elapsed / 1e3)}s)`);
+        }
+        return false;
+      }
+    };
+  }
+});
+
+// src/services/uniswap.ts
+var uniswap_exports = {};
+__export(uniswap_exports, {
+  UniswapService: () => UniswapService,
+  uniswapService: () => uniswapService
+});
+var UNISWAP_V3_ROUTER, UNISWAP_V3_QUOTER, USDC_ADDRESS, WETH_ADDRESS, QUOTER_ABI, ROUTER_ABI, UniswapService, uniswapService;
+var init_uniswap = __esm({
+  "src/services/uniswap.ts"() {
+    UNISWAP_V3_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481";
+    UNISWAP_V3_QUOTER = "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a";
+    USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+    WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+    QUOTER_ABI = parseAbi([
+      "function quoteExactOutputSingle((address tokenIn, address tokenOut, uint256 amount, uint24 fee, uint160 sqrtPriceLimitX96) params) external returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)"
+    ]);
+    ROUTER_ABI = parseAbi([
+      "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)"
+    ]);
+    UniswapService = class {
+      constructor() {
+        this.publicClient = createPublicClient({
+          chain: base,
+          transport: http("https://mainnet.base.org")
+          // Default public RPC
+        });
+      }
+      /**
+       * Get amount of USDC needed to buy exact amount of ETH
+       * @param amountETHWei Amount of ETH (Wei) needed
+       */
+      async quoteUSDCForETH(amountETHWei) {
+        try {
+          const params = {
+            tokenIn: USDC_ADDRESS,
+            tokenOut: WETH_ADDRESS,
+            amount: amountETHWei,
+            fee: 500,
+            sqrtPriceLimitX96: 0n
+          };
+          const result = await this.publicClient.readContract({
+            address: UNISWAP_V3_QUOTER,
+            abi: QUOTER_ABI,
+            functionName: "quoteExactOutputSingle",
+            args: [params]
+          });
+          const amountIn = result[0];
+          return amountIn * 105n / 100n;
+        } catch (e) {
+          console.error("Quote failed", e);
+          throw new Error("Failed to quote USDC for ETH swap");
         }
       }
+      /**
+       * Build tx data for swapping USDC -> ETH
+       * Uses SwapRouter02.exactOutputSingle + unwrapWETH9
+       */
+      buildSwapData(recipient, amountOutETH, maxAmountInUSDC) {
+        const swapParams = {
+          tokenIn: USDC_ADDRESS,
+          tokenOut: WETH_ADDRESS,
+          fee: 500,
+          recipient: UNISWAP_V3_ROUTER,
+          // Router must hold WETH to unwrap it
+          amountOut: amountOutETH,
+          amountInMaximum: maxAmountInUSDC,
+          sqrtPriceLimitX96: 0n
+        };
+        const swapCalldata = encodeFunctionData({
+          abi: ROUTER_ABI,
+          functionName: "exactOutputSingle",
+          args: [swapParams]
+        });
+        const unwrapCalldata = encodeFunctionData({
+          abi: parseAbi(["function unwrapWETH9(uint256 amountMinimum, address recipient) payable"]),
+          functionName: "unwrapWETH9",
+          args: [amountOutETH, recipient]
+        });
+        const multicallCalldata = encodeFunctionData({
+          abi: parseAbi(["function multicall(bytes[] data) payable returns (bytes[])"]),
+          functionName: "multicall",
+          args: [[swapCalldata, unwrapCalldata]]
+        });
+        return multicallCalldata;
+      }
+      getRouterAddress() {
+        return UNISWAP_V3_ROUTER;
+      }
+      getUSDCAddress() {
+        return USDC_ADDRESS;
+      }
     };
+    uniswapService = new UniswapService();
   }
 });
 
@@ -1888,23 +3119,46 @@ var TransferManager_exports = {};
 __export(TransferManager_exports, {
   TransferManager: () => TransferManager
 });
-var TransferManager;
+var OP_SEPOLIA_CONFIG, TransferManager;
 var init_TransferManager = __esm({
   "src/services/TransferManager.ts"() {
     init_cctp2();
     init_near();
     init_stargate();
+    init_stacks();
+    init_Router();
+    init_AccountAbstraction();
+    init_Optimism();
+    OP_SEPOLIA_CONFIG = {
+      chain: {
+        id: 11155420,
+        name: "Optimism Sepolia",
+        nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: ["https://sepolia.optimism.io"] } },
+        testnet: true
+      },
+      rpcUrl: "https://sepolia.optimism.io",
+      // bundlerUrl will be constructed dynamically
+      entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+      factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
+      paymasterAddress: OPTIMISM.evm?.paymasterAddress,
+      tokens: []
+    };
     TransferManager = class {
       constructor() {
         this.strategies = [
           new CCTPStrategy(),
           new StargateStrategy(),
-          new NearStrategy()
+          new StargateStrategy(),
+          new NearStrategy(),
+          new StacksStrategy()
         ];
+        this.router = new RouterService();
       }
-      async execute(context) {
+      async execute(context, logCallback) {
+        const log = logCallback || console.log;
         if (context.sourceChain === context.destChain && context.sourceToken === context.destToken) {
-          console.log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
+          log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
           return {
             success: true,
             transactionHash: "DIRECT_TRANSFER_REQUIRED",
@@ -1919,17 +3173,17 @@ var init_TransferManager = __esm({
         const strategies = this.strategies;
         const stargateStrategy = strategies.find((s) => s instanceof StargateStrategy);
         if (stargateStrategy && stargateStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${stargateStrategy.name} (Stargate)`);
+          log(`[TransferManager] Routing to: ${stargateStrategy.name} (Stargate)`);
           return stargateStrategy.execute(context);
         }
         const cctpStrategy = strategies.find((s) => s instanceof CCTPStrategy);
         if (cctpStrategy && cctpStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${cctpStrategy.name} (CCTP)`);
+          log(`[TransferManager] Routing to: ${cctpStrategy.name} (CCTP)`);
           return cctpStrategy.execute(context);
         }
         const nearStrategy = strategies.find((s) => s instanceof NearStrategy);
         if (nearStrategy && nearStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
+          log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
           return nearStrategy.execute(context);
         }
         return {
@@ -1937,781 +3191,218 @@ var init_TransferManager = __esm({
           errorReason: `No suitable transfer strategy found for ${context.sourceChain} -> ${context.destChain}`
         };
       }
-    };
-  }
-});
-
-// src/constants.ts
-var factoryAbi = [
-  {
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "salt", type: "uint256" }
-    ],
-    name: "getAccountAddress",
-    outputs: [{ name: "", type: "address" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "salt", type: "uint256" }
-    ],
-    name: "isAccountDeployed",
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "salt", type: "uint256" }
-    ],
-    name: "createAccount",
-    outputs: [{ name: "account", type: "address" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-var entryPointAbi = [
-  {
-    inputs: [
-      { name: "sender", type: "address" },
-      { name: "key", type: "uint192" }
-    ],
-    name: "getNonce",
-    outputs: [{ name: "nonce", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var smartAccountAbi = [
-  {
-    inputs: [
-      { name: "target", type: "address" },
-      { name: "value", type: "uint256" },
-      { name: "data", type: "bytes" }
-    ],
-    name: "execute",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "targets", type: "address[]" },
-      { name: "values", type: "uint256[]" },
-      { name: "datas", type: "bytes[]" }
-    ],
-    name: "executeBatch",
-    outputs: [],
-    stateMutability: "nonpayable",
-    type: "function"
-  }
-];
-var erc20Abi = [
-  {
-    inputs: [{ name: "account", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    name: "transfer",
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    name: "approve",
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    name: "allowance",
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    inputs: [
-      { name: "from", type: "address" },
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    name: "transferFrom",
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    inputs: [],
-    name: "decimals",
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-
-// src/BundlerClient.ts
-var BundlerClient = class {
-  constructor(config, entryPointAddress) {
-    this.bundlerUrl = config.bundlerUrl;
-    this.entryPointAddress = entryPointAddress;
-  }
-  async call(method, params) {
-    const response = await fetch(this.bundlerUrl, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        id: 1,
-        method,
-        params
-      })
-    });
-    const result = await response.json();
-    if (result.error) {
-      throw new Error(result.error.message);
-    }
-    return result.result;
-  }
-  async estimateGas(userOp) {
-    const result = await this.call("eth_estimateUserOperationGas", [
-      {
-        sender: userOp.sender,
-        nonce: userOp.nonce ? "0x" + userOp.nonce.toString(16) : "0x0",
-        initCode: userOp.initCode || "0x",
-        callData: userOp.callData || "0x",
-        paymasterAndData: userOp.paymasterAndData || "0x",
-        signature: "0x"
-      },
-      this.entryPointAddress
-    ]);
-    console.log("DEBUG: estimateGas result:", result);
-    return {
-      callGasLimit: result.callGasLimit,
-      verificationGasLimit: result.verificationGasLimit,
-      preVerificationGas: result.preVerificationGas,
-      maxFeePerGas: result.maxFeePerGas,
-      maxPriorityFeePerGas: result.maxPriorityFeePerGas,
-      paymasterAndData: result.paymasterAndData
-    };
-  }
-  async sendUserOperation(userOp) {
-    return await this.call("eth_sendUserOperation", [
-      {
-        sender: userOp.sender,
-        nonce: "0x" + userOp.nonce.toString(16),
-        initCode: userOp.initCode,
-        callData: userOp.callData,
-        callGasLimit: "0x" + userOp.callGasLimit.toString(16),
-        verificationGasLimit: "0x" + userOp.verificationGasLimit.toString(16),
-        preVerificationGas: "0x" + userOp.preVerificationGas.toString(16),
-        maxFeePerGas: "0x" + userOp.maxFeePerGas.toString(16),
-        maxPriorityFeePerGas: "0x" + userOp.maxPriorityFeePerGas.toString(16),
-        paymasterAndData: userOp.paymasterAndData,
-        signature: userOp.signature
-      },
-      this.entryPointAddress
-    ]);
-  }
-  async waitForUserOperation(userOpHash, timeout = 6e4) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-      const result = await this.call("eth_getUserOperationReceipt", [userOpHash]);
-      if (result) {
-        return result;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-    }
-    throw new Error("Timeout waiting for UserOperation");
-  }
-  async requestApprovalSupport(token, owner, spender, amount) {
-    return await this.call("pm_requestApprovalSupport", [
-      token,
-      owner,
-      spender,
-      amount.toString()
-    ]);
-  }
-};
-var TokenService = class {
-  constructor(chainConfig, publicClient) {
-    this.tokens = /* @__PURE__ */ new Map();
-    this.publicClient = publicClient;
-    chainConfig.tokens.forEach((token) => {
-      this.tokens.set(token.symbol.toUpperCase(), token);
-    });
-  }
-  /**
-   * Resolve token address from symbol or return address if provided
-   */
-  getTokenAddress(token) {
-    if (token.startsWith("0x")) return token;
-    const info = this.tokens.get(token.toUpperCase());
-    if (!info) throw new Error(`Token ${token} not found in chain config`);
-    return info.address;
-  }
-  /**
-   * Get balance of a token for an account
-   */
-  async getBalance(token, account) {
-    const address = this.getTokenAddress(token);
-    if (address === "0x0000000000000000000000000000000000000000") {
-      return await this.publicClient.getBalance({ address: account });
-    }
-    return await this.publicClient.readContract({
-      address,
-      abi: erc20Abi,
-      functionName: "balanceOf",
-      args: [account]
-    });
-  }
-  /**
-   * Get allowance (ERC-20 only)
-   */
-  async getAllowance(token, owner, spender) {
-    const address = this.getTokenAddress(token);
-    if (address === "0x0000000000000000000000000000000000000000") {
-      return 0n;
-    }
-    return await this.publicClient.readContract({
-      address,
-      abi: erc20Abi,
-      functionName: "allowance",
-      args: [owner, spender]
-    });
-  }
-  /**
-   * Encode transfer data
-   */
-  encodeTransfer(recipient, amount) {
-    return encodeFunctionData({
-      abi: erc20Abi,
-      functionName: "transfer",
-      args: [recipient, amount]
-    });
-  }
-  /**
-   * Encode transferFrom data
-   */
-  encodeTransferFrom(sender, recipient, amount) {
-    return encodeFunctionData({
-      abi: erc20Abi,
-      functionName: "transferFrom",
-      args: [sender, recipient, amount]
-    });
-  }
-  /**
-   * Encode approve data
-   */
-  encodeApprove(spender, amount) {
-    return encodeFunctionData({
-      abi: erc20Abi,
-      functionName: "approve",
-      args: [spender, amount]
-    });
-  }
-};
-var UserOpBuilder = class {
-  constructor(chainConfig, bundlerClient, publicClient) {
-    this.chainConfig = chainConfig;
-    this.bundlerClient = bundlerClient;
-    this.publicClient = publicClient;
-    this.entryPointAddress = chainConfig.entryPointAddress;
-    this.factoryAddress = chainConfig.factoryAddress;
-  }
-  async getNonce(smartAccountAddress) {
-    return await this.publicClient.readContract({
-      address: this.entryPointAddress,
-      abi: entryPointAbi,
-      functionName: "getNonce",
-      args: [smartAccountAddress, 0n]
-    });
-  }
-  buildInitCode(owner) {
-    const createAccountData = encodeFunctionData({
-      abi: factoryAbi,
-      functionName: "createAccount",
-      args: [owner, 0n]
-    });
-    return `${this.factoryAddress}${createAccountData.slice(2)}`;
-  }
-  async isAccountDeployed(smartAccountAddress) {
-    const code = await this.publicClient.getCode({
-      address: smartAccountAddress
-    });
-    return code !== void 0 && code !== "0x";
-  }
-  async buildUserOperationBatch(owner, smartAccountAddress, transactions) {
-    const isDeployed = await this.isAccountDeployed(smartAccountAddress);
-    const initCode = isDeployed ? "0x" : this.buildInitCode(owner);
-    const targets = transactions.map((tx) => tx.target);
-    const values = transactions.map((tx) => tx.value);
-    const datas = transactions.map((tx) => tx.data);
-    const callData = encodeFunctionData({
-      abi: smartAccountAbi,
-      functionName: "executeBatch",
-      args: [targets, values, datas]
-    });
-    const nonce = await this.getNonce(smartAccountAddress);
-    const partialOp = {
-      sender: smartAccountAddress,
-      nonce,
-      initCode,
-      callData,
-      paymasterAndData: this.chainConfig.paymasterAddress || "0x"
-    };
-    const gasEstimate = await this.bundlerClient.estimateGas(partialOp);
-    return {
-      ...partialOp,
-      callGasLimit: BigInt(gasEstimate.callGasLimit),
-      verificationGasLimit: BigInt(gasEstimate.verificationGasLimit),
-      preVerificationGas: BigInt(gasEstimate.preVerificationGas),
-      maxFeePerGas: BigInt(gasEstimate.maxFeePerGas),
-      maxPriorityFeePerGas: BigInt(gasEstimate.maxPriorityFeePerGas),
-      paymasterAndData: gasEstimate.paymasterAndData || partialOp.paymasterAndData,
-      signature: "0x"
-    };
-  }
-  async buildDeployUserOp(owner, smartAccountAddress) {
-    const isDeployed = await this.isAccountDeployed(smartAccountAddress);
-    if (isDeployed) throw new Error("Account already deployed");
-    const initCode = this.buildInitCode(owner);
-    const callData = "0x";
-    const nonce = await this.getNonce(smartAccountAddress);
-    const partialOp = {
-      sender: smartAccountAddress,
-      nonce,
-      initCode,
-      callData,
-      paymasterAndData: this.chainConfig.paymasterAddress || "0x"
-    };
-    const gasEstimate = await this.bundlerClient.estimateGas(partialOp);
-    return {
-      ...partialOp,
-      callGasLimit: BigInt(gasEstimate.callGasLimit),
-      verificationGasLimit: BigInt(gasEstimate.verificationGasLimit),
-      preVerificationGas: BigInt(gasEstimate.preVerificationGas),
-      maxFeePerGas: BigInt(gasEstimate.maxFeePerGas),
-      maxPriorityFeePerGas: BigInt(gasEstimate.maxPriorityFeePerGas),
-      paymasterAndData: gasEstimate.paymasterAndData || partialOp.paymasterAndData,
-      signature: "0x"
-    };
-  }
-  getUserOpHash(userOp) {
-    const packed = encodeAbiParameters(
-      [
-        { type: "address" },
-        { type: "uint256" },
-        { type: "bytes32" },
-        { type: "bytes32" },
-        { type: "uint256" },
-        { type: "uint256" },
-        { type: "uint256" },
-        { type: "uint256" },
-        { type: "uint256" },
-        { type: "bytes32" }
-      ],
-      [
-        userOp.sender,
-        userOp.nonce,
-        keccak256(userOp.initCode),
-        keccak256(userOp.callData),
-        userOp.callGasLimit,
-        userOp.verificationGasLimit,
-        userOp.preVerificationGas,
-        userOp.maxFeePerGas,
-        userOp.maxPriorityFeePerGas,
-        keccak256(userOp.paymasterAndData)
-      ]
-    );
-    const packedHash = keccak256(packed);
-    return keccak256(
-      encodeAbiParameters(
-        [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
-        [packedHash, this.entryPointAddress, BigInt(this.chainConfig.chain.id)]
-      )
-    );
-  }
-};
-
-// src/AccountAbstraction.ts
-var AccountAbstraction = class {
-  constructor(chainConfig) {
-    this.owner = null;
-    this.smartAccountAddress = null;
-    this.walletClient = null;
-    this.chainConfig = chainConfig;
-    if (!chainConfig.entryPointAddress) throw new Error("EntryPoint address required");
-    this.entryPointAddress = chainConfig.entryPointAddress;
-    if (!chainConfig.factoryAddress) throw new Error("Factory address required");
-    this.factoryAddress = chainConfig.factoryAddress;
-    const rpcUrl = chainConfig.rpcUrl || chainConfig.chain.rpcUrls.default.http[0];
-    this.publicClient = createPublicClient({
-      chain: chainConfig.chain,
-      transport: http(rpcUrl)
-    });
-    this.bundlerClient = new BundlerClient(chainConfig, this.entryPointAddress);
-    this.tokenService = new TokenService(chainConfig, this.publicClient);
-    this.userOpBuilder = new UserOpBuilder(chainConfig, this.bundlerClient, this.publicClient);
-  }
-  async connect(signer) {
-    if (typeof signer === "string") {
-      const account = privateKeyToAccount(signer);
-      this.owner = account.address;
-      const rpcUrl = this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0];
-      this.walletClient = createWalletClient({
-        account,
-        chain: this.chainConfig.chain,
-        transport: http(rpcUrl)
-      });
-    } else if (signer && typeof signer === "object") {
-      this.walletClient = signer;
-      if (!this.walletClient.account) throw new Error("WalletClient must have an account");
-      this.owner = this.walletClient.account.address;
-    } else {
-      if (typeof window === "undefined" || !window.ethereum) {
-        throw new Error("MetaMask is not installed and no private key provided");
-      }
-      const accounts = await window.ethereum.request({
-        method: "eth_requestAccounts"
-      });
-      if (!accounts || accounts.length === 0) throw new Error("No accounts found");
-      const chainId = await window.ethereum.request({
-        method: "eth_chainId"
-      });
-      const targetChainId = this.chainConfig.chain.id;
-      if (parseInt(chainId, 16) !== targetChainId) {
-        try {
-          await window.ethereum.request({
-            method: "wallet_switchEthereumChain",
-            params: [{ chainId: "0x" + targetChainId.toString(16) }]
-          });
-        } catch (switchError) {
-          const error = switchError;
-          if (error.code === 4902) {
-            await window.ethereum.request({
-              method: "wallet_addEthereumChain",
-              params: [
-                {
-                  chainId: "0x" + targetChainId.toString(16),
-                  chainName: this.chainConfig.chain.name,
-                  nativeCurrency: this.chainConfig.chain.nativeCurrency,
-                  rpcUrls: [this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0]],
-                  blockExplorerUrls: this.chainConfig.chain.blockExplorers?.default?.url ? [this.chainConfig.chain.blockExplorers.default.url] : []
-                }
-              ]
-            });
-          } else {
-            throw switchError;
-          }
-        }
-      }
-      this.owner = accounts[0];
-    }
-    this.smartAccountAddress = await this.getSmartAccountAddress(this.owner);
-    return {
-      owner: this.owner,
-      smartAccount: this.smartAccountAddress
-    };
-  }
-  // --- Account Management ---
-  async isAccountDeployed() {
-    if (!this.smartAccountAddress) return false;
-    const code = await this.publicClient.getBytecode({ address: this.smartAccountAddress });
-    return code !== void 0;
-  }
-  async deployAccount() {
-    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
-    return this.sendTransaction({
-      target: this.smartAccountAddress,
-      value: 0n,
-      data: "0x"
-    });
-  }
-  /**
-   * Get the Smart Account address for an owner
-   */
-  async getSmartAccountAddress(owner) {
-    const address = await this.publicClient.readContract({
-      address: this.factoryAddress,
-      abi: factoryAbi,
-      functionName: "getAccountAddress",
-      args: [owner, 0n]
-    });
-    return address;
-  }
-  // --- Token Methods (Delegated) ---
-  getTokenAddress(token) {
-    return this.tokenService.getTokenAddress(token);
-  }
-  async getBalance(token) {
-    if (!this.smartAccountAddress) throw new Error("Not connected");
-    return this.tokenService.getBalance(token, this.smartAccountAddress);
-  }
-  async getEoaBalance(token) {
-    if (!this.owner) throw new Error("Not connected");
-    return this.tokenService.getBalance(token, this.owner);
-  }
-  async getAllowance(token = "USDC") {
-    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
-    return this.tokenService.getAllowance(token, this.owner, this.smartAccountAddress);
-  }
-  /**
-   * Get comprehensive state of the account for a specific token
-   * Useful for UI initialization
-   */
-  async getAccountState(token) {
-    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
-    const tokenAddress = this.getTokenAddress(token);
-    const isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
-    const [balance, eoaBalance, allowance, isDeployed] = await Promise.all([
-      this.getBalance(token),
-      this.getEoaBalance(token),
-      isNative ? 0n : this.getAllowance(token).catch(() => 0n),
-      // Handle native/error gracefully
-      this.isAccountDeployed()
-    ]);
-    return {
-      owner: this.owner,
-      smartAccount: this.smartAccountAddress,
-      balance,
-      eoaBalance,
-      allowance,
-      isDeployed
-    };
-  }
-  // --- Transactions ---
-  async sendTransaction(tx) {
-    return this.sendBatchTransaction([tx]);
-  }
-  async sendBatchTransaction(txs) {
-    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
-    const transactions = txs.map((tx) => ({
-      target: tx.target,
-      value: tx.value ?? 0n,
-      data: tx.data ?? "0x"
-    }));
-    try {
-      const userOp = await this.userOpBuilder.buildUserOperationBatch(
-        this.owner,
-        this.smartAccountAddress,
-        transactions
-      );
-      const signed = await this.signUserOperation(userOp);
-      const hash = await this.sendUserOperation(signed);
-      return await this.waitForUserOperation(hash);
-    } catch (error) {
-      throw this.decodeError(error);
-    }
-  }
-  async deposit(amount) {
-    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
-    if (this.walletClient) {
-      return await this.walletClient.sendTransaction({
-        account: this.walletClient.account,
-        to: this.smartAccountAddress,
-        value: amount,
-        chain: this.chainConfig.chain
-      });
-    }
-    return await window.ethereum.request({
-      method: "eth_sendTransaction",
-      params: [{
-        from: this.owner,
-        to: this.smartAccountAddress,
-        value: "0x" + amount.toString(16)
-      }]
-    });
-  }
-  /**
-   * Smart Transfer: Automatically chooses best method (SA vs EOA) based on balances.
-   * Supports strict fee handling.
-   */
-  async smartTransfer(token, recipient, amount, fee) {
-    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
-    const tokenAddress = this.getTokenAddress(token);
-    const isNative = tokenAddress === "0x0000000000000000000000000000000000000000";
-    const [saBal, eoaBal, allowance] = await Promise.all([
-      this.getBalance(token),
-      this.getEoaBalance(token),
-      isNative ? 0n : this.getAllowance(token).catch(() => 0n)
-    ]);
-    const totalNeeded = amount + (fee?.amount || 0n);
-    if (saBal >= totalNeeded) {
-      const txs = [];
-      if (isNative) {
-        txs.push({ target: recipient, value: amount, data: "0x" });
-      } else {
-        txs.push({ target: tokenAddress, value: 0n, data: this.tokenService.encodeTransfer(recipient, amount) });
-      }
-      if (fee && fee.amount > 0n) {
-        if (isNative) {
-          txs.push({ target: fee.recipient, value: fee.amount, data: "0x" });
+      /**
+       * Special method to orchestrate the Base -> Optimism -> Base demo flow
+       * entirely within the SDK.
+       */
+      async executeMultiHopDemo(context, sourceAA, logCallback, overrides) {
+        const log = logCallback || console.log;
+        log("[TransferManager] Calculating Multi-Hop Route...");
+        context.sourceChain === "Base" && (sourceAA.getChainId() === 84532 || context.sourceChainId === 84532);
+        const sourceChainId = await sourceAA.getPublicClient().getChainId();
+        const isSepolia = sourceChainId === 84532;
+        const baseUrl = overrides?.bundlerUrl || "https://bundler.1llet.xyz";
+        let intermediateConfig;
+        if (isSepolia) {
+          log(`[TransferManager] Detected Testnet (Base Sepolia). Using Optimism Sepolia.`);
+          intermediateConfig = {
+            tokens: [],
+            ...OP_SEPOLIA_CONFIG,
+            bundlerUrl: `${baseUrl}/rpc?chain=optimismSepolia`
+          };
+          getAddress("0x5fd84259d66Cd46123540766Be93DFE6D43130D7");
         } else {
-          txs.push({ target: tokenAddress, value: 0n, data: this.tokenService.encodeTransfer(fee.recipient, fee.amount) });
+          log(`[TransferManager] Detected Mainnet (Base). Using Optimism Mainnet.`);
+          intermediateConfig = {
+            tokens: [],
+            // Default empty
+            ...OPTIMISM.evm,
+            bundlerUrl: `${baseUrl}/rpc?chain=optimism`
+          };
+          if (!intermediateConfig.tokens) intermediateConfig.tokens = [];
+          getAddress("0x0b2C639c533813f4Aa9D7837CAf992c92bdE5162");
         }
+        const intermediateAA = new AccountAbstraction(intermediateConfig);
+        await intermediateAA.connect();
+        const interAddress = await intermediateAA.getSmartAccount();
+        log(`[TransferManager] Refund Address (Intermediate SA): ${interAddress}`);
+        const stargate = new StargateStrategy();
+        const { getNearQuote: getNearQuote2 } = await Promise.resolve().then(() => (init_near(), near_exports));
+        const { uniswapService: uniswapService2 } = await Promise.resolve().then(() => (init_uniswap(), uniswap_exports));
+        const parsedInputAmount = parseUnits(context.amount, 6);
+        const estimatedOpAmount = parsedInputAmount * 99n / 100n;
+        const humanEstimatedOpAmount = formatUnits(estimatedOpAmount, 6);
+        log(`[TransferManager] Planning Optimism -> Base (Near) for ~${humanEstimatedOpAmount} USDC...`);
+        const nearQuote = await getNearQuote2(
+          "Optimism",
+          "Base",
+          humanEstimatedOpAmount,
+          "USDC",
+          "USDC",
+          context.recipient || context.senderAddress || await sourceAA.getSmartAccount(),
+          // Final Recipient on Base
+          interAddress
+          // Refund Address on Optimism (Intermediate SA)
+        );
+        if (!nearQuote?.depositAddress) throw new Error("Planning Failed (No Near Deposit Address)");
+        log(`[TransferManager] Near Deposit Address: ${nearQuote.depositAddress}`);
+        log("[TransferManager] Planning Base -> Optimism (Stargate Direct)...");
+        const sgResult = await stargate.execute({
+          ...context,
+          destChain: "Optimism",
+          recipient: nearQuote.depositAddress
+          // DIRECTLY to Near
+        });
+        if (!sgResult.success) throw new Error(`Step 1 Planning Failed: ${sgResult.errorReason}`);
+        const { txTarget, txData, txValue, approvalRequired } = sgResult.data;
+        const buildStep1 = async () => {
+          const requiredValue = BigInt(txValue || 0);
+          let autoSwapTxs = [];
+          if (requiredValue > 0n) {
+            const nativeBalance = await sourceAA.getBalance("0x0000000000000000000000000000000000000000");
+            if (nativeBalance < requiredValue) {
+              log(`[TransferManager] Auto-Swap: Need ETH for fee.`);
+              const missingETH = requiredValue * 110n / 100n - nativeBalance;
+              const usdcNeeded = await uniswapService2.quoteUSDCForETH(missingETH);
+              const routerAddress = uniswapService2.getRouterAddress();
+              if (!routerAddress) throw new Error("Uniswap Router not found");
+              const tokenAddr = getAddress(context.sourceToken === "USDC" ? "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" : "0x0");
+              const parsedTransferAmount = parseUnits(context.amount, 6);
+              const tokenBalance = await sourceAA.getBalance(tokenAddr);
+              const totalRequiredUSDC = parsedTransferAmount + usdcNeeded;
+              const amountToPull = totalRequiredUSDC > tokenBalance ? totalRequiredUSDC - tokenBalance : 0n;
+              if (amountToPull > 0n) {
+                const owner = sourceAA.getOwner();
+                const smartAccount = await sourceAA.getSmartAccount();
+                if (!owner || !smartAccount) throw new Error("Owner/SA not found for Pull");
+                const allowance = await sourceAA.getAllowance(tokenAddr);
+                if (allowance < amountToPull) throw new Error(`Auto-Swap: Approval needed (${formatUnits(amountToPull, 6)} USDC).`);
+                log(`[TransferManager] Auto-Swap: Pulling ${formatUnits(amountToPull, 6)} USDC...`);
+                autoSwapTxs.push({
+                  target: tokenAddr,
+                  data: encodeFunctionData({
+                    abi: erc20Abi$1,
+                    functionName: "transferFrom",
+                    args: [owner, smartAccount, amountToPull]
+                  }),
+                  value: 0n
+                });
+              }
+              const swapData = uniswapService2.buildSwapData(await sourceAA.getSmartAccount(), missingETH, usdcNeeded);
+              const approveSwapData = encodeFunctionData({
+                abi: erc20Abi$1,
+                functionName: "approve",
+                args: [routerAddress, usdcNeeded]
+              });
+              autoSwapTxs.push({ target: tokenAddr, data: approveSwapData, value: 0n });
+              autoSwapTxs.push({ target: routerAddress, data: swapData, value: 0n });
+            }
+          }
+          const batch = [...autoSwapTxs];
+          if (approvalRequired) {
+            batch.push({
+              target: approvalRequired.target,
+              data: approvalRequired.data,
+              value: BigInt(approvalRequired.value || 0)
+            });
+          }
+          batch.push({
+            target: txTarget,
+            data: txData,
+            value: BigInt(txValue || 0)
+          });
+          return sourceAA.buildBatchUserOperation(batch);
+        };
+        const steps = [
+          {
+            aa: sourceAA,
+            buildUserOp: buildStep1,
+            description: "Base -> Optimism (Stargate -> Near Direct)"
+          }
+        ];
+        return this.router.executeMultiHop(steps, log);
       }
-      console.log("SmartTransfer: Using Smart Account");
-      return this.sendBatchTransaction(txs);
-    }
-    if (eoaBal >= totalNeeded) {
-      if (isNative) {
-        console.log("SmartTransfer: Using EOA (Native)");
-        if (this.walletClient) {
-          const hash2 = await this.walletClient.sendTransaction({
-            account: this.walletClient.account,
-            to: recipient,
-            value: amount,
-            chain: this.chainConfig.chain
+      /**
+       * Specialized method for Unichain -> Stacks flow.
+       * 1. Unichain -> Ethereum (CCTP)
+       * 2. Ethereum -> Stacks (Stacks Bridge)
+       */
+      async executeUnichainToStacks(context, sourceAA, ethPrivateKey, logCallback) {
+        const log = logCallback || console.log;
+        log("[TransferManager] Starting Unichain -> Stacks Flow...");
+        const cctpStrategy = this.strategies.find((s) => s instanceof CCTPStrategy);
+        const stacksStrategy = this.strategies.find((s) => s instanceof StacksStrategy);
+        if (context.sourceChain === "Ethereum") {
+          log("[TransferManager] Source is Ethereum. Executing Stacks Bridge Step...");
+          return stacksStrategy.execute({
+            ...context,
+            facilitatorPrivateKey: ethPrivateKey
           });
-          return { receipt: { transactionHash: hash2 } };
         }
-        const hash = await window.ethereum.request({
-          method: "eth_sendTransaction",
-          params: [{ from: this.owner, to: recipient, value: "0x" + amount.toString(16) }]
-        });
-        return { receipt: { transactionHash: hash } };
-      } else {
-        console.log("SmartTransfer: Using EOA (Pull)");
-        if (allowance < totalNeeded) {
-          throw new Error(`Approval required. Please approve ${token} usage.`);
-        }
-        const txs = [];
-        txs.push({
-          target: tokenAddress,
-          value: 0n,
-          data: this.tokenService.encodeTransferFrom(this.owner, recipient, amount)
-        });
-        if (fee && fee.amount > 0n) {
-          txs.push({
-            target: tokenAddress,
-            value: 0n,
-            data: this.tokenService.encodeTransferFrom(this.owner, fee.recipient, fee.amount)
+        if (context.sourceChain === "Unichain") {
+          log("[TransferManager] Step 1: Unichain -> Ethereum (via CCTP)");
+          const ethAccount = privateKeyToAccount(ethPrivateKey);
+          const ethAddress = ethAccount.address;
+          const cctpResult = await cctpStrategy.execute({
+            ...context,
+            destChain: "Ethereum",
+            destToken: "USDC",
+            recipient: ethAddress,
+            // Send to Facilitator's ETH Wallet
+            facilitatorPrivateKey: ethPrivateKey
+            // Using same key for Unichain CCTP signing if compatible
           });
+          if (!cctpResult.success) {
+            return cctpResult;
+          }
+          log("[TransferManager] CCTP Step Initiated.");
+          if (cctpResult.mintTransactionHash) {
+            log("[TransferManager] CCTP Complete (Funds on Ethereum). Proceeding to Stacks Step...");
+            const stacksResult = await stacksStrategy.execute({
+              ...context,
+              sourceChain: "Ethereum",
+              // Context update for next leg
+              amount: cctpResult.netAmount || context.amount,
+              // Use actual net amount received
+              facilitatorPrivateKey: ethPrivateKey
+            });
+            return {
+              success: stacksResult.success,
+              transactionHash: stacksResult.transactionHash,
+              // The final Stacks Tx
+              data: {
+                cctpStep: cctpResult,
+                stacksStep: stacksResult
+              },
+              netAmount: stacksResult.netAmount,
+              errorReason: stacksResult.errorReason
+            };
+          } else {
+            log("[TransferManager] CCTP Pending (Attestation/Mint not final yet). Please resume later.");
+            return {
+              ...cctpResult,
+              attestation: {
+                message: "CCTP Initiated but not finalized (Timeout or Pending). Resume with sourceChain='Ethereum' once funds arrive.",
+                attestation: cctpResult.attestation?.attestation || ""
+              }
+            };
+          }
         }
-        return this.sendBatchTransaction(txs);
-      }
-    }
-    throw new Error(`Insufficient funds.`);
-  }
-  async transfer(token, recipient, amount) {
-    const tokenAddress = this.getTokenAddress(token);
-    if (tokenAddress === "0x0000000000000000000000000000000000000000") {
-      return this.sendTransaction({
-        target: recipient,
-        value: amount,
-        data: "0x"
-      });
-    }
-    const data = this.tokenService.encodeTransfer(recipient, amount);
-    return this.sendTransaction({
-      target: tokenAddress,
-      value: 0n,
-      data
-    });
-  }
-  /**
-   * Approve a token for the Smart Account
-   */
-  async approveToken(token, spender, amount = 115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
-    if (!this.owner) throw new Error("Not connected");
-    const support = await this.requestApprovalSupport(token, spender, amount);
-    if (support.type === "approve") {
-      const data = this.tokenService.encodeApprove(spender, amount);
-      if (this.walletClient) {
-        return await this.walletClient.sendTransaction({
-          account: this.walletClient.account,
-          to: token,
-          data,
-          chain: this.chainConfig.chain
-        });
-      }
-      return await window.ethereum.request({
-        method: "eth_sendTransaction",
-        params: [{
-          from: this.owner,
-          to: token,
-          data
-        }]
-      });
-    }
-    if (support.type === "permit") throw new Error("Permit not yet supported");
-    return "NOT_NEEDED";
-  }
-  // --- Core Bridge to Bundler/UserOp ---
-  async signUserOperation(userOp) {
-    if (!this.owner) throw new Error("Not connected");
-    const userOpHash = this.userOpBuilder.getUserOpHash(userOp);
-    let signature;
-    if (this.walletClient) {
-      signature = await this.walletClient.signMessage({
-        account: this.walletClient.account,
-        message: { raw: userOpHash }
-        // Sign hash directly
-      });
-    } else {
-      signature = await window.ethereum.request({
-        method: "personal_sign",
-        params: [userOpHash, this.owner]
-      });
-    }
-    return { ...userOp, signature };
-  }
-  async sendUserOperation(userOp) {
-    return this.bundlerClient.sendUserOperation(userOp);
-  }
-  async waitForUserOperation(hash, timeout = 6e4) {
-    return this.bundlerClient.waitForUserOperation(hash, timeout);
-  }
-  // Internal but exposed via BundlerClient originally
-  async requestApprovalSupport(token, spender, amount) {
-    if (!this.owner) throw new Error("Not connected");
-    return this.bundlerClient.requestApprovalSupport(token, this.owner, spender, amount);
-  }
-  // Error Decoding (Private)
-  decodeError(error) {
-    const msg = error?.message || "";
-    const hexMatch = msg.match(/(0x[0-9a-fA-F]+)/);
-    if (hexMatch) {
-      try {
-        const decoded = decodeErrorResult({
-          abi: [{ inputs: [{ name: "message", type: "string" }], name: "Error", type: "error" }],
-          data: hexMatch[0]
-        });
-        if (decoded.errorName === "Error") return new Error(`Smart Account Error: ${decoded.args[0]}`);
-      } catch (e) {
+        return {
+          success: false,
+          errorReason: "Unsupported Route for Unichain->Stacks Helper"
+        };
       }
-    }
-    if (msg.includes("AA21")) return new Error("Smart Account: Native transfer failed (ETH missing?)");
-    if (msg.includes("AA25")) return new Error("Smart Account: Invalid account nonce");
-    return error instanceof Error ? error : new Error(String(error));
-  }
-  // Getters
-  getOwner() {
-    return this.owner;
-  }
-  getSmartAccount() {
-    return this.smartAccountAddress;
+    };
   }
-};
+});
+
+// src/index.ts
+init_AccountAbstraction();
+init_BundlerClient();
+init_Base();
+init_Avalanche();
+init_Optimism();
 
 // src/chains.ts
 init_Base();
@@ -2805,7 +3496,11 @@ var CHAIN_CONFIGS = {
   [monad.id]: MONAD_MAINNET,
   9e3: STELLAR_MAINNET
 };
+
+// src/index.ts
+init_constants();
 var CHAIN_ID_TO_KEY = {
+  [mainnet.id]: "Ethereum",
   [base.id]: "Base",
   [baseSepolia.id]: "Base",
   [gnosis.id]: "Gnosis",
@@ -2827,75 +3522,9 @@ init_TransferManager();
 init_near();
 init_cctp2();
 init_stargate();
-var SWAP_ROUTER_02 = "0x2626664c2603336E57B271c5C0b26F421741e481";
-var QUOTER_V2 = "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a";
-var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
-var QUOTER_ABI = parseAbi([
-  "function quoteExactOutputSingle((address tokenIn, address tokenOut, uint256 amount, uint24 fee, uint160 sqrtPriceLimitX96) params) external returns (uint256 amountIn, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate)"
-]);
-var ROUTER_ABI = parseAbi([
-  "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)"
-]);
-var UniswapService = class {
-  constructor(rpcUrl) {
-    this.publicClient = createPublicClient({
-      transport: http(rpcUrl)
-    });
-  }
-  /**
-   * Quote USDC needed for exact ETH output using Uniswap V3
-   */
-  async quoteUSDCForETH(amountOutETH) {
-    try {
-      const result = await this.publicClient.readContract({
-        address: QUOTER_V2,
-        abi: QUOTER_ABI,
-        functionName: "quoteExactOutputSingle",
-        args: [{
-          tokenIn: USDC_ADDRESS,
-          tokenOut: WETH_ADDRESS,
-          amount: amountOutETH,
-          fee: 500,
-          // 0.05%
-          sqrtPriceLimitX96: 0n
-        }]
-      });
-      const amountIn = result[0];
-      return amountIn * 105n / 100n;
-    } catch (error) {
-      console.error("Failed to quote USDC for ETH swap on Uniswap V3", error);
-      throw new Error(`Failed to quote USDC for ETH swap on Uniswap V3`);
-    }
-  }
-  /**
-   * Build tx data for swapping USDC -> ETH using Uniswap V3 SwapRouter02
-   */
-  buildSwapData(recipient, amountInMax, amountOutETH) {
-    return encodeFunctionData({
-      abi: ROUTER_ABI,
-      functionName: "exactOutputSingle",
-      args: [{
-        tokenIn: USDC_ADDRESS,
-        tokenOut: WETH_ADDRESS,
-        fee: 500,
-        // 0.05%
-        recipient,
-        amountOut: amountOutETH,
-        amountInMaximum: amountInMax,
-        sqrtPriceLimitX96: 0n
-      }]
-    });
-  }
-  getRouterAddress() {
-    return SWAP_ROUTER_02;
-  }
-  getUSDCAddress() {
-    return USDC_ADDRESS;
-  }
-};
-var uniswapService = new UniswapService("https://mainnet.base.org");
+init_uniswap();
+init_Router();
 
-export { AccountAbstraction, BASE_MAINNET, BASE_SEPOLIA2 as BASE_SEPOLIA, BundlerClient, CCTPStrategy, CHAIN_CONFIGS, CHAIN_ID_TO_KEY, GNOSIS_MAINNET, NearStrategy, OPTIMISM_MAINNET, STELLAR, STELLAR_MAINNET, StargateStrategy, StellarService, TransferManager, UniswapService, entryPointAbi, erc20Abi, getNearSimulation, getStargateSimulation, smartAccountAbi, uniswapService };
+export { ARBITRUM_MAINNET, AVALANCHE, AVALANCHE_MAINNET, AccountAbstraction, BASE, BASE_MAINNET, BASE_SEPOLIA2 as BASE_SEPOLIA, BSC_MAINNET, BundlerClient, CCTPStrategy, CHAIN_CONFIGS, CHAIN_ID_TO_KEY, GNOSIS_MAINNET, MONAD_MAINNET, NearStrategy, OPTIMISM, OPTIMISM_MAINNET, POLYGON_MAINNET, RouterService, STELLAR, STELLAR_MAINNET, StargateStrategy, StellarService, TransferManager, UNICHAIN_MAINNET, UniswapService, entryPointAbi, erc20Abi, getNearQuote, getNearSimulation, getStargateSimulation, smartAccountAbi, uniswapService };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map