@1llet.xyz/erc4337-gasless-sdk 0.4.54 → 0.4.56

package/dist/index.mjs

@@ -209,14 +209,9 @@ var init_facilitator = __esm({
         chainId: 100,
         chain: gnosis,
         usdc: "0x2a22f9c3b48403ebD92cF06fF916b322a30dB834",
-        // EURe (or USDC on Gnosis? The user is swapping USDT -> USDC, wait. The user log says GNOSIS -> Optimism (USDT -> USDC).
-        // For verification, we just need RPC. The 'usdc' field is for CCTP, but verify logic just needs `rpcUrl`.
-        // I will populate others as placeholders if unknown.
         usdcName: "USDC",
-        // Placeholder
         usdcVersion: "2",
         domain: 0,
-        // Placeholder
         tokenMessenger: "0x0000000000000000000000000000000000000000",
         messageTransmitter: "0x0000000000000000000000000000000000000000",
         rpcUrl: "https://rpc.gnosischain.com"
@@ -228,8 +223,8 @@ var init_facilitator = __esm({
         usdcName: "USD Coin",
         usdcVersion: "2",
         domain: 3,
-        tokenMessenger: "0x19330d10D9Cc8751218eaf51E8885D058642E08A",
-        messageTransmitter: "0xC30362313FBBA5cf9163F0bb16a0e01f01A896ca",
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
         rpcUrl: "https://arb-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN"
       },
       Polygon: {
@@ -239,10 +234,53 @@ var init_facilitator = __esm({
         usdcName: "USD Coin",
         usdcVersion: "2",
         domain: 7,
-        // Placeholder? CCTP domain for Polygon is 7? I should check if I had it elsewhere.
-        tokenMessenger: "0x0000000000000000000000000000000000000000",
-        messageTransmitter: "0x0000000000000000000000000000000000000000",
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
         rpcUrl: "https://polygon-mainnet.g.alchemy.com/v2/49fUGmuW05ynCui0VEvDN"
+      },
+      Unichain: {
+        chainId: unichain.id,
+        chain: unichain,
+        usdc: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 10,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: unichain.rpcUrls.default.http[0]
+      },
+      Avalanche: {
+        chainId: avalanche.id,
+        chain: avalanche,
+        usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 1,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: avalanche.rpcUrls.default.http[0]
+      },
+      Worldchain: {
+        chainId: worldchain.id,
+        chain: worldchain,
+        usdc: "0x79A02482A880bCe3F13E09da970dC34dB4cD24D1",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 13,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: worldchain.rpcUrls.default.http[0]
+      },
+      Monad: {
+        chainId: monad.id,
+        chain: monad,
+        usdc: "0x754704Bc059F8C67012fEd69BC8A327a5aafb603",
+        usdcName: "USD Coin",
+        usdcVersion: "2",
+        domain: 15,
+        tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+        messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+        rpcUrl: monad.rpcUrls.default.http[0]
       }
     };
   }
@@ -1031,7 +1069,8 @@ var BASE = {
       name: "USDC",
       decimals: 6,
       address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      coingeckoId: "usd-coin"
+      coingeckoId: "usd-coin",
+      supportsStargate: true
     },
     {
       name: "ETH",
@@ -1074,6 +1113,9 @@ var BASE = {
         }
       ],
       needMemo: false
+    },
+    stargateInformation: {
+      support: true
     }
   }
 };
@@ -1278,7 +1320,8 @@ var AVALANCHE = {
       name: "USDC",
       decimals: 6,
       address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-      coingeckoId: "usd-coin"
+      coingeckoId: "usd-coin",
+      supportsStargate: true
     },
     {
       name: "AVAX",
@@ -1332,6 +1375,9 @@ var AVALANCHE = {
         }
       ],
       needMemo: false
+    },
+    stargateInformation: {
+      support: true
     }
   }
 };
@@ -2448,11 +2494,107 @@ async function getNearSimulation(sourceChain, destChain, amount, destToken, sour
   }
 }
 
