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

package/dist/index.js

@@ -6,6 +6,7 @@ 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 }; }
 
@@ -48,11 +49,11 @@ var init_bundler = __esm({
     BUNDLER_URL = process.env.NEXT_PUBLIC_BUNDLER_URL || process.env.BUNDLER_URL || DEFAULT_BUNDLER_URL;
   }
 });
-var BASE;
+exports.BASE = void 0;
 var init_Base = __esm({
   "src/chains/Evm/Base.ts"() {
     init_bundler();
-    BASE = {
+    exports.BASE = {
       assets: [
         {
           name: "USDC",
@@ -72,7 +73,7 @@ var init_Base = __esm({
         chain: chains.base,
         rpcUrl: "https://base-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
         supports7702: true,
-        erc4337: false,
+        erc4337: true,
         bundlerUrl: `${BUNDLER_URL}/rpc?chain=base`,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
         factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
@@ -110,113 +111,84 @@ var init_Base = __esm({
     };
   }
 });
-var GNOSIS;
-var init_Gnosis = __esm({
-  "src/chains/Evm/Gnosis.ts"() {
+exports.AVALANCHE = void 0;
+var init_Avalanche = __esm({
+  "src/chains/Evm/Avalanche.ts"() {
     init_bundler();
-    GNOSIS = {
+    exports.AVALANCHE = {
       assets: [
         {
           name: "USDC",
           decimals: 6,
-          address: "0x2a22f9c3b484c3629090FeED35F17Ff8F88f76F0",
-          coingeckoId: "usd-coin"
-        },
-        {
-          name: "USDT",
-          decimals: 6,
-          address: "0x4ECaBa5870353805a9F068101A40E0f32ed605C6",
-          coingeckoId: "tether"
-        },
-        {
-          name: "EURe",
-          decimals: 18,
-          address: "0x420CA0f9B9b604cE0fd9C18EF134C705e5Fa3430",
-          coingeckoId: "monerium-eur-money"
-        },
-        {
-          name: "GNO",
-          decimals: 18,
-          address: "0x9C58BAcC331c9aa871AFD802DB6379a98e80CEdb",
-          coingeckoId: "gnosis"
+          address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+          coingeckoId: "usd-coin",
+          supportsStargate: true
         },
         {
-          name: "WETH",
+          name: "AVAX",
           decimals: 18,
-          address: "0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1",
-          coingeckoId: "ethereum"
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "avalanche-2"
         },
         {
-          name: "XDAI",
-          decimals: 18,
-          address: "0x0000000000000000000000000000000000000000",
-          coingeckoId: "xdai"
+          name: "USDT",
+          decimals: 6,
+          address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+          coingeckoId: "tether"
         }
       ],
       evm: {
-        chain: chains.gnosis,
-        rpcUrl: chains.gnosis.rpcUrls.default.http[0],
-        supports7702: true,
-        erc4337: true,
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=gnosis`,
+        chain: chains.avalanche,
+        rpcUrl: chains.avalanche.rpcUrls.default.http[0],
+        supports7702: false,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=avalanche`,
+        erc4337: false,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0xC8a2Fb1f2E686417A131E09be3320cb5431CcD90",
-        paymasterAddress: "0x4C36C70d68a7c26326711e8268bb163E3784fA96"
+        factoryAddress: "0x5D1D71FE2De5D1C52c7c11311332eC7f0CBf88aF",
+        paymasterAddress: "0x6c0de464F2203FE089FF719Acf425dFfE6ac1EE5"
       },
       crossChainInformation: {
         circleInformation: {
-          supportCirclePaymaster: false,
-          aproxFromFee: 0,
+          supportCirclePaymaster: true,
           cCTPInformation: {
-            supportCCTP: false,
-            domain: 0
-          }
+            supportCCTP: true,
+            domain: 1
+          },
+          aproxFromFee: 0
         },
         nearIntentInformation: {
           support: true,
           assetsId: [
             {
-              assetId: "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
+              assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
               name: "USDC",
               decimals: 6
             },
             {
-              assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
-              name: "USDT",
-              decimals: 6
-            },
-            {
-              assetId: "nep141:gnosis-0x420ca0f9b9b604ce0fd9c18ef134c705e5fa3430.omft.near",
-              name: "EURe",
-              decimals: 18
-            },
-            {
-              assetId: "nep141:gnosis-0x9c58bacc331c9aa871afd802db6379a98e80cedb.omft.near",
-              name: "GNO",
-              decimals: 18
-            },
-            {
-              assetId: "nep141:gnosis-0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1.omft.near",
-              name: "WETH",
+              assetId: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
+              name: "AVAX",
               decimals: 18
             },
             {
-              assetId: "nep141:gnosis.omft.near",
-              name: "XDAI",
-              decimals: 18
+              assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
+              name: "USDT",
+              decimals: 6
             }
           ],
           needMemo: false
+        },
+        stargateInformation: {
+          support: true
         }
       }
     };
   }
 });
-var OPTIMISM;
+exports.OPTIMISM = void 0;
 var init_Optimism = __esm({
   "src/chains/Evm/Optimism.ts"() {
     init_bundler();
-    OPTIMISM = {
+    exports.OPTIMISM = {
       assets: [
         {
           name: "USDC",
@@ -245,7 +217,7 @@ var init_Optimism = __esm({
       ],
       evm: {
         chain: chains.optimism,
-        rpcUrl: "https://opt-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
+        rpcUrl: "https://mainnet.optimism.io",
         supports7702: false,
         erc4337: false,
         bundlerUrl: `${BUNDLER_URL}/rpc?chain=optimism`,
@@ -292,74 +264,140 @@ var init_Optimism = __esm({
     };
   }
 });
-var AVALANCHE;
-var init_Avalanche = __esm({
-  "src/chains/Evm/Avalanche.ts"() {
+exports.UNICHAIN = void 0;
+var init_Unichain = __esm({
+  "src/chains/Evm/Unichain.ts"() {
     init_bundler();
-    AVALANCHE = {
+    exports.UNICHAIN = {
       assets: [
         {
           name: "USDC",
           decimals: 6,
-          address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-          coingeckoId: "usd-coin",
-          supportsStargate: true
+          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"() {
+    init_bundler();
+    GNOSIS = {
+      assets: [
         {
-          name: "AVAX",
-          decimals: 18,
-          address: "0x0000000000000000000000000000000000000000",
-          coingeckoId: "avalanche-2"
+          name: "USDC",
+          decimals: 6,
+          address: "0x2a22f9c3b484c3629090FeED35F17Ff8F88f76F0",
+          coingeckoId: "usd-coin"
         },
         {
           name: "USDT",
           decimals: 6,
-          address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+          address: "0x4ECaBa5870353805a9F068101A40E0f32ed605C6",
           coingeckoId: "tether"
+        },
+        {
+          name: "EURe",
+          decimals: 18,
+          address: "0x420CA0f9B9b604cE0fd9C18EF134C705e5Fa3430",
+          coingeckoId: "monerium-eur-money"
+        },
+        {
+          name: "GNO",
+          decimals: 18,
+          address: "0x9C58BAcC331c9aa871AFD802DB6379a98e80CEdb",
+          coingeckoId: "gnosis"
+        },
+        {
+          name: "WETH",
+          decimals: 18,
+          address: "0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1",
+          coingeckoId: "ethereum"
+        },
+        {
+          name: "XDAI",
+          decimals: 18,
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "xdai"
         }
       ],
       evm: {
-        chain: chains.avalanche,
-        rpcUrl: chains.avalanche.rpcUrls.default.http[0],
-        supports7702: false,
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=avalanche`,
-        erc4337: false,
+        chain: chains.gnosis,
+        rpcUrl: chains.gnosis.rpcUrls.default.http[0],
+        supports7702: true,
+        erc4337: true,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=gnosis`,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0x5D1D71FE2De5D1C52c7c11311332eC7f0CBf88aF",
-        paymasterAddress: "0x6c0de464F2203FE089FF719Acf425dFfE6ac1EE5"
+        factoryAddress: "0xC8a2Fb1f2E686417A131E09be3320cb5431CcD90",
+        paymasterAddress: "0x4C36C70d68a7c26326711e8268bb163E3784fA96"
       },
       crossChainInformation: {
         circleInformation: {
-          supportCirclePaymaster: true,
+          supportCirclePaymaster: false,
+          aproxFromFee: 0,
           cCTPInformation: {
-            supportCCTP: true,
-            domain: 1
-          },
-          aproxFromFee: 0
+            supportCCTP: false,
+            domain: 0
+          }
         },
         nearIntentInformation: {
           support: true,
           assetsId: [
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
+              assetId: "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
               name: "USDC",
               decimals: 6
             },
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
-              name: "AVAX",
+              assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
+              name: "USDT",
+              decimals: 6
+            },
+            {
+              assetId: "nep141:gnosis-0x420ca0f9b9b604ce0fd9c18ef134c705e5fa3430.omft.near",
+              name: "EURe",
               decimals: 18
             },
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
-              name: "USDT",
-              decimals: 6
+              assetId: "nep141:gnosis-0x9c58bacc331c9aa871afd802db6379a98e80cedb.omft.near",
+              name: "GNO",
+              decimals: 18
+            },
+            {
+              assetId: "nep141:gnosis-0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1.omft.near",
+              name: "WETH",
+              decimals: 18
+            },
+            {
+              assetId: "nep141:gnosis.omft.near",
+              name: "XDAI",
+              decimals: 18
             }
           ],
           needMemo: false
-        },
-        stargateInformation: {
-          support: true
         }
       }
     };
@@ -586,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"() {
@@ -740,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, {
@@ -859,6 +888,17 @@ var init_facilitator = __esm({
       return isDev ? PlatformFees.DEV : PlatformFees.DEFAULT;
     };
     FACILITATOR_NETWORKS = {
+      Ethereum: {
+        chainId: chains.mainnet.id,
+        chain: chains.mainnet,
+        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 0,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: chains.mainnet.rpcUrls.default.http[0]
+      },
       Base: {
         chainId: 8453,
         chain: chains.base,
@@ -1127,6 +1167,68 @@ var init_WorldChain = __esm({
     };
   }
 });
+var ETHEREUM;
+var init_Ethereum = __esm({
+  "src/chains/Evm/Ethereum.ts"() {
+    init_bundler();
+    ETHEREUM = {
+      assets: [
+        {
+          name: "USDC",
+          decimals: 6,
+          address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+          coingeckoId: "usd-coin",
+          supportsStargate: true
+        },
+        {
+          name: "ETH",
+          decimals: 18,
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "ethereum"
+        }
+      ],
+      evm: {
+        chain: chains.mainnet,
+        rpcUrl: chains.mainnet.rpcUrls.default.http[0],
+        supports7702: true,
+        erc4337: true,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=ethereum`,
+        entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+        factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
+        paymasterAddress: "0x1e13Eb16C565E3f3FDe49A011755e50410bb1F95"
+      },
+      crossChainInformation: {
+        circleInformation: {
+          supportCirclePaymaster: true,
+          cCTPInformation: {
+            supportCCTP: true,
+            domain: 0
+          },
+          aproxFromFee: 0
+        },
+        nearIntentInformation: {
+          support: true,
+          assetsId: [
+            {
+              assetId: "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near",
+              name: "USDC",
+              decimals: 6
+            },
+            {
+              assetId: "nep141:eth.omft.near",
+              name: "ETH",
+              decimals: 18
+            }
+          ],
+          needMemo: false
+        },
+        stargateInformation: {
+          support: false
+        }
+      }
+    };
+  }
+});
 
 // src/chains/index.ts
 var init_chains = __esm({
@@ -1142,6 +1244,8 @@ var init_chains = __esm({
     init_Monad();
     init_Binance();
     init_Gnosis();
+    init_Ethereum();
+    init_Stacks();
   }
 });
 
@@ -1151,17 +1255,18 @@ var init_chainsInformation = __esm({
   "src/constants/chainsInformation.ts"() {
     init_chains();
     NETWORKS = {
-      Optimism: OPTIMISM,
+      Optimism: exports.OPTIMISM,
       Arbitrum: ARBITRUM,
-      Base: BASE,
-      Unichain: UNICHAIN,
+      Base: exports.BASE,
+      Unichain: exports.UNICHAIN,
       Polygon: POLYGON,
-      Avalanche: AVALANCHE,
+      Avalanche: exports.AVALANCHE,
       WorldChain: WORLD_CHAIN,
       Stellar: exports.STELLAR,
       Monad,
       BNB,
-      Gnosis: GNOSIS
+      Gnosis: GNOSIS,
+      Ethereum: ETHEREUM
     };
   }
 });
@@ -1408,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
@@ -1674,15 +1779,15 @@ var init_near = __esm({
               return { success: false, errorReason: `Stellar Verification Failed: ${e.message}` };
             }
           }
-          const { createPublicClient: createPublicClient4, http: http4 } = await import('viem');
+          const { createPublicClient: createPublicClient5, http: http5 } = await import('viem');
           const { FACILITATOR_NETWORKS: FACILITATOR_NETWORKS2 } = await Promise.resolve().then(() => (init_facilitator(), facilitator_exports));
           const networkConfig = FACILITATOR_NETWORKS2[sourceChain];
           if (!networkConfig) {
             return { success: false, errorReason: `Unsupported source chain for verification: ${sourceChain}` };
           }
-          const publicClient = createPublicClient4({
+          const publicClient = createPublicClient5({
             chain: networkConfig.chain,
-            transport: http4(networkConfig.rpcUrl)
+            transport: http5(networkConfig.rpcUrl)
           });
           try {
             console.log(`[NearStrategy] Waiting for receipt...`);
@@ -1883,6 +1988,7 @@ var init_stargate = __esm({
             success: true,
             transactionHash: "PENDING_USER_SIGNATURE",
             netAmount: amount,
+            estimatedReceived: selectedQuote.dstAmount,
             data: {
               strategy: "Stargate",
               quote: selectedQuote,
@@ -1906,6 +2012,221 @@ var init_stargate = __esm({
     };
   }
 });
+var STACKS_BRIDGE_ADDRESS_ETH, stacksBridgeAbi, StacksStrategy;
+var init_stacks = __esm({
+  "src/services/stacks.ts"() {
+    init_chainsInformation();
+    STACKS_BRIDGE_ADDRESS_ETH = "0x8888888199b2Df864bf678259607d6D5EBb4e3Ce";
+    stacksBridgeAbi = [
+      {
+        "inputs": [
+          { "internalType": "uint256", "name": "value", "type": "uint256" },
+          { "internalType": "uint32", "name": "remoteDomain", "type": "uint32" },
+          { "internalType": "bytes32", "name": "remoteRecipient", "type": "bytes32" },
+          { "internalType": "address", "name": "localToken", "type": "address" },
+          { "internalType": "uint256", "name": "maxFee", "type": "uint256" },
+          { "internalType": "bytes", "name": "hookData", "type": "bytes" }
+        ],
+        "name": "depositToRemote",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+      }
+    ];
+    StacksStrategy = class {
+      constructor() {
+        this.name = "Stacks";
+      }
+      canHandle(context) {
+        return context.sourceChain === "Ethereum" && context.destChain === "Stacks";
+      }
+      async execute(context) {
+        const { amount, recipient, facilitatorPrivateKey, sourceChain } = context;
+        if (sourceChain !== "Ethereum") {
+          return { success: false, errorReason: "Stacks Strategy only supports financing from Ethereum" };
+        }
+        if (!facilitatorPrivateKey) {
+          return { success: false, errorReason: "Private Key required for Stacks Bridge execution" };
+        }
+        const networkConfig = NETWORKS[sourceChain];
+        if (!networkConfig || !networkConfig.evm) {
+          return { success: false, errorReason: `Unsupported chain or missing EVM config: ${sourceChain}` };
+        }
+        try {
+          const account = accounts.privateKeyToAccount(facilitatorPrivateKey);
+          const client = viem.createWalletClient({
+            account,
+            chain: networkConfig.evm.chain,
+            transport: viem.http(networkConfig.evm.rpcUrl)
+          });
+          const publicClient = viem.createPublicClient({
+            chain: networkConfig.evm.chain,
+            transport: viem.http(networkConfig.evm.rpcUrl)
+          });
+          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,
+            functionName: "allowance",
+            args: [account.address, STACKS_BRIDGE_ADDRESS_ETH]
+          });
+          if (allowance < amountBigInt) {
+            console.log("[Stacks] Approving bridge...");
+            const approveHash = await client.writeContract({
+              address: usdcAddress,
+              abi: viem.erc20Abi,
+              functionName: "approve",
+              args: [STACKS_BRIDGE_ADDRESS_ETH, amountBigInt],
+              chain: networkConfig.evm.chain
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveHash });
+            console.log("[Stacks] Approved.");
+          }
+          const REMOTE_DOMAIN_STACKS = 10003;
+          let recipientBytes32;
+          if (recipient.startsWith("0x")) {
+            recipientBytes32 = viem.padHex(recipient, { size: 32 });
+          } else {
+            try {
+              const [version, hash2] = c32check.c32addressDecode(recipient);
+              recipientBytes32 = viem.padHex(`0x${hash2}`, { size: 32 });
+            } catch (e) {
+              throw new Error(`Invalid Stacks Recipient: ${e.message}`);
+            }
+          }
+          console.log(`[Stacks] Depositing ${amount} USDC to ${recipient} (Domain ${REMOTE_DOMAIN_STACKS})...`);
+          const hash = await client.writeContract({
+            address: STACKS_BRIDGE_ADDRESS_ETH,
+            abi: stacksBridgeAbi,
+            functionName: "depositToRemote",
+            args: [
+              amountBigInt,
+              REMOTE_DOMAIN_STACKS,
+              recipientBytes32,
+              usdcAddress,
+              0n,
+              // maxFee
+              "0x"
+              // hookData
+            ],
+            chain: networkConfig.evm.chain
+          });
+          console.log(`[Stacks] Deposit Tx: ${hash}`);
+          const receipt = await publicClient.waitForTransactionReceipt({ hash });
+          if (receipt.status === "success") {
+            return {
+              success: true,
+              transactionHash: hash,
+              netAmount: amountBigInt.toString()
+            };
+          } else {
+            return {
+              success: false,
+              transactionHash: hash,
+              errorReason: "Stacks Deposit Transaction Reverted"
+            };
+          }
+        } catch (error) {
+          return {
+            success: false,
+            errorReason: error instanceof Error ? error.message : "Using Stacks Bridge failed"
+          };
+        }
+      }
+    };
+  }
+});
+
+// src/services/Router.ts
+exports.RouterService = void 0;
+var init_Router = __esm({
+  "src/services/Router.ts"() {
+    exports.RouterService = class {
+      /**
+       * Orchestrates a Multi-Hop transfer by signing ALL UserOps upfront (Reverse Order),
+       * and then executing them sequentially (Forward Order) with polling support.
+       * 
+       * @param steps Array of MultiHopStep ordered by execution (Source -> Intermediate -> Dest)
+       * @param onLog Optional callback for logging progress
+       */
+      async executeMultiHop(steps, onLog = console.log) {
+        onLog("[Router] Orchestrating Multi-Hop Sequence...");
+        const signedOps = [];
+        onLog("[Router] Phase 1: Preparation & Upfront Signing (Reverse Order)...");
+        for (let i = steps.length - 1; i >= 0; i--) {
+          const step = steps[i];
+          onLog(`[Router] Preparing Step ${i + 1}: ${step.description}...`);
+          try {
+            const userOp = await step.buildUserOp();
+            onLog(`[Router] Please sign Step ${i + 1} (${step.description})...`);
+            const signedOp = await step.aa.signUserOperation(userOp);
+            signedOps.unshift({ stepIndex: i, signedOp });
+            onLog(`[Router] Step ${i + 1} Signed Successfully.`);
+          } catch (err) {
+            onLog(`[Router] Error preparing Step ${i + 1}: ${err.message}`);
+            throw err;
+          }
+        }
+        onLog("[Router] Phase 2: Sequential Execution (Forward Order)...");
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          const signedOp = signedOps[i].signedOp;
+          if (step.waitCondition) {
+            onLog(`[Router] Step ${i + 1} requires waiting (e.g. for funds)...`);
+            const success = await this.pollCondition(step.waitCondition, onLog);
+            if (!success) throw new Error(`Timeout waiting for condition at Step ${i + 1}`);
+          }
+          onLog(`[Router] Executing Step ${i + 1}...`);
+          try {
+            const hash = await step.aa.sendUserOperation(signedOp);
+            onLog(`[Router] Step ${i + 1} Sent! Hash: ${hash}`);
+            onLog(`[Router] Waiting for Step ${i + 1} confirmation...`);
+            const receipt = await step.aa.waitForUserOperation(hash);
+            if (!receipt.success) {
+              throw new Error(`Step ${i + 1} Failed on-chain!`);
+            }
+            onLog(`[Router] Step ${i + 1} Confirmed.`);
+          } catch (err) {
+            onLog(`[Router] Execution Failed at Step ${i + 1}: ${err.message}`);
+            throw err;
+          }
+        }
+        onLog("[Router] Multi-Hop Sequence Completed Successfully! \u{1F680}");
+        return true;
+      }
+      async pollCondition(condition, onLog) {
+        const timeout = 6e4 * 10;
+        const interval = 5e3;
+        let elapsed = 0;
+        while (elapsed < timeout) {
+          try {
+            const passed = await condition();
+            if (passed) return true;
+          } catch (e) {
+            onLog(`[Router] Polling check failed (retrying): ${e.message}`);
+          }
+          await new Promise((r) => setTimeout(r, interval));
+          elapsed += interval;
+          if (elapsed % 2e4 === 0) onLog(`[Router] Still waiting... (${Math.floor(elapsed / 1e3)}s)`);
+        }
+        return false;
+      }
+    };
+  }
+});
 
 // src/services/TransferManager.ts
 var TransferManager_exports = {};
@@ -1918,17 +2239,24 @@ var init_TransferManager = __esm({
     init_cctp2();
     init_near();
     init_stargate();
+    init_stacks();
+    init_Router();
+    init_chainsInformation();
     exports.TransferManager = class {
       constructor() {
         this.strategies = [
           new exports.CCTPStrategy(),
           new exports.StargateStrategy(),
-          new exports.NearStrategy()
+          new exports.StargateStrategy(),
+          new exports.NearStrategy(),
+          new StacksStrategy()
         ];
+        this.router = new exports.RouterService();
       }
-      async execute(context) {
+      async execute(context, logCallback) {
+        const log = logCallback || console.log;
         if (context.sourceChain === context.destChain && context.sourceToken === context.destToken) {
-          console.log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
+          log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
           return {
             success: true,
             transactionHash: "DIRECT_TRANSFER_REQUIRED",
@@ -1940,20 +2268,38 @@ 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)) {
-          console.log(`[TransferManager] Routing to: ${stargateStrategy.name} (Stargate)`);
+          log(`[TransferManager] Routing to: ${stargateStrategy.name} (Stargate)`);
           return stargateStrategy.execute(context);
         }
         const cctpStrategy = strategies.find((s) => s instanceof exports.CCTPStrategy);
         if (cctpStrategy && cctpStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${cctpStrategy.name} (CCTP)`);
+          log(`[TransferManager] Routing to: ${cctpStrategy.name} (CCTP)`);
           return cctpStrategy.execute(context);
         }
         const nearStrategy = strategies.find((s) => s instanceof exports.NearStrategy);
         if (nearStrategy && nearStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
+          log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
           return nearStrategy.execute(context);
         }
         return {
@@ -1961,6 +2307,115 @@ var init_TransferManager = __esm({
           errorReason: `No suitable transfer strategy found for ${context.sourceChain} -> ${context.destChain}`
         };
       }
+      /**
+       * Specialized method for Base/Unichain -> Stacks flow.
+       * 1. EVM (Base/Unichain) -> Ethereum (CCTP)
+       * 2. Ethereum -> Stacks (Stacks Bridge)
+       */
+      async executeEVMToStacks(context, sourceAA, ethPrivateKey, logCallback) {
+        const log = logCallback || console.log;
+        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") {
+          log("[TransferManager] Source is Ethereum. Executing Stacks Bridge Step...");
+          return stacksStrategy.execute({
+            ...context,
+            facilitatorPrivateKey: ethPrivateKey
+          });
+        }
+        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;
+          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,
+              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: false,
+              errorReason: `Funding/CCTP Failed: ${err instanceof Error ? err.message : String(err)}`
+            };
+          }
+        }
+        return {
+          success: false,
+          errorReason: `Unsupported Route for ${context.sourceChain}->Stacks Helper`
+        };
+      }
     };
   }
 });
@@ -2174,6 +2629,24 @@ var BundlerClient = class {
       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) {
@@ -2396,6 +2869,23 @@ var AccountAbstraction = class {
     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);
@@ -2474,13 +2964,29 @@ var AccountAbstraction = class {
    * Get the Smart Account address for an owner
    */
   async getSmartAccountAddress(owner) {
-    const address = await this.publicClient.readContract({
-      address: this.factoryAddress,
-      abi: factoryAbi,
-      functionName: "getAccountAddress",
-      args: [owner, 0n]
-    });
-    return address;
+    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) {
@@ -2737,6 +3243,12 @@ var AccountAbstraction = class {
   }
 };
 
+// src/index.ts
+init_Base();
+init_Avalanche();
+init_Optimism();
+init_Unichain();
+
 // src/chains.ts
 init_Base();
 init_Gnosis();
@@ -2778,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,
@@ -2805,17 +3320,18 @@ function mapToSDKConfig(data) {
     }))
   };
 }
-var BASE_MAINNET = mapToSDKConfig(BASE);
-var OPTIMISM_MAINNET = mapToSDKConfig(OPTIMISM);
+var BASE_MAINNET = mapToSDKConfig(exports.BASE);
+var OPTIMISM_MAINNET = mapToSDKConfig(exports.OPTIMISM);
 var GNOSIS_MAINNET = mapToSDKConfig(GNOSIS);
 var BASE_SEPOLIA2 = mapToSDKConfig(BASE_SEPOLIA);
-var AVALANCHE_MAINNET = mapToSDKConfig(AVALANCHE);
+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,
@@ -2827,9 +3343,11 @@ 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
 };
 var CHAIN_ID_TO_KEY = {
+  [chains.mainnet.id]: "Ethereum",
   [chains.base.id]: "Base",
   [chains.baseSepolia.id]: "Base",
   [chains.gnosis.id]: "Gnosis",
@@ -2841,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
@@ -2936,18 +3455,29 @@ var UniswapService = class {
 };
 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;