@actalink/commonlib 0.0.1

package/dist/index.js

@@ -0,0 +1,1939 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/tokens.ts
+import { getAddress, zeroAddress } from "viem";
+import {
+  arbitrum as arbitrum2,
+  base as base2,
+  bsc as bsc2,
+  mainnet as mainnet2,
+  linea,
+  optimism as optimism2,
+  polygon as polygon2
+} from "viem/chains";
+
+// src/chains.ts
+import { arbitrum, base, bsc, optimism, polygon, mainnet } from "viem/chains";
+var supportedChains = [
+  arbitrum,
+  base,
+  bsc,
+  mainnet,
+  optimism,
+  polygon
+];
+function getChainById(chainId) {
+  const chain = supportedChains.find((c) => c.id === chainId);
+  if (!chain) throw new Error(`Chain ${chainId} not supported.`);
+  return chain;
+}
+function getChainExplorerByChainId(chainId) {
+  switch (chainId) {
+    case arbitrum.id:
+      return "https://arbiscan.io";
+    case base.id:
+      return "https://basescan.org";
+    case bsc.id:
+      return "https://bscscan.com";
+    case mainnet.id:
+      return "https://etherscan.io";
+    case optimism.id:
+      return "https://optimistic.etherscan.io";
+    case polygon.id:
+      return "https://polygonscan.com";
+    default:
+      return void 0;
+  }
+}
+
+// src/types.ts
+var TokenLogo = /* @__PURE__ */ ((TokenLogo2) => {
+  TokenLogo2["ETH"] = "https://pay.daimo.com/chain-logos/ethereum.png";
+  TokenLogo2["WETH"] = "https://pay.daimo.com/coin-logos/weth.png";
+  TokenLogo2["USDC"] = "https://pay.daimo.com/coin-logos/usdc.png";
+  TokenLogo2["EURC"] = "https://pay.daimo.com/coin-logos/eurc.png";
+  TokenLogo2["USDT"] = "https://pay.daimo.com/coin-logos/usdt.png";
+  TokenLogo2["DAI"] = "https://pay.daimo.com/coin-logos/dai.png";
+  TokenLogo2["POL"] = "https://pay.daimo.com/coin-logos/pol.png";
+  TokenLogo2["BNB"] = "https://pay.daimo.com/coin-logos/bnb.png";
+  return TokenLogo2;
+})(TokenLogo || {});
+var ConnectorType = /* @__PURE__ */ ((ConnectorType2) => {
+  ConnectorType2["SELF_CUSTODY"] = "Self-Custody";
+  ConnectorType2["CEX"] = "CEX";
+  return ConnectorType2;
+})(ConnectorType || {});
+var PolicyFlags = /* @__PURE__ */ ((PolicyFlags2) => {
+  PolicyFlags2["FOR_ALL_VALIDATION"] = "0x0000";
+  PolicyFlags2["NOT_FOR_VALIDATE_USEROP"] = "0x0001";
+  PolicyFlags2["NOT_FOR_VALIDATE_SIG"] = "0x0002";
+  return PolicyFlags2;
+})(PolicyFlags || {});
+
+// src/tokens.ts
+var arbitrumETH = nativeETH(arbitrum2.id);
+var arbitrumWETH = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://pay.daimo.com/coin-logos/weth.png" /* WETH */
+});
+var arbitrumUSDC = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),
+  name: "USD Coin",
+  symbol: "USDC",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var arbitrumDAI = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://pay.daimo.com/coin-logos/dai.png" /* DAI */
+});
+var arbitrumUSDT = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://pay.daimo.com/coin-logos/usdt.png" /* USDT */
+});
+var arbitrumUSDCe = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Bridged USD Coin",
+  symbol: "USDCe",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var arbitrumTokens = [arbitrumUSDC, arbitrumUSDT];
+var baseETH = nativeETH(base2.id);
+var baseWETH = token({
+  chainId: base2.id,
+  address: getAddress("0x4200000000000000000000000000000000000006"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://pay.daimo.com/coin-logos/weth.png" /* WETH */
+});
+var baseUSDC = token({
+  chainId: base2.id,
+  address: getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
+  name: "USD Coin",
+  symbol: "USDC",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var baseEURC = token({
+  chainId: base2.id,
+  address: getAddress("0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42"),
+  decimals: 6,
+  fiatISO: "EUR",
+  name: "EURC",
+  symbol: "EURC",
+  logoURI: "https://pay.daimo.com/coin-logos/eurc.png" /* EURC */
+});
+var baseUSDbC = token({
+  chainId: base2.id,
+  address: getAddress("0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA"),
+  name: "Bridged USD Coin",
+  symbol: "USDbC",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://pay.daimo.com/coin-logos/usdbc.png"
+});
+var baseDAI = token({
+  chainId: base2.id,
+  address: getAddress("0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"),
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  fiatISO: "USD",
+  decimals: 18,
+  logoURI: "https://pay.daimo.com/coin-logos/dai.png" /* DAI */
+});
+var baseUSDT = token({
+  chainId: base2.id,
+  address: getAddress("0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"),
+  name: "Tether USD",
+  symbol: "USDT",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://pay.daimo.com/coin-logos/usdt.png" /* USDT */
+});
+var baseTokens = [baseUSDC, baseUSDT];
+var bscBNB = nativeToken({
+  chainId: bsc2.id,
+  name: "BNB",
+  symbol: "BNB",
+  logoURI: "https://pay.daimo.com/coin-logos/bnb.png" /* BNB */
+});
+var bscWBNB = token({
+  chainId: bsc2.id,
+  address: getAddress("0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"),
+  decimals: 18,
+  name: "Wrapped BNB",
+  symbol: "WBNB",
+  logoURI: "https://pay.daimo.com/coin-logos/bnb.png" /* BNB */
+});
+var bscUSDC = token({
+  chainId: bsc2.id,
+  address: getAddress("0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var bscUSDT = token({
+  chainId: bsc2.id,
+  address: getAddress("0x55d398326f99059fF775485246999027B3197955"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://pay.daimo.com/coin-logos/usdt.png" /* USDT */
+});
+var bscTokens = [bscUSDT];
+var ethereumETH = nativeETH(mainnet2.id);
+var ethereumWETH = token({
+  chainId: mainnet2.id,
+  address: getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://pay.daimo.com/coin-logos/weth.png" /* WETH */
+});
+var ethereumUSDC = token({
+  chainId: mainnet2.id,
+  address: getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var ethereumDAI = token({
+  chainId: mainnet2.id,
+  address: getAddress("0x6B175474E89094C44Da98b954EedeAC495271d0F"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://pay.daimo.com/coin-logos/dai.png" /* DAI */
+});
+var ethereumUSDT = token({
+  chainId: mainnet2.id,
+  address: getAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://pay.daimo.com/coin-logos/usdt.png" /* USDT */
+});
+var ethereumEURC = token({
+  chainId: mainnet2.id,
+  address: getAddress("0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c"),
+  decimals: 6,
+  fiatISO: "EUR",
+  name: "EURC",
+  symbol: "EURC",
+  logoURI: "https://pay.daimo.com/coin-logos/eurc.png" /* EURC */
+});
+var ethereumTokens = [ethereumUSDC, ethereumUSDT];
+var lineaETH = nativeETH(linea.id);
+var lineaWETH = token({
+  chainId: linea.id,
+  address: getAddress("0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://pay.daimo.com/coin-logos/weth.png" /* WETH */
+});
+var lineaUSDC = token({
+  chainId: linea.id,
+  address: getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var lineaDAI = token({
+  chainId: linea.id,
+  address: getAddress("0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://pay.daimo.com/coin-logos/dai.png" /* DAI */
+});
+var optimismETH = nativeETH(optimism2.id);
+var optimismWETH = token({
+  chainId: optimism2.id,
+  address: getAddress("0x4200000000000000000000000000000000000006"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://pay.daimo.com/coin-logos/weth.png" /* WETH */
+});
+var optimismUSDC = token({
+  chainId: optimism2.id,
+  address: getAddress("0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var optimismDAI = token({
+  chainId: optimism2.id,
+  address: getAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://pay.daimo.com/coin-logos/dai.png" /* DAI */
+});
+var optimismUSDT = token({
+  chainId: optimism2.id,
+  address: getAddress("0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://pay.daimo.com/coin-logos/usdt.png" /* USDT */
+});
+var optimismUSDCe = token({
+  chainId: optimism2.id,
+  address: getAddress("0x7F5c764cBc14f9669B88837ca1490cCa17c31607"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Bridged USD Coin",
+  symbol: "USDCe",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var optimismTokens = [optimismUSDC, optimismUSDT];
+var polygonPOL = nativeToken({
+  chainId: polygon2.id,
+  name: "Polygon",
+  symbol: "POL",
+  logoURI: "https://pay.daimo.com/coin-logos/pol.png" /* POL */
+});
+var polygonWPOL = token({
+  chainId: polygon2.id,
+  address: getAddress("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+  decimals: 18,
+  name: "Wrapped Polygon",
+  symbol: "WPOL",
+  logoURI: "https://pay.daimo.com/coin-logos/pol.png" /* POL */
+});
+var polygonWETH = token({
+  chainId: polygon2.id,
+  address: getAddress("0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://pay.daimo.com/coin-logos/weth.png" /* WETH */
+});
+var polygonUSDC = token({
+  chainId: polygon2.id,
+  address: getAddress("0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var polygonDAI = token({
+  chainId: polygon2.id,
+  address: getAddress("0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://pay.daimo.com/coin-logos/dai.png" /* DAI */
+});
+var polygonUSDT = token({
+  chainId: polygon2.id,
+  address: getAddress("0xc2132D05D31c914a87C6611C10748AEb04B58e8F"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://pay.daimo.com/coin-logos/usdt.png" /* USDT */
+});
+var polygonUSDCe = token({
+  chainId: polygon2.id,
+  address: getAddress("0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin (PoS)",
+  symbol: "USDCe",
+  logoURI: "https://pay.daimo.com/coin-logos/usdc.png" /* USDC */
+});
+var polygonTokens = [polygonUSDC, polygonUSDT];
+var supportedTokensByChain = /* @__PURE__ */ new Map([
+  [arbitrum2.id, arbitrumTokens],
+  //done
+  [base2.id, baseTokens],
+  //done
+  [bsc2.id, bscTokens],
+  //done
+  [mainnet2.id, ethereumTokens],
+  //done
+  [optimism2.id, optimismTokens],
+  //done
+  [polygon2.id, polygonTokens]
+  //done
+]);
+function nativeETH(chainId) {
+  return nativeToken({
+    chainId,
+    name: "Ether",
+    symbol: "ETH",
+    logoURI: "https://pay.daimo.com/chain-logos/ethereum.png" /* ETH */
+  });
+}
+function nativeToken({
+  chainId,
+  name,
+  symbol,
+  logoURI,
+  address = zeroAddress,
+  decimals = 18
+}) {
+  return {
+    chainId,
+    address,
+    name,
+    decimals,
+    symbol,
+    logoURI,
+    logoSourceURI: logoURI
+  };
+}
+function token({
+  chainId,
+  address,
+  name,
+  symbol,
+  decimals,
+  fiatISO,
+  logoURI
+}) {
+  return {
+    chainId,
+    address,
+    name,
+    symbol,
+    decimals,
+    fiatISO,
+    logoURI,
+    logoSourceURI: logoURI
+  };
+}
+function getTokenByChainIdAndSymbol(chainId, symbol) {
+  const chain = getChainById(chainId);
+  if (!chain) throw new Error(`Chain ${chainId} not supported.`);
+  const tokens = supportedTokensByChain.get(chain.id);
+  if (!tokens) throw new Error(`Tokens not found for chain ${chainId}.`);
+  const token2 = tokens.find((t) => t.symbol === symbol);
+  if (!token2)
+    throw new Error(`Token ${symbol} not found for chain ${chainId}.`);
+  return token2;
+}
+var tokensCommonSymbols = [
+  "USDC",
+  "USDT",
+  "DAI",
+  "ETH",
+  "WETH",
+  "BNB",
+  "WBNB",
+  "USDCe",
+  "USDbC",
+  "EURC",
+  "POL",
+  "WPOL"
+];
+
+// src/deposit.ts
+import { toHex as toHex2, zeroAddress as zeroAddress4 } from "viem";
+
+// src/account.ts
+import {
+  http as http2,
+  getAddress as getAddress2,
+  parseAbi as parseAbi2
+} from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import {
+  createPaymasterClient,
+  formatUserOperationRequest
+} from "viem/account-abstraction";
+import { addressToEmptyAccount, createKernelAccount as createKernelAccount2 } from "@zerodev/sdk";
+import { getEntryPoint, KERNEL_V3_1 } from "@zerodev/sdk/constants";
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import { createSmartAccountClient } from "permissionless";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+import { prepareUserOperationForErc20Paymaster } from "permissionless/experimental/pimlico";
+
+// src/rpc.ts
+function getRpcByChainId(chainId) {
+  switch (chainId) {
+    case 1:
+      return "https://eth-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    case 10:
+      return "https://opt-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    case 56:
+      return "https://bsc-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    case 137:
+      return "https://polygon-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    case 8453:
+      return "https://base-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    case 42161:
+      return "https://arbitrum-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    case 59144:
+      return "https://linea-mainnet.g.alchemy.com/v2/2uxlNSyeU1IcP7HMKteJM21td0IAHroW";
+    default:
+      return void 0;
+  }
+}
+function getPimlicoRpcByChainId(chainId) {
+  switch (chainId) {
+    case 1:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    case 10:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    case 56:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    case 137:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    case 8453:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    case 42161:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    case 59144:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_kJYDesTFhp9siAfj9W868S`;
+    default:
+      return void 0;
+  }
+}
+
+// src/viemClient.ts
+import {
+  http,
+  createPublicClient,
+  parseAbi,
+  encodeFunctionData
+} from "viem";
+var ViemClient = class {
+  constructor(chainId, walletClient) {
+    this.chainId = chainId;
+    this.walletClient = walletClient;
+  }
+  publicClient() {
+    return createPublicClient({
+      chain: getChainById(this.chainId),
+      transport: http(getRpcByChainId(this.chainId))
+    });
+  }
+  checkTokenAllowance(token2, owner, spender) {
+    return __async(this, null, function* () {
+      const allowance = yield this.publicClient().readContract({
+        address: token2.address,
+        abi: parseAbi([
+          "function allowance(address,address) view returns (uint256)"
+        ]),
+        functionName: "allowance",
+        args: [owner, spender]
+      });
+      return allowance;
+    });
+  }
+  checkAndApproveToken(token2, spender, amount) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.walletClient === void 0) {
+        throw new Error("Wallet client is required");
+      }
+      const signerAddress = (_a = this.walletClient.account) == null ? void 0 : _a.address;
+      console.log("signerAddress", signerAddress);
+      if (signerAddress === void 0) {
+        throw new Error("Signer address is required");
+      }
+      const allowance = yield this.checkTokenAllowance(
+        token2,
+        signerAddress,
+        spender
+      );
+      if (allowance < amount) {
+        const txn = yield this.walletClient.sendTransaction({
+          to: token2.address,
+          account: signerAddress,
+          chain: getChainById(token2.chainId),
+          value: BigInt(0),
+          data: encodeFunctionData({
+            abi: parseAbi(["function approve(address,uint)"]),
+            functionName: "approve",
+            args: [spender, amount]
+          })
+        });
+        const receipt = yield this.publicClient().waitForTransactionReceipt({
+          hash: txn,
+          confirmations: token2.chainId === 1 ? 1 : 5
+        });
+        return amount;
+      }
+      return allowance;
+    });
+  }
+};
+
+// src/utils.ts
+import {
+  constants,
+  fixSignedData,
+  toSigner,
+  KernelV3AccountAbi,
+  KernelFactoryStakerAbi,
+  KernelV3FactoryAbi,
+  KernelV3_1AccountAbi,
+  createKernelAccount
+} from "@zerodev/sdk";
+import {
+  toKernelPluginManager
+} from "@zerodev/sdk/accounts";
+import {
+  concat,
+  encodeAbiParameters,
+  keccak256,
+  slice,
+  zeroAddress as zeroAddress2,
+  decodeFunctionData
+} from "viem";
+import {
+  toAccount,
+  privateKeyToAccount
+} from "viem/accounts";
+import { getChainId, readContract } from "viem/actions";
+import { getAction } from "viem/utils";
+import {
+  getUserOperationHash
+} from "viem/account-abstraction";
+import {
+  toCallPolicy,
+  toGasPolicy,
+  toRateLimitPolicy,
+  toSignatureCallerPolicy,
+  toSudoPolicy,
+  toTimestampPolicy
+} from "@zerodev/permissions/policies";
+import { coerce, gt } from "semver";
+var ECDSA_SIGNER_CONTRACT = "0x6A6F069E2a08c2468e7724Ab3250CdBFBA14D4FF";
+var toSignerId = (signer) => {
+  return encodeAbiParameters(
+    [{ name: "signerData", type: "bytes" }],
+    [concat([signer.signerContractAddress, signer.getSignerData()])]
+  );
+};
+function toECDSASigner(_0) {
+  return __async(this, arguments, function* (signer, signerContractAddress = ECDSA_SIGNER_CONTRACT) {
+    const viemSigner = yield toSigner({ signer });
+    const account = toAccount({
+      address: viemSigner.address,
+      signMessage(_02) {
+        return __async(this, arguments, function* ({ message }) {
+          return fixSignedData(yield viemSigner.signMessage({ message }));
+        });
+      },
+      signTransaction(_, __) {
+        return __async(this, null, function* () {
+          throw new Error("Smart account signer doesn't need to sign transactions");
+        });
+      },
+      signTypedData(typedData) {
+        return __async(this, null, function* () {
+          return fixSignedData(
+            yield viemSigner.signTypedData(__spreadValues({}, typedData))
+          );
+        });
+      }
+    });
+    return {
+      account,
+      signerContractAddress,
+      getSignerData: () => {
+        return viemSigner.address;
+      },
+      getDummySignature: () => constants.DUMMY_ECDSA_SIG
+    };
+  });
+}
+var toPolicyId = (policies) => {
+  return encodeAbiParameters(
+    [{ name: "policiesData", type: "bytes[]" }],
+    [
+      policies.map(
+        (policy) => concat([policy.getPolicyInfoInBytes(), policy.getPolicyData()])
+      )
+    ]
+  );
+};
+function toPermissionValidator(_0, _1) {
+  return __async(this, arguments, function* (client, {
+    signer,
+    policies,
+    entryPoint,
+    kernelVersion: _,
+    flag = "0x0000" /* FOR_ALL_VALIDATION */
+  }) {
+    const chainId = client.chain ? client.chain.id : yield getChainId(client);
+    if (entryPoint.version !== "0.7") {
+      throw new Error("Only EntryPoint 0.7 is supported");
+    }
+    const getEnableData = (_kernelAccountAddress) => __async(null, null, function* () {
+      const enableData = encodeAbiParameters(
+        [{ name: "policyAndSignerData", type: "bytes[]" }],
+        [
+          [
+            ...policies.map(
+              (policy) => concat([policy.getPolicyInfoInBytes(), policy.getPolicyData()])
+            ),
+            concat([flag, signer.signerContractAddress, signer.getSignerData()])
+          ]
+        ]
+      );
+      return enableData;
+    });
+    const getPermissionId = () => {
+      const pIdData = encodeAbiParameters(
+        [{ name: "policyAndSignerData", type: "bytes[]" }],
+        [[toPolicyId(policies), flag, toSignerId(signer)]]
+      );
+      return slice(keccak256(pIdData), 0, 4);
+    };
+    return __spreadProps(__spreadValues({}, signer.account), {
+      supportedKernelVersions: ">=0.3.0",
+      validatorType: "PERMISSION",
+      address: zeroAddress2,
+      source: "PermissionValidator",
+      getEnableData,
+      getIdentifier: getPermissionId,
+      signMessage: (_02) => __async(null, [_02], function* ({ message }) {
+        return concat(["0xff", yield signer.account.signMessage({ message })]);
+      }),
+      signTypedData: (typedData) => __async(null, null, function* () {
+        return concat(["0xff", yield signer.account.signTypedData(typedData)]);
+      }),
+      signUserOperation: (userOperation) => __async(null, null, function* () {
+        const userOpHash = getUserOperationHash({
+          userOperation: __spreadProps(__spreadValues({}, userOperation), {
+            signature: "0x"
+          }),
+          entryPointAddress: entryPoint.address,
+          entryPointVersion: entryPoint.version,
+          chainId
+        });
+        const signature = yield signer.account.signMessage({
+          message: { raw: userOpHash }
+        });
+        return concat(["0xff", signature]);
+      }),
+      getNonceKey(_accountAddress, customNonceKey) {
+        return __async(this, null, function* () {
+          if (customNonceKey) {
+            return customNonceKey;
+          }
+          return BigInt(0);
+        });
+      },
+      getStubSignature(_userOperation) {
+        return __async(this, null, function* () {
+          return concat(["0xff", signer.getDummySignature()]);
+        });
+      },
+      getPluginSerializationParams: () => {
+        return {
+          policies
+        };
+      },
+      isEnabled: (kernelAccountAddress, _selector) => __async(null, null, function* () {
+        try {
+          const permissionConfig = yield getAction(
+            client,
+            readContract,
+            "readContract"
+          )({
+            abi: KernelV3AccountAbi,
+            address: kernelAccountAddress,
+            functionName: "permissionConfig",
+            args: [getPermissionId()]
+          });
+          return permissionConfig.signer === signer.signerContractAddress;
+        } catch (error) {
+          return false;
+        }
+      })
+    });
+  });
+}
+function bytesToBase64(bytes) {
+  const binString = Array.from(bytes, (x) => String.fromCodePoint(x)).join("");
+  return btoa(binString);
+}
+function isPermissionValidatorPlugin(plugin) {
+  return (plugin == null ? void 0 : plugin.getPluginSerializationParams) !== void 0;
+}
+var serializePermissionAccountParams = (params) => {
+  const replacer = (_, value) => {
+    if (typeof value === "bigint") {
+      return value.toString();
+    }
+    return value;
+  };
+  const jsonString = JSON.stringify(params, replacer);
+  const uint8Array = new TextEncoder().encode(jsonString);
+  const base64String = bytesToBase64(uint8Array);
+  return base64String;
+};
+var serializePermissionAccount = (account, privateKey, enableSignature, eip7702Auth) => __async(null, null, function* () {
+  if (!isPermissionValidatorPlugin(account.kernelPluginManager))
+    throw new Error("Account plugin is not a permission validator");
+  const permissionParams = account.kernelPluginManager.getPluginSerializationParams();
+  const action = account.kernelPluginManager.getAction();
+  const validityData = account.kernelPluginManager.getValidityData();
+  const _enableSignature = enableSignature != null ? enableSignature : yield account.kernelPluginManager.getPluginEnableSignature(
+    account.address
+  );
+  const _eip7702Auth = account.authorization ? eip7702Auth != null ? eip7702Auth : yield account == null ? void 0 : account.eip7702Auth : void 0;
+  const accountParams = {
+    initCode: yield account.generateInitCode(),
+    accountAddress: account.address
+  };
+  const paramsToBeSerialized = {
+    permissionParams,
+    action,
+    validityData,
+    accountParams,
+    enableSignature: _enableSignature,
+    privateKey,
+    eip7702Auth: _eip7702Auth
+  };
+  return serializePermissionAccountParams(paramsToBeSerialized);
+});
+var isKernelVersionAfter = (kernelVersion, version) => {
+  const coercedKernelVersion = coerce(kernelVersion);
+  if (!coercedKernelVersion) return false;
+  return gt(coercedKernelVersion, version);
+};
+function base64ToBytes(base64) {
+  const binString = atob(base64);
+  return Uint8Array.from(binString, (m) => m.codePointAt(0));
+}
+var deserializePermissionAccountParams = (params) => {
+  const uint8Array = base64ToBytes(params);
+  const jsonString = new TextDecoder().decode(uint8Array);
+  return JSON.parse(jsonString);
+};
+var deserializePermissionAccount = (client, entryPoint, kernelVersion, modularPermissionAccountParams, modularSigner) => __async(null, null, function* () {
+  var _a;
+  if (entryPoint.version !== "0.7") {
+    throw new Error("Only EntryPoint 0.7 is supported");
+  }
+  const params = deserializePermissionAccountParams(
+    modularPermissionAccountParams
+  );
+  let signer;
+  if (params.privateKey)
+    signer = yield toECDSASigner(privateKeyToAccount(params.privateKey));
+  else if (modularSigner) signer = modularSigner;
+  else throw new Error("No signer or serialized sessionKey provided");
+  const modularPermissionPlugin = yield toPermissionValidator(client, {
+    signer,
+    policies: yield Promise.all(
+      ((_a = params.permissionParams.policies) == null ? void 0 : _a.map(
+        (policy) => createPolicyFromParams(policy)
+      )) || []
+    ),
+    entryPoint,
+    kernelVersion
+  });
+  const { index, validatorInitData, useMetaFactory } = decodeParamsFromInitCode(
+    params.accountParams.initCode,
+    kernelVersion
+  );
+  const kernelPluginManager = yield toKernelPluginManager(client, __spreadValues({
+    regular: modularPermissionPlugin,
+    pluginEnableSignature: params.enableSignature,
+    validatorInitData,
+    action: params.action,
+    entryPoint,
+    kernelVersion
+  }, params.validityData));
+  return createKernelAccount(client, {
+    entryPoint,
+    kernelVersion,
+    plugins: kernelPluginManager,
+    index,
+    address: params.accountParams.accountAddress,
+    useMetaFactory,
+    eip7702Auth: params.eip7702Auth
+  });
+});
+var createPolicyFromParams = (policy) => __async(null, null, function* () {
+  switch (policy.policyParams.type) {
+    case "call":
+      return yield toCallPolicy(policy.policyParams);
+    case "gas":
+      return yield toGasPolicy(policy.policyParams);
+    case "rate-limit":
+      return yield toRateLimitPolicy(policy.policyParams);
+    case "signature-caller":
+      return yield toSignatureCallerPolicy(policy.policyParams);
+    case "sudo":
+      return yield toSudoPolicy(policy.policyParams);
+    case "timestamp":
+      return yield toTimestampPolicy(policy.policyParams);
+    default:
+      throw new Error("Unsupported policy type");
+  }
+});
+var decodeParamsFromInitCode = (initCode, kernelVersion) => {
+  let index;
+  let validatorInitData;
+  let deployWithFactoryFunctionData;
+  let useMetaFactory = true;
+  if (initCode === "0x") {
+    return {
+      index: void 0,
+      validatorInitData: void 0,
+      useMetaFactory: true
+    };
+  }
+  try {
+    deployWithFactoryFunctionData = decodeFunctionData({
+      abi: KernelFactoryStakerAbi,
+      data: initCode
+    });
+  } catch (error) {
+    deployWithFactoryFunctionData = decodeFunctionData({
+      abi: KernelV3FactoryAbi,
+      data: initCode
+    });
+    useMetaFactory = false;
+  }
+  if (!deployWithFactoryFunctionData) throw new Error("Invalid initCode");
+  if (deployWithFactoryFunctionData.functionName === "deployWithFactory") {
+    index = BigInt(deployWithFactoryFunctionData.args[2]);
+    let initializeFunctionData;
+    if (kernelVersion === "0.3.0") {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3AccountAbi,
+        data: deployWithFactoryFunctionData.args[1]
+      });
+    } else {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3_1AccountAbi,
+        data: deployWithFactoryFunctionData.args[1]
+      });
+    }
+    if (!initializeFunctionData) throw new Error("Invalid initCode");
+    if (initializeFunctionData.functionName === "initialize") {
+      validatorInitData = {
+        validatorAddress: initializeFunctionData.args[0],
+        identifier: initializeFunctionData.args[0],
+        enableData: initializeFunctionData.args[2],
+        initConfig: isKernelVersionAfter(kernelVersion, "0.3.1") && Array.isArray(initializeFunctionData.args[4]) ? [...initializeFunctionData.args[4]] : void 0
+      };
+    }
+  } else if (deployWithFactoryFunctionData.functionName === "createAccount") {
+    index = BigInt(deployWithFactoryFunctionData.args[1]);
+    let initializeFunctionData;
+    if (kernelVersion === "0.3.0") {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3AccountAbi,
+        data: deployWithFactoryFunctionData.args[0]
+      });
+    } else {
+      initializeFunctionData = decodeFunctionData({
+        abi: KernelV3_1AccountAbi,
+        data: deployWithFactoryFunctionData.args[0]
+      });
+    }
+    if (!initializeFunctionData) throw new Error("Invalid initCode");
+    if (initializeFunctionData.functionName === "initialize") {
+      validatorInitData = {
+        validatorAddress: initializeFunctionData.args[0],
+        identifier: initializeFunctionData.args[0],
+        enableData: initializeFunctionData.args[2],
+        initConfig: isKernelVersionAfter(kernelVersion, "0.3.1") && Array.isArray(initializeFunctionData.args[4]) ? [...initializeFunctionData.args[4]] : void 0
+      };
+    }
+  }
+  if (index === void 0 || validatorInitData === void 0)
+    throw new Error("Invalid initCode");
+  return { index, validatorInitData, useMetaFactory };
+};
+var getPeriodInterval = (periodUnit) => {
+  switch (periodUnit) {
+    case "5mins":
+      return 5 * 60;
+    case "day":
+      return 24 * 60 * 60;
+    case "week":
+      return 7 * 24 * 60 * 60;
+    case "month":
+      return 28 * 24 * 60 * 60;
+    case "year":
+      return 365 * 24 * 60 * 60;
+    default:
+      throw new Error("Invalid period unit");
+  }
+};
+
+// src/account.ts
+import {
+  toCallPolicy as toCallPolicy2,
+  CallPolicyVersion,
+  ParamCondition
+} from "@zerodev/permissions/policies";
+var ActaAccount = class {
+  constructor(chainId, publicClient, signer) {
+    this.chainId = chainId;
+    this.signer = signer;
+    this.publicClient = publicClient;
+  }
+  createAccount() {
+    return __async(this, null, function* () {
+      const kernelVersion = KERNEL_V3_1;
+      const entryPoint = getEntryPoint("0.7");
+      const ecdsaValidator = yield signerToEcdsaValidator(this.publicClient, {
+        signer: this.signer,
+        entryPoint,
+        kernelVersion
+      });
+      const account = yield createKernelAccount2(this.publicClient, {
+        plugins: {
+          sudo: ecdsaValidator
+        },
+        entryPoint,
+        kernelVersion
+      });
+      return account;
+    });
+  }
+  createAccountHelpers() {
+    return __async(this, null, function* () {
+      const account = yield this.createAccount();
+      const entryPoint = getEntryPoint("0.7");
+      const paymasterClient = createPaymasterClient({
+        transport: http2(getPimlicoRpcByChainId(this.chainId))
+      });
+      const pimlicoClient = createPimlicoClient({
+        chain: getChainById(this.chainId),
+        transport: http2(getPimlicoRpcByChainId(this.chainId)),
+        entryPoint
+      });
+      const accountClient = createSmartAccountClient({
+        account,
+        chain: getChainById(this.chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: http2(getPimlicoRpcByChainId(this.chainId)),
+        userOperation: {
+          estimateFeesPerGas: () => __async(this, null, function* () {
+            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
+          }),
+          prepareUserOperation: prepareUserOperationForErc20Paymaster(pimlicoClient)
+        }
+      });
+      return { paymasterClient, pimlicoClient, accountClient };
+    });
+  }
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      const {
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver
+      } = parameters;
+      if (amount <= BigInt(0)) {
+        throw new Error("Amount must be greater than 0.");
+      }
+      if (receiver === signerAddress) {
+        throw new Error("Receiver cannot be the same as the signer.");
+      }
+      const account = yield this.createAccount();
+      const { accountClient, pimlicoClient } = yield this.createAccountHelpers();
+      const fromAddress = signerAddress;
+      const smartAccountAddress = account.address;
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not found.");
+      }
+      const quotes = yield pimlicoClient.getTokenQuotes({
+        tokens: [token2.address],
+        chain: getChainById(chainId)
+      });
+      const { postOpGas, exchangeRate, paymaster } = quotes[0];
+      const userOperation = yield accountClient.prepareUserOperation({
+        calls: [
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [fromAddress, smartAccountAddress, BigInt(0)]
+          },
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function approve(address,uint)"]),
+            functionName: "approve",
+            args: [paymaster, BigInt(0)]
+          },
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transfer(address,uint)"]),
+            functionName: "transfer",
+            args: [
+              "0x061BA68bc8208F4AddBeE86F74F17D77129cCF70",
+              BigInt(0)
+            ]
+          },
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transfer(address,uint)"]),
+            functionName: "transfer",
+            args: [receiver, BigInt(0)]
+          }
+        ]
+      });
+      const userOperationMaxGas = userOperation.preVerificationGas + userOperation.callGasLimit + userOperation.verificationGasLimit + (userOperation.paymasterPostOpGasLimit || BigInt(0)) + (userOperation.paymasterVerificationGasLimit || BigInt(0));
+      const userOperationMaxCost = BigInt(
+        userOperationMaxGas * userOperation.maxFeePerGas
+      );
+      const estimatedGasCostInToken = (userOperationMaxCost + postOpGas * userOperation.maxFeePerGas) * exchangeRate / BigInt(1e18);
+      const ActalinkFeesInToken = amount * BigInt(20) / BigInt(1e4);
+      const estimatedTotalFeesInToken = estimatedGasCostInToken + ActalinkFeesInToken;
+      const feeInclusiveAmountInToken = amount - estimatedTotalFeesInToken;
+      const feeExclusiveAmountInToken = amount + estimatedTotalFeesInToken;
+      return {
+        estimatedGasCostInToken,
+        ActalinkFeesInToken,
+        estimatedTotalFeesInToken,
+        feeInclusiveAmountInToken,
+        feeExclusiveAmountInToken,
+        paymaster,
+        userOperation
+      };
+    });
+  }
+  signSinglePaymentOperation(singlePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (!this.signer) {
+          throw new Error("Signer is required for self custody payments.");
+        }
+        const {
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive
+        } = singlePaymentParams;
+        if (amount <= BigInt(0)) {
+          throw new Error("Amount must be greater than 0.");
+        }
+        if (receiver === signerAddress) {
+          throw new Error("Receiver cannot be the same as the signer.");
+        }
+        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (!token2) {
+          throw new Error("Token not found.");
+        }
+        const viemClient = new ViemClient(this.chainId, this.signer);
+        const {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster
+        } = yield this.estimateSinglePaymentGas({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive
+        });
+        const account = yield this.createAccount();
+        const { accountClient } = yield this.createAccountHelpers();
+        const fromAddress = signerAddress;
+        const smartAccountAddress = account.address;
+        const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
+        const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : amount;
+        yield viemClient.checkAndApproveToken(
+          token2,
+          smartAccountAddress,
+          amountToTransfer
+        );
+        const userOperation = yield accountClient.prepareUserOperation({
+          calls: [
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [fromAddress, smartAccountAddress, amountToTransfer]
+            },
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function approve(address,uint)"]),
+              functionName: "approve",
+              args: [paymaster, estimatedGasCostInToken]
+            },
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transfer(address,uint)"]),
+              functionName: "transfer",
+              args: [
+                "0x061BA68bc8208F4AddBeE86F74F17D77129cCF70",
+                ActalinkFeesInToken
+              ]
+            },
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transfer(address,uint)"]),
+              functionName: "transfer",
+              args: [receiver, receiverAmount]
+            }
+          ],
+          paymasterContext: {
+            token: token2.address
+          }
+        });
+        const signature = yield account.signUserOperation(__spreadProps(__spreadValues({}, userOperation), {
+          chainId: this.chainId
+        }));
+        const rpcParameters = formatUserOperationRequest(__spreadProps(__spreadValues({}, userOperation), {
+          signature
+        }));
+        return rpcParameters;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to sign single payment operation.");
+      }
+    });
+  }
+  signRecurringPayments(recurringPaymentParams) {
+    return __async(this, null, function* () {
+      if (!this.signer) {
+        throw new Error("Signer is required for self custody payments.");
+      }
+      const {
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver,
+        feeInclusive,
+        count,
+        intervalUnit,
+        startDate,
+        endDate
+      } = recurringPaymentParams;
+      if (amount <= BigInt(0)) {
+        throw new Error("Amount must be greater than 0.");
+      }
+      if (receiver === signerAddress) {
+        throw new Error("Receiver cannot be the same as the signer.");
+      }
+      if (!intervalUnit) {
+        throw new Error("Interval unit is required.");
+      }
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not found.");
+      }
+      const kernelVersion = KERNEL_V3_1;
+      const entryPoint = getEntryPoint("0.7");
+      const paymentCount = count != null ? count : 24;
+      const account = yield this.createAccount();
+      const smartAccountAddress = account.address;
+      const viemClient = new ViemClient(this.chainId, this.signer);
+      const { paymasterClient, pimlicoClient } = yield this.createAccountHelpers();
+      const sessionKeySigner = yield toECDSASigner(
+        privateKeyToAccount2(
+          "0x8519baaeb81ebbcf3597d93c2f9790d1eda37097121e844e1b88c1ab77b67ae2"
+        )
+      );
+      const ecdsaValidator = yield signerToEcdsaValidator(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          signer: this.signer
+        }
+      );
+      const sessionKeyAddress = "0x0744F720fe178AC21F25a30263B6269a1C0bB106";
+      const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
+      const emptySessionKeySigner = yield toECDSASigner(emptyAccount);
+      const {
+        paymaster,
+        ActalinkFeesInToken,
+        feeInclusiveAmountInToken,
+        feeExclusiveAmountInToken,
+        estimatedTotalFeesInToken,
+        userOperation,
+        estimatedGasCostInToken
+      } = yield this.estimateSinglePaymentGas({
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver,
+        feeInclusive
+      });
+      const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
+      const receiverAmount = feeInclusive ? feeInclusiveAmountInToken : amount;
+      yield viemClient.checkAndApproveToken(
+        token2,
+        smartAccountAddress,
+        amountToTransfer * BigInt(paymentCount) + estimatedGasCostInToken * BigInt(2) * BigInt(paymentCount)
+      );
+      const callPolicy = toCallPolicy2({
+        policyVersion: CallPolicyVersion.V0_0_4,
+        permissions: [
+          {
+            target: token2.address,
+            valueLimit: BigInt(0),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [
+              {
+                condition: ParamCondition.EQUAL,
+                value: signerAddress
+              },
+              {
+                condition: ParamCondition.EQUAL,
+                value: smartAccountAddress
+              },
+              {
+                condition: ParamCondition.GREATER_THAN_OR_EQUAL,
+                value: 0
+              }
+            ]
+          },
+          {
+            target: token2.address,
+            valueLimit: BigInt(0),
+            abi: parseAbi2(["function approve(address,uint)"]),
+            functionName: "approve",
+            args: [
+              {
+                condition: ParamCondition.EQUAL,
+                value: paymaster
+              },
+              {
+                condition: ParamCondition.GREATER_THAN_OR_EQUAL,
+                value: 0
+              }
+            ]
+          },
+          {
+            target: token2.address,
+            valueLimit: BigInt(0),
+            abi: parseAbi2(["function transfer(address,uint)"]),
+            functionName: "transfer",
+            args: [
+              {
+                condition: ParamCondition.ONE_OF,
+                value: ["0xbDCBee616C26D5282227a672C3d0B87EA477A3fe", receiver]
+              },
+              {
+                condition: ParamCondition.GREATER_THAN_OR_EQUAL,
+                value: 0
+              }
+            ]
+          }
+        ]
+      });
+      const permissionPlugin = yield toPermissionValidator(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          signer: emptySessionKeySigner,
+          policies: [callPolicy]
+        }
+      );
+      const serializedSessionKeyAccount = yield createKernelAccount2(
+        viemClient.publicClient(),
+        {
+          entryPoint,
+          kernelVersion,
+          plugins: {
+            sudo: ecdsaValidator,
+            regular: permissionPlugin
+          }
+        }
+      );
+      const approval = yield serializePermissionAccount(
+        serializedSessionKeyAccount
+      );
+      return approval;
+    });
+  }
+};
+
+// src/api.ts
+import { toHex } from "viem";
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["Get"] = "get";
+  HttpMethod2["Post"] = "post";
+  HttpMethod2["Delete"] = "delete";
+  HttpMethod2["Update"] = "update";
+  return HttpMethod2;
+})(HttpMethod || {});
+function sendRequest(_0) {
+  return __async(this, arguments, function* ({
+    url,
+    method,
+    body,
+    headers = {}
+  }) {
+    var _a;
+    const response = yield fetch(url, {
+      method,
+      headers: __spreadProps(__spreadValues({}, headers), {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      }),
+      body: JSON.stringify(body)
+    });
+    let jsonResponse;
+    const res = yield response.json();
+    if (!response.ok) {
+      jsonResponse = {
+        error: {
+          code: response.status,
+          message: response.statusText
+        },
+        data: void 0
+      };
+      return jsonResponse;
+    }
+    if (!res) {
+      jsonResponse = {
+        error: {
+          code: 400,
+          message: "No response received."
+        },
+        data: void 0
+      };
+      return jsonResponse;
+    }
+    if (res == null ? void 0 : res.error) {
+      jsonResponse = {
+        error: {
+          code: response.status,
+          message: res.error
+        },
+        data: void 0
+      };
+      return jsonResponse;
+    }
+    jsonResponse = {
+      data: res.data,
+      message: (_a = res.message) != null ? _a : "Success",
+      error: void 0
+    };
+    return jsonResponse;
+  });
+}
+function createSessionAPICall(url, sessionBodyParams) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: sessionBodyParams
+    });
+    return response.data;
+  });
+}
+function verifySessionAPICall(url, sessionId) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url,
+      method: "get" /* Get */
+    });
+    return response.data;
+  });
+}
+function scheduleRecurringPaymentsAPICall(url, params) {
+  return __async(this, null, function* () {
+    const parsedParams = __spreadProps(__spreadValues({}, params), {
+      amount: toHex(params.amount)
+    });
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: parsedParams
+    });
+    return response.data;
+  });
+}
+function executeSinglePaymentAPICall(url, userOperation, paymentParams, serviceParams) {
+  return __async(this, null, function* () {
+    const params = {
+      userOperation,
+      paymentParams,
+      serviceParams
+    };
+    const response = yield sendRequest({
+      url,
+      method: "post" /* Post */,
+      body: params
+    });
+    return response.data;
+  });
+}
+
+// src/deposit.ts
+var transactionServiceUrl = "https://api.acta.link/transaction/v1/";
+var depositServiceUrl = "https://api.acta.link/deposit/v1/";
+var ActaDeposit = class {
+  constructor(parameters) {
+    this.count = 0;
+    this.intervalUnit = void 0;
+    this.startDate = void 0;
+    this.endDate = void 0;
+    this.serviceSessionParams = void 0;
+    this.depositSessionId = "";
+    this.status = "not_started";
+    this.serviceType = "deposit";
+    var _a;
+    this.connectorType = parameters.connectorType;
+    this.walletClient = parameters.walletClient;
+    this.signerAddress = parameters.signerAddress;
+    this.chainId = parameters.chainId;
+    this.token = parameters.token;
+    this.amount = parameters.amount;
+    this.receiver = parameters.receiver;
+    this.feeInclusive = parameters.feeInclusive;
+    this.paymentType = parameters.paymentType;
+    this.count = parameters.count;
+    this.intervalUnit = parameters.intervalUnit;
+    this.startDate = parameters.startDate;
+    this.endDate = parameters.endDate;
+    this.depositSessionId = (_a = parameters.depositSessionId) != null ? _a : "";
+    this.viemClient = new ViemClient(this.chainId, this.walletClient);
+    this.account = new ActaAccount(
+      this.chainId,
+      this.viemClient.publicClient(),
+      this.walletClient
+    );
+  }
+  createSession(serviceSessionparams) {
+    return __async(this, null, function* () {
+      try {
+        if (!this.signerAddress || this.signerAddress === zeroAddress4) {
+          throw new Error("Signer address is required.");
+        }
+        if (this.paymentType !== "single" && this.paymentType !== "choose" && this.paymentType !== "recurring") {
+          throw new Error("Invalid payment type.");
+        }
+        if (!this.receiver || this.receiver === zeroAddress4) {
+          throw new Error("Receiver is required.");
+        }
+        if (this.paymentType === "recurring" && (this.count === void 0 || this.count === 0)) {
+          throw new Error("Count is required for recurring payments.");
+        }
+        if (this.paymentType === "recurring" && this.intervalUnit === void 0) {
+          throw new Error("Interval unit is required for recurring payments.");
+        }
+        if (this.depositSessionId !== "") {
+          const session2 = yield verifySessionAPICall(
+            `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
+            this.depositSessionId
+          );
+          this.depositSessionId = session2.sessionId;
+          return session2.sessionId;
+        }
+        const token2 = getTokenByChainIdAndSymbol(this.chainId, this.token);
+        if (!token2) {
+          throw new Error("Token not supported.");
+        }
+        const session = yield createSessionAPICall(
+          `${depositServiceUrl}session`,
+          {
+            paymentParams: {
+              signerAddress: this.signerAddress,
+              chainId: this.chainId,
+              token: token2.address,
+              amount: toHex2(this.amount),
+              receiver: this.receiver,
+              feeInclusive: this.feeInclusive,
+              serviceType: "deposit",
+              paymentType: this.paymentType,
+              count: this.count,
+              intervalUnit: this.intervalUnit,
+              startDate: this.startDate,
+              endDate: this.endDate
+            },
+            serviceSessionParams: serviceSessionparams
+          }
+        );
+        this.depositSessionId = session.sessionId;
+        this.status = "session_created";
+        const sessionId = session.sessionId;
+        return sessionId;
+      } catch (error) {
+        this.status = "session_fetch_failed";
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create deposit session.");
+      }
+    });
+  }
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      try {
+        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+          throw new Error("Only self custody payments are supported.");
+        }
+        const {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster,
+          userOperation
+        } = yield this.account.estimateSinglePaymentGas(parameters);
+        return {
+          estimatedGasCostInToken,
+          ActalinkFeesInToken,
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken,
+          paymaster,
+          userOperation
+        };
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to estimate single payment gas.");
+      }
+    });
+  }
+  createPayment(servicePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (this.paymentType === "single") {
+          const paymentParams = this.serviceType === "deposit" ? __spreadProps(__spreadValues({}, servicePaymentParams), {
+            depositSessionId: this.depositSessionId
+          }) : servicePaymentParams;
+          const id = yield this.createSinglePayment(paymentParams);
+          return id;
+        }
+        if (this.paymentType === "choose") {
+        }
+        if (this.paymentType === "recurring") {
+          const paymentParams = this.serviceType === "deposit" ? __spreadProps(__spreadValues({}, servicePaymentParams), {
+            depositSessionId: this.depositSessionId
+          }) : servicePaymentParams;
+          const id = yield this.createRecurringPayments(paymentParams);
+          return id;
+        }
+      } catch (error) {
+        this.status = "payment_failed";
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create payment.");
+      }
+    });
+  }
+  createSinglePayment(servicePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+          throw new Error("Only self custody payments are supported.");
+        }
+        if (!this.depositSessionId || this.depositSessionId === "") {
+          throw new Error("Deposit session ID is required.");
+        }
+        if (this.depositSessionId !== "") {
+          const session = yield verifySessionAPICall(
+            `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
+            this.depositSessionId
+          );
+          this.depositSessionId = session.sessionId;
+        }
+        const signerAddress = this.signerAddress;
+        const chainId = this.chainId;
+        const tokenSymbol = this.token;
+        const amount = this.amount;
+        const receiver = this.receiver;
+        const feeInclusive = this.feeInclusive;
+        const serviceType = this.serviceType;
+        const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+        if (!token2) {
+          throw new Error("Token not supported.");
+        }
+        const rpcParameters = yield this.account.signSinglePaymentOperation({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive
+        });
+        const txn = yield executeSinglePaymentAPICall(
+          `${transactionServiceUrl}execute/single`,
+          rpcParameters,
+          {
+            senderAddress: signerAddress,
+            receiverAddress: receiver,
+            chainId,
+            tokenAddress: token2.address,
+            amount: toHex2(amount),
+            feeInclusive,
+            serviceType
+          },
+          servicePaymentParams
+        );
+        return txn.transaction.id;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create payment.");
+      }
+    });
+  }
+  // private async pollPayment(interval: number) {
+  //   const intervalId = setInterval(async () => {
+  //     const result = await fetch(
+  //       `${this.serviceUrl}/v1/${this.serviceType}/status?id=${this.depositSessionId}`,
+  //       {
+  //         method: "GET",
+  //         headers: {
+  //           "Content-Type": "application/json",
+  //         },
+  //       }
+  //     );
+  //     const res = await result.json();
+  //     const status = res.data.status;
+  //     if (status === "success" || status === "failed") {
+  //       this.status =
+  //         status === "success" ? "payment_completed" : "payment_failed";
+  //       clearInterval(intervalId);
+  //     }
+  //   }, interval);
+  //   return () => clearInterval(intervalId);
+  // }
+  createRecurringPayments(servicePaymentParams) {
+    return __async(this, null, function* () {
+      if (this.connectorType !== "Self-Custody" /* SELF_CUSTODY */) {
+        throw new Error("Only self custody payments are supported.");
+      }
+      if (!this.depositSessionId || this.depositSessionId === "") {
+        throw new Error("Deposit session ID is required.");
+      }
+      if (!this.walletClient) {
+        throw new Error("Signer is required for self custody payments.");
+      }
+      if (this.depositSessionId !== "") {
+        const session = yield verifySessionAPICall(
+          `${depositServiceUrl}verify-session?sessionId=${this.depositSessionId}`,
+          this.depositSessionId
+        );
+        this.depositSessionId = session.sessionId;
+      }
+      const signerAddress = this.signerAddress;
+      const chainId = this.chainId;
+      const tokenSymbol = this.token;
+      const amount = this.amount;
+      const receiver = this.receiver;
+      const feeInclusive = this.feeInclusive;
+      const count = this.count;
+      const intervalUnit = this.intervalUnit;
+      const startDate = this.startDate;
+      const endDate = this.endDate;
+      const serviceType = this.serviceType;
+      const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+      if (!token2) {
+        throw new Error("Token not supported.");
+      }
+      if (!chainId || !count || !intervalUnit || !startDate || !endDate) {
+        throw new Error("Invalid parameters.");
+      }
+      const approval = yield this.account.signRecurringPayments({
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        feeInclusive,
+        count,
+        intervalUnit,
+        startDate,
+        endDate,
+        receiver
+      });
+      const txn = yield scheduleRecurringPaymentsAPICall(
+        `${transactionServiceUrl}schedule/recurring`,
+        {
+          amount,
+          chainId,
+          feeInclusive,
+          intervalCount: count,
+          intervalUnit,
+          senderAddress: signerAddress,
+          receiverAddress: receiver,
+          tokenAddress: token2.address,
+          startAt: startDate,
+          endAt: endDate,
+          approval,
+          serviceParams: servicePaymentParams,
+          serviceType
+        }
+      );
+      return txn.recurringTransaction.id;
+    });
+  }
+};
+export {
+  ActaAccount,
+  ActaDeposit,
+  ConnectorType,
+  HttpMethod,
+  PolicyFlags,
+  TokenLogo,
+  ViemClient,
+  arbitrumDAI,
+  arbitrumETH,
+  arbitrumUSDC,
+  arbitrumUSDCe,
+  arbitrumUSDT,
+  arbitrumWETH,
+  base64ToBytes,
+  baseDAI,
+  baseETH,
+  baseEURC,
+  baseUSDC,
+  baseUSDT,
+  baseUSDbC,
+  baseWETH,
+  bscBNB,
+  bscUSDC,
+  bscUSDT,
+  bscWBNB,
+  bytesToBase64,
+  createPolicyFromParams,
+  createSessionAPICall,
+  decodeParamsFromInitCode,
+  deserializePermissionAccount,
+  deserializePermissionAccountParams,
+  ethereumDAI,
+  ethereumETH,
+  ethereumEURC,
+  ethereumUSDC,
+  ethereumUSDT,
+  ethereumWETH,
+  executeSinglePaymentAPICall,
+  getChainById,
+  getChainExplorerByChainId,
+  getPeriodInterval,
+  getPimlicoRpcByChainId,
+  getRpcByChainId,
+  getTokenByChainIdAndSymbol,
+  isKernelVersionAfter,
+  isPermissionValidatorPlugin,
+  lineaDAI,
+  lineaETH,
+  lineaUSDC,
+  lineaWETH,
+  optimismDAI,
+  optimismETH,
+  optimismUSDC,
+  optimismUSDCe,
+  optimismUSDT,
+  optimismWETH,
+  polygonDAI,
+  polygonPOL,
+  polygonUSDC,
+  polygonUSDCe,
+  polygonUSDT,
+  polygonWETH,
+  polygonWPOL,
+  scheduleRecurringPaymentsAPICall,
+  sendRequest,
+  serializePermissionAccount,
+  serializePermissionAccountParams,
+  supportedChains,
+  supportedTokensByChain,
+  toECDSASigner,
+  toPermissionValidator,
+  toPolicyId,
+  toSignerId,
+  token,
+  tokensCommonSymbols,
+  verifySessionAPICall
+};