+// src/services/stargate.ts
+var STARGATE_API_URL = "https://stargate.finance/api/v1/quotes";
+var StargateStrategy = class {
+  constructor() {
+    this.name = "StargateFinance";
+  }
+  canHandle(context) {
+    const { sourceChain, destChain, sourceToken } = context;
+    if (sourceChain === "Base" && destChain === "Avalanche" && sourceToken === "USDC") {
+      return true;
+    }
+    const sourceConfig = NETWORKS[sourceChain];
+    const destConfig = NETWORKS[destChain];
+    if (!sourceConfig || !destConfig) return false;
+    const sourceStargate = sourceConfig.crossChainInformation.stargateInformation?.support;
+    const destStargate = destConfig.crossChainInformation.stargateInformation?.support;
+    if (!sourceStargate || !destStargate) return false;
+    const sourceAsset = sourceConfig.assets.find((a) => a.name === (sourceToken || "USDC"));
+    const destAsset = destConfig.assets.find((a) => a.name === (context.destToken || "USDC"));
+    return !!(sourceAsset?.supportsStargate && destAsset?.supportsStargate);
+  }
+  async execute(context) {
+    const { sourceChain, destChain, amount, recipient, destToken, sourceToken, senderAddress } = context;
+    console.log(`[StargateStrategy] Executing ${sourceChain} -> ${destChain} for ${amount} ${sourceToken}`);
+    const sourceConfig = NETWORKS[sourceChain];
+    const destConfig = NETWORKS[destChain];
+    if (!sourceConfig || !destConfig) {
+      return { success: false, errorReason: "Invalid chain configuration" };
+    }
+    const sourceAsset = sourceConfig.assets.find((a) => a.name === (sourceToken || "USDC"));
+    const destAsset = destConfig.assets.find((a) => a.name === (destToken || "USDC"));
+    if (!sourceAsset || !destAsset) {
+      return { success: false, errorReason: "Invalid asset configuration" };
+    }
+    const decimals = sourceAsset.decimals;
+    const amountAtomic = Math.floor(parseFloat(amount) * Math.pow(10, decimals)).toString();
+    const minAmountAtomic = Math.floor(parseFloat(amountAtomic) * 0.995).toString();
+    const srcChainKey = sourceChain.toLowerCase();
+    const dstChainKey = destChain.toLowerCase();
+    const url = new URL(STARGATE_API_URL);
+    url.searchParams.append("srcToken", sourceAsset.address);
+    url.searchParams.append("dstToken", destAsset.address);
+    url.searchParams.append("srcAddress", senderAddress || recipient);
+    url.searchParams.append("dstAddress", recipient);
+    url.searchParams.append("srcChainKey", srcChainKey);
+    url.searchParams.append("dstChainKey", dstChainKey);
+    url.searchParams.append("srcAmount", amountAtomic);
+    url.searchParams.append("dstAmountMin", minAmountAtomic);
+    console.log(`[StargateStrategy] Fetching quote from: ${url.toString()}`);
+    try {
+      const response = await fetch(url.toString());
+      const data = await response.json();
+      if (!response.ok) {
+        console.error("[StargateStrategy] API Error:", data);
+        return { success: false, errorReason: `Stargate API Error: ${JSON.stringify(data)}` };
+      }
+      console.log("[StargateStrategy] Quote received:", JSON.stringify(data, null, 2));
+      const quotes = data.quotes || [];
+      if (quotes.length === 0) {
+        return { success: false, errorReason: "No routes found from Stargate API" };
+      }
+      const selectedQuote = quotes.find((q) => q.route === "stargate/v2/taxi") || quotes[0];
+      console.log(`[StargateStrategy] Selected Route: ${selectedQuote.route}`);
+      const bridgeStep = selectedQuote.steps.find((s) => s.type === "bridge");
+      if (!bridgeStep || !bridgeStep.transaction) {
+        return { success: false, errorReason: "No bridge transaction found in quote" };
+      }
+      const txData = bridgeStep.transaction;
+      const approvalTx = selectedQuote.steps.find((s) => s.type === "approve")?.transaction;
+      return {
+        success: true,
+        transactionHash: "PENDING_USER_SIGNATURE",
+        netAmount: amount,
+        data: {
+          strategy: "Stargate",
+          quote: selectedQuote,
+          // Normalized Transaction Data for execution
+          txTarget: txData.to,
+          txData: txData.data,
+          txValue: txData.value,
+          // Metadata
+          approvalRequired: approvalTx ? {
+            target: approvalTx.to,
+            data: approvalTx.data,
+            value: approvalTx.value
+          } : null
+        }
+      };
+    } catch (e) {
+      console.error("[StargateStrategy] Execution Error:", e);
+      return { success: false, errorReason: e.message };
+    }
+  }
+};
+
 // src/services/TransferManager.ts
 var TransferManager = class {
   constructor() {
     this.strategies = [
       new CCTPStrategy(),
+      new StargateStrategy(),
       new NearStrategy()
     ];
   }
@@ -2471,6 +2613,11 @@ var TransferManager = class {
       };
     }
     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)`);
+      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)`);