@t402/wdk-gasless 1.0.0

package/dist/cjs/index.js

@@ -0,0 +1,727 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CHAIN_IDS: () => CHAIN_IDS,
+  DEFAULT_BUNDLER_URLS: () => DEFAULT_BUNDLER_URLS,
+  SAFE_4337_ADDRESSES: () => SAFE_4337_ADDRESSES,
+  USDC_ADDRESSES: () => USDC_ADDRESSES,
+  USDT0_ADDRESSES: () => USDT0_ADDRESSES,
+  WdkGaslessClient: () => WdkGaslessClient,
+  WdkSmartAccount: () => WdkSmartAccount,
+  createWdkGaslessClient: () => createWdkGaslessClient,
+  createWdkSmartAccount: () => createWdkSmartAccount,
+  getChainName: () => getChainName,
+  getTokenAddress: () => getTokenAddress
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_viem2 = require("viem");
+var import_evm = require("@t402/evm");
+
+// src/account.ts
+var import_viem = require("viem");
+var SAFE_4337_ADDRESSES = {
+  /** Safe 4337 Module */
+  module: "0xa581c4A4DB7175302464fF3C06380BC3270b4037",
+  /** Safe Module Setup */
+  moduleSetup: "0x2dd68b007B46fBe91B9A7c3EDa5A7a1063cB5b47",
+  /** Safe Singleton */
+  singleton: "0x29fcB43b46531BcA003ddC8FCB67FFE91900C762",
+  /** Safe Proxy Factory */
+  proxyFactory: "0x4e1DCf7AD4e460CfD30791CCC4F9c8a4f820ec67",
+  /** Safe Fallback Handler */
+  fallbackHandler: "0xfd0732Dc9E303f09fCEf3a7388Ad10A83459Ec99",
+  /** Add Modules Lib */
+  addModulesLib: "0x8EcD4ec46D4D2a6B64fE960B3D64e8B94B2234eb"
+};
+var PROXY_FACTORY_ABI = [
+  {
+    inputs: [
+      { name: "singleton", type: "address" },
+      { name: "initializer", type: "bytes" },
+      { name: "saltNonce", type: "uint256" }
+    ],
+    name: "createProxyWithNonce",
+    outputs: [{ name: "proxy", type: "address" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "singleton", type: "address" },
+      { name: "initializer", type: "bytes" },
+      { name: "saltNonce", type: "uint256" }
+    ],
+    name: "proxyCreationCode",
+    outputs: [{ name: "", type: "bytes" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var SAFE_ABI = [
+  {
+    inputs: [
+      { name: "owners", type: "address[]" },
+      { name: "threshold", type: "uint256" },
+      { name: "to", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "fallbackHandler", type: "address" },
+      { name: "paymentToken", type: "address" },
+      { name: "payment", type: "uint256" },
+      { name: "paymentReceiver", type: "address" }
+    ],
+    name: "setup",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var ADD_MODULES_LIB_ABI = [
+  {
+    inputs: [{ name: "modules", type: "address[]" }],
+    name: "enableModules",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var SAFE_4337_MODULE_ABI = [
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "data", type: "bytes" },
+      { name: "operation", type: "uint8" }
+    ],
+    name: "executeUserOp",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { name: "tos", type: "address[]" },
+      { name: "values", type: "uint256[]" },
+      { name: "datas", type: "bytes[]" },
+      { name: "operations", type: "uint8[]" }
+    ],
+    name: "executeUserOpBatch",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var WdkSmartAccount = class {
+  wdkAccount;
+  publicClient;
+  chainId;
+  owners;
+  threshold;
+  saltNonce;
+  cachedAddress;
+  cachedInitCode;
+  cachedOwnerAddress;
+  deploymentChecked = false;
+  isAccountDeployed = false;
+  constructor(config) {
+    this.wdkAccount = config.wdkAccount;
+    this.publicClient = config.publicClient;
+    this.chainId = config.chainId;
+    this.threshold = config.threshold ?? 1;
+    this.saltNonce = config.saltNonce ?? 0n;
+    this.owners = config.additionalOwners ?? [];
+  }
+  /**
+   * Initialize the account (fetch WDK address)
+   * Call this before using the account
+   */
+  async initialize() {
+    if (!this.cachedOwnerAddress) {
+      const address = await this.wdkAccount.getAddress();
+      this.cachedOwnerAddress = address;
+      if (!this.owners.includes(this.cachedOwnerAddress)) {
+        this.owners.unshift(this.cachedOwnerAddress);
+      }
+    }
+  }
+  /**
+   * Get the WDK account's EOA address
+   */
+  async getOwnerAddress() {
+    await this.initialize();
+    return this.cachedOwnerAddress;
+  }
+  /**
+   * Get the smart account address (counterfactual)
+   */
+  async getAddress() {
+    await this.initialize();
+    if (this.cachedAddress) {
+      return this.cachedAddress;
+    }
+    const initCode = await this.getInitCode();
+    if (initCode === "0x") {
+      const initializerData = await this.buildInitializer();
+      const salt = (0, import_viem.keccak256)(
+        (0, import_viem.encodeAbiParameters)(
+          [{ type: "bytes32" }, { type: "uint256" }],
+          [(0, import_viem.keccak256)(initializerData), this.saltNonce]
+        )
+      );
+      const proxyCreationCode = await this.publicClient.readContract({
+        address: SAFE_4337_ADDRESSES.proxyFactory,
+        abi: PROXY_FACTORY_ABI,
+        functionName: "proxyCreationCode",
+        args: [SAFE_4337_ADDRESSES.singleton, initializerData, this.saltNonce]
+      });
+      this.cachedAddress = (0, import_viem.getContractAddress)({
+        bytecode: proxyCreationCode,
+        from: SAFE_4337_ADDRESSES.proxyFactory,
+        opcode: "CREATE2",
+        salt
+      });
+    } else {
+      const initializerData = `0x${initCode.slice(2 + 40 * 2)}`;
+      const salt = (0, import_viem.keccak256)(
+        (0, import_viem.encodeAbiParameters)(
+          [{ type: "bytes32" }, { type: "uint256" }],
+          [(0, import_viem.keccak256)(initializerData), this.saltNonce]
+        )
+      );
+      const proxyCreationCode = await this.publicClient.readContract({
+        address: SAFE_4337_ADDRESSES.proxyFactory,
+        abi: PROXY_FACTORY_ABI,
+        functionName: "proxyCreationCode",
+        args: [SAFE_4337_ADDRESSES.singleton, initializerData, this.saltNonce]
+      });
+      this.cachedAddress = (0, import_viem.getContractAddress)({
+        bytecode: proxyCreationCode,
+        from: SAFE_4337_ADDRESSES.proxyFactory,
+        opcode: "CREATE2",
+        salt
+      });
+    }
+    return this.cachedAddress;
+  }
+  /**
+   * Sign a UserOperation hash using the WDK account
+   */
+  async signUserOpHash(userOpHash) {
+    await this.initialize();
+    const signature = await this.wdkAccount.signMessage(userOpHash);
+    return (0, import_viem.concat)([signature, "0x00"]);
+  }
+  /**
+   * Get the account's init code for deployment
+   */
+  async getInitCode() {
+    await this.initialize();
+    if (await this.isDeployed()) {
+      return "0x";
+    }
+    if (this.cachedInitCode) {
+      return this.cachedInitCode;
+    }
+    const safeSetupData = await this.buildInitializer();
+    const createProxyData = (0, import_viem.encodeFunctionData)({
+      abi: PROXY_FACTORY_ABI,
+      functionName: "createProxyWithNonce",
+      args: [SAFE_4337_ADDRESSES.singleton, safeSetupData, this.saltNonce]
+    });
+    this.cachedInitCode = (0, import_viem.concat)([
+      SAFE_4337_ADDRESSES.proxyFactory,
+      createProxyData
+    ]);
+    return this.cachedInitCode;
+  }
+  /**
+   * Check if the account is deployed
+   */
+  async isDeployed() {
+    if (this.deploymentChecked) {
+      return this.isAccountDeployed;
+    }
+    await this.initialize();
+    const address = this.cachedAddress ?? await this.getAddress();
+    const code = await this.publicClient.getCode({ address });
+    this.deploymentChecked = true;
+    this.isAccountDeployed = code !== void 0 && code !== "0x";
+    return this.isAccountDeployed;
+  }
+  /**
+   * Encode a call to the account's execute function
+   */
+  encodeExecute(target, value, data) {
+    return (0, import_viem.encodeFunctionData)({
+      abi: SAFE_4337_MODULE_ABI,
+      functionName: "executeUserOp",
+      args: [target, value, data, 0]
+      // operation: CALL
+    });
+  }
+  /**
+   * Encode a batch call to the account's executeBatch function
+   */
+  encodeExecuteBatch(targets, values, datas) {
+    if (targets.length !== values.length || targets.length !== datas.length) {
+      throw new Error("Array lengths must match");
+    }
+    const operations = targets.map(() => 0);
+    return (0, import_viem.encodeFunctionData)({
+      abi: SAFE_4337_MODULE_ABI,
+      functionName: "executeUserOpBatch",
+      args: [targets, values, datas, operations]
+    });
+  }
+  /**
+   * Build the Safe setup initializer data
+   */
+  async buildInitializer() {
+    await this.initialize();
+    const setupModulesData = (0, import_viem.encodeFunctionData)({
+      abi: ADD_MODULES_LIB_ABI,
+      functionName: "enableModules",
+      args: [[SAFE_4337_ADDRESSES.module]]
+    });
+    return (0, import_viem.encodeFunctionData)({
+      abi: SAFE_ABI,
+      functionName: "setup",
+      args: [
+        this.owners,
+        BigInt(this.threshold),
+        SAFE_4337_ADDRESSES.addModulesLib,
+        // to: AddModulesLib
+        setupModulesData,
+        // data: enableModules([module])
+        SAFE_4337_ADDRESSES.fallbackHandler,
+        "0x0000000000000000000000000000000000000000",
+        // paymentToken
+        0n,
+        // payment
+        "0x0000000000000000000000000000000000000000"
+        // paymentReceiver
+      ]
+    });
+  }
+  /**
+   * Get the Safe's owners
+   */
+  getOwners() {
+    return [...this.owners];
+  }
+  /**
+   * Get the Safe's threshold
+   */
+  getThreshold() {
+    return this.threshold;
+  }
+  /**
+   * Clear cached values (useful after deployment)
+   */
+  clearCache() {
+    this.cachedAddress = void 0;
+    this.cachedInitCode = void 0;
+    this.deploymentChecked = false;
+    this.isAccountDeployed = false;
+  }
+};
+async function createWdkSmartAccount(config) {
+  const account = new WdkSmartAccount(config);
+  await account.initialize();
+  return account;
+}
+
+// src/constants.ts
+var USDT0_ADDRESSES = {
+  ethereum: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+  arbitrum: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+  ink: "0x0200C29006150606B650577BBE7B6248F58470c1",
+  berachain: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+  unichain: "0x588ce4F028D8e7B53B687865d6A67b3A54C75518",
+  base: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee",
+  optimism: "0x6C96dE32CEa08842dcc4058c14d3aaAD7Fa41dee"
+};
+var USDC_ADDRESSES = {
+  ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  arbitrum: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  optimism: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  polygon: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"
+};
+var CHAIN_IDS = {
+  ethereum: 1,
+  arbitrum: 42161,
+  base: 8453,
+  optimism: 10,
+  polygon: 137,
+  ink: 57073,
+  berachain: 80084,
+  unichain: 130
+};
+var DEFAULT_BUNDLER_URLS = {
+  1: "https://api.pimlico.io/v2/ethereum/rpc",
+  42161: "https://api.pimlico.io/v2/arbitrum/rpc",
+  8453: "https://api.pimlico.io/v2/base/rpc",
+  10: "https://api.pimlico.io/v2/optimism/rpc",
+  137: "https://api.pimlico.io/v2/polygon/rpc"
+};
+function getTokenAddress(token, chainName) {
+  if (token.startsWith("0x")) {
+    return token;
+  }
+  const addresses = token === "USDT0" ? USDT0_ADDRESSES : USDC_ADDRESSES;
+  const address = addresses[chainName.toLowerCase()];
+  if (!address) {
+    throw new Error(`Token ${token} not available on ${chainName}`);
+  }
+  return address;
+}
+function getChainName(chainId) {
+  const entry = Object.entries(CHAIN_IDS).find(([, id]) => id === chainId);
+  if (!entry) {
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  return entry[0];
+}
+
+// src/client.ts
+var ERC20_TRANSFER_ABI = [
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var ERC20_BALANCE_ABI = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+var WdkGaslessClient = class {
+  signer;
+  builder;
+  bundler;
+  paymaster;
+  chainId;
+  publicClient;
+  chainName;
+  constructor(config) {
+    this.signer = config.signer;
+    this.builder = new import_evm.UserOpBuilder();
+    this.bundler = new import_evm.BundlerClient(config.bundler);
+    this.paymaster = config.paymaster ? new import_evm.PaymasterClient(config.paymaster) : void 0;
+    this.chainId = config.chainId;
+    this.publicClient = config.publicClient;
+    this.chainName = getChainName(config.chainId);
+  }
+  /**
+   * Execute a gasless payment
+   *
+   * Sends USDT0 (or other tokens) without the user paying gas fees.
+   * Gas is sponsored by a paymaster if configured.
+   */
+  async pay(params) {
+    const token = params.token ?? "USDT0";
+    const tokenAddress = getTokenAddress(token, this.chainName);
+    const callData = (0, import_viem2.encodeFunctionData)({
+      abi: ERC20_TRANSFER_ABI,
+      functionName: "transfer",
+      args: [params.to, params.amount]
+    });
+    const intent = {
+      to: tokenAddress,
+      value: 0n,
+      data: callData
+    };
+    const gasEstimate = await this.estimateGas(intent);
+    const paymasterData = await this.getPaymasterData(gasEstimate);
+    const sponsored = paymasterData !== void 0;
+    const userOp = await this.builder.buildUserOp(
+      this.signer,
+      intent,
+      this.publicClient,
+      gasEstimate,
+      paymasterData
+    );
+    const signedUserOp = await this.builder.signUserOp(
+      userOp,
+      this.signer,
+      this.publicClient,
+      this.chainId
+    );
+    const result = await this.bundler.sendUserOperation(signedUserOp);
+    const sender = await this.signer.getAddress();
+    return {
+      userOpHash: result.userOpHash,
+      sender,
+      sponsored,
+      wait: async () => {
+        const receipt = await result.wait();
+        return {
+          userOpHash: receipt.userOpHash,
+          txHash: receipt.receipt.transactionHash,
+          blockNumber: receipt.receipt.blockNumber,
+          success: receipt.success,
+          gasUsed: receipt.actualGasUsed,
+          gasCost: receipt.actualGasCost,
+          reason: receipt.reason
+        };
+      }
+    };
+  }
+  /**
+   * Execute multiple payments in a single transaction
+   *
+   * More gas efficient than individual payments.
+   * All payments are executed atomically.
+   */
+  async payBatch(params) {
+    const intents = params.payments.map((payment) => {
+      const token = payment.token ?? "USDT0";
+      const tokenAddress = getTokenAddress(token, this.chainName);
+      return {
+        to: tokenAddress,
+        value: 0n,
+        data: (0, import_viem2.encodeFunctionData)({
+          abi: ERC20_TRANSFER_ABI,
+          functionName: "transfer",
+          args: [payment.to, payment.amount]
+        })
+      };
+    });
+    const gasEstimate = await this.estimateBatchGas(intents);
+    const paymasterData = await this.getPaymasterData(gasEstimate);
+    const sponsored = paymasterData !== void 0;
+    const userOp = await this.builder.buildBatchUserOp(
+      this.signer,
+      intents,
+      this.publicClient,
+      gasEstimate,
+      paymasterData
+    );
+    const signedUserOp = await this.builder.signUserOp(
+      userOp,
+      this.signer,
+      this.publicClient,
+      this.chainId
+    );
+    const result = await this.bundler.sendUserOperation(signedUserOp);
+    const sender = await this.signer.getAddress();
+    return {
+      userOpHash: result.userOpHash,
+      sender,
+      sponsored,
+      wait: async () => {
+        const receipt = await result.wait();
+        return {
+          userOpHash: receipt.userOpHash,
+          txHash: receipt.receipt.transactionHash,
+          blockNumber: receipt.receipt.blockNumber,
+          success: receipt.success,
+          gasUsed: receipt.actualGasUsed,
+          gasCost: receipt.actualGasCost,
+          reason: receipt.reason
+        };
+      }
+    };
+  }
+  /**
+   * Check if a payment can be sponsored (free gas)
+   */
+  async canSponsor(params) {
+    if (!this.paymaster) {
+      return {
+        canSponsor: false,
+        reason: "No paymaster configured"
+      };
+    }
+    const token = params.token ?? "USDT0";
+    const tokenAddress = getTokenAddress(token, this.chainName);
+    const callData = (0, import_viem2.encodeFunctionData)({
+      abi: ERC20_TRANSFER_ABI,
+      functionName: "transfer",
+      args: [params.to, params.amount]
+    });
+    const sender = await this.signer.getAddress();
+    const encodedCallData = this.signer.encodeExecute(tokenAddress, 0n, callData);
+    try {
+      const canSponsor = await this.paymaster.willSponsor(
+        { sender, callData: encodedCallData },
+        this.chainId,
+        import_evm.ENTRYPOINT_V07_ADDRESS
+      );
+      if (canSponsor) {
+        return { canSponsor: true };
+      } else {
+        const intent = {
+          to: tokenAddress,
+          value: 0n,
+          data: callData
+        };
+        const gasEstimate = await this.estimateGas(intent);
+        const gasPrice = await this.publicClient.getGasPrice();
+        const estimatedGasCost = (gasEstimate.verificationGasLimit + gasEstimate.callGasLimit + gasEstimate.preVerificationGas) * gasPrice;
+        return {
+          canSponsor: false,
+          reason: "Payment not eligible for sponsorship",
+          estimatedGasCost
+        };
+      }
+    } catch (error) {
+      return {
+        canSponsor: false,
+        reason: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Get the smart account address
+   */
+  async getAccountAddress() {
+    return this.signer.getAddress();
+  }
+  /**
+   * Check if the smart account is deployed
+   */
+  async isAccountDeployed() {
+    return this.signer.isDeployed();
+  }
+  /**
+   * Get the token balance of the smart account
+   */
+  async getBalance(token = "USDT0") {
+    const tokenAddress = getTokenAddress(token, this.chainName);
+    const accountAddress = await this.signer.getAddress();
+    const balance = await this.publicClient.readContract({
+      address: tokenAddress,
+      abi: ERC20_BALANCE_ABI,
+      functionName: "balanceOf",
+      args: [accountAddress]
+    });
+    return balance;
+  }
+  /**
+   * Get the formatted token balance
+   */
+  async getFormattedBalance(token = "USDT0", decimals = 6) {
+    const balance = await this.getBalance(token);
+    return (0, import_viem2.formatUnits)(balance, decimals);
+  }
+  /**
+   * Estimate gas for a single transaction
+   */
+  async estimateGas(intent) {
+    const sender = await this.signer.getAddress();
+    const callData = this.signer.encodeExecute(
+      intent.to,
+      intent.value ?? 0n,
+      intent.data ?? "0x"
+    );
+    try {
+      return await this.bundler.estimateUserOperationGas({
+        sender,
+        callData
+      });
+    } catch {
+      return {
+        verificationGasLimit: 150000n,
+        callGasLimit: 100000n,
+        preVerificationGas: 50000n
+      };
+    }
+  }
+  /**
+   * Estimate gas for a batch transaction
+   */
+  async estimateBatchGas(intents) {
+    const sender = await this.signer.getAddress();
+    const callData = this.signer.encodeExecuteBatch(
+      intents.map((i) => i.to),
+      intents.map((i) => i.value ?? 0n),
+      intents.map((i) => i.data ?? "0x")
+    );
+    try {
+      return await this.bundler.estimateUserOperationGas({
+        sender,
+        callData
+      });
+    } catch {
+      return {
+        verificationGasLimit: 150000n,
+        callGasLimit: 100000n * BigInt(intents.length),
+        preVerificationGas: 50000n
+      };
+    }
+  }
+  /**
+   * Get paymaster data if configured
+   */
+  async getPaymasterData(_gasEstimate) {
+    if (!this.paymaster) return void 0;
+    const sender = await this.signer.getAddress();
+    return this.paymaster.getPaymasterData(
+      { sender },
+      this.chainId,
+      import_evm.ENTRYPOINT_V07_ADDRESS
+    );
+  }
+};
+async function createWdkGaslessClient(config) {
+  const smartAccount = await createWdkSmartAccount({
+    wdkAccount: config.wdkAccount,
+    publicClient: config.publicClient,
+    chainId: config.chainId,
+    saltNonce: config.saltNonce
+  });
+  return new WdkGaslessClient({
+    signer: smartAccount,
+    bundler: config.bundler,
+    paymaster: config.paymaster,
+    chainId: config.chainId,
+    publicClient: config.publicClient
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHAIN_IDS,
+  DEFAULT_BUNDLER_URLS,
+  SAFE_4337_ADDRESSES,
+  USDC_ADDRESSES,
+  USDT0_ADDRESSES,
+  WdkGaslessClient,
+  WdkSmartAccount,
+  createWdkGaslessClient,
+  createWdkSmartAccount,
+  getChainName,
+  getTokenAddress
+});
+//# sourceMappingURL=index.js.map