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

package/dist/index.js

@@ -1,11 +1,12 @@
 'use strict';
 
-var viem = require('viem');
-var accounts = require('viem/accounts');
 var chains = require('viem/chains');
 var StellarSdk = require('stellar-sdk');
 var axios = require('axios');
+var viem = require('viem');
+var accounts = require('viem/accounts');
 var oneClickSdkTypescript = require('@defuse-protocol/one-click-sdk-typescript');
+var c32check = require('c32check');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -40,858 +41,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/constants.ts
-var factoryAbi; exports.entryPointAbi = void 0; exports.smartAccountAbi = void 0; exports.erc20Abi = void 0;
-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"
-      }
-    ];
-    exports.entryPointAbi = [
-      {
-        inputs: [
-          { name: "sender", type: "address" },
-          { name: "key", type: "uint192" }
-        ],
-        name: "getNonce",
-        outputs: [{ name: "nonce", type: "uint256" }],
-        stateMutability: "view",
-        type: "function"
-      }
-    ];
-    exports.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"
-      }
-    ];
-    exports.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
-exports.BundlerClient = void 0;
-var init_BundlerClient = __esm({
-  "src/BundlerClient.ts"() {
-    exports.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: exports.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: exports.erc20Abi,
-          functionName: "allowance",
-          args: [owner, spender]
-        });
-      }
-      /**
-       * Encode transfer data
-       */
-      encodeTransfer(recipient, amount) {
-        return viem.encodeFunctionData({
-          abi: exports.erc20Abi,
-          functionName: "transfer",
-          args: [recipient, amount]
-        });
-      }
-      /**
-       * Encode transferFrom data
-       */
-      encodeTransferFrom(sender, recipient, amount) {
-        return viem.encodeFunctionData({
-          abi: exports.erc20Abi,
-          functionName: "transferFrom",
-          args: [sender, recipient, amount]
-        });
-      }
-      /**
-       * Encode approve data
-       */
-      encodeApprove(spender, amount) {
-        return viem.encodeFunctionData({
-          abi: exports.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: exports.entryPointAbi,
-          functionName: "getNonce",
-          args: [smartAccountAddress, 0n]
-        });
-      }
-      buildInitCode(owner) {
-        const createAccountData = viem.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 = viem.encodeFunctionData({
-          abi: exports.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 = viem.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,
-            viem.keccak256(userOp.initCode),
-            viem.keccak256(userOp.callData),
-            userOp.callGasLimit,
-            userOp.verificationGasLimit,
-            userOp.preVerificationGas,
-            userOp.maxFeePerGas,
-            userOp.maxPriorityFeePerGas,
-            viem.keccak256(userOp.paymasterAndData)
-          ]
-        );
-        const packedHash = viem.keccak256(packed);
-        return viem.keccak256(
-          viem.encodeAbiParameters(
-            [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
-            [packedHash, this.entryPointAddress, BigInt(this.chainConfig.chain.id)]
-          )
-        );
-      }
-    };
-  }
-});
-exports.AccountAbstraction = void 0;
-var init_AccountAbstraction = __esm({
-  "src/AccountAbstraction.ts"() {
-    init_constants();
-    init_BundlerClient();
-    init_TokenService();
-    init_UserOpBuilder();
-    exports.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 = viem.createPublicClient({
-          chain: chainConfig.chain,
-          transport: viem.http(rpcUrl)
-        });
-        this.bundlerClient = new exports.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 = accounts.privateKeyToAccount(signer);
-          this.owner = account.address;
-          const rpcUrl = this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0];
-          this.walletClient = viem.createWalletClient({
-            account,
-            chain: this.chainConfig.chain,
-            transport: viem.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 = viem.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({
@@ -1115,6 +264,43 @@ var init_Optimism = __esm({
     };
   }
 });
+exports.UNICHAIN = void 0;
+var init_Unichain = __esm({
+  "src/chains/Evm/Unichain.ts"() {
+    init_bundler();
+    exports.UNICHAIN = {
+      assets: [
+        {
+          name: "USDC",
+          decimals: 6,
+          address: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+          coingeckoId: "usd-coin"
+        }
+      ],
+      evm: {
+        chain: chains.unichain,
+        rpcUrl: "https://unichain-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=unichain`,
+        supports7702: true,
+        erc4337: false,
+        entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+        factoryAddress: "0xB2E45aCbB68f3e98C87B6df16625f22e11728556",
+        paymasterAddress: "0x7A92b3Fee017E3E181a51D9045AACE30eC2B387D"
+      },
+      crossChainInformation: {
+        circleInformation: {
+          supportCirclePaymaster: true,
+          cCTPInformation: {
+            supportCCTP: true,
+            domain: 10
+          },
+          aproxFromFee: 0
+        },
+        nearIntentInformation: null
+      }
+    };
+  }
+});
 var GNOSIS;
 var init_Gnosis = __esm({
   "src/chains/Evm/Gnosis.ts"() {
@@ -1438,43 +624,6 @@ var init_Arbitrum = __esm({
     };
   }
 });
-var UNICHAIN;
-var init_Unichain = __esm({
-  "src/chains/Evm/Unichain.ts"() {
-    init_bundler();
-    UNICHAIN = {
-      assets: [
-        {
-          name: "USDC",
-          decimals: 6,
-          address: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
-          coingeckoId: "usd-coin"
-        }
-      ],
-      evm: {
-        chain: chains.unichain,
-        rpcUrl: "https://unichain-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=unichain`,
-        supports7702: true,
-        erc4337: false,
-        entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0xB2E45aCbB68f3e98C87B6df16625f22e11728556",
-        paymasterAddress: "0x7A92b3Fee017E3E181a51D9045AACE30eC2B387D"
-      },
-      crossChainInformation: {
-        circleInformation: {
-          supportCirclePaymaster: true,
-          cCTPInformation: {
-            supportCCTP: true,
-            domain: 10
-          },
-          aproxFromFee: 0
-        },
-        nearIntentInformation: null
-      }
-    };
-  }
-});
 var Monad;
 var init_Monad = __esm({
   "src/chains/Evm/Monad.ts"() {
@@ -1592,6 +741,34 @@ var init_Stellar = __esm({
   }
 });
 
+// src/chains/NoEvm/Stacks.ts
+var STACKS;
+var init_Stacks = __esm({
+  "src/chains/NoEvm/Stacks.ts"() {
+    STACKS = {
+      assets: [
+        {
+          name: "USDC",
+          decimals: 6,
+          address: "SP2ZNGJ15SD91GWW54B2Q1V31749666c2Q01",
+          // Placeholder or real Stacks token ID
+          coingeckoId: "usd-coin"
+        }
+      ],
+      nonEvm: {
+        serverURL: "https://api.mainnet.hiro.so"
+      },
+      crossChainInformation: {
+        circleInformation: {
+          supportCirclePaymaster: false,
+          aproxFromFee: 0
+        },
+        nearIntentInformation: null
+      }
+    };
+  }
+});
+
 // src/services/StellarService.ts
 var StellarService_exports = {};
 __export(StellarService_exports, {
@@ -2068,6 +1245,7 @@ var init_chains = __esm({
     init_Binance();
     init_Gnosis();
     init_Ethereum();
+    init_Stacks();
   }
 });
 
@@ -2080,7 +1258,7 @@ var init_chainsInformation = __esm({
       Optimism: exports.OPTIMISM,
       Arbitrum: ARBITRUM,
       Base: exports.BASE,
-      Unichain: UNICHAIN,
+      Unichain: exports.UNICHAIN,
       Polygon: POLYGON,
       Avalanche: exports.AVALANCHE,
       WorldChain: WORLD_CHAIN,
@@ -2335,7 +1513,7 @@ async function executeCCTPBridge(sourceChain, amount, crossChainConfig, facilita
     mintTransactionHash: mintHash,
     payer: payerAddress,
     fee: fee.toString(),
-    netAmount: amountBigInt.toString(),
+    netAmount: (amountBigInt - fee).toString(),
     attestation: {
       message: attestationResponse.message,
       attestation: attestationResponse.attestation
@@ -2398,14 +1576,6 @@ var init_cctp2 = __esm({
     };
   }
 });
-
-// src/services/near.ts
-var near_exports = {};
-__export(near_exports, {
-  NearStrategy: () => exports.NearStrategy,
-  getNearQuote: () => getNearQuote,
-  getNearSimulation: () => getNearSimulation
-});
 async function getNearQuote(sourceChain, destChain, amount, destToken, sourceToken, recipient, senderAddress, options) {
   const sourceConfig = NETWORKS[sourceChain];
   const destConfig = NETWORKS[destChain];
@@ -2854,7 +2024,8 @@ var init_stacks = __esm({
           { "internalType": "uint32", "name": "remoteDomain", "type": "uint32" },
           { "internalType": "bytes32", "name": "remoteRecipient", "type": "bytes32" },
           { "internalType": "address", "name": "localToken", "type": "address" },
-          { "internalType": "uint256", "name": "maxFee", "type": "uint256" }
+          { "internalType": "uint256", "name": "maxFee", "type": "uint256" },
+          { "internalType": "bytes", "name": "hookData", "type": "bytes" }
         ],
         "name": "depositToRemote",
         "outputs": [],
@@ -2892,8 +2063,20 @@ var init_stacks = __esm({
             chain: networkConfig.evm.chain,
             transport: viem.http(networkConfig.evm.rpcUrl)
           });
-          const usdcAddress = viem.getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48");
+          const ethAssets = NETWORKS["Ethereum"].assets;
+          const usdcToken = ethAssets.find((a) => a.name === "USDC");
+          if (!usdcToken || !usdcToken.address) throw new Error("USDC config/address not found for Ethereum");
+          const usdcAddress = viem.getAddress(usdcToken.address);
           const amountBigInt = viem.parseUnits(amount, 6);
+          const balance = await publicClient.readContract({
+            address: usdcAddress,
+            abi: viem.erc20Abi,
+            functionName: "balanceOf",
+            args: [account.address]
+          });
+          if (balance < amountBigInt) {
+            throw new Error(`Insufficient USDC balance on Ethereum (Facilitator). Has: ${balance}, Needed: ${amountBigInt}`);
+          }
           const allowance = await publicClient.readContract({
             address: usdcAddress,
             abi: viem.erc20Abi,
@@ -2918,9 +2101,10 @@ var init_stacks = __esm({
             recipientBytes32 = viem.padHex(recipient, { size: 32 });
           } else {
             try {
-              recipientBytes32 = viem.padHex(viem.toHex(recipient), { size: 32 });
+              const [version, hash2] = c32check.c32addressDecode(recipient);
+              recipientBytes32 = viem.padHex(`0x${hash2}`, { size: 32 });
             } catch (e) {
-              throw new Error("Invalid Stacks Recipient Format. Must be Hex or convertible.");
+              throw new Error(`Invalid Stacks Recipient: ${e.message}`);
             }
           }
           console.log(`[Stacks] Depositing ${amount} USDC to ${recipient} (Domain ${REMOTE_DOMAIN_STACKS})...`);
@@ -2933,8 +2117,10 @@ var init_stacks = __esm({
               REMOTE_DOMAIN_STACKS,
               recipientBytes32,
               usdcAddress,
-              0n
-              // maxFee (0 for now, or estimated)
+              0n,
+              // maxFee
+              "0x"
+              // hookData
             ],
             chain: networkConfig.evm.chain
           });
@@ -3032,109 +2218,13 @@ var init_Router = __esm({
           } 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: () => exports.UniswapService,
-  uniswapService: () => exports.uniswapService
-});
-var UNISWAP_V3_ROUTER, UNISWAP_V3_QUOTER, USDC_ADDRESS, WETH_ADDRESS, QUOTER_ABI, ROUTER_ABI; exports.UniswapService = void 0; exports.uniswapService = void 0;
-var init_uniswap = __esm({
-  "src/services/uniswap.ts"() {
-    UNISWAP_V3_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481";
-    UNISWAP_V3_QUOTER = "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a";
-    USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-    WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
-    QUOTER_ABI = viem.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 = viem.parseAbi([
-      "function exactOutputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96) params) external payable returns (uint256 amountIn)"
-    ]);
-    exports.UniswapService = class {
-      constructor() {
-        this.publicClient = viem.createPublicClient({
-          chain: chains.base,
-          transport: viem.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");
+          await new Promise((r) => setTimeout(r, interval));
+          elapsed += interval;
+          if (elapsed % 2e4 === 0) onLog(`[Router] Still waiting... (${Math.floor(elapsed / 1e3)}s)`);
         }
-      }
-      /**
-       * 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 = viem.encodeFunctionData({
-          abi: ROUTER_ABI,
-          functionName: "exactOutputSingle",
-          args: [swapParams]
-        });
-        const unwrapCalldata = viem.encodeFunctionData({
-          abi: viem.parseAbi(["function unwrapWETH9(uint256 amountMinimum, address recipient) payable"]),
-          functionName: "unwrapWETH9",
-          args: [amountOutETH, recipient]
-        });
-        const multicallCalldata = viem.encodeFunctionData({
-          abi: viem.parseAbi(["function multicall(bytes[] data) payable returns (bytes[])"]),
-          functionName: "multicall",
-          args: [[swapCalldata, unwrapCalldata]]
-        });
-        return multicallCalldata;
-      }
-      getRouterAddress() {
-        return UNISWAP_V3_ROUTER;
-      }
-      getUSDCAddress() {
-        return USDC_ADDRESS;
+        return false;
       }
     };
-    exports.uniswapService = new exports.UniswapService();
   }
 });
 
@@ -3143,7 +2233,7 @@ var TransferManager_exports = {};
 __export(TransferManager_exports, {
   TransferManager: () => exports.TransferManager
 });
-var OP_SEPOLIA_CONFIG; exports.TransferManager = void 0;
+exports.TransferManager = void 0;
 var init_TransferManager = __esm({
   "src/services/TransferManager.ts"() {
     init_cctp2();
@@ -3151,23 +2241,7 @@ var init_TransferManager = __esm({
     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: exports.OPTIMISM.evm?.paymasterAddress,
-      tokens: []
-    };
+    init_chainsInformation();
     exports.TransferManager = class {
       constructor() {
         this.strategies = [
@@ -3194,6 +2268,24 @@ var init_TransferManager = __esm({
             }
           };
         }
+        if (context.destChain === "Stacks" && context.sourceChain !== "Ethereum") {
+          const networkConfig = NETWORKS[context.sourceChain];
+          if (networkConfig?.crossChainInformation?.circleInformation?.cCTPInformation?.supportCCTP) {
+            log(`[TransferManager] Auto-Routing to Stacks via CCTP (${context.sourceChain} -> Ethereum -> Stacks)`);
+            if (!context.sourceAA || !context.facilitatorPrivateKey) {
+              return {
+                success: false,
+                errorReason: "Source AA and Facilitator Private Key required for Stacks Multi-Hop"
+              };
+            }
+            return this.executeEVMToStacks(
+              context,
+              context.sourceAA,
+              context.facilitatorPrivateKey,
+              logCallback
+            );
+          }
+        }
         const strategies = this.strategies;
         const stargateStrategy = strategies.find((s) => s instanceof exports.StargateStrategy);
         if (stargateStrategy && stargateStrategy.canHandle(context)) {
@@ -3216,144 +2308,13 @@ var init_TransferManager = __esm({
         };
       }
       /**
-       * 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`
-          };
-          viem.getAddress("0x5fd84259d66Cd46123540766Be93DFE6D43130D7");
-        } else {
-          log(`[TransferManager] Detected Mainnet (Base). Using Optimism Mainnet.`);
-          intermediateConfig = {
-            tokens: [],
-            // Default empty
-            ...exports.OPTIMISM.evm,
-            bundlerUrl: `${baseUrl}/rpc?chain=optimism`
-          };
-          if (!intermediateConfig.tokens) intermediateConfig.tokens = [];
-          viem.getAddress("0x0b2C639c533813f4Aa9D7837CAf992c92bdE5162");
-        }
-        const intermediateAA = new exports.AccountAbstraction(intermediateConfig);
-        await intermediateAA.connect();
-        const interAddress = await intermediateAA.getSmartAccount();
-        log(`[TransferManager] Refund Address (Intermediate SA): ${interAddress}`);
-        const stargate = new exports.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 = viem.parseUnits(context.amount, 6);
-        const estimatedOpAmount = parsedInputAmount * 99n / 100n;
-        const humanEstimatedOpAmount = viem.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 = viem.getAddress(context.sourceToken === "USDC" ? "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" : "0x0");
-              const parsedTransferAmount = viem.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 (${viem.formatUnits(amountToPull, 6)} USDC).`);
-                log(`[TransferManager] Auto-Swap: Pulling ${viem.formatUnits(amountToPull, 6)} USDC...`);
-                autoSwapTxs.push({
-                  target: tokenAddr,
-                  data: viem.encodeFunctionData({
-                    abi: viem.erc20Abi,
-                    functionName: "transferFrom",
-                    args: [owner, smartAccount, amountToPull]
-                  }),
-                  value: 0n
-                });
-              }
-              const swapData = uniswapService2.buildSwapData(await sourceAA.getSmartAccount(), missingETH, usdcNeeded);
-              const approveSwapData = viem.encodeFunctionData({
-                abi: viem.erc20Abi,
-                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);
-      }
-      /**
-       * Specialized method for Unichain -> Stacks flow.
-       * 1. Unichain -> Ethereum (CCTP)
+       * Specialized method for Base/Unichain -> Stacks flow.
+       * 1. EVM (Base/Unichain) -> Ethereum (CCTP)
        * 2. Ethereum -> Stacks (Stacks Bridge)
        */
-      async executeUnichainToStacks(context, sourceAA, ethPrivateKey, logCallback) {
+      async executeEVMToStacks(context, sourceAA, ethPrivateKey, logCallback) {
         const log = logCallback || console.log;
-        log("[TransferManager] Starting Unichain -> Stacks Flow...");
+        log(`[TransferManager] Starting ${context.sourceChain} -> Stacks Flow...`);
         const cctpStrategy = this.strategies.find((s) => s instanceof exports.CCTPStrategy);
         const stacksStrategy = this.strategies.find((s) => s instanceof StacksStrategy);
         if (context.sourceChain === "Ethereum") {
@@ -3363,70 +2324,930 @@ var init_TransferManager = __esm({
             facilitatorPrivateKey: ethPrivateKey
           });
         }
-        if (context.sourceChain === "Unichain") {
-          log("[TransferManager] Step 1: Unichain -> Ethereum (via CCTP)");
+        const sourceConfig = NETWORKS[context.sourceChain];
+        const supportsCCTP = sourceConfig?.crossChainInformation?.circleInformation?.cCTPInformation?.supportCCTP;
+        if (supportsCCTP) {
+          log(`[TransferManager] Step 1: ${context.sourceChain} -> Ethereum (via CCTP)`);
           const ethAccount = accounts.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({
+          log(`[TransferManager] Funding Facilitator (${ethAddress})...`);
+          try {
+            const amountBigInt = viem.parseUnits(context.amount, 6);
+            const executeFunding = async () => {
+              try {
+                return await sourceAA.smartTransfer(
+                  "USDC",
+                  ethAddress,
+                  amountBigInt
+                );
+              } catch (e) {
+                const msg = e.message || String(e);
+                if (msg.includes("Approval required")) {
+                  log("[TransferManager] Approval Required. Approving USDC...");
+                  const saAddress = await sourceAA.getSmartAccount();
+                  if (!saAddress) throw new Error("SA Address missing for approval");
+                  await sourceAA.approveToken(sourceAA.getTokenAddress("USDC"), saAddress, amountBigInt);
+                  log("[TransferManager] Approved. Retrying Transfer...");
+                  return await sourceAA.smartTransfer(
+                    "USDC",
+                    ethAddress,
+                    amountBigInt
+                  );
+                }
+                throw e;
+              }
+            };
+            const transferResult = await executeFunding();
+            if ("success" in transferResult && !transferResult.success) {
+              throw new Error("Funding Transfer Failed");
+            }
+            const fundingHash = transferResult.receipt.transactionHash;
+            log(`[TransferManager] Funds Sent. Hash: ${fundingHash}`);
+            const cctpResult = await cctpStrategy.execute({
               ...context,
-              sourceChain: "Ethereum",
-              // Context update for next leg
-              amount: cctpResult.netAmount || context.amount,
-              // Use actual net amount received
-              facilitatorPrivateKey: ethPrivateKey
+              destChain: "Ethereum",
+              destToken: "USDC",
+              recipient: ethAddress,
+              facilitatorPrivateKey: ethPrivateKey,
+              depositTxHash: fundingHash
             });
+            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",
+                amount: cctpResult.netAmount ? viem.formatUnits(BigInt(cctpResult.netAmount), 6) : context.amount,
+                facilitatorPrivateKey: ethPrivateKey
+              });
+              return {
+                success: stacksResult.success,
+                transactionHash: stacksResult.transactionHash,
+                data: {
+                  fundingStep: { transactionHash: fundingHash },
+                  cctpStep: cctpResult,
+                  stacksStep: stacksResult
+                },
+                netAmount: stacksResult.netAmount,
+                errorReason: stacksResult.errorReason
+              };
+            } else {
+              log("[TransferManager] CCTP Pending. Please resume later.");
+              return {
+                ...cctpResult,
+                attestation: {
+                  message: "CCTP Initiated but not finalized.",
+                  attestation: cctpResult.attestation?.attestation || ""
+                }
+              };
+            }
+          } catch (err) {
             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 || ""
-              }
+              success: false,
+              errorReason: `Funding/CCTP Failed: ${err instanceof Error ? err.message : String(err)}`
             };
           }
         }
         return {
           success: false,
-          errorReason: "Unsupported Route for Unichain->Stacks Helper"
+          errorReason: `Unsupported Route for ${context.sourceChain}->Stacks Helper`
         };
       }
     };
   }
 });
 
+// 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()
+    ]);
+  }
+  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 = 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 viem.encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [recipient, amount]
+    });
+  }
+  /**
+   * Encode transferFrom data
+   */
+  encodeTransferFrom(sender, recipient, amount) {
+    return viem.encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transferFrom",
+      args: [sender, recipient, amount]
+    });
+  }
+  /**
+   * Encode approve data
+   */
+  encodeApprove(spender, amount) {
+    return viem.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 = viem.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 = viem.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 = viem.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,
+        viem.keccak256(userOp.initCode),
+        viem.keccak256(userOp.callData),
+        userOp.callGasLimit,
+        userOp.verificationGasLimit,
+        userOp.preVerificationGas,
+        userOp.maxFeePerGas,
+        userOp.maxPriorityFeePerGas,
+        viem.keccak256(userOp.paymasterAndData)
+      ]
+    );
+    const packedHash = viem.keccak256(packed);
+    return viem.keccak256(
+      viem.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 = viem.createPublicClient({
+      chain: chainConfig.chain,
+      transport: viem.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 = accounts.privateKeyToAccount(signer);
+      this.owner = account.address;
+      const rpcUrl = this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0];
+      this.walletClient = viem.createWalletClient({
+        account,
+        chain: this.chainConfig.chain,
+        transport: viem.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 = viem.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/index.ts
-init_AccountAbstraction();
-init_BundlerClient();
 init_Base();
 init_Avalanche();
 init_Optimism();
+init_Unichain();
 
 // src/chains.ts
 init_Base();
@@ -3469,11 +3290,14 @@ init_Arbitrum();
 init_Unichain();
 init_Monad();
 init_Stellar();
+init_Stacks();
 function mapToSDKConfig(data) {
   if (data.nonEvm) {
+    const isStacks = data.assets[0].address?.toString().startsWith("SP") || data.nonEvm.serverURL?.includes("hiro");
+    const chainId = isStacks ? 5e3 : 9e3;
+    const chainName = isStacks ? "Stacks" : "Stellar";
     return {
-      chain: { id: 9e3, name: "Stellar" },
-      // Custom ID for Stellar
+      chain: { id: chainId, name: chainName },
       tokens: data.assets.map((a) => ({
         symbol: a.name,
         decimals: a.decimals,
@@ -3504,9 +3328,10 @@ var AVALANCHE_MAINNET = mapToSDKConfig(exports.AVALANCHE);
 var BSC_MAINNET = mapToSDKConfig(BNB);
 var POLYGON_MAINNET = mapToSDKConfig(POLYGON);
 var ARBITRUM_MAINNET = mapToSDKConfig(ARBITRUM);
-var UNICHAIN_MAINNET = mapToSDKConfig(UNICHAIN);
+var UNICHAIN_MAINNET = mapToSDKConfig(exports.UNICHAIN);
 var MONAD_MAINNET = mapToSDKConfig(Monad);
 var STELLAR_MAINNET = mapToSDKConfig(exports.STELLAR);
+var STACKS_MAINNET = mapToSDKConfig(STACKS);
 var CHAIN_CONFIGS = {
   [chains.base.id]: BASE_MAINNET,
   [chains.baseSepolia.id]: BASE_SEPOLIA2,
@@ -3518,11 +3343,9 @@ var CHAIN_CONFIGS = {
   [chains.arbitrum.id]: ARBITRUM_MAINNET,
   [chains.unichain.id]: UNICHAIN_MAINNET,
   [chains.monad.id]: MONAD_MAINNET,
-  9e3: STELLAR_MAINNET
+  9e3: STELLAR_MAINNET,
+  5e3: STACKS_MAINNET
 };
-
-// src/index.ts
-init_constants();
 var CHAIN_ID_TO_KEY = {
   [chains.mainnet.id]: "Ethereum",
   [chains.base.id]: "Base",
@@ -3536,7 +3359,8 @@ var CHAIN_ID_TO_KEY = {
   [chains.avalanche.id]: "Avalanche",
   [chains.unichain.id]: "Unichain",
   [chains.monad.id]: "Monad",
-  "9000": "Stellar"
+  "9000": "Stellar",
+  "5000": "Stacks"
 };
 
 // src/index.ts
@@ -3546,24 +3370,117 @@ init_TransferManager();
 init_near();
 init_cctp2();
 init_stargate();
-init_uniswap();
+var UNISWAP_V3_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481";
+var UNISWAP_V3_QUOTER = "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a";
+var USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var WETH_ADDRESS = "0x4200000000000000000000000000000000000006";
+var QUOTER_ABI = viem.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 = viem.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() {
+    this.publicClient = viem.createPublicClient({
+      chain: chains.base,
+      transport: viem.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 = viem.encodeFunctionData({
+      abi: ROUTER_ABI,
+      functionName: "exactOutputSingle",
+      args: [swapParams]
+    });
+    const unwrapCalldata = viem.encodeFunctionData({
+      abi: viem.parseAbi(["function unwrapWETH9(uint256 amountMinimum, address recipient) payable"]),
+      functionName: "unwrapWETH9",
+      args: [amountOutETH, recipient]
+    });
+    const multicallCalldata = viem.encodeFunctionData({
+      abi: viem.parseAbi(["function multicall(bytes[] data) payable returns (bytes[])"]),
+      functionName: "multicall",
+      args: [[swapCalldata, unwrapCalldata]]
+    });
+    return multicallCalldata;
+  }
+  getRouterAddress() {
+    return UNISWAP_V3_ROUTER;
+  }
+  getUSDCAddress() {
+    return USDC_ADDRESS;
+  }
+};
+var uniswapService = new UniswapService();
+
+// src/index.ts
 init_Router();
 
 exports.ARBITRUM_MAINNET = ARBITRUM_MAINNET;
 exports.AVALANCHE_MAINNET = AVALANCHE_MAINNET;
+exports.AccountAbstraction = AccountAbstraction;
 exports.BASE_MAINNET = BASE_MAINNET;
 exports.BASE_SEPOLIA = BASE_SEPOLIA2;
 exports.BSC_MAINNET = BSC_MAINNET;
+exports.BundlerClient = BundlerClient;
 exports.CHAIN_CONFIGS = CHAIN_CONFIGS;
 exports.CHAIN_ID_TO_KEY = CHAIN_ID_TO_KEY;
 exports.GNOSIS_MAINNET = GNOSIS_MAINNET;
 exports.MONAD_MAINNET = MONAD_MAINNET;
 exports.OPTIMISM_MAINNET = OPTIMISM_MAINNET;
 exports.POLYGON_MAINNET = POLYGON_MAINNET;
+exports.STACKS_MAINNET = STACKS_MAINNET;
 exports.STELLAR_MAINNET = STELLAR_MAINNET;
 exports.UNICHAIN_MAINNET = UNICHAIN_MAINNET;
+exports.UniswapService = UniswapService;
+exports.entryPointAbi = entryPointAbi;
+exports.erc20Abi = erc20Abi;
 exports.getNearQuote = getNearQuote;
 exports.getNearSimulation = getNearSimulation;
 exports.getStargateSimulation = getStargateSimulation;
+exports.smartAccountAbi = smartAccountAbi;
+exports.uniswapService = uniswapService;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map