@vera-pay/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,1409 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CADENCE_HANDLERS: () => CADENCE_HANDLERS,
+  DEFAULT_IPFS_GATEWAY: () => DEFAULT_IPFS_GATEWAY,
+  DEPLOYED_CONTRACTS: () => DEPLOYED_CONTRACTS,
+  ERC20_ABI: () => ERC20_ABI,
+  FlowScheduler: () => FlowScheduler,
+  KNOWN_TOKENS: () => KNOWN_TOKENS,
+  NETWORKS: () => NETWORKS,
+  VERA_PAY_ABI: () => VERA_PAY_ABI,
+  VeraPayClient: () => VeraPayClient,
+  buildPaymentReceipt: () => buildPaymentReceipt,
+  createKuboAdapter: () => createKuboAdapter,
+  createMemoryAdapter: () => createMemoryAdapter,
+  createStorachaAdapter: () => createStorachaAdapter,
+  ipfsGatewayUrl: () => ipfsGatewayUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var import_ethers = require("ethers");
+
+// src/abi.ts
+var VERA_PAY_ABI = [
+  {
+    type: "constructor",
+    inputs: [
+      { name: "_feeRecipient", type: "address" },
+      { name: "_feeBps", type: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "createPlan",
+    inputs: [
+      { name: "_paymentToken", type: "address" },
+      { name: "_amount", type: "uint256" },
+      { name: "_interval", type: "uint256" },
+      { name: "_name", type: "string" },
+      { name: "_metadataURI", type: "string" }
+    ],
+    outputs: [{ name: "planId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "togglePlan",
+    inputs: [{ name: "_planId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "subscribe",
+    inputs: [{ name: "_planId", type: "uint256" }],
+    outputs: [{ name: "subId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "cancelSubscription",
+    inputs: [{ name: "_subId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "processPayment",
+    inputs: [{ name: "_subId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "batchProcessPayments",
+    inputs: [{ name: "_subIds", type: "uint256[]" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getPlan",
+    inputs: [{ name: "_planId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "merchant", type: "address" },
+          { name: "paymentToken", type: "address" },
+          { name: "amount", type: "uint256" },
+          { name: "interval", type: "uint256" },
+          { name: "name", type: "string" },
+          { name: "metadataURI", type: "string" },
+          { name: "active", type: "bool" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getSubscription",
+    inputs: [{ name: "_subId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "planId", type: "uint256" },
+          { name: "subscriber", type: "address" },
+          { name: "startTime", type: "uint256" },
+          { name: "lastPaymentTime", type: "uint256" },
+          { name: "paymentsCount", type: "uint256" },
+          { name: "active", type: "bool" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getMerchantPlans",
+    inputs: [{ name: "_merchant", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getSubscriberSubscriptions",
+    inputs: [{ name: "_subscriber", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isPaymentDue",
+    inputs: [{ name: "_subId", type: "uint256" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getDuePayments",
+    inputs: [{ name: "_subIds", type: "uint256[]" }],
+    outputs: [{ name: "due", type: "uint256[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "nextPlanId",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "nextSubscriptionId",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "protocolFeeBps",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "activeSub",
+    inputs: [
+      { name: "planId", type: "uint256" },
+      { name: "subscriber", type: "address" }
+    ],
+    outputs: [{ name: "subId", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "PlanCreated",
+    inputs: [
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "merchant", type: "address", indexed: true },
+      { name: "paymentToken", type: "address", indexed: false },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "interval", type: "uint256", indexed: false },
+      { name: "name", type: "string", indexed: false },
+      { name: "metadataURI", type: "string", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PlanToggled",
+    inputs: [
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "active", type: "bool", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Subscribed",
+    inputs: [
+      { name: "subscriptionId", type: "uint256", indexed: true },
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "subscriber", type: "address", indexed: true }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "PaymentProcessed",
+    inputs: [
+      { name: "subscriptionId", type: "uint256", indexed: true },
+      { name: "planId", type: "uint256", indexed: true },
+      { name: "subscriber", type: "address", indexed: true },
+      { name: "merchant", type: "address", indexed: false },
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "protocolFee", type: "uint256", indexed: false },
+      { name: "timestamp", type: "uint256", indexed: false }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "SubscriptionCancelled",
+    inputs: [
+      { name: "subscriptionId", type: "uint256", indexed: true },
+      { name: "subscriber", type: "address", indexed: true }
+    ],
+    anonymous: false
+  }
+];
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "decimals",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "symbol",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "mint",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
+
+// src/constants.ts
+var NETWORKS = {
+  "flow-testnet": {
+    chainId: 545,
+    rpcUrl: "https://testnet.evm.nodes.onflow.org",
+    blockExplorer: "https://testnet.explorer.flow.com",
+    evmBlockExplorer: "https://testnet.evm.flow.com",
+    name: "Flow EVM Testnet"
+  },
+  "flow-mainnet": {
+    chainId: 747,
+    rpcUrl: "https://mainnet.evm.nodes.onflow.org",
+    blockExplorer: "https://explorer.flow.com",
+    evmBlockExplorer: "https://evm.flow.com",
+    name: "Flow EVM Mainnet"
+  }
+};
+var DEPLOYED_CONTRACTS = {
+  "flow-testnet": "0x24730C8387C11e6031f692Bf0B14000D93271766"
+};
+var KNOWN_TOKENS = {
+  "flow-testnet": {
+    USDC: "0x9C080703256BDF9Ea1b485aE72f13E31f74C558b",
+    "USDC.e": "0x9B7550D337bB449b89C6f9C926C3b976b6f4095b"
+  },
+  "flow-mainnet": {
+    USDT: "0x674843C06FF83502ddb4D37c2E09C01cdA38cbc8"
+  }
+};
+var CADENCE_HANDLERS = {
+  "flow-testnet": "7c0bf27829276c6b"
+};
+var DEFAULT_IPFS_GATEWAY = "https://storacha.link/ipfs";
+
+// src/ipfs.ts
+function createKuboAdapter(apiUrl) {
+  return {
+    async uploadJson(data) {
+      const blob = new Blob([JSON.stringify(data)], {
+        type: "application/json"
+      });
+      const form = new FormData();
+      form.append("file", blob, "receipt.json");
+      const res = await fetch(`${apiUrl}/api/v0/add?pin=true`, {
+        method: "POST",
+        body: form
+      });
+      if (!res.ok) throw new Error(`IPFS upload failed: ${res.statusText}`);
+      const result = await res.json();
+      return result.Hash;
+    },
+    async fetchJson(cid) {
+      const res = await fetch(`${DEFAULT_IPFS_GATEWAY}/${cid}`);
+      if (!res.ok) throw new Error(`IPFS fetch failed: ${res.statusText}`);
+      return res.json();
+    }
+  };
+}
+function createStorachaAdapter(clientOrConfig) {
+  let resolvedClient = null;
+  let initPromise = null;
+  async function getClient() {
+    if (resolvedClient) return resolvedClient;
+    if ("uploadFile" in clientOrConfig) {
+      resolvedClient = clientOrConfig;
+      return resolvedClient;
+    }
+    if (!initPromise) {
+      initPromise = (async () => {
+        const { key, proof } = clientOrConfig;
+        const Client = await import("@storacha/client");
+        const ed25519 = await import("@storacha/client/principal/ed25519");
+        const { StoreMemory } = await import("@storacha/client/stores/memory");
+        const Proof = await import("@storacha/client/proof");
+        const principal = ed25519.parse(key);
+        const client = await Client.create({ principal, store: new StoreMemory() });
+        const space = await client.addSpace(await Proof.parse(proof));
+        await client.setCurrentSpace(space.did());
+        resolvedClient = client;
+        return client;
+      })();
+    }
+    return initPromise;
+  }
+  return {
+    async uploadJson(data) {
+      const client = await getClient();
+      if (!client) throw new Error("Storacha client failed to initialize");
+      const blob = new Blob([JSON.stringify(data, null, 2)], {
+        type: "application/json"
+      });
+      const cid = await client.uploadFile(blob);
+      return cid.toString();
+    },
+    async fetchJson(cid) {
+      const res = await fetch(`${DEFAULT_IPFS_GATEWAY}/${cid}`);
+      if (!res.ok) throw new Error(`IPFS fetch failed: ${res.statusText}`);
+      return res.json();
+    }
+  };
+}
+function createMemoryAdapter() {
+  const store = /* @__PURE__ */ new Map();
+  let counter = 0;
+  return {
+    async uploadJson(data) {
+      const json = JSON.stringify(data);
+      const cid = `mem_${++counter}_${Date.now()}`;
+      store.set(cid, json);
+      return cid;
+    },
+    async fetchJson(cid) {
+      const json = store.get(cid);
+      if (!json) throw new Error(`CID not found in memory store: ${cid}`);
+      return JSON.parse(json);
+    }
+  };
+}
+function buildPaymentReceipt(event, txHash, blockNumber, chainId) {
+  return {
+    subscriptionId: event.subscriptionId.toString(),
+    planId: event.planId.toString(),
+    subscriber: event.subscriber,
+    merchant: event.merchant,
+    amount: event.amount.toString(),
+    protocolFee: event.protocolFee.toString(),
+    timestamp: Number(event.timestamp),
+    txHash,
+    blockNumber,
+    chainId
+  };
+}
+function ipfsGatewayUrl(cid) {
+  return `${DEFAULT_IPFS_GATEWAY}/${cid}`;
+}
+
+// src/client.ts
+var VeraPayClient = class _VeraPayClient {
+  contract;
+  provider;
+  config;
+  signer;
+  ipfs;
+  constructor(config2, signerOrProvider, ipfsAdapter) {
+    this.config = config2;
+    this.ipfs = ipfsAdapter;
+    if ("getAddress" in signerOrProvider) {
+      this.signer = signerOrProvider;
+      this.provider = signerOrProvider.provider;
+    } else {
+      this.provider = signerOrProvider;
+    }
+    this.contract = new import_ethers.ethers.Contract(
+      config2.contractAddress,
+      VERA_PAY_ABI,
+      this.signer ?? this.provider
+    );
+  }
+  /**
+   * Convenience factory that auto-configures for a known Flow network.
+   */
+  static fromNetwork(network, contractAddress, signerOrProvider, ipfsAdapter) {
+    const net = NETWORKS[network];
+    return new _VeraPayClient(
+      { contractAddress, rpcUrl: net.rpcUrl, chainId: net.chainId },
+      signerOrProvider,
+      ipfsAdapter
+    );
+  }
+  // ── Merchant API ─────────────────────────────────────────────────────
+  async createPlan(params) {
+    this.requireSigner();
+    const tx2 = await this.contract.createPlan(
+      params.paymentToken,
+      params.amount,
+      params.interval,
+      params.name,
+      params.metadataURI ?? ""
+    );
+    const receipt = await tx2.wait();
+    const log = receipt.logs.find(
+      (l) => l.topics[0] === import_ethers.ethers.id(
+        "PlanCreated(uint256,address,address,uint256,uint256,string,string)"
+      )
+    );
+    const planId = log ? BigInt(log.topics[1]) : 0n;
+    return { planId, tx: tx2 };
+  }
+  async togglePlan(planId) {
+    this.requireSigner();
+    return this.contract.togglePlan(planId);
+  }
+  async getMerchantPlans(merchant) {
+    return this.contract.getMerchantPlans(merchant);
+  }
+  // ── Subscriber API ───────────────────────────────────────────────────
+  /**
+   * Approve the VeraPay contract to pull `amount` of the given ERC-20 token,
+   * then subscribe to the plan. Returns subscription ID and the payment receipt
+   * (optionally pinned to IPFS).
+   */
+  async subscribeWithApproval(planId, options) {
+    this.requireSigner();
+    const plan = await this.getPlan(planId);
+    const token = new import_ethers.ethers.Contract(
+      plan.paymentToken,
+      ERC20_ABI,
+      this.signer
+    );
+    const approveAmount = options?.approveMax ? import_ethers.ethers.MaxUint256 : plan.amount * 12n;
+    const approveTx = await token.approve(
+      this.config.contractAddress,
+      approveAmount
+    );
+    await approveTx.wait();
+    return this.subscribe(planId);
+  }
+  async subscribe(planId) {
+    this.requireSigner();
+    const tx2 = await this.contract.subscribe(planId);
+    const txReceipt = await tx2.wait();
+    const paymentReceipt = await this.extractPaymentReceipt(txReceipt);
+    const subLog = txReceipt.logs.find(
+      (l) => l.topics[0] === import_ethers.ethers.id("Subscribed(uint256,uint256,address)")
+    );
+    const subscriptionId = subLog ? BigInt(subLog.topics[1]) : 0n;
+    return { subscriptionId, receipt: paymentReceipt, tx: tx2 };
+  }
+  async cancelSubscription(subscriptionId) {
+    this.requireSigner();
+    return this.contract.cancelSubscription(subscriptionId);
+  }
+  async getSubscriberSubscriptions(subscriber) {
+    return this.contract.getSubscriberSubscriptions(subscriber);
+  }
+  // ── Keeper / Relayer API ─────────────────────────────────────────────
+  async processPayment(subscriptionId) {
+    this.requireSigner();
+    const tx2 = await this.contract.processPayment(subscriptionId);
+    const txReceipt = await tx2.wait();
+    const receipt = await this.extractPaymentReceipt(txReceipt);
+    return { receipt, tx: tx2 };
+  }
+  async batchProcessPayments(subscriptionIds) {
+    this.requireSigner();
+    return this.contract.batchProcessPayments(subscriptionIds);
+  }
+  async isPaymentDue(subscriptionId) {
+    return this.contract.isPaymentDue(subscriptionId);
+  }
+  async getDuePayments(subscriptionIds) {
+    return this.contract.getDuePayments(subscriptionIds);
+  }
+  /**
+   * Start a polling loop that checks for due payments and processes them.
+   * Returns a cleanup function to stop the loop.
+   */
+  startKeeper(subscriptionIds, intervalMs = 6e4, onPayment, onError) {
+    let running = true;
+    const tick = async () => {
+      if (!running) return;
+      try {
+        const due = await this.getDuePayments(subscriptionIds);
+        for (const subId of due) {
+          const { receipt } = await this.processPayment(subId);
+          onPayment?.(receipt);
+        }
+      } catch (err) {
+        onError?.(err);
+      }
+      if (running) setTimeout(tick, intervalMs);
+    };
+    tick();
+    return () => {
+      running = false;
+    };
+  }
+  // ── Read helpers ─────────────────────────────────────────────────────
+  async getNextPlanId() {
+    return this.contract.nextPlanId();
+  }
+  async getNextSubscriptionId() {
+    return this.contract.nextSubscriptionId();
+  }
+  async listActivePlans() {
+    const nextId = await this.getNextPlanId();
+    const plans = [];
+    for (let i = 0n; i < nextId; i++) {
+      try {
+        const plan = await this.getPlan(i);
+        if (plan.active) plans.push(plan);
+      } catch {
+      }
+    }
+    return plans;
+  }
+  async getPlan(planId) {
+    const raw = await this.contract.getPlan(planId);
+    return {
+      planId,
+      merchant: raw.merchant,
+      paymentToken: raw.paymentToken,
+      amount: raw.amount,
+      interval: raw.interval,
+      name: raw.name,
+      metadataURI: raw.metadataURI,
+      active: raw.active
+    };
+  }
+  async getSubscription(subscriptionId) {
+    const raw = await this.contract.getSubscription(subscriptionId);
+    return {
+      subscriptionId,
+      planId: raw.planId,
+      subscriber: raw.subscriber,
+      startTime: raw.startTime,
+      lastPaymentTime: raw.lastPaymentTime,
+      paymentsCount: raw.paymentsCount,
+      active: raw.active
+    };
+  }
+  async getProtocolFeeBps() {
+    return this.contract.protocolFeeBps();
+  }
+  // ── IPFS ─────────────────────────────────────────────────────────────
+  get hasIPFS() {
+    return !!this.ipfs;
+  }
+  get contractAddress() {
+    return this.config.contractAddress;
+  }
+  /**
+   * Pin a payment receipt to IPFS and return the CID.
+   */
+  async pinReceipt(receipt) {
+    if (!this.ipfs) throw new Error("No IPFS adapter configured");
+    const cid = await this.ipfs.uploadJson(receipt);
+    receipt.ipfsCid = cid;
+    return cid;
+  }
+  async fetchReceipt(cid) {
+    if (!this.ipfs) throw new Error("No IPFS adapter configured");
+    return this.ipfs.fetchJson(cid);
+  }
+  setIPFSAdapter(adapter) {
+    this.ipfs = adapter;
+  }
+  // ── Listeners ────────────────────────────────────────────────────────
+  onPaymentProcessed(callback, filter) {
+    const eventFilter = this.contract.filters.PaymentProcessed(
+      filter?.subscriptionId ?? null,
+      filter?.planId ?? null,
+      filter?.subscriber ?? null
+    );
+    this.contract.on(
+      eventFilter,
+      async (subscriptionId, planId, subscriber, merchant, amount, protocolFee, timestamp, event) => {
+        const receipt = buildPaymentReceipt(
+          { subscriptionId, planId, subscriber, merchant, amount, protocolFee, timestamp },
+          event.transactionHash,
+          event.blockNumber,
+          this.config.chainId ?? 0
+        );
+        if (this.ipfs) {
+          try {
+            receipt.ipfsCid = await this.ipfs.uploadJson(receipt);
+          } catch {
+          }
+        }
+        callback(receipt);
+      }
+    );
+    return this.contract;
+  }
+  removeAllListeners() {
+    this.contract.removeAllListeners();
+  }
+  // ── Internal ─────────────────────────────────────────────────────────
+  requireSigner() {
+    if (!this.signer) {
+      throw new Error("A signer is required for write operations");
+    }
+  }
+  async extractPaymentReceipt(txReceipt) {
+    const iface = new import_ethers.ethers.Interface(VERA_PAY_ABI);
+    const paymentTopic = import_ethers.ethers.id(
+      "PaymentProcessed(uint256,uint256,address,address,uint256,uint256,uint256)"
+    );
+    for (const log of txReceipt.logs) {
+      if (log.topics[0] === paymentTopic) {
+        const parsed = iface.parseLog({
+          topics: [...log.topics],
+          data: log.data
+        });
+        if (!parsed) continue;
+        const receipt = buildPaymentReceipt(
+          {
+            subscriptionId: BigInt(log.topics[1]),
+            planId: BigInt(log.topics[2]),
+            subscriber: import_ethers.ethers.getAddress("0x" + log.topics[3].slice(26)),
+            merchant: parsed.args.merchant,
+            amount: parsed.args.amount,
+            protocolFee: parsed.args.protocolFee,
+            timestamp: parsed.args.timestamp
+          },
+          txReceipt.hash,
+          txReceipt.blockNumber,
+          this.config.chainId ?? 0
+        );
+        if (this.ipfs) {
+          try {
+            receipt.ipfsCid = await this.ipfs.uploadJson(receipt);
+          } catch {
+          }
+        }
+        return receipt;
+      }
+    }
+    return {
+      subscriptionId: "0",
+      planId: "0",
+      subscriber: "",
+      merchant: "",
+      amount: "0",
+      protocolFee: "0",
+      timestamp: 0,
+      txHash: txReceipt.hash,
+      blockNumber: txReceipt.blockNumber,
+      chainId: this.config.chainId ?? 0
+    };
+  }
+};
+
+// src/scheduler.ts
+var fcl = __toESM(require("@onflow/fcl"));
+var NETWORK_CONFIG = {
+  testnet: {
+    accessNode: "https://rest-testnet.onflow.org",
+    discoveryWallet: "https://fcl-discovery.onflow.org/testnet/authn",
+    flowNetwork: "testnet",
+    contracts: {
+      FlowTransactionScheduler: "0x8c5303eaa26202d6",
+      FlowTransactionSchedulerUtils: "0x8c5303eaa26202d6",
+      FlowToken: "0x7e60df042a9c0868",
+      FungibleToken: "0x9a0766d93b6608b7",
+      EVM: "0x8c5303eaa26202d6"
+    }
+  },
+  mainnet: {
+    accessNode: "https://rest-mainnet.onflow.org",
+    discoveryWallet: "https://fcl-discovery.onflow.org/authn",
+    flowNetwork: "mainnet",
+    contracts: {
+      FlowTransactionScheduler: "0xe467b9dd11fa00df",
+      FlowTransactionSchedulerUtils: "0xe467b9dd11fa00df",
+      FlowToken: "0x1654653399040a61",
+      FungibleToken: "0xf233dcee88fe0abe",
+      EVM: "0xe467b9dd11fa00df"
+    }
+  }
+};
+function schedulePaymentCdc(c) {
+  return `
+import FlowTransactionScheduler from ${c.FlowTransactionScheduler}
+import FlowTransactionSchedulerUtils from ${c.FlowTransactionSchedulerUtils}
+import FlowToken from ${c.FlowToken}
+import FungibleToken from ${c.FungibleToken}
+
+transaction(
+    subscriptionId: UInt256,
+    delaySeconds: UFix64,
+    priority: UInt8,
+    executionEffort: UInt64
+) {
+    prepare(signer: auth(BorrowValue, SaveValue, IssueStorageCapabilityController, PublishCapability, GetStorageCapabilityController) &Account) {
+        let future = getCurrentBlock().timestamp + delaySeconds
+
+        let pr = priority == 0
+            ? FlowTransactionScheduler.Priority.High
+            : priority == 1
+                ? FlowTransactionScheduler.Priority.Medium
+                : FlowTransactionScheduler.Priority.Low
+
+        var handlerCap: Capability<auth(FlowTransactionScheduler.Execute) &{FlowTransactionScheduler.TransactionHandler}>? = nil
+        let controllers = signer.capabilities.storage.getControllers(forPath: /storage/VeraPayScheduledPaymentHandler)
+        for controller in controllers {
+            if let cap = controller.capability as? Capability<auth(FlowTransactionScheduler.Execute) &{FlowTransactionScheduler.TransactionHandler}> {
+                handlerCap = cap
+                break
+            }
+        }
+
+        assert(handlerCap != nil, message: "No handler capability found. Run InitVeraPayHandler first.")
+
+        if signer.storage.borrow<&AnyResource>(from: FlowTransactionSchedulerUtils.managerStoragePath) == nil {
+            let manager <- FlowTransactionSchedulerUtils.createManager()
+            signer.storage.save(<-manager, to: FlowTransactionSchedulerUtils.managerStoragePath)
+
+            let managerCap = signer.capabilities.storage.issue<&{FlowTransactionSchedulerUtils.Manager}>(
+                FlowTransactionSchedulerUtils.managerStoragePath
+            )
+            signer.capabilities.publish(managerCap, at: FlowTransactionSchedulerUtils.managerPublicPath)
+        }
+
+        let manager = signer.storage.borrow<auth(FlowTransactionSchedulerUtils.Owner) &{FlowTransactionSchedulerUtils.Manager}>(
+            from: FlowTransactionSchedulerUtils.managerStoragePath
+        ) ?? panic("Could not borrow Manager")
+
+        let est = FlowTransactionScheduler.estimate(
+            data: subscriptionId as AnyStruct,
+            timestamp: future,
+            priority: pr,
+            executionEffort: executionEffort
+        )
+
+        assert(
+            est.timestamp != nil || pr == FlowTransactionScheduler.Priority.Low,
+            message: est.error ?? "Fee estimation failed"
+        )
+
+        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(
+            from: /storage/flowTokenVault
+        ) ?? panic("Could not borrow FlowToken vault")
+
+        let fees <- vault.withdraw(amount: est.flowFee ?? 0.0) as! @FlowToken.Vault
+
+        let transactionId = manager.schedule(
+            handlerCap: handlerCap!,
+            data: subscriptionId,
+            timestamp: future,
+            priority: pr,
+            executionEffort: executionEffort,
+            fees: <-fees
+        )
+
+        log("Scheduled payment for sub #".concat(subscriptionId.toString())
+            .concat(" | txId: ").concat(transactionId.toString())
+            .concat(" | at: ").concat(future.toString()))
+    }
+}
+`;
+}
+function cancelPaymentCdc(c) {
+  return `
+import FlowTransactionScheduler from ${c.FlowTransactionScheduler}
+import FlowTransactionSchedulerUtils from ${c.FlowTransactionSchedulerUtils}
+import FlowToken from ${c.FlowToken}
+import FungibleToken from ${c.FungibleToken}
+
+transaction(transactionId: UInt64) {
+    prepare(signer: auth(BorrowValue) &Account) {
+        let manager = signer.storage.borrow<auth(FlowTransactionSchedulerUtils.Owner) &{FlowTransactionSchedulerUtils.Manager}>(
+            from: FlowTransactionSchedulerUtils.managerStoragePath
+        ) ?? panic("Could not borrow Manager")
+
+        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(
+            from: /storage/flowTokenVault
+        ) ?? panic("Could not borrow FlowToken vault")
+
+        let refund <- manager.cancel(id: transactionId)
+        vault.deposit(from: <-refund)
+
+        log("Cancelled scheduled transaction #".concat(transactionId.toString()))
+    }
+}
+`;
+}
+function setupCoaCdc(c) {
+  return `
+import EVM from ${c.EVM}
+import FlowToken from ${c.FlowToken}
+import FungibleToken from ${c.FungibleToken}
+
+transaction(fundAmount: UFix64) {
+    prepare(signer: auth(BorrowValue, SaveValue, IssueStorageCapabilityController, PublishCapability) &Account) {
+        if signer.storage.borrow<&EVM.CadenceOwnedAccount>(from: /storage/evm) != nil {
+            log("COA already exists at /storage/evm")
+            return
+        }
+
+        let coa <- EVM.createCadenceOwnedAccount()
+
+        if fundAmount > 0.0 {
+            let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(
+                from: /storage/flowTokenVault
+            ) ?? panic("Could not borrow FlowToken vault")
+
+            let tokens <- vault.withdraw(amount: fundAmount) as! @FlowToken.Vault
+            coa.deposit(from: <-tokens)
+        }
+
+        signer.storage.save(<-coa, to: /storage/evm)
+
+        let callCap = signer.capabilities.storage.issue<auth(EVM.Call) &EVM.CadenceOwnedAccount>(/storage/evm)
+        let publicCap = signer.capabilities.storage.issue<&EVM.CadenceOwnedAccount>(/storage/evm)
+        signer.capabilities.publish(publicCap, at: /public/evm)
+
+        log("COA created and funded with ".concat(fundAmount.toString()).concat(" FLOW"))
+    }
+}
+`;
+}
+function initHandlerCdc(c, handlerAddr) {
+  return `
+import VeraPayScheduledPaymentHandler from 0x${handlerAddr}
+import FlowTransactionScheduler from ${c.FlowTransactionScheduler}
+import EVM from ${c.EVM}
+
+transaction(verapayEvmAddress: String) {
+    prepare(signer: auth(BorrowValue, SaveValue, LoadValue, IssueStorageCapabilityController, PublishCapability, UnpublishCapability, GetStorageCapabilityController) &Account) {
+        // 1. Destroy old handler resource if it exists
+        if let oldHandler <- signer.storage.load<@AnyResource>(from: /storage/VeraPayScheduledPaymentHandler) {
+            destroy oldHandler
+            log("Destroyed old VeraPay handler")
+        }
+
+        // 2. Unpublish old public capability
+        signer.capabilities.unpublish(/public/VeraPayScheduledPaymentHandler)
+
+        // 3. Delete all old capability controllers for the handler storage path
+        let oldControllers = signer.capabilities.storage.getControllers(forPath: /storage/VeraPayScheduledPaymentHandler)
+        for controller in oldControllers {
+            controller.delete()
+        }
+
+        // 4. Get or create COA capability
+        let evmAddr = EVM.addressFromString(verapayEvmAddress)
+
+        var coaCap: Capability<auth(EVM.Call) &EVM.CadenceOwnedAccount>? = nil
+        let controllers = signer.capabilities.storage.getControllers(forPath: /storage/evm)
+        for controller in controllers {
+            if let cap = controller.capability as? Capability<auth(EVM.Call) &EVM.CadenceOwnedAccount> {
+                coaCap = cap
+                break
+            }
+        }
+
+        if coaCap == nil {
+            coaCap = signer.capabilities.storage.issue<auth(EVM.Call) &EVM.CadenceOwnedAccount>(/storage/evm)
+        }
+
+        // 5. Create fresh handler with new address
+        let handler <- VeraPayScheduledPaymentHandler.createHandler(
+            coaCapability: coaCap!,
+            verapayAddress: evmAddr
+        )
+        signer.storage.save(<-handler, to: /storage/VeraPayScheduledPaymentHandler)
+
+        // 6. Issue fresh capabilities
+        signer.capabilities.storage.issue<auth(FlowTransactionScheduler.Execute) &{FlowTransactionScheduler.TransactionHandler}>(
+            /storage/VeraPayScheduledPaymentHandler
+        )
+
+        let publicCap = signer.capabilities.storage.issue<&{FlowTransactionScheduler.TransactionHandler}>(
+            /storage/VeraPayScheduledPaymentHandler
+        )
+        signer.capabilities.publish(publicCap, at: /public/VeraPayScheduledPaymentHandler)
+
+        log("VeraPay handler initialized for contract: ".concat(verapayEvmAddress))
+    }
+}
+`;
+}
+var FlowScheduler = class _FlowScheduler {
+  constructor(config2) {
+    this.config = config2;
+    this.ipfs = config2.ipfsAdapter;
+  }
+  configured = false;
+  ipfs;
+  get hasIPFS() {
+    return !!this.ipfs;
+  }
+  setIPFSAdapter(adapter) {
+    this.ipfs = adapter;
+  }
+  ensureConfigured() {
+    if (this.configured) return;
+    const net = NETWORK_CONFIG[this.config.network];
+    fcl.config().put("accessNode.api", net.accessNode).put("discovery.wallet", net.discoveryWallet).put("flow.network", net.flowNetwork);
+    this.configured = true;
+  }
+  /** Trigger FCL wallet authentication (Blocto, Lilico, etc.) */
+  async authenticate() {
+    this.ensureConfigured();
+    const user = await fcl.authenticate();
+    return { addr: user.addr ?? "" };
+  }
+  /** Disconnect the current wallet */
+  async unauthenticate() {
+    await fcl.unauthenticate();
+  }
+  /** Get the currently authenticated Flow address, or null */
+  async currentUser() {
+    this.ensureConfigured();
+    const snapshot = await fcl.currentUser.snapshot();
+    return snapshot.addr ?? null;
+  }
+  /**
+   * Create a Cadence Owned Account (COA) and fund it with FLOW for EVM gas.
+   * Idempotent — skips if COA already exists. Must be called before initHandler.
+   * Returns the Flow transaction ID.
+   */
+  async setupCOA(fundAmount = "1.0") {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const txId = await fcl.mutate({
+      cadence: setupCoaCdc(contracts),
+      args: (arg, t) => [arg(fundAmount, t.UFix64)],
+      limit: 9999
+    });
+    return txId;
+  }
+  /**
+   * Initialize the VeraPay scheduled payment handler on the connected account.
+   * Idempotent — skips if already initialized. Requires a COA (call setupCOA first).
+   * Returns the Flow transaction ID.
+   */
+  async initHandler() {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const evmAddr = this.config.evmContractAddress.startsWith("0x") ? this.config.evmContractAddress : "0x" + this.config.evmContractAddress;
+    const txId = await fcl.mutate({
+      cadence: initHandlerCdc(contracts, this.config.handlerAddress),
+      args: (arg, t) => [arg(evmAddr, t.String)],
+      limit: 9999
+    });
+    return txId;
+  }
+  /**
+   * Convenience method: runs setupCOA + initHandler in sequence.
+   * Both are idempotent so it's safe to call on every session.
+   */
+  async setup(fundAmount = "1.0") {
+    const coaTxId = await this.setupCOA(fundAmount);
+    await this.waitForTransaction(coaTxId);
+    const handlerTxId = await this.initHandler();
+    await this.waitForTransaction(handlerTxId);
+    return { coaTxId, handlerTxId };
+  }
+  /**
+   * Schedule a subscription payment to be executed at a future time.
+   * The connected Flow wallet pays the scheduling fees.
+   * Returns the Flow transaction ID.
+   */
+  async schedulePayment(params) {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const txId = await fcl.mutate({
+      cadence: schedulePaymentCdc(contracts),
+      args: (arg, t) => [
+        arg(params.subscriptionId, t.UInt256),
+        arg(params.delaySeconds, t.UFix64),
+        arg(String(params.priority), t.UInt8),
+        arg(String(params.executionEffort), t.UInt64)
+      ],
+      limit: 9999
+    });
+    return txId;
+  }
+  /**
+   * Cancel a previously scheduled payment and receive a partial fee refund.
+   * Returns the Flow transaction ID.
+   */
+  async cancelScheduledPayment(scheduledTransactionId) {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const txId = await fcl.mutate({
+      cadence: cancelPaymentCdc(contracts),
+      args: (arg, t) => [
+        arg(scheduledTransactionId, t.UInt64)
+      ],
+      limit: 9999
+    });
+    return txId;
+  }
+  /**
+   * Make the COA approve an EVM spender (e.g., VeraPay) to transfer ERC20 tokens.
+   * This is required before the scheduled payment can pull tokens from the COA.
+   * Returns the Flow transaction ID.
+   */
+  async approveERC20(tokenAddress, amount = "115792089237316195423570985008687907853269984665640564039457584007913129639935") {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const token = tokenAddress.startsWith("0x") ? tokenAddress : "0x" + tokenAddress;
+    const spender = this.config.evmContractAddress.startsWith("0x") ? this.config.evmContractAddress : "0x" + this.config.evmContractAddress;
+    const txId = await fcl.mutate({
+      cadence: `
+import EVM from ${contracts.EVM}
+
+transaction(tokenAddress: String, spenderAddress: String, amount: UInt256) {
+    prepare(signer: auth(BorrowValue) &Account) {
+        let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)
+            ?? panic("No COA found. Run Setup first.")
+
+        let calldata = EVM.encodeABIWithSignature(
+            "approve(address,uint256)",
+            [EVM.addressFromString(spenderAddress), amount]
+        )
+
+        let result = coa.call(
+            to: EVM.addressFromString(tokenAddress),
+            data: calldata,
+            gasLimit: 100_000,
+            value: EVM.Balance(attoflow: 0)
+        )
+
+        assert(result.status == EVM.Status.successful, message: "ERC20 approve failed")
+    }
+}
+`,
+      args: (arg, t) => [
+        arg(token, t.String),
+        arg(spender, t.String),
+        arg(amount, t.UInt256)
+      ],
+      limit: 9999
+    });
+    return txId;
+  }
+  /**
+   * Subscribe the COA to a VeraPay plan AND schedule the next recurring payment
+   * in a single Cadence transaction.
+   *
+   * 1. COA calls subscribe(planId) on the EVM contract (first payment is charged immediately)
+   * 2. Decodes the returned subscription ID from the EVM call
+   * 3. Schedules the next payment via FlowTransactionScheduler with the plan's interval as delay
+   *
+   * If an IPFS adapter is configured, the payment receipt is automatically
+   * pinned after the transaction seals.
+   *
+   * Returns the Flow tx ID, and optionally the receipt + IPFS CID.
+   */
+  async subscribeAndSchedule(params) {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const verapay = this.config.evmContractAddress.startsWith("0x") ? this.config.evmContractAddress : "0x" + this.config.evmContractAddress;
+    const txId = await fcl.mutate({
+      cadence: `
+import EVM from ${contracts.EVM}
+import FlowTransactionScheduler from ${contracts.FlowTransactionScheduler}
+import FlowTransactionSchedulerUtils from ${contracts.FlowTransactionSchedulerUtils}
+import FlowToken from ${contracts.FlowToken}
+import FungibleToken from ${contracts.FungibleToken}
+
+transaction(
+    verapayAddress: String,
+    planId: UInt256,
+    intervalSeconds: UFix64,
+    priority: UInt8,
+    executionEffort: UInt64
+) {
+    prepare(signer: auth(BorrowValue, SaveValue, IssueStorageCapabilityController, PublishCapability, GetStorageCapabilityController) &Account) {
+        // 1. Subscribe via COA
+        let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)
+            ?? panic("No COA found. Run Setup first.")
+
+        let calldata = EVM.encodeABIWithSignature(
+            "subscribe(uint256)",
+            [planId]
+        )
+
+        let result = coa.call(
+            to: EVM.addressFromString(verapayAddress),
+            data: calldata,
+            gasLimit: 300_000,
+            value: EVM.Balance(attoflow: 0)
+        )
+
+        assert(result.status == EVM.Status.successful,
+            message: "VeraPay subscribe failed: ".concat(result.errorCode.toString()))
+
+        // 2. Decode the returned subscription ID (uint256)
+        let decoded = EVM.decodeABI(types: [Type<UInt256>()], data: result.data)
+        let subscriptionId = decoded[0] as! UInt256
+
+        log("Subscribed! Sub ID: ".concat(subscriptionId.toString()))
+
+        // 3. Schedule next payment
+        let future = getCurrentBlock().timestamp + intervalSeconds
+
+        let pr = priority == 0
+            ? FlowTransactionScheduler.Priority.High
+            : priority == 1
+                ? FlowTransactionScheduler.Priority.Medium
+                : FlowTransactionScheduler.Priority.Low
+
+        var handlerCap: Capability<auth(FlowTransactionScheduler.Execute) &{FlowTransactionScheduler.TransactionHandler}>? = nil
+        let controllers = signer.capabilities.storage.getControllers(forPath: /storage/VeraPayScheduledPaymentHandler)
+        for controller in controllers {
+            if let cap = controller.capability as? Capability<auth(FlowTransactionScheduler.Execute) &{FlowTransactionScheduler.TransactionHandler}> {
+                handlerCap = cap
+                break
+            }
+        }
+
+        assert(handlerCap != nil, message: "No handler capability found. Run InitVeraPayHandler first.")
+
+        if signer.storage.borrow<&AnyResource>(from: FlowTransactionSchedulerUtils.managerStoragePath) == nil {
+            let manager <- FlowTransactionSchedulerUtils.createManager()
+            signer.storage.save(<-manager, to: FlowTransactionSchedulerUtils.managerStoragePath)
+
+            let managerCap = signer.capabilities.storage.issue<&{FlowTransactionSchedulerUtils.Manager}>(
+                FlowTransactionSchedulerUtils.managerStoragePath
+            )
+            signer.capabilities.publish(managerCap, at: FlowTransactionSchedulerUtils.managerPublicPath)
+        }
+
+        let manager = signer.storage.borrow<auth(FlowTransactionSchedulerUtils.Owner) &{FlowTransactionSchedulerUtils.Manager}>(
+            from: FlowTransactionSchedulerUtils.managerStoragePath
+        ) ?? panic("Could not borrow Manager")
+
+        let est = FlowTransactionScheduler.estimate(
+            data: subscriptionId as AnyStruct,
+            timestamp: future,
+            priority: pr,
+            executionEffort: executionEffort
+        )
+
+        assert(
+            est.timestamp != nil || pr == FlowTransactionScheduler.Priority.Low,
+            message: est.error ?? "Fee estimation failed"
+        )
+
+        let vault = signer.storage.borrow<auth(FungibleToken.Withdraw) &FlowToken.Vault>(
+            from: /storage/flowTokenVault
+        ) ?? panic("Could not borrow FlowToken vault")
+
+        let fees <- vault.withdraw(amount: est.flowFee ?? 0.0) as! @FlowToken.Vault
+
+        let transactionId = manager.schedule(
+            handlerCap: handlerCap!,
+            data: subscriptionId,
+            timestamp: future,
+            priority: pr,
+            executionEffort: executionEffort,
+            fees: <-fees
+        )
+
+        log("Scheduled next payment for sub #".concat(subscriptionId.toString())
+            .concat(" | txId: ").concat(transactionId.toString())
+            .concat(" | at: ").concat(future.toString()))
+    }
+}
+`,
+      args: (arg, t) => [
+        arg(verapay, t.String),
+        arg(String(params.planId), t.UInt256),
+        arg(params.intervalSeconds, t.UFix64),
+        arg(String(params.priority ?? 1), t.UInt8),
+        arg(String(params.executionEffort ?? 1e3), t.UInt64)
+      ],
+      limit: 9999
+    });
+    const result = { flowTxId: txId };
+    try {
+      const sealed = await this.waitForTransaction(txId);
+      result.scheduledTxId = _FlowScheduler.extractScheduledTxId(sealed.events);
+      if (this.ipfs) {
+        try {
+          const receipt = {
+            subscriptionId: "pending",
+            planId: String(params.planId),
+            subscriber: await this.currentUser() ?? "",
+            merchant: "",
+            amount: "0",
+            protocolFee: "0",
+            timestamp: Math.floor(Date.now() / 1e3),
+            txHash: txId,
+            blockNumber: 0,
+            chainId: this.config.network === "testnet" ? 545 : 747
+          };
+          const cid = await this.ipfs.uploadJson(receipt);
+          receipt.ipfsCid = cid;
+          result.receipt = receipt;
+          result.ipfsCid = cid;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return result;
+  }
+  /**
+   * Subscribe the COA to a VeraPay plan via an EVM call (without scheduling).
+   * The COA must have already approved the VeraPay contract to spend its tokens.
+   * Returns the Flow transaction ID.
+   */
+  async subscribeToPlan(planId) {
+    this.ensureConfigured();
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    const verapay = this.config.evmContractAddress.startsWith("0x") ? this.config.evmContractAddress : "0x" + this.config.evmContractAddress;
+    const txId = await fcl.mutate({
+      cadence: `
+import EVM from ${contracts.EVM}
+
+transaction(verapayAddress: String, planId: UInt256) {
+    prepare(signer: auth(BorrowValue) &Account) {
+        let coa = signer.storage.borrow<auth(EVM.Call) &EVM.CadenceOwnedAccount>(from: /storage/evm)
+            ?? panic("No COA found. Run Setup first.")
+
+        let calldata = EVM.encodeABIWithSignature(
+            "subscribe(uint256)",
+            [planId]
+        )
+
+        let result = coa.call(
+            to: EVM.addressFromString(verapayAddress),
+            data: calldata,
+            gasLimit: 300_000,
+            value: EVM.Balance(attoflow: 0)
+        )
+
+        assert(result.status == EVM.Status.successful, message: "VeraPay subscribe failed: ".concat(result.errorCode.toString()))
+    }
+}
+`,
+      args: (arg, t) => [
+        arg(verapay, t.String),
+        arg(String(planId), t.UInt256)
+      ],
+      limit: 9999
+    });
+    return txId;
+  }
+  /**
+   * Query the COA's EVM address for a given Flow account.
+   * Returns the hex EVM address (0x...) or null if no COA exists.
+   */
+  async getCoaEvmAddress(flowAddress) {
+    this.ensureConfigured();
+    const addr = flowAddress ?? await this.currentUser();
+    if (!addr) return null;
+    const contracts = NETWORK_CONFIG[this.config.network].contracts;
+    try {
+      const result = await fcl.query({
+        cadence: `
+import EVM from ${contracts.EVM}
+
+access(all) fun main(flowAddress: Address): String? {
+    if let acc = getAuthAccount<auth(BorrowValue) &Account>(flowAddress)
+        .storage.borrow<&EVM.CadenceOwnedAccount>(from: /storage/evm) {
+        return "0x".concat(acc.address().toString())
+    }
+    return nil
+}
+`,
+        args: (arg, t) => [arg(addr, t.Address)]
+      });
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  /** Wait for a Flow transaction to be sealed. Returns the transaction result with events. */
+  async waitForTransaction(txId) {
+    this.ensureConfigured();
+    const result = await fcl.tx(txId).onceSealed();
+    return result;
+  }
+  /**
+   * Extract the scheduled transaction ID from sealed tx events.
+   * Looks for the FlowTransactionScheduler.TransactionScheduled event.
+   */
+  static extractScheduledTxId(events) {
+    const evt = events.find((e) => e.type.includes("FlowTransactionScheduler") && e.type.includes("TransactionScheduled"));
+    if (!evt) return void 0;
+    const id = evt.data.id ?? evt.data.transactionId ?? evt.data.scheduledTransactionId;
+    return id != null ? String(id) : void 0;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CADENCE_HANDLERS,
+  DEFAULT_IPFS_GATEWAY,
+  DEPLOYED_CONTRACTS,
+  ERC20_ABI,
+  FlowScheduler,
+  KNOWN_TOKENS,
+  NETWORKS,
+  VERA_PAY_ABI,
+  VeraPayClient,
+  buildPaymentReceipt,
+  createKuboAdapter,
+  createMemoryAdapter,
+  createStorachaAdapter,
+  ipfsGatewayUrl
+});