@arcenpay/react 0.0.1 → 0.0.2

package/dist/chunk-JFY4DVS7.mjs

@@ -0,0 +1,1174 @@
+import {
+  getChain
+} from "./chunk-GY2HMODH.mjs";
+
+// src/lib/zerodev.ts
+import {
+  createKernelAccount,
+  createKernelAccountClient,
+  createZeroDevPaymasterClient,
+  constants as zeroDevConstants
+} from "@zerodev/sdk";
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import {
+  createPublicClient as createPublicClient2,
+  http as http2,
+  encodeFunctionData
+} from "viem";
+import { sepolia as sepolia2, baseSepolia as baseSepolia2, base } from "viem/chains";
+
+// src/internal/sdk-core/addresses.ts
+var ADDRESSES = {
+  // Ethereum Sepolia (Testnet) — Deployed 2026-03-19
+  11155111: {
+    subscriptionRegistry: "0xE206C519076535A9d24c852093860CFD780908C1",
+    autopayModule: "0xc82417e378b23AD9Ae73229EF08a4BA7896a4351",
+    planFactory: "0x4F97E0c2Ac053b735640fEb164a08Cb45ba83db1",
+    feeCollector: "0xa8A0D3007e5680D387A50C1a1E2Eb0AD092ca396",
+    sessionVault: "0xd68b9C0a34d61CC3b3F982A5EC6Cc5a5739e46D9",
+    zkUsageVerifier: "0x1f75d66692416cE880d51Baf6CdcBeE98E5837c0",
+    mirrorRegistry: "0xC187CD32d569ec0E84B9b378f8E63f3a74afac74"
+  },
+  // Base Sepolia (Testnet) — Deployed 2026-04-23
+  84532: {
+    subscriptionRegistry: "0xF9610c064FFD64255A1d509d17b2Af8733084e50",
+    autopayModule: "0x69Ac04bFdC045A99A2D31bb141A74da354a94c19",
+    planFactory: "0x66775Af13C63781AAd28203CC5d3E9eE5d5eB83d",
+    feeCollector: "0x5F32fBfF19385A78c3F721007758E9924FAD4133",
+    sessionVault: "0x96BcE2d49e3e4EddBBF3aa07354E66615BC2623c",
+    zkUsageVerifier: "0x03290b6988F87925A4939d974895bC30981aA90D",
+    mirrorRegistry: "0xe7E0dFfa82596ee6Ba1755bc25c29376a07236dE"
+  },
+  // Base Mainnet — set ARCENPAY_CONTRACT_8453_* env vars after audit + deployment
+  8453: {
+    subscriptionRegistry: "0x0000000000000000000000000000000000000000",
+    autopayModule: "0x0000000000000000000000000000000000000000",
+    planFactory: "0x0000000000000000000000000000000000000000",
+    feeCollector: "0x0000000000000000000000000000000000000000",
+    sessionVault: "0x0000000000000000000000000000000000000000",
+    zkUsageVerifier: "0x0000000000000000000000000000000000000000",
+    mirrorRegistry: "0x0000000000000000000000000000000000000000"
+  }
+};
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var CONTRACT_KEYS = [
+  "subscriptionRegistry",
+  "autopayModule",
+  "planFactory",
+  "feeCollector",
+  "sessionVault",
+  "zkUsageVerifier"
+];
+function applyEnvOverrides(chainId, base2) {
+  if (typeof process === "undefined") return base2;
+  const result = { ...base2 };
+  for (const key of CONTRACT_KEYS) {
+    const envKey = `ARCENPAY_CONTRACT_${chainId}_${key}`;
+    const legacyKey = `MEAP_CONTRACT_${chainId}_${key}`;
+    const override = process.env[envKey] ?? process.env[legacyKey];
+    if (override && override.startsWith("0x")) {
+      result[key] = override;
+    }
+  }
+  const mirrorOverride = process.env[`ARCENPAY_CONTRACT_${chainId}_mirrorRegistry`] ?? process.env[`MEAP_CONTRACT_${chainId}_mirrorRegistry`];
+  if (mirrorOverride && mirrorOverride.startsWith("0x")) {
+    result.mirrorRegistry = mirrorOverride;
+  }
+  const yieldOverride = process.env[`ARCENPAY_CONTRACT_${chainId}_yieldSessionVault`] ?? process.env[`MEAP_CONTRACT_${chainId}_yieldSessionVault`];
+  if (yieldOverride && yieldOverride.startsWith("0x")) {
+    result.yieldSessionVault = yieldOverride;
+  }
+  return result;
+}
+function getContractAddresses(chainId) {
+  const base2 = ADDRESSES[chainId];
+  if (!base2) {
+    throw new Error(`No contract addresses configured for chain ${chainId}`);
+  }
+  const addresses = applyEnvOverrides(chainId, base2);
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") {
+    const allZero = CONTRACT_KEYS.every(
+      (k) => addresses[k] === ZERO_ADDRESS
+    );
+    if (allZero) {
+      throw new Error(
+        `[getContractAddresses] Chain ${chainId} has no deployed contracts. Set ARCENPAY_CONTRACT_${chainId}_<key> env vars or deploy contracts before using this chain in production.`
+      );
+    }
+  }
+  return addresses;
+}
+
+// src/internal/sdk-core/environment.ts
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+var REQUIRED_CONTRACT_KEYS = [
+  "subscriptionRegistry",
+  "autopayModule",
+  "planFactory",
+  "feeCollector",
+  "sessionVault",
+  "zkUsageVerifier"
+];
+var DEFAULT_SERVICES = {
+  11155111: {
+    rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com"
+  },
+  84532: {
+    rpcUrl: "https://sepolia.base.org"
+  },
+  8453: {
+    rpcUrl: "https://mainnet.base.org"
+  }
+};
+var LEGACY_RPC_ENV_KEYS = {
+  11155111: ["SEPOLIA_RPC_URL"],
+  84532: ["BASE_SEPOLIA_RPC_URL"],
+  8453: ["BASE_MAINNET_RPC_URL"]
+};
+var SERVICE_ENV_KEYS = {
+  rpcUrl: (chainId) => [
+    `ARCENPAY_RPC_URL_${chainId}`,
+    `MEAP_RPC_URL_${chainId}`,
+    `RPC_URL_${chainId}`,
+    `NEXT_PUBLIC_RPC_URL_${chainId}`,
+    ...LEGACY_RPC_ENV_KEYS[chainId] || [],
+    "ARCENPAY_RPC_URL",
+    "MEAP_RPC_URL",
+    "RPC_URL",
+    "NEXT_PUBLIC_RPC_URL"
+  ],
+  subgraphUrl: (chainId) => [
+    `ARCENPAY_SUBGRAPH_URL_${chainId}`,
+    `MEAP_SUBGRAPH_URL_${chainId}`,
+    `NEXT_PUBLIC_GRAPH_URL_${chainId}`,
+    "ARCENPAY_SUBGRAPH_URL",
+    "MEAP_SUBGRAPH_URL",
+    "NEXT_PUBLIC_GRAPH_URL"
+  ],
+  facilitatorUrl: (chainId) => [
+    `ARCENPAY_FACILITATOR_URL_${chainId}`,
+    `MEAP_FACILITATOR_URL_${chainId}`,
+    `FACILITATOR_BASE_URL_${chainId}`,
+    `FACILITATOR_URL_${chainId}`,
+    `NEXT_PUBLIC_FACILITATOR_BASE_URL_${chainId}`,
+    `NEXT_PUBLIC_FACILITATOR_URL_${chainId}`,
+    "ARCENPAY_FACILITATOR_URL",
+    "MEAP_FACILITATOR_URL",
+    "FACILITATOR_BASE_URL",
+    "FACILITATOR_URL",
+    "NEXT_PUBLIC_FACILITATOR_BASE_URL",
+    "NEXT_PUBLIC_FACILITATOR_URL"
+  ]
+};
+function getEnv(keys) {
+  if (typeof process === "undefined") return void 0;
+  for (const key of keys) {
+    const value = process.env[key]?.trim();
+    if (value) return value;
+  }
+  return void 0;
+}
+function resolveServiceUrl(chainId, service, fallback) {
+  return getEnv(SERVICE_ENV_KEYS[service](chainId)) || fallback || "";
+}
+function isZeroAddress(value) {
+  return (value || "").toLowerCase() === ZERO_ADDRESS2;
+}
+function getChainEnvironment(chainId) {
+  const chain = getChain(chainId);
+  const defaults = DEFAULT_SERVICES[chainId] || {
+    rpcUrl: chain.rpcUrls.default.http[0] || ""
+  };
+  return {
+    chainId,
+    chainName: chain.name,
+    isTestnet: Boolean(chain.testnet),
+    contracts: getContractAddresses(chainId),
+    services: {
+      rpcUrl: resolveServiceUrl(chainId, "rpcUrl", defaults.rpcUrl),
+      subgraphUrl: resolveServiceUrl(chainId, "subgraphUrl", defaults.subgraphUrl),
+      facilitatorUrl: resolveServiceUrl(
+        chainId,
+        "facilitatorUrl",
+        defaults.facilitatorUrl
+      )
+    }
+  };
+}
+function isValidHttpUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function validateChainEnvironment(chainId, options = {}) {
+  const env = getChainEnvironment(chainId);
+  const production = options.production ?? (typeof process !== "undefined" ? process.env.NODE_ENV === "production" : false);
+  const requiredContracts = options.requiredContracts || REQUIRED_CONTRACT_KEYS;
+  const requiredServices = options.requiredServices || ["rpcUrl"];
+  const contractErrors = requiredContracts.filter((key) => isZeroAddress(env.contracts[key])).map((key) => `${String(key)} is zero-address`);
+  if (production && contractErrors.length > 0) {
+    throw new Error(
+      `[validateChainEnvironment] Chain ${chainId} invalid contracts: ${contractErrors.join(", ")}`
+    );
+  }
+  const serviceErrors = requiredServices.filter((key) => !env.services[key] || !isValidHttpUrl(env.services[key] || "")).map((key) => `${String(key)} is missing or invalid`);
+  if (serviceErrors.length > 0) {
+    throw new Error(
+      `[validateChainEnvironment] Chain ${chainId} invalid services: ${serviceErrors.join(", ")}`
+    );
+  }
+  return { ok: true };
+}
+
+// src/internal/sdk-core/app-origin.ts
+var ARCENPAY_LOCAL_APP_URL = "http://localhost:3000";
+var ARCENPAY_PRODUCTION_APP_URL = "https://app.arcenpay.com";
+var DEFAULT_ENV_KEYS = [
+  "ARCENPAY_BASE_URL",
+  "NEXT_PUBLIC_ARCENPAY_BASE_URL"
+];
+function trimTrailingSlash(value) {
+  return value.replace(/\/$/, "");
+}
+function getRuntimeEnv() {
+  if (typeof process === "undefined") return void 0;
+  return process.env;
+}
+function readEnvValue(env, keys) {
+  if (!env) return void 0;
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value) return value;
+  }
+  return void 0;
+}
+function resolveArcenPayBaseUrl(options = {}) {
+  if (options.explicit?.trim()) {
+    return trimTrailingSlash(options.explicit.trim());
+  }
+  const env = options.env ?? getRuntimeEnv();
+  const envOverride = readEnvValue(env, options.envKeys ?? DEFAULT_ENV_KEYS);
+  if (envOverride) {
+    return trimTrailingSlash(envOverride);
+  }
+  const localDevUrl = options.localDevUrl ?? ARCENPAY_LOCAL_APP_URL;
+  const productionUrl = options.productionUrl ?? ARCENPAY_PRODUCTION_APP_URL;
+  const nodeEnv = env?.NODE_ENV;
+  if (nodeEnv && nodeEnv !== "production") {
+    return localDevUrl;
+  }
+  return productionUrl;
+}
+
+// src/internal/sdk-core/abis.ts
+var SubscriptionRegistryABI = [
+  // Core functions
+  {
+    type: "function",
+    name: "mint",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "planId", type: "uint256" },
+      { name: "duration", type: "uint64" }
+    ],
+    outputs: [{ name: "tokenId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "renew",
+    inputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "extension", type: "uint64" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "cancel",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "changePlan",
+    inputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "newPlanId", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "isValid",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "expiresAt",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint64" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPlanFeatures",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [
+      { name: "planId", type: "uint256" },
+      { name: "planTier", type: "string" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getWalletSubscription",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "importSubscription",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "tokenId", type: "uint256" },
+      { name: "planId", type: "uint256" },
+      { name: "expiration", type: "uint64" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "finalizeMigration",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "hasActiveSubscription",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "authorizedBillers",
+    inputs: [{ name: "biller", type: "address" }],
+    outputs: [{ name: "isAuthorized", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setCrossChainTransports",
+    inputs: [
+      { name: "axelarTransport", type: "address" },
+      { name: "ccipTransport", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "dispatchCrossChainUpdate",
+    inputs: [
+      { name: "tokenId", type: "uint256" },
+      { name: "destinationChainId", type: "uint256" },
+      { name: "refundAddress", type: "address" }
+    ],
+    outputs: [
+      { name: "messageId", type: "bytes32" },
+      { name: "routeUsed", type: "uint8" }
+    ],
+    stateMutability: "payable"
+  },
+  // Events
+  {
+    type: "event",
+    name: "SubscriptionMinted",
+    inputs: [
+      { name: "subscriber", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "expiration", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "SubscriptionRenewed",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "newExpiration", type: "uint64", indexed: false },
+      { name: "amountPaid", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "SubscriptionCancelled",
+    inputs: [{ name: "tokenId", type: "uint256", indexed: true }]
+  },
+  {
+    type: "event",
+    name: "SubscriptionPlanChanged",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "previousPlanId", type: "uint256", indexed: true },
+      { name: "newPlanId", type: "uint256", indexed: true },
+      { name: "expiration", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "BillingSuccess",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "CrossChainDispatchRequested",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "destinationChainId", type: "uint256", indexed: true },
+      { name: "route", type: "uint8", indexed: true },
+      { name: "messageId", type: "bytes32", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "CrossChainFallbackTriggered",
+    inputs: [
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "destinationChainId", type: "uint256", indexed: true },
+      { name: "primaryError", type: "bytes", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "SubscriptionImported",
+    inputs: [
+      { name: "subscriber", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "expiration", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "RegistryMigrationFinalized",
+    inputs: []
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true }
+    ]
+  }
+];
+var PlanFactoryABI = [
+  {
+    type: "function",
+    name: "createPlan",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "tier", type: "string" },
+      { name: "price", type: "uint256" },
+      { name: "billingInterval", type: "uint32" },
+      { name: "acceptedToken", type: "address" },
+      { name: "metadataURI", type: "string" }
+    ],
+    outputs: [{ name: "planId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getPlan",
+    inputs: [{ name: "planId", type: "uint256" }],
+    outputs: [
+      {
+        name: "plan",
+        type: "tuple",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "provider", type: "address" },
+          { name: "name", type: "string" },
+          { name: "tier", type: "string" },
+          { name: "price", type: "uint256" },
+          { name: "billingInterval", type: "uint32" },
+          { name: "acceptedToken", type: "address" },
+          { name: "active", type: "bool" },
+          { name: "metadataURI", type: "string" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getProviderPlans",
+    inputs: [{ name: "provider", type: "address" }],
+    outputs: [{ name: "planIds", type: "uint256[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isProvider",
+    inputs: [{ name: "provider", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "PlanCreated",
+    inputs: [
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "provider", type: "address", indexed: true },
+      { name: "name", type: "string", indexed: false },
+      { name: "price", type: "uint256", indexed: false },
+      { name: "billingInterval", type: "uint32", indexed: false }
+    ]
+  },
+  {
+    type: "function",
+    name: "deactivatePlan",
+    inputs: [{ name: "planId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updatePlan",
+    inputs: [
+      { name: "planId", type: "uint256" },
+      { name: "price", type: "uint256" },
+      { name: "metadataURI", type: "string" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "PlanDeactivated",
+    inputs: [{ name: "planId", type: "uint256", indexed: true }]
+  }
+];
+var ERC7579AutopayModuleABI = [
+  {
+    type: "function",
+    name: "onInstall",
+    inputs: [{ name: "data", type: "bytes" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "onUninstall",
+    inputs: [{ name: "data", type: "bytes" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "execute",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "isInitialized",
+    inputs: [{ name: "smartAccount", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getConfig",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [
+      {
+        name: "config",
+        type: "tuple",
+        components: [
+          { name: "merchant", type: "address" },
+          { name: "maxAmount", type: "uint256" },
+          { name: "token", type: "address" },
+          { name: "interval", type: "uint32" },
+          { name: "startTime", type: "uint64" },
+          { name: "planId", type: "uint256" },
+          { name: "maxTotalAmount", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "updateConfig",
+    inputs: [
+      {
+        name: "config",
+        type: "tuple",
+        components: [
+          { name: "merchant", type: "address" },
+          { name: "maxAmount", type: "uint256" },
+          { name: "token", type: "address" },
+          { name: "interval", type: "uint32" },
+          { name: "startTime", type: "uint64" },
+          { name: "planId", type: "uint256" },
+          { name: "maxTotalAmount", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "canExecute",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "lastPullTime",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint64" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "mirrorDestinationChainId",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isAccountPaused",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "importAccountState",
+    inputs: [
+      { name: "account", type: "address" },
+      {
+        name: "config",
+        type: "tuple",
+        components: [
+          { name: "merchant", type: "address" },
+          { name: "maxAmount", type: "uint256" },
+          { name: "token", type: "address" },
+          { name: "interval", type: "uint32" },
+          { name: "startTime", type: "uint64" },
+          { name: "planId", type: "uint256" },
+          { name: "maxTotalAmount", type: "uint256" }
+        ]
+      },
+      { name: "lastPullTime_", type: "uint64" },
+      { name: "totalPulled_", type: "uint256" },
+      { name: "mirrorDestinationChainId_", type: "uint256" },
+      { name: "accountPaused_", type: "bool" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "finalizeMigration",
+    inputs: [],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "AutopayConfigured",
+    inputs: [
+      { name: "account", type: "address", indexed: true },
+      { name: "merchant", type: "address", indexed: true },
+      { name: "maxAmount", type: "uint256", indexed: false },
+      { name: "token", type: "address", indexed: false },
+      { name: "interval", type: "uint32", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "AutopayConfigUpdated",
+    inputs: [
+      { name: "account", type: "address", indexed: true },
+      { name: "previousPlanId", type: "uint256", indexed: true },
+      { name: "newPlanId", type: "uint256", indexed: true },
+      { name: "maxAmount", type: "uint256", indexed: false },
+      { name: "interval", type: "uint32", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "PaymentExecuted",
+    inputs: [
+      { name: "account", type: "address", indexed: true },
+      { name: "merchant", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "BillingExecuted",
+    inputs: [
+      { name: "account", type: "address", indexed: true },
+      { name: "merchant", type: "address", indexed: true },
+      { name: "tokenId", type: "uint256", indexed: true },
+      { name: "planId", type: "uint256", indexed: false },
+      { name: "reason", type: "uint8", indexed: false },
+      { name: "grossAmount", type: "uint256", indexed: false },
+      { name: "merchantAmount", type: "uint256", indexed: false },
+      { name: "protocolFee", type: "uint256", indexed: false },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "AutopayRevoked",
+    inputs: [{ name: "account", type: "address", indexed: true }]
+  },
+  {
+    type: "event",
+    name: "AccountStateImported",
+    inputs: [
+      { name: "account", type: "address", indexed: true },
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "lastPullTime", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "MigrationFinalized",
+    inputs: []
+  }
+];
+
+// src/internal/sdk-core/accounts.ts
+import { createPublicClient, http } from "viem";
+
+// src/lib/zerodev.ts
+var CHAIN_MAP = {
+  11155111: sepolia2,
+  84532: baseSepolia2,
+  8453: base
+};
+var ENTRY_POINT = zeroDevConstants.getEntryPoint("0.7");
+var ENTRY_POINT_ADDRESS = ENTRY_POINT.address;
+var KERNEL_VERSION = zeroDevConstants.KERNEL_V3_1;
+function getZeroDevChainLabel(chainId) {
+  if (chainId === 84532) return "Base Sepolia";
+  if (chainId === 8453) return "Base";
+  if (chainId === 11155111) return "Sepolia";
+  return `Chain ${chainId}`;
+}
+function resolveZeroDevUrls(params) {
+  const specificUnified = process.env[`NEXT_PUBLIC_ZERODEV_RPC_${params.chainId}`];
+  const specificBundler = process.env[`NEXT_PUBLIC_ZERODEV_BUNDLER_RPC_${params.chainId}`];
+  const specificPaymaster = process.env[`NEXT_PUBLIC_ZERODEV_PAYMASTER_RPC_${params.chainId}`];
+  const genericUnified = process.env.NEXT_PUBLIC_ZERODEV_RPC;
+  const genericBundler = process.env.NEXT_PUBLIC_ZERODEV_BUNDLER_RPC;
+  const genericPaymaster = process.env.NEXT_PUBLIC_ZERODEV_PAYMASTER_RPC;
+  const defaultUnifiedV3 = `https://rpc.zerodev.app/api/v3/${params.projectId}/chain/${params.chainId}`;
+  const hasConfiguredUrls = !!(params.bundlerUrl || params.paymasterUrl || specificUnified || specificBundler || specificPaymaster || genericUnified || genericBundler || genericPaymaster);
+  return {
+    bundlerUrl: params.bundlerUrl || specificUnified || specificBundler || genericUnified || genericBundler || defaultUnifiedV3 || `https://rpc.zerodev.app/api/v2/bundler/${params.projectId}`,
+    paymasterUrl: params.paymasterUrl || specificUnified || specificPaymaster || genericUnified || genericPaymaster || defaultUnifiedV3 || `https://rpc.zerodev.app/api/v2/paymaster/${params.projectId}`,
+    hasConfiguredUrls
+  };
+}
+function normalizeZeroDevError(error, params) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  const chainLabel = getZeroDevChainLabel(params.chainId);
+  const usingDefaultUrls = !params.hasConfiguredUrls;
+  if (message.includes("ChainId not found")) {
+    const nextStep = usingDefaultUrls ? `Enable ${chainLabel} for ZeroDev project ${params.projectId}, or set NEXT_PUBLIC_ZERODEV_BUNDLER_RPC_${params.chainId} and NEXT_PUBLIC_ZERODEV_PAYMASTER_RPC_${params.chainId} to chain-specific endpoints.` : `The configured ZeroDev endpoint does not recognize ${chainLabel} for project ${params.projectId}. Verify the project supports chain ${params.chainId} or replace the override URLs. Bundler URL: ${params.bundlerUrl ?? "n/a"}. Paymaster URL: ${params.paymasterUrl ?? "n/a"}.`;
+    return new Error(
+      `ZeroDev project ${params.projectId} is not configured for ${chainLabel} (chain ${params.chainId}). ${nextStep}`
+    );
+  }
+  return error instanceof Error ? error : new Error(message);
+}
+function isRecoverableSmartAccountFundingError(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  const lower = message.toLowerCase();
+  return lower.includes("smart account does not have sufficient funds") || lower.includes("sufficient funds to execute the user operation") || lower.includes("insufficient funds") || lower.includes("user operation") && lower.includes("paymaster");
+}
+async function createKernelExecutionContext(config) {
+  const chain = CHAIN_MAP[config.chainId] || baseSepolia2;
+  const { bundlerUrl, paymasterUrl, hasConfiguredUrls } = resolveZeroDevUrls({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    bundlerUrl: config.bundlerUrl,
+    paymasterUrl: config.paymasterUrl
+  });
+  const publicClient = createPublicClient2({
+    chain,
+    transport: http2()
+  });
+  const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+    signer: config.walletClient,
+    entryPoint: ENTRY_POINT,
+    kernelVersion: KERNEL_VERSION
+  });
+  const kernelAccount = await createKernelAccount(publicClient, {
+    plugins: { sudo: ecdsaValidator },
+    entryPoint: ENTRY_POINT,
+    kernelVersion: KERNEL_VERSION
+  });
+  const paymasterClient = createZeroDevPaymasterClient({
+    chain,
+    transport: http2(paymasterUrl)
+  });
+  const kernelClient = createKernelAccountClient({
+    account: kernelAccount,
+    chain,
+    bundlerTransport: http2(bundlerUrl),
+    middleware: {
+      sponsorUserOperation: async ({
+        userOperation
+      }) => {
+        return paymasterClient.sponsorUserOperation({
+          userOperation,
+          entryPoint: ENTRY_POINT_ADDRESS
+        });
+      }
+    }
+  });
+  return {
+    publicClient,
+    kernelAccount,
+    kernelClient,
+    bundlerUrl,
+    paymasterUrl,
+    hasConfiguredUrls
+  };
+}
+async function deploySmartAccount(config) {
+  const chain = CHAIN_MAP[config.chainId] || baseSepolia2;
+  const contracts = getContractAddresses(config.chainId);
+  const { bundlerUrl, paymasterUrl, hasConfiguredUrls } = resolveZeroDevUrls({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    bundlerUrl: config.bundlerUrl,
+    paymasterUrl: config.paymasterUrl
+  });
+  const publicClient = createPublicClient2({
+    chain,
+    transport: http2()
+  });
+  const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+    signer: config.walletClient,
+    entryPoint: ENTRY_POINT,
+    kernelVersion: KERNEL_VERSION
+  });
+  const kernelAccount = await createKernelAccount(publicClient, {
+    plugins: {
+      sudo: ecdsaValidator
+    },
+    entryPoint: ENTRY_POINT,
+    kernelVersion: KERNEL_VERSION
+  });
+  const smartAccountAddress = kernelAccount.address;
+  const code = await publicClient.getCode({ address: smartAccountAddress });
+  const alreadyDeployed = !!code && code !== "0x";
+  const paymasterClient = createZeroDevPaymasterClient({
+    chain,
+    transport: http2(paymasterUrl)
+  });
+  const kernelClient = createKernelAccountClient({
+    account: kernelAccount,
+    chain,
+    bundlerTransport: http2(bundlerUrl),
+    middleware: {
+      sponsorUserOperation: async ({
+        userOperation
+      }) => {
+        return paymasterClient.sponsorUserOperation({
+          userOperation,
+          entryPoint: ENTRY_POINT_ADDRESS
+        });
+      }
+    }
+  });
+  let installTxHash;
+  if (contracts.autopayModule) {
+    try {
+      const initialized = await publicClient.readContract({
+        address: contracts.autopayModule,
+        abi: ERC7579AutopayModuleABI,
+        functionName: "isInitialized",
+        args: [smartAccountAddress]
+      });
+      if (initialized) {
+        console.log(
+          `[ZeroDev] AutopayModule already initialized for ${smartAccountAddress}`
+        );
+        return {
+          smartAccountAddress,
+          installTxHash,
+          alreadyDeployed
+        };
+      }
+      const installData = encodeFunctionData({
+        abi: [
+          {
+            type: "function",
+            name: "installModule",
+            inputs: [
+              { name: "moduleType", type: "uint256" },
+              { name: "module", type: "address" },
+              { name: "initData", type: "bytes" }
+            ],
+            outputs: [],
+            stateMutability: "nonpayable"
+          }
+        ],
+        functionName: "installModule",
+        args: [
+          2n,
+          // Module type 2 = Executor
+          contracts.autopayModule,
+          "0x"
+          // Empty init data
+        ]
+      });
+      installTxHash = await kernelClient.sendTransaction({
+        to: smartAccountAddress,
+        data: installData,
+        value: 0n
+      });
+      console.log(
+        `[ZeroDev] AutopayModule installed on ${smartAccountAddress} \u2014 tx: ${installTxHash}`
+      );
+    } catch (err) {
+      if (err?.message?.includes("already installed") || err?.message?.includes("AlreadyInitialized")) {
+        console.log(
+          `[ZeroDev] AutopayModule already installed on ${smartAccountAddress}`
+        );
+      } else {
+        const normalizedError = normalizeZeroDevError(err, {
+          projectId: config.projectId,
+          chainId: config.chainId,
+          bundlerUrl,
+          paymasterUrl,
+          hasConfiguredUrls
+        });
+        if (isRecoverableSmartAccountFundingError(normalizedError)) {
+          console.warn(
+            "[ZeroDev] Module installation needs prefund or sponsorship; callers may fall back to the connected wallet:",
+            normalizedError.message
+          );
+        } else {
+          console.error(
+            "[ZeroDev] Module installation failed:",
+            normalizedError.message
+          );
+        }
+        throw normalizedError;
+      }
+    }
+  }
+  return {
+    smartAccountAddress,
+    installTxHash,
+    alreadyDeployed
+  };
+}
+async function revokeAutopayModule(config) {
+  const chain = CHAIN_MAP[config.chainId] || baseSepolia2;
+  const contracts = getContractAddresses(config.chainId);
+  if (!contracts.autopayModule) {
+    throw new Error("Autopay module address not configured for this chain.");
+  }
+  const { bundlerUrl, paymasterUrl, hasConfiguredUrls } = resolveZeroDevUrls({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    bundlerUrl: config.bundlerUrl,
+    paymasterUrl: config.paymasterUrl
+  });
+  const publicClient = createPublicClient2({
+    chain,
+    transport: http2()
+  });
+  const initialized = await publicClient.readContract({
+    address: contracts.autopayModule,
+    abi: ERC7579AutopayModuleABI,
+    functionName: "isInitialized",
+    args: [config.smartAccountAddress]
+  });
+  if (!initialized) {
+    return { alreadyRevoked: true };
+  }
+  const { kernelAccount, kernelClient } = await createKernelExecutionContext({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    walletClient: config.walletClient,
+    bundlerUrl,
+    paymasterUrl
+  });
+  if (kernelAccount.address.toLowerCase() !== config.smartAccountAddress.toLowerCase()) {
+    throw new Error(
+      `Kernel account mismatch. Expected ${config.smartAccountAddress}, got ${kernelAccount.address}.`
+    );
+  }
+  const revokeData = encodeFunctionData({
+    abi: ERC7579AutopayModuleABI,
+    functionName: "onUninstall",
+    args: ["0x"]
+  });
+  try {
+    const txHash = await kernelClient.sendTransaction({
+      to: contracts.autopayModule,
+      data: revokeData,
+      value: 0n
+    });
+    return { txHash, alreadyRevoked: false };
+  } catch (error) {
+    throw normalizeZeroDevError(error, {
+      projectId: config.projectId,
+      chainId: config.chainId,
+      bundlerUrl,
+      paymasterUrl,
+      hasConfiguredUrls
+    });
+  }
+}
+async function sendSmartAccountTransaction(config) {
+  const {
+    publicClient,
+    kernelAccount,
+    kernelClient,
+    bundlerUrl,
+    paymasterUrl,
+    hasConfiguredUrls
+  } = await createKernelExecutionContext({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    walletClient: config.walletClient,
+    bundlerUrl: config.bundlerUrl,
+    paymasterUrl: config.paymasterUrl
+  });
+  if (config.smartAccountAddress && kernelAccount.address.toLowerCase() !== config.smartAccountAddress.toLowerCase()) {
+    throw new Error(
+      `Kernel account mismatch. Expected ${config.smartAccountAddress}, got ${kernelAccount.address}.`
+    );
+  }
+  try {
+    const txHash = await kernelClient.sendTransaction({
+      to: config.to,
+      data: config.data,
+      value: config.value ?? 0n
+    });
+    await publicClient.waitForTransactionReceipt({ hash: txHash });
+    return {
+      smartAccountAddress: kernelAccount.address,
+      txHash
+    };
+  } catch (error) {
+    throw normalizeZeroDevError(error, {
+      projectId: config.projectId,
+      chainId: config.chainId,
+      bundlerUrl,
+      paymasterUrl,
+      hasConfiguredUrls
+    });
+  }
+}
+async function updateAutopayConfig(config) {
+  const contracts = getContractAddresses(config.chainId);
+  if (!contracts.autopayModule) {
+    throw new Error("Autopay module address is not configured for this chain.");
+  }
+  const data = encodeFunctionData({
+    abi: ERC7579AutopayModuleABI,
+    functionName: "updateConfig",
+    args: [
+      {
+        merchant: config.merchant,
+        maxAmount: config.maxAmount,
+        token: config.token,
+        interval: config.interval,
+        startTime: config.startTime,
+        planId: config.planId,
+        maxTotalAmount: config.maxTotalAmount ?? 0n
+      }
+    ]
+  });
+  return sendSmartAccountTransaction({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    walletClient: config.walletClient,
+    smartAccountAddress: config.smartAccountAddress,
+    to: contracts.autopayModule,
+    data,
+    bundlerUrl: config.bundlerUrl,
+    paymasterUrl: config.paymasterUrl
+  });
+}
+async function cancelSubscription(config) {
+  const contracts = getContractAddresses(config.chainId);
+  if (!contracts.subscriptionRegistry) {
+    throw new Error(
+      "Subscription registry address is not configured for this chain."
+    );
+  }
+  const data = encodeFunctionData({
+    abi: SubscriptionRegistryABI,
+    functionName: "cancelSubscription",
+    args: [config.tokenId]
+  });
+  return sendSmartAccountTransaction({
+    projectId: config.projectId,
+    chainId: config.chainId,
+    walletClient: config.walletClient,
+    smartAccountAddress: config.smartAccountAddress,
+    to: contracts.subscriptionRegistry,
+    data,
+    bundlerUrl: config.bundlerUrl,
+    paymasterUrl: config.paymasterUrl
+  });
+}
+
+export {
+  getContractAddresses,
+  getChainEnvironment,
+  validateChainEnvironment,
+  resolveArcenPayBaseUrl,
+  SubscriptionRegistryABI,
+  PlanFactoryABI,
+  ERC7579AutopayModuleABI,
+  isRecoverableSmartAccountFundingError,
+  deploySmartAccount,
+  revokeAutopayModule,
+  sendSmartAccountTransaction,
+  updateAutopayConfig,
+  cancelSubscription
+};