@1llet.xyz/erc4337-gasless-sdk 0.2.0 → 0.4.1

package/dist/index.mjs

@@ -0,0 +1,714 @@
+// src/AccountAbstraction.ts
+import {
+  createPublicClient,
+  http,
+  decodeErrorResult
+} from "viem";
+
+// src/constants.ts
+var factoryAbi = [
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "salt", type: "uint256" }
+    ],
+    name: "getAccountAddress",
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "salt", type: "uint256" }
+    ],
+    name: "isAccountDeployed",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "salt", type: "uint256" }
+    ],
+    name: "createAccount",
+    outputs: [{ name: "account", type: "address" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var entryPointAbi = [
+  {
+    inputs: [
+      { name: "sender", type: "address" },
+      { name: "key", type: "uint192" }
+    ],
+    name: "getNonce",
+    outputs: [{ name: "nonce", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var smartAccountAbi = [
+  {
+    inputs: [
+      { name: "target", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" }
+    ],
+    name: "execute",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "targets", type: "address[]" },
+      { name: "values", type: "uint256[]" },
+      { name: "datas", type: "bytes[]" }
+    ],
+    name: "executeBatch",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var erc20Abi = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transferFrom",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "decimals",
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/BundlerClient.ts
+var BundlerClient = class {
+  constructor(config, entryPointAddress) {
+    this.bundlerUrl = config.bundlerUrl;
+    this.chainId = config.chain.id;
+    this.entryPointAddress = entryPointAddress;
+  }
+  async call(method, params) {
+    const response = await fetch(this.bundlerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method,
+        params
+      })
+    });
+    const result = await response.json();
+    if (result.error) {
+      throw new Error(result.error.message);
+    }
+    return result.result;
+  }
+  async estimateGas(userOp) {
+    return await this.call("eth_estimateUserOperationGas", [
+      {
+        sender: userOp.sender,
+        nonce: userOp.nonce ? "0x" + userOp.nonce.toString(16) : "0x0",
+        initCode: userOp.initCode || "0x",
+        callData: userOp.callData || "0x",
+        paymasterAndData: userOp.paymasterAndData || "0x",
+        signature: "0x"
+      },
+      this.entryPointAddress
+    ]);
+  }
+  async sendUserOperation(userOp) {
+    return await this.call("eth_sendUserOperation", [
+      {
+        sender: userOp.sender,
+        nonce: "0x" + userOp.nonce.toString(16),
+        initCode: userOp.initCode,
+        callData: userOp.callData,
+        callGasLimit: "0x" + userOp.callGasLimit.toString(16),
+        verificationGasLimit: "0x" + userOp.verificationGasLimit.toString(16),
+        preVerificationGas: "0x" + userOp.preVerificationGas.toString(16),
+        maxFeePerGas: "0x" + userOp.maxFeePerGas.toString(16),
+        maxPriorityFeePerGas: "0x" + userOp.maxPriorityFeePerGas.toString(16),
+        paymasterAndData: userOp.paymasterAndData,
+        signature: userOp.signature
+      },
+      this.entryPointAddress
+    ]);
+  }
+  async waitForUserOperation(userOpHash, timeout = 6e4) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const result = await this.call("eth_getUserOperationReceipt", [userOpHash]);
+      if (result) {
+        return result;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+    }
+    throw new Error("Timeout waiting for UserOperation");
+  }
+  async requestApprovalSupport(token, owner, spender, amount) {
+    return await this.call("pm_requestApprovalSupport", [
+      token,
+      owner,
+      spender,
+      amount.toString()
+    ]);
+  }
+};
+
+// src/TokenService.ts
+import { encodeFunctionData } from "viem";
+var TokenService = class {
+  constructor(chainConfig, publicClient) {
+    this.tokens = /* @__PURE__ */ new Map();
+    this.publicClient = publicClient;
+    chainConfig.tokens.forEach((token) => {
+      this.tokens.set(token.symbol.toUpperCase(), token);
+    });
+  }
+  /**
+   * Resolve token address from symbol or return address if provided
+   */
+  getTokenAddress(token) {
+    if (token === "ETH") {
+      return "0x0000000000000000000000000000000000000000";
+    }
+    if (token.startsWith("0x")) return token;
+    const info = this.tokens.get(token.toUpperCase());
+    if (!info) throw new Error(`Token ${token} not found in chain config`);
+    return info.address;
+  }
+  /**
+   * Get balance of a token for an account
+   */
+  async getBalance(token, account) {
+    const address = this.getTokenAddress(token);
+    if (address === "0x0000000000000000000000000000000000000000") {
+      return await this.publicClient.getBalance({ address: account });
+    }
+    return await this.publicClient.readContract({
+      address,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [account]
+    });
+  }
+  /**
+   * Get allowance (ERC-20 only)
+   */
+  async getAllowance(token, owner, spender) {
+    const address = this.getTokenAddress(token);
+    if (address === "0x0000000000000000000000000000000000000000") {
+      return 0n;
+    }
+    return await this.publicClient.readContract({
+      address,
+      abi: erc20Abi,
+      functionName: "allowance",
+      args: [owner, spender]
+    });
+  }
+  /**
+   * Encode transfer data
+   */
+  encodeTransfer(recipient, amount) {
+    return encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [recipient, amount]
+    });
+  }
+  /**
+   * Encode approve data
+   */
+  encodeApprove(spender, amount) {
+    return encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [spender, amount]
+    });
+  }
+};
+
+// src/UserOpBuilder.ts
+import {
+  encodeFunctionData as encodeFunctionData2,
+  encodeAbiParameters,
+  keccak256
+} from "viem";
+var UserOpBuilder = class {
+  constructor(chainConfig, bundlerClient, publicClient) {
+    this.chainConfig = chainConfig;
+    this.bundlerClient = bundlerClient;
+    this.publicClient = publicClient;
+    this.entryPointAddress = chainConfig.entryPointAddress;
+    this.factoryAddress = chainConfig.factoryAddress;
+  }
+  async getNonce(smartAccountAddress) {
+    return await this.publicClient.readContract({
+      address: this.entryPointAddress,
+      abi: entryPointAbi,
+      functionName: "getNonce",
+      args: [smartAccountAddress, 0n]
+    });
+  }
+  buildInitCode(owner) {
+    const createAccountData = encodeFunctionData2({
+      abi: factoryAbi,
+      functionName: "createAccount",
+      args: [owner, 0n]
+    });
+    return `${this.factoryAddress}${createAccountData.slice(2)}`;
+  }
+  async isAccountDeployed(smartAccountAddress) {
+    const code = await this.publicClient.getCode({
+      address: smartAccountAddress
+    });
+    return code !== void 0 && code !== "0x";
+  }
+  async buildUserOperationBatch(owner, smartAccountAddress, transactions) {
+    const isDeployed = await this.isAccountDeployed(smartAccountAddress);
+    const initCode = isDeployed ? "0x" : this.buildInitCode(owner);
+    const targets = transactions.map((tx) => tx.target);
+    const values = transactions.map((tx) => tx.value);
+    const datas = transactions.map((tx) => tx.data);
+    const callData = encodeFunctionData2({
+      abi: smartAccountAbi,
+      functionName: "executeBatch",
+      args: [targets, values, datas]
+    });
+    const nonce = await this.getNonce(smartAccountAddress);
+    const partialOp = {
+      sender: smartAccountAddress,
+      nonce,
+      initCode,
+      callData,
+      paymasterAndData: this.chainConfig.paymasterAddress || "0x"
+    };
+    const gasEstimate = await this.bundlerClient.estimateGas(partialOp);
+    return {
+      ...partialOp,
+      callGasLimit: BigInt(gasEstimate.callGasLimit),
+      verificationGasLimit: BigInt(gasEstimate.verificationGasLimit),
+      preVerificationGas: BigInt(gasEstimate.preVerificationGas),
+      maxFeePerGas: BigInt(gasEstimate.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(gasEstimate.maxPriorityFeePerGas),
+      signature: "0x"
+    };
+  }
+  async buildDeployUserOp(owner, smartAccountAddress) {
+    const isDeployed = await this.isAccountDeployed(smartAccountAddress);
+    if (isDeployed) throw new Error("Account already deployed");
+    const initCode = this.buildInitCode(owner);
+    const callData = "0x";
+    const nonce = await this.getNonce(smartAccountAddress);
+    const partialOp = {
+      sender: smartAccountAddress,
+      nonce,
+      initCode,
+      callData,
+      paymasterAndData: this.chainConfig.paymasterAddress || "0x"
+    };
+    const gasEstimate = await this.bundlerClient.estimateGas(partialOp);
+    return {
+      ...partialOp,
+      callGasLimit: BigInt(gasEstimate.callGasLimit),
+      verificationGasLimit: BigInt(gasEstimate.verificationGasLimit),
+      preVerificationGas: BigInt(gasEstimate.preVerificationGas),
+      maxFeePerGas: BigInt(gasEstimate.maxFeePerGas),
+      maxPriorityFeePerGas: BigInt(gasEstimate.maxPriorityFeePerGas),
+      signature: "0x"
+    };
+  }
+  getUserOpHash(userOp) {
+    const packed = encodeAbiParameters(
+      [
+        { type: "address" },
+        { type: "uint256" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "uint256" },
+        { type: "bytes32" }
+      ],
+      [
+        userOp.sender,
+        userOp.nonce,
+        keccak256(userOp.initCode),
+        keccak256(userOp.callData),
+        userOp.callGasLimit,
+        userOp.verificationGasLimit,
+        userOp.preVerificationGas,
+        userOp.maxFeePerGas,
+        userOp.maxPriorityFeePerGas,
+        keccak256(userOp.paymasterAndData)
+      ]
+    );
+    const packedHash = keccak256(packed);
+    return keccak256(
+      encodeAbiParameters(
+        [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
+        [packedHash, this.entryPointAddress, BigInt(this.chainConfig.chain.id)]
+      )
+    );
+  }
+};
+
+// src/AccountAbstraction.ts
+var AccountAbstraction = class {
+  constructor(chainConfig) {
+    this.owner = null;
+    this.smartAccountAddress = null;
+    this.chainConfig = chainConfig;
+    if (!chainConfig.entryPointAddress) throw new Error("EntryPoint address required");
+    this.entryPointAddress = chainConfig.entryPointAddress;
+    if (!chainConfig.factoryAddress) throw new Error("Factory address required");
+    this.factoryAddress = chainConfig.factoryAddress;
+    const rpcUrl = chainConfig.rpcUrl || chainConfig.chain.rpcUrls.default.http[0];
+    this.publicClient = createPublicClient({
+      chain: chainConfig.chain,
+      transport: http(rpcUrl)
+    });
+    this.bundlerClient = new BundlerClient(chainConfig, this.entryPointAddress);
+    this.tokenService = new TokenService(chainConfig, this.publicClient);
+    this.userOpBuilder = new UserOpBuilder(chainConfig, this.bundlerClient, this.publicClient);
+  }
+  /**
+   * Connect to MetaMask and get the owner address
+   */
+  async connect() {
+    if (typeof window === "undefined" || !window.ethereum) {
+      throw new Error("MetaMask is not installed");
+    }
+    const accounts = await window.ethereum.request({
+      method: "eth_requestAccounts"
+    });
+    if (!accounts || accounts.length === 0) throw new Error("No accounts found");
+    const chainId = await window.ethereum.request({
+      method: "eth_chainId"
+    });
+    const targetChainId = this.chainConfig.chain.id;
+    if (parseInt(chainId, 16) !== targetChainId) {
+      try {
+        await window.ethereum.request({
+          method: "wallet_switchEthereumChain",
+          params: [{ chainId: "0x" + targetChainId.toString(16) }]
+        });
+      } catch (switchError) {
+        const error = switchError;
+        if (error.code === 4902) {
+          await window.ethereum.request({
+            method: "wallet_addEthereumChain",
+            params: [
+              {
+                chainId: "0x" + targetChainId.toString(16),
+                chainName: this.chainConfig.chain.name,
+                nativeCurrency: this.chainConfig.chain.nativeCurrency,
+                rpcUrls: [this.chainConfig.rpcUrl || this.chainConfig.chain.rpcUrls.default.http[0]],
+                blockExplorerUrls: this.chainConfig.chain.blockExplorers?.default?.url ? [this.chainConfig.chain.blockExplorers.default.url] : []
+              }
+            ]
+          });
+        } else {
+          throw switchError;
+        }
+      }
+    }
+    this.owner = accounts[0];
+    this.smartAccountAddress = await this.getSmartAccountAddress(this.owner);
+    return {
+      owner: this.owner,
+      smartAccount: this.smartAccountAddress
+    };
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Check if the Smart Account is deployed
+   */
+  async isAccountDeployed() {
+    if (!this.smartAccountAddress) throw new Error("Not connected");
+    return this.userOpBuilder.isAccountDeployed(this.smartAccountAddress);
+  }
+  // --- Token Methods (Delegated) ---
+  getTokenAddress(token) {
+    return this.tokenService.getTokenAddress(token);
+  }
+  async getUsdcBalance() {
+    if (!this.smartAccountAddress) throw new Error("Not connected");
+    return this.tokenService.getBalance("USDC", this.smartAccountAddress);
+  }
+  async getEoaUsdcBalance() {
+    if (!this.owner) throw new Error("Not connected");
+    return this.tokenService.getBalance("USDC", this.owner);
+  }
+  async getAllowance() {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    return this.tokenService.getAllowance("USDC", this.owner, this.smartAccountAddress);
+  }
+  // --- Transactions ---
+  async deployAccount() {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    try {
+      const userOp = await this.userOpBuilder.buildDeployUserOp(this.owner, this.smartAccountAddress);
+      const signed = await this.signUserOperation(userOp);
+      const hash = await this.sendUserOperation(signed);
+      return await this.waitForUserOperation(hash);
+    } catch (error) {
+      throw this.decodeError(error);
+    }
+  }
+  async sendTransaction(tx) {
+    return this.sendBatchTransaction([tx]);
+  }
+  async sendBatchTransaction(txs) {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    const transactions = txs.map((tx) => ({
+      target: tx.target,
+      value: tx.value ?? 0n,
+      data: tx.data ?? "0x"
+    }));
+    try {
+      const userOp = await this.userOpBuilder.buildUserOperationBatch(
+        this.owner,
+        this.smartAccountAddress,
+        transactions
+      );
+      const signed = await this.signUserOperation(userOp);
+      const hash = await this.sendUserOperation(signed);
+      return await this.waitForUserOperation(hash);
+    } catch (error) {
+      throw this.decodeError(error);
+    }
+  }
+  async deposit(amount) {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    const txHash = await window.ethereum.request({
+      method: "eth_sendTransaction",
+      params: [{
+        from: this.owner,
+        to: this.smartAccountAddress,
+        value: "0x" + amount.toString(16)
+      }]
+    });
+    return txHash;
+  }
+  async transfer(token, recipient, amount) {
+    const tokenAddress = this.getTokenAddress(token);
+    if (tokenAddress === "0x0000000000000000000000000000000000000000") {
+      return this.sendTransaction({
+        target: recipient,
+        value: amount,
+        data: "0x"
+      });
+    }
+    const data = this.tokenService.encodeTransfer(recipient, amount);
+    return this.sendTransaction({
+      target: tokenAddress,
+      value: 0n,
+      data
+    });
+  }
+  /**
+   * Approve a token for the Smart Account
+   */
+  async approveToken(token, spender, amount = 115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
+    if (!this.owner) throw new Error("Not connected");
+    const support = await this.requestApprovalSupport(token, spender, amount);
+    if (support.type === "approve") {
+      const data = this.tokenService.encodeApprove(spender, amount);
+      const txHash = await window.ethereum.request({
+        method: "eth_sendTransaction",
+        params: [{
+          from: this.owner,
+          to: token,
+          data
+        }]
+      });
+      return txHash;
+    }
+    if (support.type === "permit") throw new Error("Permit not yet supported");
+    return "NOT_NEEDED";
+  }
+  // --- Core Bridge to Bundler/UserOp ---
+  // Deprecated/Legacy but kept for compatibility or advanced usage?
+  // buildUserOperationBatch moved to internal usage mostly, but maybe exposed?
+  // If I remove them from public API, that is a BREAKING change if user used them.
+  // User requested "modularize", but usually expects same public API.
+  // I will expose them as simple delegates if needed, or assume they primarily use sendBatchTransaction.
+  // The previous implementation exposed `buildUserOperationBatch`.
+  async buildUserOperationBatch(transactions) {
+    if (!this.owner || !this.smartAccountAddress) throw new Error("Not connected");
+    return this.userOpBuilder.buildUserOperationBatch(this.owner, this.smartAccountAddress, transactions);
+  }
+  async signUserOperation(userOp) {
+    if (!this.owner) throw new Error("Not connected");
+    const userOpHash = this.userOpBuilder.getUserOpHash(userOp);
+    const signature = await window.ethereum.request({
+      method: "personal_sign",
+      params: [userOpHash, this.owner]
+    });
+    return { ...userOp, signature };
+  }
+  async sendUserOperation(userOp) {
+    return this.bundlerClient.sendUserOperation(userOp);
+  }
+  async waitForUserOperation(hash, timeout = 6e4) {
+    return this.bundlerClient.waitForUserOperation(hash, timeout);
+  }
+  // Internal but exposed via BundlerClient originally
+  async requestApprovalSupport(token, spender, amount) {
+    if (!this.owner) throw new Error("Not connected");
+    return this.bundlerClient.requestApprovalSupport(token, this.owner, spender, amount);
+  }
+  // Error Decoding (Private)
+  decodeError(error) {
+    const msg = error?.message || "";
+    const hexMatch = msg.match(/(0x[0-9a-fA-F]+)/);
+    if (hexMatch) {
+      try {
+        const decoded = decodeErrorResult({
+          abi: [{ inputs: [{ name: "message", type: "string" }], name: "Error", type: "error" }],
+          data: hexMatch[0]
+        });
+        if (decoded.errorName === "Error") return new Error(`Smart Account Error: ${decoded.args[0]}`);
+      } catch (e) {
+      }
+    }
+    if (msg.includes("AA21")) return new Error("Smart Account: Native transfer failed (ETH missing?)");
+    if (msg.includes("AA25")) return new Error("Smart Account: Invalid account nonce");
+    return error instanceof Error ? error : new Error(String(error));
+  }
+  // Getters
+  getOwner() {
+    return this.owner;
+  }
+  getSmartAccount() {
+    return this.smartAccountAddress;
+  }
+};
+
+// src/chains.ts
+import { base, baseSepolia } from "viem/chains";
+var BASE_MAINNET = {
+  chain: base,
+  bundlerUrl: "http://localhost:3000/rpc?chain=base",
+  // Default to local bundler pattern
+  // Addresses
+  entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+  factoryAddress: "0xe2584152891E4769025807DEa0cD611F135aDC68",
+  paymasterAddress: "0x1e13Eb16C565E3f3FDe49A011755e50410bb1F95",
+  tokens: [
+    {
+      symbol: "USDC",
+      decimals: 6,
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+    },
+    {
+      symbol: "ETH",
+      decimals: 18,
+      address: "0x0000000000000000000000000000000000000000"
+    }
+  ]
+};
+var BASE_SEPOLIA = {
+  chain: baseSepolia,
+  bundlerUrl: "http://localhost:3000/rpc?chain=baseSepolia",
+  // Default to local bundler pattern
+  // Addresses
+  entryPointAddress: "0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789",
+  factoryAddress: "0x9406Cc6185a346906296840746125a0E44976454",
+  // Paymaster not configured in deployments.ts for Sepolia?
+  tokens: [
+    {
+      symbol: "USDC",
+      decimals: 6,
+      address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+    },
+    {
+      symbol: "ETH",
+      decimals: 18,
+      address: "0x0000000000000000000000000000000000000000"
+    }
+  ]
+};
+var CHAIN_CONFIGS = {
+  [base.id]: BASE_MAINNET,
+  [baseSepolia.id]: BASE_SEPOLIA
+};
+export {
+  AccountAbstraction,
+  BASE_MAINNET,
+  BASE_SEPOLIA,
+  BundlerClient,
+  CHAIN_CONFIGS,
+  entryPointAbi,
+  erc20Abi,
+  smartAccountAbi
+};
+//# sourceMappingURL=index.mjs.map