@arcenpay/node 0.0.1 → 0.0.2

package/dist/index.js

@@ -30,6 +30,65 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/internal/sdk-core/chains.ts
+function getChain(chainId) {
+  const chainMap = {
+    11155111: sepolia,
+    84532: baseSepolia,
+    8453: baseMainnet
+  };
+  const chain = chainMap[chainId];
+  if (!chain) {
+    throw new Error(
+      `[getChain] Unsupported chainId: ${chainId}. Supported: ${Object.keys(chainMap).join(", ")}`
+    );
+  }
+  return chain;
+}
+var import_viem, sepolia, baseSepolia, baseMainnet, DEFAULT_CHAIN_ID;
+var init_chains = __esm({
+  "src/internal/sdk-core/chains.ts"() {
+    "use strict";
+    import_viem = require("viem");
+    sepolia = (0, import_viem.defineChain)({
+      id: 11155111,
+      name: "Sepolia",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: {
+        default: { http: ["https://ethereum-sepolia-rpc.publicnode.com"] }
+      },
+      blockExplorers: {
+        default: { name: "Etherscan", url: "https://sepolia.etherscan.io" }
+      },
+      testnet: true
+    });
+    baseSepolia = (0, import_viem.defineChain)({
+      id: 84532,
+      name: "Base Sepolia",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: {
+        default: { http: ["https://sepolia.base.org"] }
+      },
+      blockExplorers: {
+        default: { name: "BaseScan", url: "https://sepolia.basescan.org" }
+      },
+      testnet: true
+    });
+    baseMainnet = (0, import_viem.defineChain)({
+      id: 8453,
+      name: "Base",
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: {
+        default: { http: ["https://mainnet.base.org"] }
+      },
+      blockExplorers: {
+        default: { name: "BaseScan", url: "https://basescan.org" }
+      }
+    });
+    DEFAULT_CHAIN_ID = 84532;
+  }
+});
+
 // src/services/nonce-store.ts
 var nonce_store_exports = {};
 __export(nonce_store_exports, {
@@ -139,8 +198,1020 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/internal/sdk-core/index.ts
+init_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, base9) {
+  if (typeof process === "undefined") return base9;
+  const result = { ...base9 };
+  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 base9 = ADDRESSES[chainId];
+  if (!base9) {
+    throw new Error(`No contract addresses configured for chain ${chainId}`);
+  }
+  const addresses = applyEnvOverrides(chainId, base9);
+  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
+init_chains();
+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 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
+      )
+    }
+  };
+}
+
+// src/internal/sdk-core/runtime-profile.ts
+init_chains();
+
+// 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 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: []
+  }
+];
+var SessionVaultABI = [
+  {
+    type: "function",
+    name: "fundSession",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "token", type: "address" }
+    ],
+    outputs: [{ name: "sessionId", type: "bytes32" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "topUp",
+    inputs: [
+      { name: "sessionId", type: "bytes32" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "settle",
+    inputs: [
+      { name: "sessionId", type: "bytes32" },
+      { name: "amount", type: "uint256" },
+      { name: "provider", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    inputs: [{ name: "sessionId", type: "bytes32" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getBalance",
+    inputs: [{ name: "sessionId", type: "bytes32" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentBalance",
+    inputs: [{ name: "agent", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getSession",
+    inputs: [{ name: "sessionId", type: "bytes32" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "agent", type: "address" },
+          { name: "token", type: "address" },
+          { name: "balance", type: "uint256" },
+          { name: "totalFunded", type: "uint256" },
+          { name: "totalSettled", type: "uint256" },
+          { name: "active", type: "bool" },
+          { name: "createdAt", type: "uint64" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentSessions",
+    inputs: [{ name: "agent", type: "address" }],
+    outputs: [{ name: "", type: "bytes32[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "authorizedSettlers",
+    inputs: [{ name: "", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "SessionFunded",
+    inputs: [
+      { name: "agent", type: "address", indexed: true },
+      { name: "sessionId", type: "bytes32", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "token", type: "address", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "SessionSettled",
+    inputs: [
+      { name: "sessionId", type: "bytes32", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "provider", type: "address", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "SessionWithdrawn",
+    inputs: [
+      { name: "sessionId", type: "bytes32", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "agent", type: "address", indexed: true }
+    ]
+  }
+];
+var ZKUsageVerifierABI = [
+  {
+    type: "function",
+    name: "setGroth16Verifier",
+    inputs: [{ name: "verifier", type: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "groth16Verifier",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "submitProof",
+    inputs: [
+      {
+        name: "proof",
+        type: "tuple",
+        components: [
+          { name: "a", type: "uint256[2]" },
+          { name: "b", type: "uint256[2][2]" },
+          { name: "c", type: "uint256[2]" }
+        ]
+      },
+      {
+        name: "inputs",
+        type: "tuple",
+        components: [
+          { name: "agentAddress", type: "bytes32" },
+          { name: "sessionId", type: "bytes32" },
+          { name: "callCount", type: "uint256" },
+          { name: "windowStart", type: "uint64" },
+          { name: "windowEnd", type: "uint64" },
+          { name: "merkleRoot", type: "bytes32" },
+          { name: "nullifier", type: "bytes32" }
+        ]
+      }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "isNullifierUsed",
+    inputs: [{ name: "nullifier", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getRateSchedule",
+    inputs: [{ name: "planId", type: "uint256" }],
+    outputs: [{ name: "ratePerCall", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getPendingBalance",
+    inputs: [{ name: "agent", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "BillingSettled",
+    inputs: [
+      { name: "sessionId", type: "bytes32", indexed: true },
+      { name: "agentAddress", type: "bytes32", indexed: true },
+      { name: "callCount", type: "uint256", indexed: false },
+      { name: "settlementAmount", type: "uint256", indexed: false },
+      { name: "windowStart", type: "uint64", indexed: false },
+      { name: "windowEnd", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Groth16VerifierSet",
+    inputs: [{ name: "verifier", type: "address", indexed: true }]
+  }
+];
+var FeeCollectorABI = [
+  // ── Core fee collection ──
+  {
+    type: "function",
+    name: "collectSubscriptionFee",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: [{ name: "feeAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "collectSettlementFee",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: [{ name: "feeAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // ── Provider-specific fee collection ──
+  {
+    type: "function",
+    name: "collectSubscriptionFeeFor",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "provider", type: "address" }
+    ],
+    outputs: [{ name: "feeAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "collectSettlementFeeFor",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "provider", type: "address" }
+    ],
+    outputs: [{ name: "feeAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // ── Fee rate queries ──
+  {
+    type: "function",
+    name: "subscriptionFeeRate",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "settlementFeeRate",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getProviderSubFeeBps",
+    inputs: [{ name: "provider", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getProviderSettleFeeBps",
+    inputs: [{ name: "provider", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  // ── Tier management ──
+  {
+    type: "function",
+    name: "syncProviderTier",
+    inputs: [
+      { name: "provider", type: "address" },
+      { name: "tier", type: "uint8" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setTierFeeRates",
+    inputs: [
+      { name: "tier", type: "uint8" },
+      { name: "subFeeBps", type: "uint256" },
+      { name: "settleFeeBps", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "setProviderFeeRates",
+    inputs: [
+      { name: "provider", type: "address" },
+      { name: "subFeeBps", type: "uint256" },
+      { name: "settleFeeBps", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "tierSubFeeBps",
+    inputs: [{ name: "tier", type: "uint8" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tierSettleFeeBps",
+    inputs: [{ name: "tier", type: "uint8" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  // ── Treasury ──
+  {
+    type: "function",
+    name: "accumulatedFees",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "withdrawFees",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  // ── Events ──
+  {
+    type: "event",
+    name: "FeeCollected",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "feeAmount", type: "uint256", indexed: false },
+      { name: "feeType", type: "string", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "FeesWithdrawn",
+    inputs: [
+      { name: "treasury", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "ProviderFeeRateSet",
+    inputs: [
+      { name: "provider", type: "address", indexed: true },
+      { name: "subFeeBps", type: "uint256", indexed: false },
+      { name: "settleFeeBps", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "ProviderTierSynced",
+    inputs: [
+      { name: "provider", type: "address", indexed: true },
+      { name: "tier", type: "uint8", indexed: false },
+      { name: "subFeeBps", type: "uint256", indexed: false },
+      { name: "settleFeeBps", type: "uint256", indexed: false }
+    ]
+  }
+];
+
+// src/internal/sdk-core/constants.ts
+var X402_VERSION = "1";
+var X402_SCHEME = "exact";
+
+// src/internal/sdk-core/accounts.ts
+var import_viem2 = require("viem");
+
+// src/internal/sdk-core/index.ts
+init_chains();
+
 // src/client.ts
-var import_sdk = require("@arcenpay/sdk");
 var ArcenClient = class {
   apiKey;
   baseUrl;
@@ -151,7 +1222,7 @@ var ArcenClient = class {
       throw new Error('ArcenClient: apiKey must start with "api_"');
     }
     this.apiKey = config.apiKey;
-    this.baseUrl = (0, import_sdk.resolveArcenPayBaseUrl)({ explicit: config.baseUrl });
+    this.baseUrl = resolveArcenPayBaseUrl({ explicit: config.baseUrl });
     this.timeoutMs = config.timeoutMs ?? 1e4;
   }
   buildAuthHeader() {
@@ -386,9 +1457,8 @@ var ArcenApiError = class extends Error {
 };
 
 // src/middleware/x402.ts
-var import_sdk2 = require("@arcenpay/sdk");
-var import_viem = require("viem");
-var import_chains = require("viem/chains");
+var import_viem3 = require("viem");
+var import_chains5 = require("viem/chains");
 var PAYMENT_DOMAIN = {
   name: "MEAP x402 Payment",
   version: "1"
@@ -404,9 +1474,9 @@ var PAYMENT_TYPES = {
   ]
 };
 var CHAIN_MAP = {
-  11155111: import_chains.sepolia,
-  84532: import_chains.baseSepolia,
-  8453: import_chains.base
+  11155111: import_chains5.sepolia,
+  84532: import_chains5.baseSepolia,
+  8453: import_chains5.base
 };
 var CHAIN_ID_TO_NETWORK = {
   11155111: "ethereum-sepolia",
@@ -501,24 +1571,26 @@ function x402Middleware(options) {
     const { InMemoryNonceStore: InMemoryNonceStore2 } = (init_nonce_store(), __toCommonJS(nonce_store_exports));
     nonceStore = new InMemoryNonceStore2();
   }
-  const rateAtomicUnits = (0, import_viem.parseUnits)(ratePerCall, 6);
-  const chainEnv = (0, import_sdk2.getChainEnvironment)(chainId);
+  const rateAtomicUnits = (0, import_viem3.parseUnits)(ratePerCall, 6);
+  const chainEnv = getChainEnvironment(chainId);
   const contracts = chainEnv.contracts;
   const payToAddress = payTo || contracts.feeCollector || "0x0000000000000000000000000000000000000000";
-  const chain = CHAIN_MAP[chainId] || import_chains.sepolia;
-  const publicClient = (0, import_viem.createPublicClient)({
+  const chain = CHAIN_MAP[chainId] || import_chains5.sepolia;
+  const publicClient = (0, import_viem3.createPublicClient)({
     chain,
-    transport: (0, import_viem.http)(rpcUrl || chainEnv.services.rpcUrl || chain.rpcUrls.default.http[0])
+    transport: (0, import_viem3.http)(
+      rpcUrl || chainEnv.services.rpcUrl || chain.rpcUrls.default.http[0]
+    )
   });
   return async (req, res, next) => {
     const paymentHeader = req.headers["x-payment"];
     if (!paymentHeader) {
       const x402Response = {
         ok: false,
-        version: import_sdk2.X402_VERSION,
+        version: X402_VERSION,
         accepts: [
           {
-            scheme: import_sdk2.X402_SCHEME,
+            scheme: X402_SCHEME,
             network: resolvedNetwork,
             maxAmountRequired: rateAtomicUnits.toString(),
             resource: `${req.protocol}://${req.get("host")}${req.originalUrl}`,
@@ -580,7 +1652,7 @@ function x402Middleware(options) {
         return;
       }
       const signerClaimed = typeof payload.from === "string" ? payload.from : "";
-      if (!(0, import_viem.isAddress)(signerClaimed)) {
+      if (!(0, import_viem3.isAddress)(signerClaimed)) {
         sendRejection(
           res,
           "MALFORMED_PAYMENT_PAYLOAD",
@@ -619,7 +1691,7 @@ function x402Middleware(options) {
       }
       let recoveredSigner;
       try {
-        recoveredSigner = await (0, import_viem.recoverTypedDataAddress)({
+        recoveredSigner = await (0, import_viem3.recoverTypedDataAddress)({
           domain: { ...PAYMENT_DOMAIN, chainId: BigInt(chainId) },
           types: PAYMENT_TYPES,
           primaryType: "Payment",
@@ -681,7 +1753,7 @@ function x402Middleware(options) {
         try {
           const balance = await publicClient.readContract({
             address: contracts.sessionVault,
-            abi: import_sdk2.SessionVaultABI,
+            abi: SessionVaultABI,
             functionName: "getAgentBalance",
             args: [verifiedSigner]
           });
@@ -771,10 +1843,9 @@ var import_crypto = require("crypto");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_url = require("url");
-var import_viem2 = require("viem");
-var import_accounts = require("viem/accounts");
-var import_chains2 = require("viem/chains");
-var import_sdk3 = require("@arcenpay/sdk");
+var import_viem4 = require("viem");
+var import_accounts2 = require("viem/accounts");
+var import_chains6 = require("viem/chains");
 var UsageProofErrorCodes = {
   TOOLING_UNAVAILABLE: "TOOLING_UNAVAILABLE",
   ARTIFACTS_MISSING: "ARTIFACTS_MISSING",
@@ -795,12 +1866,12 @@ var UsageProofError = class extends Error {
   }
 };
 var CHAIN_MAP2 = {
-  11155111: import_chains2.sepolia,
-  84532: import_chains2.baseSepolia,
-  8453: import_chains2.base
+  11155111: import_chains6.sepolia,
+  84532: import_chains6.baseSepolia,
+  8453: import_chains6.base
 };
 var MAX_ENTRIES = 128;
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_ADDRESS3 = "0x0000000000000000000000000000000000000000";
 var UsageService = class {
   logs = /* @__PURE__ */ new Map();
   config;
@@ -809,8 +1880,8 @@ var UsageService = class {
   walletClient;
   runtimeValidated = false;
   constructor(config = {}) {
-    const chainId = config.chainId ?? import_sdk3.DEFAULT_CHAIN_ID;
-    const chain = CHAIN_MAP2[chainId] || import_chains2.baseSepolia;
+    const chainId = config.chainId ?? DEFAULT_CHAIN_ID;
+    const chain = CHAIN_MAP2[chainId] || import_chains6.baseSepolia;
     const rpcUrl = config.rpcUrl || chain.rpcUrls.default.http[0];
     const proofMode = config.proofMode ?? (process.env.NODE_ENV === "development" ? "dev" : "strict");
     const circuitsRootDir = this.resolveCircuitsRoot(config.circuitsRootDir);
@@ -831,19 +1902,19 @@ var UsageService = class {
     };
     if (config.signerPrivateKey) {
       const key = config.signerPrivateKey.startsWith("0x") ? config.signerPrivateKey : `0x${config.signerPrivateKey}`;
-      this.signerAccount = (0, import_accounts.privateKeyToAccount)(key);
+      this.signerAccount = (0, import_accounts2.privateKeyToAccount)(key);
     } else {
       this.signerAccount = null;
     }
-    this.publicClient = (0, import_viem2.createPublicClient)({
+    this.publicClient = (0, import_viem4.createPublicClient)({
       chain,
-      transport: (0, import_viem2.http)(rpcUrl)
+      transport: (0, import_viem4.http)(rpcUrl)
     });
     if (this.signerAccount) {
-      this.walletClient = (0, import_viem2.createWalletClient)({
+      this.walletClient = (0, import_viem4.createWalletClient)({
         account: this.signerAccount,
         chain,
-        transport: (0, import_viem2.http)(rpcUrl)
+        transport: (0, import_viem4.http)(rpcUrl)
       });
     } else {
       this.walletClient = null;
@@ -904,7 +1975,9 @@ var UsageService = class {
   }
   aggregateUsage(sessionId, windowEnd) {
     const logs = this.logs.get(sessionId) || [];
-    const windowLogs = logs.filter((entry) => entry.callData.timestamp <= windowEnd);
+    const windowLogs = logs.filter(
+      (entry) => entry.callData.timestamp <= windowEnd
+    );
     const windowStart = windowLogs.length > 0 ? Math.min(...windowLogs.map((entry) => entry.callData.timestamp)) : 0;
     return {
       sessionId,
@@ -935,7 +2008,7 @@ var UsageService = class {
       );
     }
     const sessionIdBytes32 = this.normalizeBytes32(sessionId);
-    const agentAddress = this.signerAccount?.address || ZERO_ADDRESS;
+    const agentAddress = this.signerAccount?.address || ZERO_ADDRESS3;
     const agentAddressBytes32 = this.addressToBytes32(agentAddress);
     const logHashes = aggregation.logs.map((log) => this.hashUsageLog(log));
     const logTimestamps = aggregation.logs.map(
@@ -957,7 +2030,13 @@ var UsageService = class {
       const prover = await this.loadCircuitProver();
       proofResult = await prover.prove(circuitInput);
       publicSignals = proofResult.publicSignals;
-      this.assertPublicSignals(publicSignals, aggregation, agentAddress, sessionIdBytes32, prover);
+      this.assertPublicSignals(
+        publicSignals,
+        aggregation,
+        agentAddress,
+        sessionIdBytes32,
+        prover
+      );
     } catch (err) {
       if (this.config.proofMode === "strict") {
         throw this.wrapProofError(err);
@@ -1023,8 +2102,8 @@ var UsageService = class {
         "UsageService: Cannot submit proof \u2014 no signer private key configured. Set signerPrivateKey in UsageServiceConfig."
       );
     }
-    const chainId = this.config.chainId ?? import_sdk3.DEFAULT_CHAIN_ID;
-    const contracts = (0, import_sdk3.getContractAddresses)(chainId);
+    const chainId = this.config.chainId ?? DEFAULT_CHAIN_ID;
+    const contracts = getContractAddresses(chainId);
     const verifierAddress = contracts.zkUsageVerifier;
     if (!verifierAddress || verifierAddress === "0x0000000000000000000000000000000000000000") {
       throw new Error(
@@ -1047,7 +2126,7 @@ var UsageService = class {
     };
     const txHash = await this.walletClient.writeContract({
       address: verifierAddress,
-      abi: import_sdk3.ZKUsageVerifierABI,
+      abi: ZKUsageVerifierABI,
       functionName: "submitProof",
       args: [onChainProof, onChainInputs]
     });
@@ -1100,7 +2179,9 @@ var UsageService = class {
       this.config.zkeyPath,
       this.config.verificationKeyPath
     ];
-    const missing = required.filter((artifactPath) => !import_fs.default.existsSync(artifactPath));
+    const missing = required.filter(
+      (artifactPath) => !import_fs.default.existsSync(artifactPath)
+    );
     if (missing.length > 0) {
       throw new UsageProofError(
         UsageProofErrorCodes.ARTIFACTS_MISSING,
@@ -1146,7 +2227,9 @@ var UsageService = class {
       const raw = import_fs.default.readFileSync(this.config.verificationKeyPath, "utf8");
       const vkey = JSON.parse(raw);
       if (vkey.protocol !== "groth16") {
-        throw new Error(`Unsupported protocol: ${String(vkey.protocol || "unknown")}`);
+        throw new Error(
+          `Unsupported protocol: ${String(vkey.protocol || "unknown")}`
+        );
       }
       if (typeof vkey.nPublic === "number" && vkey.nPublic !== 7) {
         throw new Error(`Expected 7 public inputs, received ${vkey.nPublic}`);
@@ -1259,13 +2342,12 @@ var UsageService = class {
 };
 
 // src/services/settlement.ts
-var import_viem3 = require("viem");
-var import_chains3 = require("viem/chains");
-var import_sdk4 = require("@arcenpay/sdk");
+var import_viem5 = require("viem");
+var import_chains7 = require("viem/chains");
 var CHAIN_MAP3 = {
-  11155111: import_chains3.sepolia,
-  84532: import_chains3.baseSepolia,
-  8453: import_chains3.base
+  11155111: import_chains7.sepolia,
+  84532: import_chains7.baseSepolia,
+  8453: import_chains7.base
 };
 var SettlementService = class {
   rpcUrl;
@@ -1278,14 +2360,14 @@ var SettlementService = class {
   publicClient;
   constructor(config) {
     this.rpcUrl = config.rpcUrl;
-    this.chainId = config.chainId ?? import_sdk4.DEFAULT_CHAIN_ID;
-    const contracts = (0, import_sdk4.getContractAddresses)(this.chainId);
+    this.chainId = config.chainId ?? DEFAULT_CHAIN_ID;
+    const contracts = getContractAddresses(this.chainId);
     this.zkVerifierAddress = config.zkVerifierAddress || contracts.zkUsageVerifier;
     this.sessionVaultAddress = config.sessionVaultAddress || contracts.sessionVault;
-    const chain = CHAIN_MAP3[this.chainId] || import_chains3.baseSepolia;
-    this.publicClient = (0, import_viem3.createPublicClient)({
+    const chain = CHAIN_MAP3[this.chainId] || import_chains7.baseSepolia;
+    this.publicClient = (0, import_viem5.createPublicClient)({
       chain,
-      transport: (0, import_viem3.http)(this.rpcUrl)
+      transport: (0, import_viem5.http)(this.rpcUrl)
     });
   }
   /**
@@ -1295,7 +2377,7 @@ var SettlementService = class {
     try {
       const balance = await this.publicClient.readContract({
         address: this.sessionVaultAddress,
-        abi: import_sdk4.SessionVaultABI,
+        abi: SessionVaultABI,
         functionName: "getAgentBalance",
         args: [agentAddress]
       });
@@ -1312,7 +2394,7 @@ var SettlementService = class {
     try {
       const session = await this.publicClient.readContract({
         address: this.sessionVaultAddress,
-        abi: import_sdk4.SessionVaultABI,
+        abi: SessionVaultABI,
         functionName: "getSession",
         args: [sessionId]
       });
@@ -1406,14 +2488,13 @@ var SettlementService = class {
 };
 
 // src/services/settlement-writer.ts
-var import_viem4 = require("viem");
-var import_accounts2 = require("viem/accounts");
-var import_chains4 = require("viem/chains");
-var import_sdk5 = require("@arcenpay/sdk");
+var import_viem6 = require("viem");
+var import_accounts3 = require("viem/accounts");
+var import_chains8 = require("viem/chains");
 var CHAIN_MAP4 = {
-  11155111: import_chains4.sepolia,
-  84532: import_chains4.baseSepolia,
-  8453: import_chains4.base
+  11155111: import_chains8.sepolia,
+  84532: import_chains8.baseSepolia,
+  8453: import_chains8.base
 };
 function isBytes32(value) {
   return /^0x[a-fA-F0-9]{64}$/.test(value);
@@ -1422,11 +2503,19 @@ function normalizeSession(raw) {
   const value = raw;
   const agent = value?.agent ?? value?.[0] ?? "0x0000000000000000000000000000000000000000";
   const token = value?.token ?? value?.[1] ?? "0x0000000000000000000000000000000000000000";
-  const balance = BigInt(value?.balance ?? value?.[2] ?? 0n);
-  const totalFunded = BigInt(value?.totalFunded ?? value?.[3] ?? 0n);
-  const totalSettled = BigInt(value?.totalSettled ?? value?.[4] ?? 0n);
+  const balance = BigInt(
+    value?.balance ?? value?.[2] ?? 0n
+  );
+  const totalFunded = BigInt(
+    value?.totalFunded ?? value?.[3] ?? 0n
+  );
+  const totalSettled = BigInt(
+    value?.totalSettled ?? value?.[4] ?? 0n
+  );
   const active = Boolean(value?.active ?? value?.[5] ?? false);
-  const createdAt = BigInt(value?.createdAt ?? value?.[6] ?? 0n);
+  const createdAt = BigInt(
+    value?.createdAt ?? value?.[6] ?? 0n
+  );
   return {
     agent,
     token,
@@ -1447,29 +2536,31 @@ var SettlementWriterService = class {
   publicClient;
   walletClient;
   constructor(config) {
-    this.chainId = config.chainId ?? import_sdk5.DEFAULT_CHAIN_ID;
-    const chain = CHAIN_MAP4[this.chainId] || import_chains4.baseSepolia;
-    const contracts = (0, import_sdk5.getContractAddresses)(this.chainId);
+    this.chainId = config.chainId ?? DEFAULT_CHAIN_ID;
+    const chain = CHAIN_MAP4[this.chainId] || import_chains8.baseSepolia;
+    const contracts = getContractAddresses(this.chainId);
     this.sessionVaultAddress = config.sessionVaultAddress || contracts.sessionVault;
     this.feeCollectorAddress = config.feeCollectorAddress || contracts.feeCollector;
-    const account = (0, import_accounts2.privateKeyToAccount)(config.privateKey);
+    const account = (0, import_accounts3.privateKeyToAccount)(config.privateKey);
     this.signerAddress = account.address;
     this.providerAddress = config.providerAddress || account.address;
     this.waitForReceipt = config.waitForReceipt ?? true;
-    if (!(0, import_viem4.isAddress)(this.sessionVaultAddress)) {
-      throw new Error("Invalid SessionVault address for SettlementWriterService");
+    if (!(0, import_viem6.isAddress)(this.sessionVaultAddress)) {
+      throw new Error(
+        "Invalid SessionVault address for SettlementWriterService"
+      );
     }
-    if (!(0, import_viem4.isAddress)(this.providerAddress)) {
+    if (!(0, import_viem6.isAddress)(this.providerAddress)) {
       throw new Error("Invalid provider address for SettlementWriterService");
     }
-    this.publicClient = (0, import_viem4.createPublicClient)({
+    this.publicClient = (0, import_viem6.createPublicClient)({
       chain,
-      transport: (0, import_viem4.http)(config.rpcUrl || chain.rpcUrls.default.http[0])
+      transport: (0, import_viem6.http)(config.rpcUrl || chain.rpcUrls.default.http[0])
     });
-    this.walletClient = (0, import_viem4.createWalletClient)({
+    this.walletClient = (0, import_viem6.createWalletClient)({
       account,
       chain,
-      transport: (0, import_viem4.http)(config.rpcUrl || chain.rpcUrls.default.http[0])
+      transport: (0, import_viem6.http)(config.rpcUrl || chain.rpcUrls.default.http[0])
     });
   }
   getSignerAddress() {
@@ -1479,12 +2570,12 @@ var SettlementWriterService = class {
     return this.sessionVaultAddress;
   }
   async isSignerAuthorized(address = this.signerAddress) {
-    if (!(0, import_viem4.isAddress)(address)) {
+    if (!(0, import_viem6.isAddress)(address)) {
       return false;
     }
     const authorized = await this.publicClient.readContract({
       address: this.sessionVaultAddress,
-      abi: import_sdk5.SessionVaultABI,
+      abi: SessionVaultABI,
       functionName: "authorizedSettlers",
       args: [address]
     });
@@ -1493,7 +2584,7 @@ var SettlementWriterService = class {
   async getSession(sessionId) {
     const rawSession = await this.publicClient.readContract({
       address: this.sessionVaultAddress,
-      abi: import_sdk5.SessionVaultABI,
+      abi: SessionVaultABI,
       functionName: "getSession",
       args: [sessionId]
     });
@@ -1506,7 +2597,7 @@ var SettlementWriterService = class {
     }
     const sessionIds = await this.publicClient.readContract({
       address: this.sessionVaultAddress,
-      abi: import_sdk5.SessionVaultABI,
+      abi: SessionVaultABI,
       functionName: "getAgentSessions",
       args: [signer]
     });
@@ -1523,13 +2614,16 @@ var SettlementWriterService = class {
     throw new Error("No active billing session found for signer");
   }
   async settleForSigner(input) {
-    if (!(0, import_viem4.isAddress)(input.signer)) {
+    if (!(0, import_viem6.isAddress)(input.signer)) {
       throw new Error("Invalid signer address for settlement");
     }
     if (input.amount <= 0n) {
       throw new Error("Settlement amount must be greater than zero");
     }
-    const resolvedSessionId = await this.resolveSessionId(input.sessionIdHint, input.signer);
+    const resolvedSessionId = await this.resolveSessionId(
+      input.sessionIdHint,
+      input.signer
+    );
     const session = await this.getSession(resolvedSessionId);
     if (!session.active) {
       throw new Error("Session is not active");
@@ -1543,31 +2637,36 @@ var SettlementWriterService = class {
       );
     }
     const providerAddress = input.providerAddress || this.providerAddress;
-    if (!(0, import_viem4.isAddress)(providerAddress)) {
+    if (!(0, import_viem6.isAddress)(providerAddress)) {
       throw new Error("Invalid settlement provider address");
     }
     const txHash = await this.walletClient.writeContract({
       address: this.sessionVaultAddress,
-      abi: import_sdk5.SessionVaultABI,
+      abi: SessionVaultABI,
       functionName: "settle",
       args: [resolvedSessionId, input.amount, providerAddress]
     });
     if (this.waitForReceipt) {
       await this.publicClient.waitForTransactionReceipt({ hash: txHash });
     }
-    if ((0, import_viem4.isAddress)(this.feeCollectorAddress)) {
+    if ((0, import_viem6.isAddress)(this.feeCollectorAddress)) {
       try {
         const feeTxHash = await this.walletClient.writeContract({
           address: this.feeCollectorAddress,
-          abi: import_sdk5.FeeCollectorABI,
+          abi: FeeCollectorABI,
           functionName: "collectSettlementFeeFor",
           args: [input.amount, providerAddress]
         });
         if (this.waitForReceipt) {
-          await this.publicClient.waitForTransactionReceipt({ hash: feeTxHash });
+          await this.publicClient.waitForTransactionReceipt({
+            hash: feeTxHash
+          });
         }
       } catch (err) {
-        console.warn("[SettlementWriter] Fee collection failed (non-fatal):", err);
+        console.warn(
+          "[SettlementWriter] Fee collection failed (non-fatal):",
+          err
+        );
       }
     }
     return {
@@ -1580,13 +2679,12 @@ var SettlementWriterService = class {
 };
 
 // src/services/events.ts
-var import_viem5 = require("viem");
-var import_chains5 = require("viem/chains");
-var import_sdk6 = require("@arcenpay/sdk");
+var import_viem7 = require("viem");
+var import_chains9 = require("viem/chains");
 var CHAIN_MAP5 = {
-  11155111: import_chains5.sepolia,
-  84532: import_chains5.baseSepolia,
-  8453: import_chains5.base
+  11155111: import_chains9.sepolia,
+  84532: import_chains9.baseSepolia,
+  8453: import_chains9.base
 };
 var EventListenerService = class {
   publicClient;
@@ -1596,14 +2694,14 @@ var EventListenerService = class {
   pollInterval = null;
   lastBlock = 0n;
   constructor(config) {
-    const chainId = config.chainId ?? import_sdk6.DEFAULT_CHAIN_ID;
-    const chain = CHAIN_MAP5[chainId] || import_chains5.baseSepolia;
-    const contracts = (0, import_sdk6.getContractAddresses)(chainId);
+    const chainId = config.chainId ?? DEFAULT_CHAIN_ID;
+    const chain = CHAIN_MAP5[chainId] || import_chains9.baseSepolia;
+    const contracts = getContractAddresses(chainId);
     this.registryAddress = config.registryAddress || contracts.subscriptionRegistry;
     this.autopayModuleAddress = contracts.autopayModule;
-    this.publicClient = (0, import_viem5.createPublicClient)({
+    this.publicClient = (0, import_viem7.createPublicClient)({
       chain,
-      transport: (0, import_viem5.http)(config.rpcUrl)
+      transport: (0, import_viem7.http)(config.rpcUrl)
     });
   }
   /**
@@ -1615,7 +2713,10 @@ var EventListenerService = class {
     this.callbacks.set(eventType, existing);
     return () => {
       const cbs = this.callbacks.get(eventType) || [];
-      this.callbacks.set(eventType, cbs.filter((cb) => cb !== callback));
+      this.callbacks.set(
+        eventType,
+        cbs.filter((cb) => cb !== callback)
+      );
     };
   }
   /**
@@ -1627,7 +2728,9 @@ var EventListenerService = class {
     } catch {
       this.lastBlock = 0n;
     }
-    console.log(`[EventListener] Watching SubscriptionRegistry at ${this.registryAddress} from block ${this.lastBlock}`);
+    console.log(
+      `[EventListener] Watching SubscriptionRegistry at ${this.registryAddress} from block ${this.lastBlock}`
+    );
     this.pollInterval = setInterval(async () => {
       await this.poll();
     }, intervalMs);
@@ -1651,7 +2754,13 @@ var EventListenerService = class {
       if (currentBlock <= this.lastBlock) return;
       const addr = this.registryAddress;
       const from = this.lastBlock + 1n;
-      const [mintedLogs, renewedLogs, cancelledLogs, planChangedLogs, billingLogs] = await Promise.all([
+      const [
+        mintedLogs,
+        renewedLogs,
+        cancelledLogs,
+        planChangedLogs,
+        billingLogs
+      ] = await Promise.all([
         this.publicClient.getLogs({
           address: addr,
           event: {
@@ -1686,9 +2795,7 @@ var EventListenerService = class {
           event: {
             type: "event",
             name: "SubscriptionCancelled",
-            inputs: [
-              { name: "tokenId", type: "uint256", indexed: true }
-            ]
+            inputs: [{ name: "tokenId", type: "uint256", indexed: true }]
           },
           fromBlock: from,
           toBlock: currentBlock
@@ -1798,7 +2905,9 @@ var EventListenerService = class {
    * Dispatch event to registered callbacks
    */
   async emit(event) {
-    console.log(`[EventListener] ${event.type} \u2014 tokenId=${event.tokenId} tx=${event.transactionHash}`);
+    console.log(
+      `[EventListener] ${event.type} \u2014 tokenId=${event.tokenId} tx=${event.transactionHash}`
+    );
     const typeCallbacks = this.callbacks.get(event.type) || [];
     const wildcardCallbacks = this.callbacks.get("*") || [];
     for (const cb of [...typeCallbacks, ...wildcardCallbacks]) {
@@ -1872,7 +2981,10 @@ var WebhookService = class {
         deliveredAt: Date.now(),
         success: response.ok
       });
-      await this.persistDelivery(this.deliveryLog[this.deliveryLog.length - 1], payload);
+      await this.persistDelivery(
+        this.deliveryLog[this.deliveryLog.length - 1],
+        payload
+      );
       if (!response.ok && attempt < this.config.maxRetries) {
         await this.scheduleRetry(payload, attempt);
       }
@@ -1887,7 +2999,10 @@ var WebhookService = class {
         success: false,
         error: err.message
       });
-      await this.persistDelivery(this.deliveryLog[this.deliveryLog.length - 1], payload);
+      await this.persistDelivery(
+        this.deliveryLog[this.deliveryLog.length - 1],
+        payload
+      );
       if (attempt < this.config.maxRetries) {
         await this.scheduleRetry(payload, attempt);
       }
@@ -1905,7 +3020,9 @@ var WebhookService = class {
   async scheduleRetry(payload, currentAttempt) {
     const delay = this.config.retryDelays[currentAttempt - 1] || 18e5;
     const retryId = `retry-${payload.event}-${currentAttempt}`;
-    console.log(`[Webhook] Scheduling retry ${currentAttempt + 1} in ${delay}ms for ${payload.event}`);
+    console.log(
+      `[Webhook] Scheduling retry ${currentAttempt + 1} in ${delay}ms for ${payload.event}`
+    );
     const timer = setTimeout(() => {
       this.deliver(payload, currentAttempt + 1);
       this.pendingRetries.delete(retryId);
@@ -1920,7 +3037,9 @@ var WebhookService = class {
     if (this.deliveryLog.length > 1e3) {
       this.deliveryLog = this.deliveryLog.slice(-500);
     }
-    console.log(`[Webhook] ${entry.success ? "\u2705" : "\u274C"} ${entry.event} \u2192 ${entry.statusCode} (attempt ${entry.attemptNumber})`);
+    console.log(
+      `[Webhook] ${entry.success ? "\u2705" : "\u274C"} ${entry.event} \u2192 ${entry.statusCode} (attempt ${entry.attemptNumber})`
+    );
   }
   async persistDelivery(entry, payload) {
     if (!entry || !this.config.onDelivery) return;
@@ -2005,7 +3124,9 @@ var EmailService = class {
         return { success: false, error: err };
       }
       const result = await response.json();
-      console.log(`[Email] \u2705 Sent ${template} to ${recipient.email} (${result.id})`);
+      console.log(
+        `[Email] \u2705 Sent ${template} to ${recipient.email} (${result.id})`
+      );
       return { success: true, messageId: result.id };
     } catch (err) {
       console.error(`[Email] Error sending ${template}:`, err.message);
@@ -2336,7 +3457,9 @@ var TablelandService = class {
   }
   ensureInitialized() {
     if (!this.initialized || !this.dbRead) {
-      throw new Error("[Tableland] Service not initialized. Call initialize() first.");
+      throw new Error(
+        "[Tableland] Service not initialized. Call initialize() first."
+      );
     }
   }
   ensureWritable() {
@@ -2356,7 +3479,7 @@ var TablelandService = class {
 };
 
 // src/services/lit.ts
-var import_constants = require("@lit-protocol/constants");
+var import_constants2 = require("@lit-protocol/constants");
 var import_encryption = require("@lit-protocol/encryption");
 var import_lit_node_client = require("@lit-protocol/lit-node-client");
 var LitProtocolService = class {
@@ -2370,13 +3493,13 @@ var LitProtocolService = class {
       switch (this.config.network) {
         case "habanero":
         case "datil":
-          return import_constants.LIT_NETWORK.Datil;
+          return import_constants2.LIT_NETWORK.Datil;
         case "datil-test":
         case "manzano":
-          return import_constants.LIT_NETWORK.DatilTest;
+          return import_constants2.LIT_NETWORK.DatilTest;
         case "datil-dev":
         default:
-          return import_constants.LIT_NETWORK.DatilDev;
+          return import_constants2.LIT_NETWORK.DatilDev;
       }
     })();
     this.litClient = new import_lit_node_client.LitNodeClient({
@@ -2496,7 +3619,9 @@ var AggregatorService = class {
     this.logs.set(entry.sessionId, existing);
     const thresholdReached = existing.length >= this.settlementThreshold;
     if (thresholdReached) {
-      console.log(`[Aggregator] Threshold reached for session ${entry.sessionId} (${existing.length} entries)`);
+      console.log(
+        `[Aggregator] Threshold reached for session ${entry.sessionId} (${existing.length} entries)`
+      );
     }
     return { totalEntries: existing.length, thresholdReached };
   }
@@ -2507,12 +3632,12 @@ var AggregatorService = class {
   buildMerkleTree(sessionId) {
     const entries = this.logs.get(sessionId) || [];
     if (entries.length === 0) return "0x" + "0".repeat(64);
-    const leaves = entries.map(
-      (entry) => this.hashEntry(entry)
-    );
+    const leaves = entries.map((entry) => this.hashEntry(entry));
     const root = this.computeMerkleRoot(leaves);
     this.merkleRoots.set(sessionId, root);
-    console.log(`[Aggregator] Merkle root for ${sessionId}: ${root} (${entries.length} leaves)`);
+    console.log(
+      `[Aggregator] Merkle root for ${sessionId}: ${root} (${entries.length} leaves)`
+    );
     return root;
   }
   /**
@@ -2543,7 +3668,9 @@ var AggregatorService = class {
       entries.filter((e) => e.timestamp > windowEnd)
     );
     this.merkleRoots.delete(sessionId);
-    console.log(`[Aggregator] Cleared entries for ${sessionId} before ${windowEnd}`);
+    console.log(
+      `[Aggregator] Cleared entries for ${sessionId} before ${windowEnd}`
+    );
   }
   /**
    * Get aggregation stats for monitoring
@@ -2584,7 +3711,9 @@ var AggregatorService = class {
       const nextLevel = [];
       for (let i = 0; i < currentLevel.length; i += 2) {
         const combined = currentLevel[i] + currentLevel[i + 1].slice(2);
-        nextLevel.push("0x" + (0, import_crypto3.createHash)("sha256").update(combined).digest("hex"));
+        nextLevel.push(
+          "0x" + (0, import_crypto3.createHash)("sha256").update(combined).digest("hex")
+        );
       }
       currentLevel = nextLevel;
     }
@@ -2639,7 +3768,11 @@ var RedisUsageStore = class {
       await this.connect();
     }
     const upper = Math.max(0, limit - 1);
-    const values = await this.client.lRange(sessionKey(this.config.keyPrefix, sessionId), 0, upper);
+    const values = await this.client.lRange(
+      sessionKey(this.config.keyPrefix, sessionId),
+      0,
+      upper
+    );
     return values.map((value) => {
       try {
         return JSON.parse(value);
@@ -2652,14 +3785,24 @@ var RedisUsageStore = class {
     if (!this.connected) {
       await this.connect();
     }
-    await this.client.hSet(settlementKey(this.config.keyPrefix), sessionId, txHash);
-    await this.client.expire(settlementKey(this.config.keyPrefix), this.config.ttlSeconds);
+    await this.client.hSet(
+      settlementKey(this.config.keyPrefix),
+      sessionId,
+      txHash
+    );
+    await this.client.expire(
+      settlementKey(this.config.keyPrefix),
+      this.config.ttlSeconds
+    );
   }
   async getLatestSettlementTx(sessionId) {
     if (!this.connected) {
       await this.connect();
     }
-    const txHash = await this.client.hGet(settlementKey(this.config.keyPrefix), sessionId);
+    const txHash = await this.client.hGet(
+      settlementKey(this.config.keyPrefix),
+      sessionId
+    );
     return txHash ?? null;
   }
   async stop() {
@@ -2886,14 +4029,13 @@ var ProofOrchestrator = class {
 };
 
 // src/services/transport-axelar.ts
-var import_viem6 = require("viem");
-var import_accounts3 = require("viem/accounts");
-var import_chains6 = require("viem/chains");
-var import_sdk8 = require("@arcenpay/sdk");
+var import_viem8 = require("viem");
+var import_accounts4 = require("viem/accounts");
+var import_chains10 = require("viem/chains");
 var CHAIN_MAP6 = {
-  11155111: import_chains6.sepolia,
-  84532: import_chains6.baseSepolia,
-  8453: import_chains6.base
+  11155111: import_chains10.sepolia,
+  84532: import_chains10.baseSepolia,
+  8453: import_chains10.base
 };
 var AXELAR_CHAIN_NAMES = {
   1: "ethereum",
@@ -2952,18 +4094,18 @@ var AxelarTransport = class {
   signerAddress;
   constructor(config) {
     this.config = config;
-    this.chainId = config.chainId ?? import_sdk8.DEFAULT_CHAIN_ID;
-    const chain = CHAIN_MAP6[this.chainId] || import_chains6.baseSepolia;
-    const account = (0, import_accounts3.privateKeyToAccount)(config.privateKey);
+    this.chainId = config.chainId ?? DEFAULT_CHAIN_ID;
+    const chain = CHAIN_MAP6[this.chainId] || import_chains10.baseSepolia;
+    const account = (0, import_accounts4.privateKeyToAccount)(config.privateKey);
     this.signerAddress = account.address;
-    this.publicClient = (0, import_viem6.createPublicClient)({
+    this.publicClient = (0, import_viem8.createPublicClient)({
       chain,
-      transport: (0, import_viem6.http)(config.rpcUrl)
+      transport: (0, import_viem8.http)(config.rpcUrl)
     });
-    this.walletClient = (0, import_viem6.createWalletClient)({
+    this.walletClient = (0, import_viem8.createWalletClient)({
       account,
       chain,
-      transport: (0, import_viem6.http)(config.rpcUrl)
+      transport: (0, import_viem8.http)(config.rpcUrl)
     });
   }
   /**
@@ -3050,14 +4192,13 @@ var AxelarTransport = class {
 };
 
 // src/services/transport-ccip.ts
-var import_viem7 = require("viem");
-var import_accounts4 = require("viem/accounts");
-var import_chains7 = require("viem/chains");
-var import_sdk9 = require("@arcenpay/sdk");
+var import_viem9 = require("viem");
+var import_accounts5 = require("viem/accounts");
+var import_chains11 = require("viem/chains");
 var CHAIN_MAP7 = {
-  11155111: import_chains7.sepolia,
-  84532: import_chains7.baseSepolia,
-  8453: import_chains7.base
+  11155111: import_chains11.sepolia,
+  84532: import_chains11.baseSepolia,
+  8453: import_chains11.base
 };
 var CCIP_CHAIN_SELECTORS = {
   1: 5009297550715157269n,
@@ -3142,19 +4283,19 @@ var CCIPTransport = class {
   gasLimit;
   constructor(config) {
     this.config = config;
-    this.chainId = config.chainId ?? import_sdk9.DEFAULT_CHAIN_ID;
+    this.chainId = config.chainId ?? DEFAULT_CHAIN_ID;
     this.gasLimit = config.gasLimit || 200000n;
-    const chain = CHAIN_MAP7[this.chainId] || import_chains7.baseSepolia;
-    const account = (0, import_accounts4.privateKeyToAccount)(config.privateKey);
+    const chain = CHAIN_MAP7[this.chainId] || import_chains11.baseSepolia;
+    const account = (0, import_accounts5.privateKeyToAccount)(config.privateKey);
     this.signerAddress = account.address;
-    this.publicClient = (0, import_viem7.createPublicClient)({
+    this.publicClient = (0, import_viem9.createPublicClient)({
       chain,
-      transport: (0, import_viem7.http)(config.rpcUrl)
+      transport: (0, import_viem9.http)(config.rpcUrl)
     });
-    this.walletClient = (0, import_viem7.createWalletClient)({
+    this.walletClient = (0, import_viem9.createWalletClient)({
       account,
       chain,
-      transport: (0, import_viem7.http)(config.rpcUrl)
+      transport: (0, import_viem9.http)(config.rpcUrl)
     });
   }
   /**
@@ -3226,7 +4367,10 @@ var CCIPTransport = class {
         address: this.config.routerAddress,
         abi: CCIP_ROUTER_ABI,
         functionName: "getFee",
-        args: [destSelector, this.buildMessage(payload, destinationAddressOverride)]
+        args: [
+          destSelector,
+          this.buildMessage(payload, destinationAddressOverride)
+        ]
       });
     } catch {
       return 5000000000000000n;
@@ -3241,14 +4385,13 @@ var CCIPTransport = class {
 };
 
 // src/services/keeper.ts
-var import_viem8 = require("viem");
-var import_accounts5 = require("viem/accounts");
-var import_chains8 = require("viem/chains");
-var import_sdk10 = require("@arcenpay/sdk");
+var import_viem10 = require("viem");
+var import_accounts6 = require("viem/accounts");
+var import_chains12 = require("viem/chains");
 var CHAIN_MAP8 = {
-  11155111: import_chains8.sepolia,
-  84532: import_chains8.baseSepolia,
-  8453: import_chains8.base
+  11155111: import_chains12.sepolia,
+  84532: import_chains12.baseSepolia,
+  8453: import_chains12.base
 };
 var BillingKeeper = class {
   chainId;
@@ -3265,24 +4408,24 @@ var BillingKeeper = class {
   renewalLog = [];
   callbacks = [];
   constructor(config) {
-    this.chainId = config.chainId ?? import_sdk10.DEFAULT_CHAIN_ID;
-    const chain = CHAIN_MAP8[this.chainId] || import_chains8.baseSepolia;
-    const contracts = (0, import_sdk10.getContractAddresses)(this.chainId);
+    this.chainId = config.chainId ?? DEFAULT_CHAIN_ID;
+    const chain = CHAIN_MAP8[this.chainId] || import_chains12.baseSepolia;
+    const contracts = getContractAddresses(this.chainId);
     this.registryAddress = contracts.subscriptionRegistry;
     this.autopayModuleAddress = contracts.autopayModule;
     this.intervalMs = config.intervalMs || 6e4;
     this.batchSize = config.batchSize || 20;
     this.renewalBufferSeconds = config.renewalBufferSeconds || 86400;
-    const account = (0, import_accounts5.privateKeyToAccount)(config.privateKey);
+    const account = (0, import_accounts6.privateKeyToAccount)(config.privateKey);
     this.signerAddress = account.address;
-    this.publicClient = (0, import_viem8.createPublicClient)({
+    this.publicClient = (0, import_viem10.createPublicClient)({
       chain,
-      transport: (0, import_viem8.http)(config.rpcUrl)
+      transport: (0, import_viem10.http)(config.rpcUrl)
     });
-    this.walletClient = (0, import_viem8.createWalletClient)({
+    this.walletClient = (0, import_viem10.createWalletClient)({
       account,
       chain,
-      transport: (0, import_viem8.http)(config.rpcUrl)
+      transport: (0, import_viem10.http)(config.rpcUrl)
     });
   }
   /**
@@ -3372,7 +4515,7 @@ var BillingKeeper = class {
     try {
       const totalSupply = await this.publicClient.readContract({
         address: this.registryAddress,
-        abi: import_sdk10.SubscriptionRegistryABI,
+        abi: SubscriptionRegistryABI,
         functionName: "totalSupply"
       });
       const tokenIds = [];
@@ -3380,13 +4523,13 @@ var BillingKeeper = class {
         try {
           const tokenId = await this.publicClient.readContract({
             address: this.registryAddress,
-            abi: import_sdk10.SubscriptionRegistryABI,
+            abi: SubscriptionRegistryABI,
             functionName: "tokenByIndex",
             args: [index]
           });
           const expiresAt = await this.publicClient.readContract({
             address: this.registryAddress,
-            abi: import_sdk10.SubscriptionRegistryABI,
+            abi: SubscriptionRegistryABI,
             functionName: "expiresAt",
             args: [tokenId]
           });
@@ -3402,7 +4545,10 @@ var BillingKeeper = class {
       }
       return tokenIds;
     } catch (err) {
-      console.error("[BillingKeeper] Error finding expiring subscriptions:", err);
+      console.error(
+        "[BillingKeeper] Error finding expiring subscriptions:",
+        err
+      );
       return [];
     }
   }
@@ -3413,7 +4559,7 @@ var BillingKeeper = class {
     try {
       const subscriber = await this.publicClient.readContract({
         address: this.registryAddress,
-        abi: import_sdk10.SubscriptionRegistryABI,
+        abi: SubscriptionRegistryABI,
         functionName: "ownerOf",
         args: [tokenId]
       });
@@ -3426,11 +4572,13 @@ var BillingKeeper = class {
       }
       const config = await this.publicClient.readContract({
         address: this.autopayModuleAddress,
-        abi: import_sdk10.ERC7579AutopayModuleABI,
+        abi: ERC7579AutopayModuleABI,
         functionName: "getConfig",
         args: [subscriber]
       });
-      const merchant = String(config?.merchant ?? config?.[0] ?? "").toLowerCase();
+      const merchant = String(
+        config?.merchant ?? config?.[0] ?? ""
+      ).toLowerCase();
       const amount = BigInt(config?.maxAmount ?? config?.[1] ?? 0);
       if (amount <= 0n) {
         console.log(
@@ -3445,7 +4593,7 @@ var BillingKeeper = class {
       }
       const txHash = await this.walletClient.writeContract({
         address: this.autopayModuleAddress,
-        abi: import_sdk10.ERC7579AutopayModuleABI,
+        abi: ERC7579AutopayModuleABI,
         functionName: "execute",
         args: [subscriber, amount]
       });
@@ -3482,7 +4630,7 @@ var BillingKeeper = class {
     try {
       const config = await this.publicClient.readContract({
         address: this.autopayModuleAddress,
-        abi: import_sdk10.ERC7579AutopayModuleABI,
+        abi: ERC7579AutopayModuleABI,
         functionName: "getConfig",
         args: [subscriber]
       });