@actalink/sdkv2 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1582 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActaAccessSDK: () => ActaAccessSDK,
+  ActaAccount: () => ActaAccount,
+  HttpMethod: () => HttpMethod,
+  ViemClient: () => ViemClient,
+  arbitrumDAI: () => arbitrumDAI,
+  arbitrumETH: () => arbitrumETH,
+  arbitrumUSDC: () => arbitrumUSDC,
+  arbitrumUSDCe: () => arbitrumUSDCe,
+  arbitrumUSDT: () => arbitrumUSDT,
+  arbitrumWETH: () => arbitrumWETH,
+  baseDAI: () => baseDAI,
+  baseETH: () => baseETH,
+  baseEURC: () => baseEURC,
+  baseSepoliaUSDC: () => baseSepoliaUSDC,
+  baseUSDC: () => baseUSDC,
+  baseUSDT: () => baseUSDT,
+  baseUSDbC: () => baseUSDbC,
+  baseWETH: () => baseWETH,
+  bscBNB: () => bscBNB,
+  bscUSDC: () => bscUSDC,
+  bscUSDT: () => bscUSDT,
+  bscWBNB: () => bscWBNB,
+  ethereumDAI: () => ethereumDAI,
+  ethereumETH: () => ethereumETH,
+  ethereumEURC: () => ethereumEURC,
+  ethereumUSDC: () => ethereumUSDC,
+  ethereumUSDT: () => ethereumUSDT,
+  ethereumWETH: () => ethereumWETH,
+  executeSinglePaymentAPICall: () => executeSinglePaymentAPICall,
+  fetchPaymentStatus: () => fetchPaymentStatus,
+  fetchRecurringTransactionWithId: () => fetchRecurringTransactionWithId,
+  getChainById: () => getChainById,
+  getChainExplorerByChainId: () => getChainExplorerByChainId,
+  getPimlicoRpcByChainId: () => getPimlicoRpcByChainId,
+  getTokenByChainIdAndAddress: () => getTokenByChainIdAndAddress,
+  getTokenByChainIdAndSymbol: () => getTokenByChainIdAndSymbol,
+  lineaDAI: () => lineaDAI,
+  lineaETH: () => lineaETH,
+  lineaUSDC: () => lineaUSDC,
+  lineaWETH: () => lineaWETH,
+  mainnetChains: () => mainnetChains,
+  optimismDAI: () => optimismDAI,
+  optimismETH: () => optimismETH,
+  optimismUSDC: () => optimismUSDC,
+  optimismUSDCe: () => optimismUSDCe,
+  optimismUSDT: () => optimismUSDT,
+  optimismWETH: () => optimismWETH,
+  polygonAmoyUSDC: () => polygonAmoyUSDC,
+  polygonDAI: () => polygonDAI,
+  polygonPOL: () => polygonPOL,
+  polygonUSDC: () => polygonUSDC,
+  polygonUSDCe: () => polygonUSDCe,
+  polygonUSDT: () => polygonUSDT,
+  polygonWETH: () => polygonWETH,
+  polygonWPOL: () => polygonWPOL,
+  scheduleRecurringPaymentsAPICall: () => scheduleRecurringPaymentsAPICall,
+  sendRequest: () => sendRequest,
+  sepoliaUSDC: () => sepoliaUSDC,
+  supportedChains: () => supportedChains,
+  supportedTokensByChain: () => supportedTokensByChain,
+  testnetChains: () => testnetChains,
+  token: () => token,
+  tokensCommonSymbols: () => tokensCommonSymbols,
+  waitForPaymentStatus: () => waitForPaymentStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tokens.ts
+var import_viem2 = require("viem");
+var import_chains3 = require("viem/chains");
+
+// src/chains.ts
+var import_chains = require("viem/chains");
+var import_chains2 = require("viem/chains");
+var supportedChains = [
+  import_chains2.arbitrum,
+  import_chains2.base,
+  import_chains2.bsc,
+  import_chains2.mainnet,
+  import_chains2.optimism,
+  import_chains2.polygon
+];
+var mainnetChains = [import_chains2.arbitrum, import_chains2.base, import_chains2.bsc, import_chains2.mainnet, import_chains2.optimism, import_chains2.polygon];
+var testnetChains = [import_chains.sepolia, import_chains.baseSepolia, import_chains.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 import_chains2.arbitrum.id:
+      return "https://arbiscan.io";
+    case import_chains2.base.id:
+      return "https://basescan.org";
+    case import_chains2.bsc.id:
+      return "https://bscscan.com";
+    case import_chains2.mainnet.id:
+      return "https://etherscan.io";
+    case import_chains2.optimism.id:
+      return "https://optimistic.etherscan.io";
+    case import_chains2.polygon.id:
+      return "https://polygonscan.com";
+    default:
+      return void 0;
+  }
+}
+
+// src/types/schema.ts
+var import_zod = require("zod");
+var import_viem = require("viem");
+var ProviderConfigSchema = import_zod.z.object({
+  type: import_zod.z.enum(["alchemy", "infura", "quicknode", "other"]),
+  apiKey: import_zod.z.string().min(1, "API key is required"),
+  url: import_zod.z.string().url().optional()
+});
+var ActaAccessConfigSchema = import_zod.z.object({
+  projectId: import_zod.z.string().min(1, "projectId is required")
+});
+var CreateSinglePaymentSchema = import_zod.z.object({
+  signerAddress: import_zod.z.string().refine((val) => (0, import_viem.isAddress)(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  chainId: import_zod.z.union([
+    import_zod.z.literal(1),
+    import_zod.z.literal(42161),
+    import_zod.z.literal(8453),
+    import_zod.z.literal(59144),
+    import_zod.z.literal(56),
+    import_zod.z.literal(10),
+    import_zod.z.literal(137)
+  ]),
+  publicClient: import_zod.z.custom(
+    (val) => val !== void 0,
+    "Invalid PublicClient Instance"
+  ),
+  walletClient: import_zod.z.custom(
+    (val) => val !== void 0,
+    "Invalid WalletClient Instance"
+  ),
+  token: import_zod.z.enum(["USDC", "USDT"]),
+  amount: import_zod.z.bigint().refine((v) => v > BigInt(0), "Amount must be positive"),
+  receiver: import_zod.z.string().refine((val) => (0, import_viem.isAddress)(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  allowMaxTokenApproval: import_zod.z.boolean()
+});
+var CreateRecurringPaymentSchema = import_zod.z.object({
+  signerAddress: import_zod.z.string().refine((val) => (0, import_viem.isAddress)(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  chainId: import_zod.z.union([
+    import_zod.z.literal(1),
+    import_zod.z.literal(42161),
+    import_zod.z.literal(8453),
+    import_zod.z.literal(59144),
+    import_zod.z.literal(56),
+    import_zod.z.literal(10),
+    import_zod.z.literal(137)
+  ]),
+  publicClient: import_zod.z.custom(
+    (val) => val !== void 0,
+    "Invalid PublicClient Instance"
+  ),
+  walletClient: import_zod.z.custom(
+    (val) => val !== void 0,
+    "Invalid WalletClient Instance"
+  ),
+  token: import_zod.z.enum(["USDC", "USDT"]),
+  amount: import_zod.z.bigint().refine((v) => v > BigInt(0), "Amount must be positive"),
+  receiver: import_zod.z.string().refine((val) => (0, import_viem.isAddress)(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  allowMaxTokenApproval: import_zod.z.boolean(),
+  count: import_zod.z.number().int().positive(),
+  intervalUnit: import_zod.z.enum(["day", "week", "month", "year"])
+});
+var EstimateSinglePaymentGasSchema = import_zod.z.object({
+  signerAddress: import_zod.z.string().refine((val) => (0, import_viem.isAddress)(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val),
+  chainId: import_zod.z.union([
+    import_zod.z.literal(1),
+    import_zod.z.literal(42161),
+    import_zod.z.literal(8453),
+    import_zod.z.literal(59144),
+    import_zod.z.literal(56),
+    import_zod.z.literal(10),
+    import_zod.z.literal(137)
+  ]),
+  publicClient: import_zod.z.custom(
+    (val) => val !== void 0,
+    "Invalid PublicClient Instance"
+  ),
+  walletClient: import_zod.z.custom(
+    (val) => val !== void 0,
+    "Invalid WalletClient Instance"
+  ),
+  token: import_zod.z.enum(["USDC", "USDT"]),
+  amount: import_zod.z.bigint().refine((v) => v > BigInt(0), "Amount must be positive"),
+  receiver: import_zod.z.string().refine((val) => (0, import_viem.isAddress)(val), {
+    message: "Invalid Ethereum address"
+  }).transform((val) => val)
+});
+var PaymentStatusSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  status: import_zod.z.enum(["pending", "success", "failed", "cancelled"]),
+  transactionHash: import_zod.z.string().optional(),
+  error: import_zod.z.string().optional(),
+  createdAt: import_zod.z.string(),
+  updatedAt: import_zod.z.string()
+});
+var PollPaymentStatusSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1, "Payment ID is required")
+});
+
+// src/tokens.ts
+var arbitrumETH = nativeETH(import_chains3.arbitrum.id);
+var arbitrumWETH = token({
+  chainId: import_chains3.arbitrum.id,
+  address: (0, import_viem2.getAddress)("0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var arbitrumUSDC = token({
+  chainId: import_chains3.arbitrum.id,
+  address: (0, import_viem2.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: import_chains3.arbitrum.id,
+  address: (0, import_viem2.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: import_chains3.arbitrum.id,
+  address: (0, import_viem2.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: import_chains3.arbitrum.id,
+  address: (0, import_viem2.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(import_chains3.base.id);
+var baseWETH = token({
+  chainId: import_chains3.base.id,
+  address: (0, import_viem2.getAddress)("0x4200000000000000000000000000000000000006"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var baseUSDC = token({
+  chainId: import_chains3.base.id,
+  address: (0, import_viem2.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: import_chains3.base.id,
+  address: (0, import_viem2.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: import_chains3.base.id,
+  address: (0, import_viem2.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: import_chains3.base.id,
+  address: (0, import_viem2.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: import_chains3.base.id,
+  address: (0, import_viem2.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: import_chains3.bsc.id,
+  name: "BNB",
+  symbol: "BNB",
+  logoURI: "https://api.acta.link/deposit/v1/logos/bnb.png" /* BNB */
+});
+var bscWBNB = token({
+  chainId: import_chains3.bsc.id,
+  address: (0, import_viem2.getAddress)("0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c"),
+  decimals: 18,
+  name: "Wrapped BNB",
+  symbol: "WBNB",
+  logoURI: "https://api.acta.link/deposit/v1/logos/bnb.png" /* BNB */
+});
+var bscUSDC = token({
+  chainId: import_chains3.bsc.id,
+  address: (0, import_viem2.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: import_chains3.bsc.id,
+  address: (0, import_viem2.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(import_chains3.mainnet.id);
+var ethereumWETH = token({
+  chainId: import_chains3.mainnet.id,
+  address: (0, import_viem2.getAddress)("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var ethereumUSDC = token({
+  chainId: import_chains3.mainnet.id,
+  address: (0, import_viem2.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: import_chains3.mainnet.id,
+  address: (0, import_viem2.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: import_chains3.mainnet.id,
+  address: (0, import_viem2.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: import_chains3.mainnet.id,
+  address: (0, import_viem2.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(import_chains3.linea.id);
+var lineaWETH = token({
+  chainId: import_chains3.linea.id,
+  address: (0, import_viem2.getAddress)("0xe5d7c2a44ffddf6b295a15c148167daaaf5cf34f"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var lineaUSDC = token({
+  chainId: import_chains3.linea.id,
+  address: (0, import_viem2.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: import_chains3.linea.id,
+  address: (0, import_viem2.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(import_chains3.optimism.id);
+var optimismWETH = token({
+  chainId: import_chains3.optimism.id,
+  address: (0, import_viem2.getAddress)("0x4200000000000000000000000000000000000006"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var optimismUSDC = token({
+  chainId: import_chains3.optimism.id,
+  address: (0, import_viem2.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: import_chains3.optimism.id,
+  address: (0, import_viem2.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: import_chains3.optimism.id,
+  address: (0, import_viem2.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: import_chains3.optimism.id,
+  address: (0, import_viem2.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: import_chains3.polygon.id,
+  name: "Polygon",
+  symbol: "POL",
+  logoURI: "https://api.acta.link/deposit/v1/logos/pol.png" /* POL */
+});
+var polygonWPOL = token({
+  chainId: import_chains3.polygon.id,
+  address: (0, import_viem2.getAddress)("0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270"),
+  decimals: 18,
+  name: "Wrapped Polygon",
+  symbol: "WPOL",
+  logoURI: "https://api.acta.link/deposit/v1/logos/pol.png" /* POL */
+});
+var polygonWETH = token({
+  chainId: import_chains3.polygon.id,
+  address: (0, import_viem2.getAddress)("0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619"),
+  decimals: 18,
+  name: "Wrapped Ether",
+  symbol: "WETH",
+  logoURI: "https://api.acta.link/deposit/v1/logos/weth.png" /* WETH */
+});
+var polygonUSDC = token({
+  chainId: import_chains3.polygon.id,
+  address: (0, import_viem2.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: import_chains3.polygon.id,
+  address: (0, import_viem2.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: import_chains3.polygon.id,
+  address: (0, import_viem2.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: import_chains3.polygon.id,
+  address: (0, import_viem2.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: import_chains3.polygonAmoy.id,
+  address: (0, import_viem2.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: import_chains3.baseSepolia.id,
+  address: (0, import_viem2.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: import_chains3.sepolia.id,
+  address: (0, import_viem2.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([
+  [import_chains3.arbitrum.id, arbitrumTokens],
+  //done
+  [import_chains3.base.id, baseTokens],
+  //done
+  [import_chains3.bsc.id, bscTokens],
+  //done
+  [import_chains3.mainnet.id, ethereumTokens],
+  //done
+  [import_chains3.optimism.id, optimismTokens],
+  //done
+  [import_chains3.polygon.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 = import_viem2.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
+var import_viem4 = require("viem");
+var import_account_abstraction = require("viem/account-abstraction");
+var import_sdk = require("@zerodev/sdk");
+var import_constants = require("@zerodev/sdk/constants");
+var import_ecdsa_validator = require("@zerodev/ecdsa-validator");
+var import_permissionless = require("permissionless");
+var import_pimlico = require("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
+var import_viem3 = require("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: (0, import_viem3.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: (0, import_viem3.encodeFunctionData)({
+            abi: (0, import_viem3.parseAbi)(["function approve(address,uint)"]),
+            functionName: "approve",
+            args: [spender, allowMaxTokenApproval ? import_viem3.maxUint256 : amount]
+          })
+        });
+        const receipt = yield this.publicClient.waitForTransactionReceipt({
+          hash: txn,
+          confirmations: token2.chainId === 1 || 11155111 ? 1 : 5
+        });
+        return amount;
+      }
+      return allowance;
+    });
+  }
+};
+
+// src/account.ts
+var import_signers = require("@zerodev/permissions/signers");
+var import_permissions = require("@zerodev/permissions");
+var import_policies = require("@zerodev/permissions/policies");
+var ActaAccount = class {
+  constructor(publicClient, signer) {
+    this.signer = signer;
+    this.publicClient = publicClient;
+  }
+  createAccount() {
+    return __async(this, null, function* () {
+      const kernelVersion = import_constants.KERNEL_V3_1;
+      const entryPoint = (0, import_constants.getEntryPoint)("0.7");
+      const ecdsaValidator = yield (0, import_ecdsa_validator.signerToEcdsaValidator)(this.publicClient, {
+        signer: this.signer,
+        entryPoint,
+        kernelVersion
+      });
+      const account = yield (0, import_sdk.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 = (0, import_constants.getEntryPoint)("0.7");
+      const paymasterClient = (0, import_account_abstraction.createPaymasterClient)({
+        transport: (0, import_viem4.http)(getPimlicoRpcByChainId(chainId))
+      });
+      const pimlicoClient = (0, import_pimlico.createPimlicoClient)({
+        chain: getChainById(chainId),
+        transport: (0, import_viem4.http)(getPimlicoRpcByChainId(chainId)),
+        entryPoint
+      });
+      const accountClient = (0, import_permissionless.createSmartAccountClient)({
+        account,
+        chain: getChainById(chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: (0, import_viem4.http)(getPimlicoRpcByChainId(chainId)),
+        userOperation: {
+          estimateFeesPerGas: () => __async(this, null, function* () {
+            return (yield pimlicoClient.getUserOperationGasPrice()).fast;
+          })
+        }
+      });
+      const kernelAccountClient = (0, import_sdk.createKernelAccountClient)({
+        account,
+        chain: getChainById(chainId),
+        paymaster: paymasterClient,
+        bundlerTransport: (0, import_viem4.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: (0, import_viem4.getAddress)(token2.address),
+            abi: (0, import_viem4.parseAbi)(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [
+              fromAddress,
+              "0x26eeCa5956Bf8C01040BAC9e6D7982a0e87F31B4",
+              BigInt(0)
+            ]
+          },
+          {
+            to: (0, import_viem4.getAddress)(token2.address),
+            abi: (0, import_viem4.parseAbi)(["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 = (0, import_permissionless.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: (0, import_viem4.getAddress)(token2.address),
+              abi: (0, import_viem4.parseAbi)(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [
+                fromAddress,
+                "0x26eeCa5956Bf8C01040BAC9e6D7982a0e87F31B4",
+                estimatedTotalFeesInToken
+              ]
+            },
+            {
+              to: (0, import_viem4.getAddress)(token2.address),
+              abi: (0, import_viem4.parseAbi)(["function transferFrom(address,address,uint)"]),
+              functionName: "transferFrom",
+              args: [fromAddress, receiver, receiverAmount]
+            }
+          ]
+        });
+        const signature = yield account.signUserOperation(__spreadProps(__spreadValues({}, userOperation), {
+          chainId
+        }));
+        const rpcParameters = (0, import_account_abstraction.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 = import_constants.KERNEL_V3_1;
+      const entryPoint = (0, import_constants.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 (0, import_ecdsa_validator.signerToEcdsaValidator)(this.publicClient, {
+        entryPoint,
+        kernelVersion,
+        signer: this.signer
+      });
+      const sessionKeyAddress = "0xFDEed8e268D74DF71f3Db7409F8A8290FF1263ED";
+      const emptyAccount = (0, import_sdk.addressToEmptyAccount)(sessionKeyAddress);
+      const emptySessionKeySigner = yield (0, import_signers.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 = (0, import_policies.toCallPolicy)({
+        policyVersion: import_policies.CallPolicyVersion.V0_0_4,
+        permissions: [
+          {
+            target: token2.address,
+            valueLimit: BigInt(0),
+            abi: (0, import_viem4.parseAbi)(["function transferFrom(address,address,uint)"]),
+            functionName: "transferFrom",
+            args: [
+              {
+                condition: import_policies.ParamCondition.EQUAL,
+                value: (0, import_viem4.getAddress)(signerAddress)
+              },
+              {
+                condition: import_policies.ParamCondition.ONE_OF,
+                value: [
+                  "0x26eeCa5956Bf8C01040BAC9e6D7982a0e87F31B4",
+                  (0, import_viem4.getAddress)(receiver)
+                ]
+              },
+              {
+                condition: import_policies.ParamCondition.LESS_THAN_OR_EQUAL,
+                value: amountExclusive
+              }
+            ]
+          }
+        ]
+      });
+      const permissionPlugin = yield (0, import_permissions.toPermissionValidator)(this.publicClient, {
+        entryPoint,
+        kernelVersion,
+        signer: emptySessionKeySigner,
+        policies: [callPolicy]
+      });
+      const serializedSessionKeyAccount = yield (0, import_sdk.createKernelAccount)(
+        this.publicClient,
+        {
+          entryPoint,
+          kernelVersion,
+          plugins: {
+            sudo: ecdsaValidator,
+            regular: permissionPlugin
+          }
+        }
+      );
+      const approval = yield (0, import_permissions.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
+var import_viem5 = require("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: (0, import_viem5.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: (0, import_viem5.toHex)(amount),
+        amountExclusive: (0, import_viem5.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");
+      }
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});