@1llet.xyz/erc4337-gasless-sdk 0.4.27 → 0.4.28

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { optimism, gnosis, baseSepolia, base, avalanche, worldchain, monad, polygon, arbitrum, bsc, unichain } from 'viem/chains';
-import { createPublicClient, http, createWalletClient, decodeErrorResult, parseSignature, maxUint256, encodeFunctionData, encodeAbiParameters, keccak256, padHex } from 'viem';
+import { createPublicClient, http, createWalletClient, decodeErrorResult, maxUint256, encodeFunctionData, encodeAbiParameters, keccak256, padHex } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import axios from 'axios';
 import { Networks } from 'stellar-sdk';
@@ -910,7 +910,7 @@ var CHAIN_ID_TO_KEY = {
   "42161": "Arbitrum"
 };
 
-// src/services/gasless.ts
+// src/services/cctp.ts
 init_facilitator();
 init_facilitator();
 
@@ -1005,120 +1005,6 @@ var messageTransmitterAbi = [
     type: "function"
   }
 ];
-
-// src/services/gasless.ts
-var GaslessStrategy = class {
-  constructor() {
-    this.name = "Gasless";
-  }
-  canHandle(context) {
-    const { sourceChain, destChain, sourceToken, destToken } = context;
-    return sourceChain === destChain && (sourceToken === destToken || !destToken);
-  }
-  async execute(context) {
-    const { paymentPayload, sourceChain, amount, recipient } = context;
-    if (!paymentPayload) {
-      return { success: false, errorReason: "Payment payload is required for Gasless Strategy" };
-    }
-    return processGaslessSettlement(
-      paymentPayload,
-      sourceChain,
-      amount,
-      context.facilitatorPrivateKey,
-      recipient
-    );
-  }
-};
-async function processGaslessSettlement(paymentPayload, sourceChain, amount, facilitatorPrivateKey, recipient) {
-  if (!facilitatorPrivateKey) {
-    return {
-      success: false,
-      errorReason: "Facilitator Private Key not provided in context"
-    };
-  }
-  const networkConfig = FACILITATOR_NETWORKS[sourceChain];
-  if (!networkConfig) {
-    return {
-      success: false,
-      errorReason: `Unsupported chain: ${sourceChain}`
-    };
-  }
-  const { authorization, signature } = paymentPayload;
-  if (!signature) {
-    return {
-      success: false,
-      errorReason: "Missing Signature in Payment Payload"
-    };
-  }
-  const publicClient = createPublicClient({
-    chain: networkConfig.chain,
-    transport: http(networkConfig.rpcUrl)
-  });
-  const walletClient = createWalletClient({
-    account: privateKeyToAccount(facilitatorPrivateKey),
-    chain: networkConfig.chain,
-    transport: http(networkConfig.rpcUrl)
-  });
-  const { v, r, s } = parseSignature(signature);
-  let transferHash;
-  try {
-    transferHash = await walletClient.writeContract({
-      chain: networkConfig.chain,
-      address: networkConfig.usdc,
-      abi: usdcErc3009Abi,
-      functionName: "transferWithAuthorization",
-      args: [
-        authorization.from,
-        authorization.to,
-        BigInt(authorization.value),
-        BigInt(authorization.validAfter),
-        BigInt(authorization.validBefore),
-        authorization.nonce,
-        Number(v),
-        r,
-        s
-      ]
-    });
-    const receipt = await publicClient.waitForTransactionReceipt({ hash: transferHash });
-    if (receipt.status !== "success") throw new Error("TransferWithAuthorization failed");
-  } catch (e) {
-    return {
-      success: false,
-      errorReason: e instanceof Error ? e.message : "Transfer failed"
-    };
-  }
-  const amountBigInt = BigInt(Math.floor(parseFloat(amount) * 1e6));
-  const fee = calculateFee();
-  try {
-    const finalTransferHash = await walletClient.writeContract({
-      chain: networkConfig.chain,
-      address: networkConfig.usdc,
-      abi: usdcErc3009Abi,
-      functionName: "transfer",
-      args: [recipient, amountBigInt - fee]
-      // Deduct Fee (0.01 or 0)
-    });
-    await publicClient.waitForTransactionReceipt({ hash: finalTransferHash });
-  } catch (e) {
-    console.error("Final transfer failed", e);
-    return {
-      success: false,
-      transactionHash: transferHash,
-      errorReason: "Final transfer to recipient failed. Funds are with facilitator."
-    };
-  }
-  return {
-    success: true,
-    transactionHash: transferHash,
-    payer: authorization.from,
-    fee: fee.toString(),
-    netAmount: amountBigInt.toString()
-  };
-}
-
-// src/services/cctp.ts
-init_facilitator();
-init_facilitator();
 var createRetrieveAttestation = async (transactionHash, chainId, timeout = 6e4) => {
   const baseUrl = "https://iris-api.circle.com";
   const url = `${baseUrl}/v2/messages/${chainId}?transactionHash=${transactionHash}`;
@@ -2094,15 +1980,15 @@ var NearStrategy = class {
     const { sourceChain, destChain, amount, recipient, destToken, sourceToken, senderAddress, depositTxHash } = context;
     if (depositTxHash) {
       console.log(`[NearStrategy] Verifying deposit hash: ${depositTxHash}`);
-      const { createPublicClient: createPublicClient4, http: http4 } = await import('viem');
+      const { createPublicClient: createPublicClient3, http: http3 } = 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 = createPublicClient3({
         chain: networkConfig.chain,
-        transport: http4(networkConfig.rpcUrl)
+        transport: http3(networkConfig.rpcUrl)
       });
       try {
         console.log(`[NearStrategy] Waiting for receipt...`);
@@ -2222,65 +2108,46 @@ async function getNearQuote(sourceChain, destChain, amount, destToken, sourceTok
   };
 }
 
-// src/services/standard.ts
-var StandardBridgeStrategy = class {
-  constructor() {
-    this.name = "StandardBridge";
-  }
-  canHandle(context) {
-    const { paymentPayload } = context;
-    return paymentPayload?.type === "STANDARD";
-  }
-  async execute(context) {
-    return {
-      success: false,
-      errorReason: "Standard Bridge Strategy is deprecated. Please use Near Intents or CCTP."
-    };
-  }
-};
-
-// src/services/BridgeManager.ts
-var BridgeManager = class {
+// src/services/TransferManager.ts
+var TransferManager = class {
   constructor() {
     this.strategies = [
-      new StandardBridgeStrategy(),
-      new GaslessStrategy(),
       new CCTPStrategy(),
       new NearStrategy()
     ];
   }
-  getStrategy(context) {
-    return this.strategies.find((strategy) => strategy.canHandle(context));
-  }
   async execute(context) {
     if (context.sourceChain === context.destChain && context.sourceToken === context.destToken) {
-      console.log(`[BridgeManager] Same Chain detected. Strategy: Gasless`);
-      const gaslessStrategy2 = new GaslessStrategy();
-      return gaslessStrategy2.execute(context);
+      console.log(`[TransferManager] Same Chain detected. Signal Direct Transfer.`);
+      return {
+        success: true,
+        transactionHash: "DIRECT_TRANSFER_REQUIRED",
+        data: {
+          action: "DIRECT_TRANSFER",
+          amount: context.amount,
+          token: context.sourceToken,
+          recipient: context.recipient
+        }
+      };
     }
     const strategies = this.strategies;
     const cctpStrategy = strategies.find((s) => s instanceof CCTPStrategy);
     if (cctpStrategy && cctpStrategy.canHandle(context)) {
-      console.log(`[BridgeManager] Routing to: ${cctpStrategy.name} (CCTP)`);
+      console.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(`[BridgeManager] Routing to: ${nearStrategy.name} (Near)`);
+      console.log(`[TransferManager] Routing to: ${nearStrategy.name} (Near)`);
       return nearStrategy.execute(context);
     }
-    const gaslessStrategy = strategies.find((s) => s instanceof GaslessStrategy);
-    if (gaslessStrategy && gaslessStrategy.canHandle(context)) {
-      console.log(`[BridgeManager] Routing to: ${gaslessStrategy.name}`);
-      return gaslessStrategy.execute(context);
-    }
     return {
       success: false,
-      errorReason: `No suitable bridge strategy found for ${context.sourceChain} -> ${context.destChain}`
+      errorReason: `No suitable transfer strategy found for ${context.sourceChain} -> ${context.destChain}`
     };
   }
 };
 
-export { AccountAbstraction, BASE_MAINNET, BASE_SEPOLIA, BridgeManager, BundlerClient, CCTPStrategy, CHAIN_CONFIGS, CHAIN_ID_TO_KEY, GNOSIS_MAINNET, GaslessStrategy, NearStrategy, OPTIMISM_MAINNET, StandardBridgeStrategy, entryPointAbi, erc20Abi, smartAccountAbi };
+export { AccountAbstraction, BASE_MAINNET, BASE_SEPOLIA, BundlerClient, CCTPStrategy, CHAIN_CONFIGS, CHAIN_ID_TO_KEY, GNOSIS_MAINNET, NearStrategy, OPTIMISM_MAINNET, TransferManager, entryPointAbi, erc20Abi, smartAccountAbi };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map