@actalink/sdkv2 0.1.0

package/dist/index.js

@@ -0,0 +1,1528 @@
+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,
+  sepolia as sepolia2,
+  polygonAmoy as polygonAmoy2,
+  baseSepolia as baseSepolia2
+} from "viem/chains";
+
+// src/chains.ts
+import { baseSepolia, polygonAmoy, sepolia } from "viem/chains";
+import { arbitrum, base, bsc, optimism, polygon, mainnet } from "viem/chains";
+var supportedChains = [
+  arbitrum,
+  base,
+  bsc,
+  mainnet,
+  optimism,
+  polygon
+];
+var mainnetChains = [arbitrum, base, bsc, mainnet, optimism, polygon];
+var testnetChains = [sepolia, baseSepolia, polygonAmoy];
+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/schema.ts
+import { z } from "zod";
+import { isAddress } from "viem";
+var ProviderConfigSchema = z.object({
+  type: z.enum(["alchemy", "infura", "quicknode", "other"]),
+  apiKey: z.string().min(1, "API key is required"),
+  url: z.string().url().optional()
+});
+var ActaAccessConfigSchema = z.object({
+  projectId: z.string().min(1, "projectId is required")
+});
+var CreateSinglePaymentSchema = z.object({
+  signerAddress: z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  chainId: z.union([
+    z.literal(1),
+    z.literal(42161),
+    z.literal(8453),
+    z.literal(59144),
+    z.literal(56),
+    z.literal(10),
+    z.literal(137)
+  ]),
+  publicClient: z.custom(
+    (val) => val !== void 0,
+    "Invalid PublicClient Instance"
+  ),
+  walletClient: z.custom(
+    (val) => val !== void 0,
+    "Invalid WalletClient Instance"
+  ),
+  token: z.enum(["USDC", "USDT"]),
+  amount: z.bigint().refine((v) => v > BigInt(0), "Amount must be positive"),
+  receiver: z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  allowMaxTokenApproval: z.boolean()
+});
+var CreateRecurringPaymentSchema = z.object({
+  signerAddress: z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  chainId: z.union([
+    z.literal(1),
+    z.literal(42161),
+    z.literal(8453),
+    z.literal(59144),
+    z.literal(56),
+    z.literal(10),
+    z.literal(137)
+  ]),
+  publicClient: z.custom(
+    (val) => val !== void 0,
+    "Invalid PublicClient Instance"
+  ),
+  walletClient: z.custom(
+    (val) => val !== void 0,
+    "Invalid WalletClient Instance"
+  ),
+  token: z.enum(["USDC", "USDT"]),
+  amount: z.bigint().refine((v) => v > BigInt(0), "Amount must be positive"),
+  receiver: z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  allowMaxTokenApproval: z.boolean(),
+  count: z.number().int().positive(),
+  intervalUnit: z.enum(["day", "week", "month", "year"])
+});
+var EstimateSinglePaymentGasSchema = z.object({
+  signerAddress: z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  chainId: z.union([
+    z.literal(1),
+    z.literal(42161),
+    z.literal(8453),
+    z.literal(59144),
+    z.literal(56),
+    z.literal(10),
+    z.literal(137)
+  ]),
+  publicClient: z.custom(
+    (val) => val !== void 0,
+    "Invalid PublicClient Instance"
+  ),
+  walletClient: z.custom(
+    (val) => val !== void 0,
+    "Invalid WalletClient Instance"
+  ),
+  token: z.enum(["USDC", "USDT"]),
+  amount: z.bigint().refine((v) => v > BigInt(0), "Amount must be positive"),
+  receiver: z.string().refine((val) => isAddress(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val)
+});
+var PaymentStatusSchema = z.object({
+  id: z.string(),
+  status: z.enum(["pending", "success", "failed", "cancelled"]),
+  transactionHash: z.string().optional(),
+  error: z.string().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+var PollPaymentStatusSchema = z.object({
+  id: z.string().min(1, "Payment ID is required")
+});
+
+// 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://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var arbitrumUSDC = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),
+  name: "USD Coin",
+  symbol: "USDC",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var arbitrumDAI = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://api.acta.link/deposit/v1/logos/dai.png" /* DAI */
+});
+var arbitrumUSDT = token({
+  chainId: arbitrum2.id,
+  address: getAddress("0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var baseUSDC = token({
+  chainId: base2.id,
+  address: getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),
+  name: "USD Coin",
+  symbol: "USDC",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var baseEURC = token({
+  chainId: base2.id,
+  address: getAddress("0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42"),
+  decimals: 6,
+  fiatISO: "EUR",
+  name: "EURC",
+  symbol: "EURC",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/usdbc.png"
+});
+var baseDAI = token({
+  chainId: base2.id,
+  address: getAddress("0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"),
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  fiatISO: "USD",
+  decimals: 18,
+  logoURI: "https://api.acta.link/deposit/v1/logos/dai.png" /* DAI */
+});
+var baseUSDT = token({
+  chainId: base2.id,
+  address: getAddress("0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"),
+  name: "Tether USD",
+  symbol: "USDT",
+  fiatISO: "USD",
+  decimals: 6,
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdt.png" /* USDT */
+});
+var baseTokens = [baseUSDC, baseUSDT];
+var bscBNB = nativeToken({
+  chainId: bsc2.id,
+  name: "BNB",
+  symbol: "BNB",
+  logoURI: "https://api.acta.link/deposit/v1/logos/bnb.png" /* BNB */
+});
+var bscWBNB = token({
+  chainId: bsc2.id,
+  address: getAddress("0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"),
+  decimals: 18,
+  name: "Wrapped BNB",
+  symbol: "WBNB",
+  logoURI: "https://api.acta.link/deposit/v1/logos/bnb.png" /* BNB */
+});
+var bscUSDC = token({
+  chainId: bsc2.id,
+  address: getAddress("0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var bscUSDT = token({
+  chainId: bsc2.id,
+  address: getAddress("0x55d398326f99059fF775485246999027B3197955"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var ethereumUSDC = token({
+  chainId: mainnet2.id,
+  address: getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var ethereumDAI = token({
+  chainId: mainnet2.id,
+  address: getAddress("0x6B175474E89094C44Da98b954EedeAC495271d0F"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://api.acta.link/deposit/v1/logos/dai.png" /* DAI */
+});
+var ethereumUSDT = token({
+  chainId: mainnet2.id,
+  address: getAddress("0xdAC17F958D2ee523a2206206994597C13D831ec7"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdt.png" /* USDT */
+});
+var ethereumEURC = token({
+  chainId: mainnet2.id,
+  address: getAddress("0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c"),
+  decimals: 6,
+  fiatISO: "EUR",
+  name: "EURC",
+  symbol: "EURC",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var lineaUSDC = token({
+  chainId: linea.id,
+  address: getAddress("0x176211869cA2b568f2A7D4EE941E073a821EE1ff"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var lineaDAI = token({
+  chainId: linea.id,
+  address: getAddress("0x4AF15ec2A0BD43Db75dd04E62FAA3B8EF36b00d5"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var optimismUSDC = token({
+  chainId: optimism2.id,
+  address: getAddress("0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var optimismDAI = token({
+  chainId: optimism2.id,
+  address: getAddress("0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://api.acta.link/deposit/v1/logos/dai.png" /* DAI */
+});
+var optimismUSDT = token({
+  chainId: optimism2.id,
+  address: getAddress("0x94b008aA00579c1307B0EF2c499aD98a8ce58e58"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var optimismTokens = [optimismUSDC, optimismUSDT];
+var polygonPOL = nativeToken({
+  chainId: polygon2.id,
+  name: "Polygon",
+  symbol: "POL",
+  logoURI: "https://api.acta.link/deposit/v1/logos/pol.png" /* POL */
+});
+var polygonWPOL = token({
+  chainId: polygon2.id,
+  address: getAddress("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+  decimals: 18,
+  name: "Wrapped Polygon",
+  symbol: "WPOL",
+  logoURI: "https://api.acta.link/deposit/v1/logos/pol.png" /* POL */
+});
+var polygonWETH = token({
+  chainId: polygon2.id,
+  address: getAddress("0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var polygonUSDC = token({
+  chainId: polygon2.id,
+  address: getAddress("0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "USD Coin",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var polygonDAI = token({
+  chainId: polygon2.id,
+  address: getAddress("0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063"),
+  decimals: 18,
+  fiatISO: "USD",
+  name: "Dai Stablecoin",
+  symbol: "DAI",
+  logoURI: "https://api.acta.link/deposit/v1/logos/dai.png" /* DAI */
+});
+var polygonUSDT = token({
+  chainId: polygon2.id,
+  address: getAddress("0xc2132D05D31c914a87C6611C10748AEb04B58e8F"),
+  decimals: 6,
+  fiatISO: "USD",
+  name: "Tether USD",
+  symbol: "USDT",
+  logoURI: "https://api.acta.link/deposit/v1/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://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var polygonTokens = [polygonUSDC, polygonUSDT];
+var polygonAmoyUSDC = token({
+  chainId: polygonAmoy2.id,
+  address: getAddress("0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582"),
+  decimals: 6,
+  fiatISO: "USDC",
+  name: "USDC",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var baseSepoliaUSDC = token({
+  chainId: baseSepolia2.id,
+  address: getAddress("0x036CbD53842c5426634e7929541eC2318f3dCF7e"),
+  decimals: 6,
+  fiatISO: "USDC",
+  name: "USDC",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+var sepoliaUSDC = token({
+  chainId: sepolia2.id,
+  address: getAddress("0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"),
+  decimals: 6,
+  fiatISO: "USDC",
+  name: "USDC",
+  symbol: "USDC",
+  logoURI: "https://api.acta.link/deposit/v1/logos/usdc.png" /* USDC */
+});
+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]
+]);
+function nativeETH(chainId) {
+  return nativeToken({
+    chainId,
+    name: "Ether",
+    symbol: "ETH",
+    logoURI: "https://api.acta.link/deposit/v1/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"
+];
+function getTokenByChainIdAndAddress(chainId, address) {
+  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.address === address);
+  if (!token2)
+    throw new Error(`Token ${address} not found for chain ${chainId}.`);
+  return token2;
+}
+
+// src/account.ts
+import {
+  http,
+  getAddress as getAddress2,
+  parseAbi as parseAbi2
+} from "viem";
+import {
+  createPaymasterClient,
+  formatUserOperationRequest
+} from "viem/account-abstraction";
+import {
+  addressToEmptyAccount,
+  createKernelAccount,
+  createKernelAccountClient
+} from "@zerodev/sdk";
+import { getEntryPoint, KERNEL_V3_1 } from "@zerodev/sdk/constants";
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import { createSmartAccountClient, getRequiredPrefund } from "permissionless";
+import { createPimlicoClient } from "permissionless/clients/pimlico";
+
+// src/rpc.ts
+function getPimlicoRpcByChainId(chainId) {
+  switch (chainId) {
+    case 1:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 10:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 56:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 137:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 8453:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 42161:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 59144:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 80002:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 84532:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    case 11155111:
+      return `https://api.pimlico.io/v2/${chainId}/rpc?apikey=pim_Jjg9Mp3i5LPCvgSyqXKK5T`;
+    default:
+      return void 0;
+  }
+}
+
+// src/viemClient.ts
+import {
+  parseAbi,
+  encodeFunctionData,
+  maxUint256
+} from "viem";
+var ViemClient = class {
+  constructor(walletClient, publicClient) {
+    this.walletClient = walletClient;
+    this.publicClient = publicClient;
+  }
+  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, allowMaxTokenApproval) {
+    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;
+      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, allowMaxTokenApproval ? maxUint256 : amount]
+          })
+        });
+        const receipt = yield this.publicClient.waitForTransactionReceipt({
+          hash: txn,
+          confirmations: token2.chainId === 1 || 11155111 ? 1 : 5
+        });
+        return amount;
+      }
+      return allowance;
+    });
+  }
+};
+
+// src/account.ts
+import { toECDSASigner } from "@zerodev/permissions/signers";
+import {
+  serializePermissionAccount,
+  toPermissionValidator
+} from "@zerodev/permissions";
+import {
+  toCallPolicy,
+  CallPolicyVersion,
+  ParamCondition
+} from "@zerodev/permissions/policies";
+var ActaAccount = class {
+  constructor(publicClient, signer) {
+    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 createKernelAccount(this.publicClient, {
+        plugins: {
+          sudo: ecdsaValidator
+        },
+        entryPoint,
+        kernelVersion
+      });
+      return account;
+    });
+  }
+  createAccountHelpers() {
+    return __async(this, null, function* () {
+      var _a;
+      const chainId = (_a = this.publicClient.chain) == null ? void 0 : _a.id;
+      if (!chainId) {
+        throw new Error("Invalid PublicClient Instance.");
+      }
+      const account = yield this.createAccount();
+      const entryPoint = getEntryPoint("0.7");
+      const paymasterClient = createPaymasterClient({
+        transport: http(getPimlicoRpcByChainId(chainId))
+      });
+      const pimlicoClient = createPimlicoClient({
+        chain: getChainById(chainId),
+        transport: http(getPimlicoRpcByChainId(chainId)),
+        entryPoint
+      });
+      const accountClient = createSmartAccountClient({
+        account,
+        chain: getChainById(chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: http(getPimlicoRpcByChainId(chainId)),
+        userOperation: {
+          estimateFeesPerGas: () => __async(this, null, function* () {
+            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
+          })
+        }
+      });
+      const kernelAccountClient = createKernelAccountClient({
+        account,
+        chain: getChainById(chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: http(getPimlicoRpcByChainId(chainId)),
+        userOperation: {
+          estimateFeesPerGas: () => __async(this, null, function* () {
+            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
+          })
+        }
+      });
+      return {
+        paymasterClient,
+        pimlicoClient,
+        accountClient,
+        kernelAccountClient
+      };
+    });
+  }
+  estimateSinglePaymentGas(parameters) {
+    return __async(this, null, function* () {
+      const {
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver,
+        feebps
+      } = 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 userOperation = yield accountClient.prepareUserOperation({
+        calls: [
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [
+              fromAddress,
+              "0x26eeCa5956Bf8C01040BAC9e6D7982a0e87F31B4",
+              BigInt(0)
+            ]
+          },
+          {
+            to: getAddress2(token2.address),
+            abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [fromAddress, receiver, BigInt(0)]
+          }
+        ]
+      });
+      const quotes = yield pimlicoClient.getTokenQuotes({
+        tokens: [token2.address],
+        chain: getChainById(chainId)
+      });
+      const userOperationMaxCost = getRequiredPrefund({
+        userOperation,
+        entryPointVersion: "0.7"
+      });
+      const postOpGas = quotes[0].postOpGas;
+      const exchangeRate = quotes[0].exchangeRate;
+      const exchangeRateNativeToUsd = quotes[0].exchangeRateNativeToUsd;
+      const maxCostInWei = userOperationMaxCost + postOpGas * userOperation.maxFeePerGas;
+      const costInToken = maxCostInWei * exchangeRate / BigInt(1e18);
+      const costInUsd = maxCostInWei * exchangeRateNativeToUsd / BigInt(1e18);
+      const ActalinkFeesInToken = amount * BigInt(feebps) / BigInt(1e4);
+      const estimatedTotalFeesInToken = costInToken + ActalinkFeesInToken;
+      const feeInclusiveAmountInToken = amount - estimatedTotalFeesInToken;
+      const feeExclusiveAmountInToken = amount + estimatedTotalFeesInToken;
+      return {
+        estimatedGasCostInToken: costInToken,
+        ActalinkFeesInToken,
+        estimatedTotalFeesInToken,
+        feeInclusiveAmountInToken,
+        feeExclusiveAmountInToken,
+        paymaster: quotes[0].paymaster,
+        userOperation
+      };
+    });
+  }
+  signSinglePaymentOperation(singlePaymentParams) {
+    return __async(this, null, function* () {
+      try {
+        if (!this.signer) {
+          throw new Error("Signer is required for self custody payments.");
+        }
+        const {
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feeInclusive,
+          allowMaxTokenApproval,
+          feebps,
+          signerAddress,
+          publicClient,
+          walletClient
+        } = 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(walletClient, publicClient);
+        const {
+          feeInclusiveAmountInToken,
+          feeExclusiveAmountInToken,
+          estimatedTotalFeesInToken
+        } = yield this.estimateSinglePaymentGas({
+          signerAddress,
+          chainId,
+          token: tokenSymbol,
+          amount,
+          receiver,
+          feebps,
+          publicClient,
+          walletClient
+        });
+        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,
+          allowMaxTokenApproval != null ? allowMaxTokenApproval : false
+        );
+        const userOperation = yield accountClient.prepareUserOperation({
+          calls: [
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [
+                fromAddress,
+                "0x26eeCa5956Bf8C01040BAC9e6D7982a0e87F31B4",
+                estimatedTotalFeesInToken
+              ]
+            },
+            {
+              to: getAddress2(token2.address),
+              abi: parseAbi2(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [fromAddress, receiver, receiverAmount]
+            }
+          ]
+        });
+        const signature = yield account.signUserOperation(__spreadProps(__spreadValues({}, userOperation), {
+          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,
+        count,
+        intervalUnit,
+        allowMaxTokenApproval,
+        feebps,
+        feeInclusive,
+        publicClient,
+        walletClient
+      } = recurringPaymentParams;
+      if (amount <= BigInt(0)) {
+        throw new Error("Amount must be greater than 0.");
+      }
+      if (!signerAddress) {
+        throw new Error("Signer Connot be empty");
+      }
+      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(walletClient, publicClient);
+      const ecdsaValidator = yield signerToEcdsaValidator(this.publicClient, {
+        entryPoint,
+        kernelVersion,
+        signer: this.signer
+      });
+      const sessionKeyAddress = "0xFDEed8e268D74DF71f3Db7409F8A8290FF1263ED";
+      const emptyAccount = addressToEmptyAccount(sessionKeyAddress);
+      const emptySessionKeySigner = yield toECDSASigner({ signer: emptyAccount });
+      const { feeExclusiveAmountInToken, estimatedGasCostInToken } = yield this.estimateSinglePaymentGas({
+        signerAddress,
+        chainId,
+        token: tokenSymbol,
+        amount,
+        receiver,
+        feebps,
+        publicClient,
+        walletClient
+      });
+      const amountToTransfer = feeInclusive ? amount : feeExclusiveAmountInToken;
+      yield viemClient.checkAndApproveToken(
+        token2,
+        smartAccountAddress,
+        amountToTransfer * BigInt(paymentCount) + estimatedGasCostInToken * BigInt(2) * BigInt(paymentCount),
+        allowMaxTokenApproval != null ? allowMaxTokenApproval : false
+      );
+      const amountExclusive = amountToTransfer + amountToTransfer / BigInt(2);
+      const callPolicy = toCallPolicy({
+        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: getAddress2(signerAddress)
+              },
+              {
+                condition: ParamCondition.ONE_OF,
+                value: [
+                  "0x26eeCa5956Bf8C01040BAC9e6D7982a0e87F31B4",
+                  getAddress2(receiver)
+                ]
+              },
+              {
+                condition: ParamCondition.LESS_THAN_OR_EQUAL,
+                value: amountExclusive
+              }
+            ]
+          }
+        ]
+      });
+      const permissionPlugin = yield toPermissionValidator(this.publicClient, {
+        entryPoint,
+        kernelVersion,
+        signer: emptySessionKeySigner,
+        policies: [callPolicy]
+      });
+      const serializedSessionKeyAccount = yield createKernelAccount(
+        this.publicClient,
+        {
+          entryPoint,
+          kernelVersion,
+          plugins: {
+            sudo: ecdsaValidator,
+            regular: permissionPlugin
+          }
+        }
+      );
+      const approval = yield serializePermissionAccount(
+        serializedSessionKeyAccount
+      );
+      return { approval, amountExclusive };
+    });
+  }
+};
+
+// src/api.ts
+var HttpMethod = /* @__PURE__ */ ((HttpMethod2) => {
+  HttpMethod2["GET"] = "GET";
+  HttpMethod2["POST"] = "POST";
+  HttpMethod2["DELETE"] = "DELETE";
+  HttpMethod2["PUT"] = "PUT";
+  HttpMethod2["PATCH"] = "PATCH";
+  return HttpMethod2;
+})(HttpMethod || {});
+function sendRequest(_0) {
+  return __async(this, arguments, function* ({
+    url,
+    method,
+    body,
+    headers = {}
+  }) {
+    var _a, _b, _c, _d;
+    try {
+      const isGet = method === "GET" /* GET */;
+      const response = yield fetch(url, {
+        method,
+        headers: __spreadValues({
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        }, headers),
+        body: isGet ? void 0 : JSON.stringify(body)
+      });
+      const contentType = (_a = response.headers.get("content-type")) != null ? _a : "";
+      let result = null;
+      if (contentType.includes("application/json")) {
+        result = yield response.json().catch(() => null);
+      }
+      if (!response.ok) {
+        return {
+          error: {
+            code: response.status,
+            message: (_b = result == null ? void 0 : result.error) != null ? _b : response.statusText
+          },
+          status: response.status
+        };
+      }
+      return {
+        data: (_c = result == null ? void 0 : result.data) != null ? _c : result,
+        message: (_d = result == null ? void 0 : result.message) != null ? _d : "Success",
+        status: response.status
+      };
+    } catch (err) {
+      return {
+        error: {
+          code: 0,
+          message: err instanceof Error ? err.message : "Network error or unexpected failure"
+        },
+        status: 0
+      };
+    }
+  });
+}
+function scheduleRecurringPaymentsAPICall(url, params) {
+  return __async(this, null, function* () {
+    const parsedParams = __spreadProps(__spreadValues({}, params), {
+      amount: params.amount,
+      amountExclusive: params.amountExclusive
+    });
+    const response = yield sendRequest({
+      url,
+      method: "POST" /* POST */,
+      body: { paymentParams: parsedParams }
+    });
+    return response.data;
+  });
+}
+function executeSinglePaymentAPICall(url, userOperation, paymentParams) {
+  return __async(this, null, function* () {
+    const params = {
+      userOperation,
+      paymentParams
+    };
+    const response = yield sendRequest({
+      url,
+      method: "POST" /* POST */,
+      body: params
+    });
+    return response.data;
+  });
+}
+function fetchRecurringTransactionWithId(url) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({ url, method: "GET" /* GET */ });
+    return response.data;
+  });
+}
+function fetchPaymentStatus(url, id) {
+  return __async(this, null, function* () {
+    const response = yield sendRequest({
+      url: `${url}?id=${encodeURIComponent(id)}`,
+      method: "GET" /* GET */
+    });
+    return response.data;
+  });
+}
+function waitForPaymentStatus(url, id, intervalMs = 2e3) {
+  return __async(this, null, function* () {
+    return new Promise((resolve, reject) => __async(null, null, function* () {
+      const poll = () => __async(null, null, function* () {
+        try {
+          const status = yield fetchPaymentStatus(url, id);
+          if (status == null ? void 0 : status.error) {
+            reject(new Error(status.error));
+            return;
+          }
+          if ((status == null ? void 0 : status.status) === "success" || (status == null ? void 0 : status.status) === "failed" || (status == null ? void 0 : status.status) === "cancelled") {
+            resolve(status);
+            return;
+          }
+          if ((status == null ? void 0 : status.status) === "pending") {
+            setTimeout(poll, intervalMs);
+          } else {
+            reject(new Error(`Unknown payment status: ${status == null ? void 0 : status.status}`));
+          }
+        } catch (error) {
+          reject(
+            error instanceof Error ? error : new Error("Unknown error occurred")
+          );
+        }
+      });
+      poll();
+    }));
+  });
+}
+
+// src/execution/access.ts
+import { toHex } from "viem";
+
+// src/constants.ts
+var ACCESS_URL = "https://api.acta.link/deposit";
+
+// src/execution/access.ts
+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");
+  }
+};
+function estimateSinglePaymentGasInternal(parameters) {
+  return __async(this, null, function* () {
+    const { publicClient, walletClient } = parameters;
+    const accountInstance = new ActaAccount(publicClient, walletClient);
+    const {
+      estimatedGasCostInToken,
+      ActalinkFeesInToken,
+      feeInclusiveAmountInToken,
+      feeExclusiveAmountInToken,
+      estimatedTotalFeesInToken,
+      paymaster,
+      userOperation
+    } = yield accountInstance.estimateSinglePaymentGas(parameters);
+    return {
+      estimatedGasCostInToken,
+      ActalinkFeesInToken,
+      feeInclusiveAmountInToken,
+      feeExclusiveAmountInToken,
+      estimatedTotalFeesInToken,
+      paymaster,
+      userOperation
+    };
+  });
+}
+function createOnetimePaymentInternal(parameters) {
+  return __async(this, null, function* () {
+    const {
+      signerAddress,
+      receiver,
+      amount,
+      token: tokenSymbol,
+      chainId,
+      feebps,
+      publicClient,
+      walletClient,
+      allowMaxTokenApproval,
+      projectId
+    } = parameters;
+    const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+    if (!token2) {
+      throw new Error("Token not supported.");
+    }
+    const accountInstance = new ActaAccount(publicClient, walletClient);
+    const rpcParameters = yield accountInstance.signSinglePaymentOperation({
+      signerAddress,
+      chainId,
+      token: tokenSymbol,
+      amount,
+      receiver,
+      feeInclusive: false,
+      allowMaxTokenApproval,
+      feebps,
+      publicClient,
+      walletClient
+    });
+    const data = yield executeSinglePaymentAPICall(
+      `${ACCESS_URL}/api/v1/execute/single`,
+      rpcParameters,
+      {
+        amount: toHex(amount),
+        chainId,
+        feeInclusive: false,
+        projectId,
+        receiver,
+        signerAddress,
+        token: token2.address
+      }
+    );
+    return data.id;
+  });
+}
+function createRecurringePaymentInternal(parameters) {
+  return __async(this, null, function* () {
+    const {
+      signerAddress,
+      receiver,
+      amount,
+      token: tokenSymbol,
+      chainId,
+      feebps,
+      publicClient,
+      walletClient,
+      allowMaxTokenApproval,
+      count,
+      intervalUnit,
+      projectId
+    } = parameters;
+    const token2 = getTokenByChainIdAndSymbol(chainId, tokenSymbol);
+    if (!token2) {
+      throw new Error("Token not supported.");
+    }
+    const accountInstance = new ActaAccount(publicClient, walletClient);
+    const { approval, amountExclusive } = yield accountInstance.signRecurringPayments({
+      signerAddress,
+      chainId,
+      token: tokenSymbol,
+      amount,
+      receiver,
+      feeInclusive: false,
+      allowMaxTokenApproval,
+      feebps,
+      publicClient,
+      walletClient,
+      count,
+      intervalUnit
+    });
+    const startAt = Math.floor(Date.now() / 1e3) + 2 * 60;
+    const data = yield scheduleRecurringPaymentsAPICall(
+      `${ACCESS_URL}/api/v1/schedule/recurring`,
+      {
+        senderAddress: signerAddress,
+        receiverAddress: receiver,
+        chainId,
+        amount: toHex(amount),
+        amountExclusive: toHex(amountExclusive),
+        approval,
+        feeInclusive: false,
+        tokenAddress: token2.address,
+        intervalUnit,
+        intervalCount: count,
+        startAt,
+        endAt: startAt + getPeriodInterval(intervalUnit) * count,
+        projectId
+      }
+    );
+    return data.id;
+  });
+}
+
+// src/access.ts
+var ActaAccessSDK = class {
+  constructor(parameters) {
+    this.projectId = parameters.projectId;
+  }
+  estimateSinglePaymentGasInToken(parameters) {
+    return __async(this, null, function* () {
+      try {
+        const result = EstimateSinglePaymentGasSchema.parse(parameters);
+        const { estimatedTotalFeesInToken } = yield estimateSinglePaymentGasInternal(__spreadProps(__spreadValues({}, result), { feebps: 10 }));
+        return estimatedTotalFeesInToken;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to estimate single payment gas.");
+      }
+    });
+  }
+  createOnetimePayment(parameters) {
+    return __async(this, null, function* () {
+      try {
+        const result = CreateSinglePaymentSchema.parse(parameters);
+        const id = yield createOnetimePaymentInternal(__spreadProps(__spreadValues({}, result), {
+          feebps: 10,
+          projectId: this.projectId
+        }));
+        return id;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create onetime payment");
+      }
+    });
+  }
+  createRecurringPayment(parameters) {
+    return __async(this, null, function* () {
+      try {
+        const result = CreateRecurringPaymentSchema.parse(parameters);
+        const id = yield createRecurringePaymentInternal(__spreadProps(__spreadValues({}, result), {
+          feebps: 10,
+          projectId: this.projectId
+        }));
+        return id;
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to create onetime payment");
+      }
+    });
+  }
+  waitForPaymentStatus(id, intervalMs = 2e3) {
+    return __async(this, null, function* () {
+      try {
+        const result = PollPaymentStatusSchema.parse({ id });
+        return yield waitForPaymentStatus(
+          `${ACCESS_URL}/api/v1/payment/status`,
+          result.id,
+          intervalMs
+        );
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(error.message);
+        }
+        throw new Error("Failed to wait for payment status");
+      }
+    });
+  }
+};
+export {
+  ActaAccessSDK,
+  ActaAccount,
+  HttpMethod,
+  ViemClient,
+  arbitrumDAI,
+  arbitrumETH,
+  arbitrumUSDC,
+  arbitrumUSDCe,
+  arbitrumUSDT,
+  arbitrumWETH,
+  baseDAI,
+  baseETH,
+  baseEURC,
+  baseSepoliaUSDC,
+  baseUSDC,
+  baseUSDT,
+  baseUSDbC,
+  baseWETH,
+  bscBNB,
+  bscUSDC,
+  bscUSDT,
+  bscWBNB,
+  ethereumDAI,
+  ethereumETH,
+  ethereumEURC,
+  ethereumUSDC,
+  ethereumUSDT,
+  ethereumWETH,
+  executeSinglePaymentAPICall,
+  fetchPaymentStatus,
+  fetchRecurringTransactionWithId,
+  getChainById,
+  getChainExplorerByChainId,
+  getPimlicoRpcByChainId,
+  getTokenByChainIdAndAddress,
+  getTokenByChainIdAndSymbol,
+  lineaDAI,
+  lineaETH,
+  lineaUSDC,
+  lineaWETH,
+  mainnetChains,
+  optimismDAI,
+  optimismETH,
+  optimismUSDC,
+  optimismUSDCe,
+  optimismUSDT,
+  optimismWETH,
+  polygonAmoyUSDC,
+  polygonDAI,
+  polygonPOL,
+  polygonUSDC,
+  polygonUSDCe,
+  polygonUSDT,
+  polygonWETH,
+  polygonWPOL,
+  scheduleRecurringPaymentsAPICall,
+  sendRequest,
+  sepoliaUSDC,
+  supportedChains,
+  supportedTokensByChain,
+  testnetChains,
+  token,
+  tokensCommonSymbols,
+  waitForPaymentStatus
+};