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

package/dist/index.mjs

@@ -1,10 +1,11 @@
-import { monad, unichain, arbitrum, polygon, bsc, avalanche, optimism, gnosis, baseSepolia, base, optimismSepolia, worldchain } from 'viem/chains';
+import { monad, unichain, arbitrum, polygon, bsc, avalanche, optimism, gnosis, baseSepolia, base, optimismSepolia, mainnet, worldchain } from 'viem/chains';
 import * as StellarSdk from 'stellar-sdk';
 import { Networks } from 'stellar-sdk';
 import axios from 'axios';
-import { parseAbi, createPublicClient, http, encodeFunctionData, createWalletClient, decodeErrorResult, encodeAbiParameters, keccak256, maxUint256, padHex } from 'viem';
+import { parseAbi, createPublicClient, http, encodeFunctionData, parseUnits, formatUnits, createWalletClient, decodeErrorResult, encodeAbiParameters, keccak256, maxUint256, padHex, getAddress, erc20Abi as erc20Abi$1 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
-import { OpenAPI, OneClickService, QuoteRequest } from '@defuse-protocol/one-click-sdk-typescript';
+import { OpenAPI, QuoteRequest, OneClickService } from '@defuse-protocol/one-click-sdk-typescript';
+import { c32addressDecode } from 'c32check';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -48,7 +49,7 @@ var init_Base = __esm({
         chain: base,
         rpcUrl: "https://base-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
         supports7702: true,
-        erc4337: false,
+        erc4337: true,
         bundlerUrl: `${BUNDLER_URL}/rpc?chain=base`,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
         factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
@@ -86,103 +87,74 @@ var init_Base = __esm({
     };
   }
 });
-var GNOSIS;
-var init_Gnosis = __esm({
-  "src/chains/Evm/Gnosis.ts"() {
+var AVALANCHE;
+var init_Avalanche = __esm({
+  "src/chains/Evm/Avalanche.ts"() {
     init_bundler();
-    GNOSIS = {
+    AVALANCHE = {
       assets: [
         {
           name: "USDC",
           decimals: 6,
-          address: "0x2a22f9c3b484c3629090FeED35F17Ff8F88f76F0",
-          coingeckoId: "usd-coin"
-        },
-        {
-          name: "USDT",
-          decimals: 6,
-          address: "0x4ECaBa5870353805a9F068101A40E0f32ed605C6",
-          coingeckoId: "tether"
-        },
-        {
-          name: "EURe",
-          decimals: 18,
-          address: "0x420CA0f9B9b604cE0fd9C18EF134C705e5Fa3430",
-          coingeckoId: "monerium-eur-money"
-        },
-        {
-          name: "GNO",
-          decimals: 18,
-          address: "0x9C58BAcC331c9aa871AFD802DB6379a98e80CEdb",
-          coingeckoId: "gnosis"
+          address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+          coingeckoId: "usd-coin",
+          supportsStargate: true
         },
         {
-          name: "WETH",
+          name: "AVAX",
           decimals: 18,
-          address: "0x6A023CCd1ff6F2045C3309768eAd9E68F978f6e1",
-          coingeckoId: "ethereum"
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "avalanche-2"
         },
         {
-          name: "XDAI",
-          decimals: 18,
-          address: "0x0000000000000000000000000000000000000000",
-          coingeckoId: "xdai"
+          name: "USDT",
+          decimals: 6,
+          address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+          coingeckoId: "tether"
         }
       ],
       evm: {
-        chain: gnosis,
-        rpcUrl: gnosis.rpcUrls.default.http[0],
-        supports7702: true,
-        erc4337: true,
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=gnosis`,
+        chain: avalanche,
+        rpcUrl: avalanche.rpcUrls.default.http[0],
+        supports7702: false,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=avalanche`,
+        erc4337: false,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0xC8a2Fb1f2E686417A131E09be3320cb5431CcD90",
-        paymasterAddress: "0x4C36C70d68a7c26326711e8268bb163E3784fA96"
+        factoryAddress: "0x5D1D71FE2De5D1C52c7c11311332eC7f0CBf88aF",
+        paymasterAddress: "0x6c0de464F2203FE089FF719Acf425dFfE6ac1EE5"
       },
       crossChainInformation: {
         circleInformation: {
-          supportCirclePaymaster: false,
-          aproxFromFee: 0,
+          supportCirclePaymaster: true,
           cCTPInformation: {
-            supportCCTP: false,
-            domain: 0
-          }
+            supportCCTP: true,
+            domain: 1
+          },
+          aproxFromFee: 0
         },
         nearIntentInformation: {
           support: true,
           assetsId: [
             {
-              assetId: "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
+              assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
               name: "USDC",
               decimals: 6
             },
             {
-              assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
-              name: "USDT",
-              decimals: 6
-            },
-            {
-              assetId: "nep141:gnosis-0x420ca0f9b9b604ce0fd9c18ef134c705e5fa3430.omft.near",
-              name: "EURe",
-              decimals: 18
-            },
-            {
-              assetId: "nep141:gnosis-0x9c58bacc331c9aa871afd802db6379a98e80cedb.omft.near",
-              name: "GNO",
-              decimals: 18
-            },
-            {
-              assetId: "nep141:gnosis-0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1.omft.near",
-              name: "WETH",
+              assetId: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
+              name: "AVAX",
               decimals: 18
             },
             {
-              assetId: "nep141:gnosis.omft.near",
-              name: "XDAI",
-              decimals: 18
+              assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
+              name: "USDT",
+              decimals: 6
             }
           ],
           needMemo: false
+        },
+        stargateInformation: {
+          support: true
         }
       }
     };
@@ -221,7 +193,7 @@ var init_Optimism = __esm({
       ],
       evm: {
         chain: optimism,
-        rpcUrl: "https://opt-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN",
+        rpcUrl: "https://mainnet.optimism.io",
         supports7702: false,
         erc4337: false,
         bundlerUrl: `${BUNDLER_URL}/rpc?chain=optimism`,
@@ -268,74 +240,140 @@ var init_Optimism = __esm({
     };
   }
 });
-var AVALANCHE;
-var init_Avalanche = __esm({
-  "src/chains/Evm/Avalanche.ts"() {
+var UNICHAIN;
+var init_Unichain = __esm({
+  "src/chains/Evm/Unichain.ts"() {
     init_bundler();
-    AVALANCHE = {
+    UNICHAIN = {
       assets: [
         {
           name: "USDC",
           decimals: 6,
-          address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-          coingeckoId: "usd-coin",
-          supportsStargate: true
+          address: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+          coingeckoId: "usd-coin"
+        }
+      ],
+      evm: {
+        chain: 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: avalanche,
-        rpcUrl: avalanche.rpcUrls.default.http[0],
-        supports7702: false,
-        bundlerUrl: `${BUNDLER_URL}/rpc?chain=avalanche`,
-        erc4337: false,
+        chain: gnosis,
+        rpcUrl: gnosis.rpcUrls.default.http[0],
+        supports7702: true,
+        erc4337: true,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=gnosis`,
         entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
-        factoryAddress: "0x5D1D71FE2De5D1C52c7c11311332eC7f0CBf88aF",
-        paymasterAddress: "0x6c0de464F2203FE089FF719Acf425dFfE6ac1EE5"
+        factoryAddress: "0xC8a2Fb1f2E686417A131E09be3320cb5431CcD90",
+        paymasterAddress: "0x4C36C70d68a7c26326711e8268bb163E3784fA96"
       },
       crossChainInformation: {
         circleInformation: {
-          supportCirclePaymaster: true,
+          supportCirclePaymaster: false,
+          aproxFromFee: 0,
           cCTPInformation: {
-            supportCCTP: true,
-            domain: 1
-          },
-          aproxFromFee: 0
+            supportCCTP: false,
+            domain: 0
+          }
         },
         nearIntentInformation: {
           support: true,
           assetsId: [
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
+              assetId: "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
               name: "USDC",
               decimals: 6
             },
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_11111111111111111111",
-              name: "AVAX",
+              assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
+              name: "USDT",
+              decimals: 6
+            },
+            {
+              assetId: "nep141:gnosis-0x420ca0f9b9b604ce0fd9c18ef134c705e5fa3430.omft.near",
+              name: "EURe",
               decimals: 18
             },
             {
-              assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
-              name: "USDT",
-              decimals: 6
+              assetId: "nep141:gnosis-0x9c58bacc331c9aa871afd802db6379a98e80cedb.omft.near",
+              name: "GNO",
+              decimals: 18
+            },
+            {
+              assetId: "nep141:gnosis-0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1.omft.near",
+              name: "WETH",
+              decimals: 18
+            },
+            {
+              assetId: "nep141:gnosis.omft.near",
+              name: "XDAI",
+              decimals: 18
             }
           ],
           needMemo: false
-        },
-        stargateInformation: {
-          support: true
         }
       }
     };
@@ -562,43 +600,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: 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"() {
@@ -716,6 +717,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, {
@@ -835,6 +864,17 @@ var init_facilitator = __esm({
       return isDev ? PlatformFees.DEV : PlatformFees.DEFAULT;
     };
     FACILITATOR_NETWORKS = {
+      Ethereum: {
+        chainId: mainnet.id,
+        chain: mainnet,
+        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 0,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: mainnet.rpcUrls.default.http[0]
+      },
       Base: {
         chainId: 8453,
         chain: base,
@@ -1103,6 +1143,68 @@ var init_WorldChain = __esm({
     };
   }
 });
+var ETHEREUM;
+var init_Ethereum = __esm({
+  "src/chains/Evm/Ethereum.ts"() {
+    init_bundler();
+    ETHEREUM = {
+      assets: [
+        {
+          name: "USDC",
+          decimals: 6,
+          address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+          coingeckoId: "usd-coin",
+          supportsStargate: true
+        },
+        {
+          name: "ETH",
+          decimals: 18,
+          address: "0x0000000000000000000000000000000000000000",
+          coingeckoId: "ethereum"
+        }
+      ],
+      evm: {
+        chain: mainnet,
+        rpcUrl: mainnet.rpcUrls.default.http[0],
+        supports7702: true,
+        erc4337: true,
+        bundlerUrl: `${BUNDLER_URL}/rpc?chain=ethereum`,
+        entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+        factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
+        paymasterAddress: "0x1e13Eb16C565E3f3FDe49A011755e50410bb1F95"
+      },
+      crossChainInformation: {
+        circleInformation: {
+          supportCirclePaymaster: true,
+          cCTPInformation: {
+            supportCCTP: true,
+            domain: 0
+          },
+          aproxFromFee: 0
+        },
+        nearIntentInformation: {
+          support: true,
+          assetsId: [
+            {
+              assetId: "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near",
+              name: "USDC",
+              decimals: 6
+            },
+            {
+              assetId: "nep141:eth.omft.near",
+              name: "ETH",
+              decimals: 18
+            }
+          ],
+          needMemo: false
+        },
+        stargateInformation: {
+          support: false
+        }
+      }
+    };
+  }
+});
 
 // src/chains/index.ts
 var init_chains = __esm({
@@ -1118,6 +1220,8 @@ var init_chains = __esm({
     init_Monad();
     init_Binance();
     init_Gnosis();
+    init_Ethereum();
+    init_Stacks();
   }
 });
 
@@ -1137,7 +1241,8 @@ var init_chainsInformation = __esm({
       Stellar: STELLAR,
       Monad,
       BNB,
-      Gnosis: GNOSIS
+      Gnosis: GNOSIS,
+      Ethereum: ETHEREUM
     };
   }
 });
@@ -1384,7 +1489,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
@@ -1650,15 +1755,15 @@ var init_near = __esm({
               return { success: false, errorReason: `Stellar Verification Failed: ${e.message}` };
             }
           }
-          const { createPublicClient: createPublicClient4, http: http4 } = await import('viem');
+          const { createPublicClient: createPublicClient5, http: http5 } = await import('viem');
           const { FACILITATOR_NETWORKS: FACILITATOR_NETWORKS2 } = await Promise.resolve().then(() => (init_facilitator(), facilitator_exports));
           const networkConfig = FACILITATOR_NETWORKS2[sourceChain];
           if (!networkConfig) {
             return { success: false, errorReason: `Unsupported source chain for verification: ${sourceChain}` };
           }
-          const publicClient = createPublicClient4({
+          const publicClient = createPublicClient5({
             chain: networkConfig.chain,
-            transport: http4(networkConfig.rpcUrl)
+            transport: http5(networkConfig.rpcUrl)
           });
           try {
             console.log(`[NearStrategy] Waiting for receipt...`);
@@ -1859,6 +1964,7 @@ var init_stargate = __esm({
             success: true,
             transactionHash: "PENDING_USER_SIGNATURE",
             netAmount: amount,
+            estimatedReceived: selectedQuote.dstAmount,
             data: {
               strategy: "Stargate",
               quote: selectedQuote,
@@ -1882,6 +1988,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 = privateKeyToAccount(facilitatorPrivateKey);
+          const client = createWalletClient({
+            account,
+            chain: networkConfig.evm.chain,
+            transport: http(networkConfig.evm.rpcUrl)
+          });
+          const publicClient = createPublicClient({
+            chain: networkConfig.evm.chain,
+            transport: http(networkConfig.evm.rpcUrl)
+          });
+          const 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 = getAddress(usdcToken.address);
+          const amountBigInt = parseUnits(amount, 6);
+          const balance = await publicClient.readContract({
+            address: usdcAddress,
+            abi: erc20Abi$1,
+            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: erc20Abi$1,
+            functionName: "allowance",
+            args: [account.address, STACKS_BRIDGE_ADDRESS_ETH]
+          });
+          if (allowance < amountBigInt) {
+            console.log("[Stacks] Approving bridge...");
+            const approveHash = await client.writeContract({
+              address: usdcAddress,
+              abi: erc20Abi$1,
+              functionName: "approve",
+              args: [STACKS_BRIDGE_ADDRESS_ETH, amountBigInt],
+              chain: networkConfig.evm.chain
+            });
+            await publicClient.waitForTransactionReceipt({ hash: approveHash });
+            console.log("[Stacks] Approved.");
+          }
+          const REMOTE_DOMAIN_STACKS = 10003;
+          let recipientBytes32;
+          if (recipient.startsWith("0x")) {
+            recipientBytes32 = padHex(recipient, { size: 32 });
+          } else {
+            try {
+              const [version, hash2] = c32addressDecode(recipient);
+              recipientBytes32 = 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
+var RouterService;
+var init_Router = __esm({
+  "src/services/Router.ts"() {
+    RouterService = class {
+      /**
+       * Orchestrates a Multi-Hop transfer by signing ALL UserOps upfront (Reverse Order),
+       * and then executing them sequentially (Forward Order) with polling support.
+       * 
+       * @param steps Array of MultiHopStep ordered by execution (Source -> Intermediate -> Dest)
+       * @param onLog Optional callback for logging progress
+       */
+      async executeMultiHop(steps, onLog = console.log) {
+        onLog("[Router] Orchestrating Multi-Hop Sequence...");
+        const signedOps = [];
+        onLog("[Router] Phase 1: Preparation & Upfront Signing (Reverse Order)...");
+        for (let i = steps.length - 1; i >= 0; i--) {
+          const step = steps[i];
+          onLog(`[Router] Preparing Step ${i + 1}: ${step.description}...`);
+          try {
+            const userOp = await step.buildUserOp();
+            onLog(`[Router] Please sign Step ${i + 1} (${step.description})...`);
+            const signedOp = await step.aa.signUserOperation(userOp);
+            signedOps.unshift({ stepIndex: i, signedOp });
+            onLog(`[Router] Step ${i + 1} Signed Successfully.`);
+          } catch (err) {
+            onLog(`[Router] Error preparing Step ${i + 1}: ${err.message}`);
+            throw err;
+          }
+        }
+        onLog("[Router] Phase 2: Sequential Execution (Forward Order)...");
+        for (let i = 0; i < steps.length; i++) {
+          const step = steps[i];
+          const signedOp = signedOps[i].signedOp;
+          if (step.waitCondition) {
+            onLog(`[Router] Step ${i + 1} requires waiting (e.g. for funds)...`);
+            const success = await this.pollCondition(step.waitCondition, onLog);
+            if (!success) throw new Error(`Timeout waiting for condition at Step ${i + 1}`);
+          }
+          onLog(`[Router] Executing Step ${i + 1}...`);
+          try {
+            const hash = await step.aa.sendUserOperation(signedOp);
+            onLog(`[Router] Step ${i + 1} Sent! Hash: ${hash}`);
+            onLog(`[Router] Waiting for Step ${i + 1} confirmation...`);
+            const receipt = await step.aa.waitForUserOperation(hash);
+            if (!receipt.success) {
+              throw new Error(`Step ${i + 1} Failed on-chain!`);
+            }
+            onLog(`[Router] Step ${i + 1} Confirmed.`);
+          } catch (err) {
+            onLog(`[Router] Execution Failed at Step ${i + 1}: ${err.message}`);
+            throw err;
+          }
+        }
+        onLog("[Router] Multi-Hop Sequence Completed Successfully! \u{1F680}");
+        return true;
+      }
+      async pollCondition(condition, onLog) {
+        const timeout = 6e4 * 10;
+        const interval = 5e3;
+        let elapsed = 0;
+        while (elapsed < timeout) {
+          try {
+            const passed = await condition();
+            if (passed) return true;
+          } catch (e) {
+            onLog(`[Router] Polling check failed (retrying): ${e.message}`);
+          }
+          await new Promise((r) => setTimeout(r, interval));
+          elapsed += interval;
+          if (elapsed % 2e4 === 0) onLog(`[Router] Still waiting... (${Math.floor(elapsed / 1e3)}s)`);
+        }
+        return false;
+      }
+    };
+  }
+});
 
 // src/services/TransferManager.ts
 var TransferManager_exports = {};
@@ -1894,17 +2215,24 @@ var init_TransferManager = __esm({
     init_cctp2();
     init_near();
     init_stargate();
+    init_stacks();
+    init_Router();
+    init_chainsInformation();
     TransferManager = class {
       constructor() {
         this.strategies = [
           new CCTPStrategy(),
           new StargateStrategy(),
-          new NearStrategy()
+          new StargateStrategy(),
+          new NearStrategy(),
+          new StacksStrategy()
         ];
+        this.router = new RouterService();
       }
-      async execute(context) {
+      async execute(context, logCallback) {
+        const log = logCallback || console.log;
         if (context.sourceChain === context.destChain && context.sourceToken === context.destToken) {
-          console.log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
+          log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
           return {
             success: true,
             transactionHash: "DIRECT_TRANSFER_REQUIRED",
@@ -1916,20 +2244,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 StargateStrategy);
         if (stargateStrategy && stargateStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${stargateStrategy.name} (Stargate)`);
+          log(`[TransferManager] Routing to: ${stargateStrategy.name} (Stargate)`);
           return stargateStrategy.execute(context);
         }
         const cctpStrategy = strategies.find((s) => s instanceof CCTPStrategy);
         if (cctpStrategy && cctpStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${cctpStrategy.name} (CCTP)`);
+          log(`[TransferManager] Routing to: ${cctpStrategy.name} (CCTP)`);
           return cctpStrategy.execute(context);
         }
         const nearStrategy = strategies.find((s) => s instanceof NearStrategy);
         if (nearStrategy && nearStrategy.canHandle(context)) {
-          console.log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
+          log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
           return nearStrategy.execute(context);
         }
         return {
@@ -1937,6 +2283,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 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 = privateKeyToAccount(ethPrivateKey);
+          const ethAddress = ethAccount.address;
+          log(`[TransferManager] Funding Facilitator (${ethAddress})...`);
+          try {
+            const amountBigInt = 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 ? 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`
+        };
+      }
     };
   }
 });
@@ -2150,6 +2605,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) {
@@ -2372,6 +2845,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 = privateKeyToAccount(signer);
@@ -2450,13 +2940,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) {
@@ -2713,6 +3219,12 @@ var AccountAbstraction = class {
   }
 };
 
+// src/index.ts
+init_Base();
+init_Avalanche();
+init_Optimism();
+init_Unichain();
+
 // src/chains.ts
 init_Base();
 init_Gnosis();
@@ -2754,11 +3266,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,
@@ -2792,6 +3307,7 @@ var ARBITRUM_MAINNET = mapToSDKConfig(ARBITRUM);
 var UNICHAIN_MAINNET = mapToSDKConfig(UNICHAIN);
 var MONAD_MAINNET = mapToSDKConfig(Monad);
 var STELLAR_MAINNET = mapToSDKConfig(STELLAR);
+var STACKS_MAINNET = mapToSDKConfig(STACKS);
 var CHAIN_CONFIGS = {
   [base.id]: BASE_MAINNET,
   [baseSepolia.id]: BASE_SEPOLIA2,
@@ -2803,9 +3319,11 @@ var CHAIN_CONFIGS = {
   [arbitrum.id]: ARBITRUM_MAINNET,
   [unichain.id]: UNICHAIN_MAINNET,
   [monad.id]: MONAD_MAINNET,
-  9e3: STELLAR_MAINNET
+  9e3: STELLAR_MAINNET,
+  5e3: STACKS_MAINNET
 };
 var CHAIN_ID_TO_KEY = {
+  [mainnet.id]: "Ethereum",
   [base.id]: "Base",
   [baseSepolia.id]: "Base",
   [gnosis.id]: "Gnosis",
@@ -2817,7 +3335,8 @@ var CHAIN_ID_TO_KEY = {
   [avalanche.id]: "Avalanche",
   [unichain.id]: "Unichain",
   [monad.id]: "Monad",
-  "9000": "Stellar"
+  "9000": "Stellar",
+  "5000": "Stacks"
 };
 
 // src/index.ts
@@ -2912,6 +3431,9 @@ var UniswapService = class {
 };
 var uniswapService = new UniswapService();
 
-export { AccountAbstraction, BASE_MAINNET, BASE_SEPOLIA2 as BASE_SEPOLIA, BundlerClient, CCTPStrategy, CHAIN_CONFIGS, CHAIN_ID_TO_KEY, GNOSIS_MAINNET, NearStrategy, OPTIMISM_MAINNET, STELLAR, STELLAR_MAINNET, StargateStrategy, StellarService, TransferManager, UniswapService, entryPointAbi, erc20Abi, getNearSimulation, getStargateSimulation, smartAccountAbi, uniswapService };
+// src/index.ts
+init_Router();
+
+export { ARBITRUM_MAINNET, AVALANCHE, AVALANCHE_MAINNET, AccountAbstraction, BASE, BASE_MAINNET, BASE_SEPOLIA2 as BASE_SEPOLIA, BSC_MAINNET, BundlerClient, CCTPStrategy, CHAIN_CONFIGS, CHAIN_ID_TO_KEY, GNOSIS_MAINNET, MONAD_MAINNET, NearStrategy, OPTIMISM, OPTIMISM_MAINNET, POLYGON_MAINNET, RouterService, STACKS_MAINNET, STELLAR, STELLAR_MAINNET, StargateStrategy, StellarService, TransferManager, UNICHAIN, UNICHAIN_MAINNET, UniswapService, entryPointAbi, erc20Abi, getNearQuote, getNearSimulation, getStargateSimulation, smartAccountAbi, uniswapService };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map