moltspay 0.5.3 → 0.5.4

package/dist/index.mjs

@@ -3541,6 +3541,980 @@ function verifyPaymentHeader(header, expectedRecipient, expectedAmount) {
 
 // src/index.ts
 init_cdp();
+
+// src/deferred/DeferredPaymentManager.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/deferred/MemoryStore.ts
+import { randomUUID } from "crypto";
+var DEFAULT_TERMS = {
+  netDays: 30,
+  graceDays: 7,
+  settlementFrequency: "on-demand"
+};
+var MemoryDeferredStore = class {
+  accounts = /* @__PURE__ */ new Map();
+  payments = /* @__PURE__ */ new Map();
+  // Index for faster lookups
+  buyerSellerIndex = /* @__PURE__ */ new Map();
+  // "buyerId:sellerId" -> accountId
+  makeKey(buyerId, sellerId) {
+    return `${buyerId}:${sellerId}`;
+  }
+  // ============ Credit Accounts ============
+  async createAccount(params) {
+    const accountId = `ca_${randomUUID().slice(0, 8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const account = {
+      accountId,
+      buyerId: params.buyerId,
+      sellerId: params.sellerId,
+      creditLimit: params.creditLimit,
+      balance: 0,
+      status: "active",
+      chain: params.chain || "base",
+      terms: { ...DEFAULT_TERMS, ...params.terms },
+      createdAt: now,
+      updatedAt: now,
+      transactions: [],
+      metadata: params.metadata
+    };
+    this.accounts.set(accountId, account);
+    this.buyerSellerIndex.set(this.makeKey(params.buyerId, params.sellerId), accountId);
+    return account;
+  }
+  async getAccount(accountId) {
+    return this.accounts.get(accountId) || null;
+  }
+  async getAccountByBuyer(buyerId, sellerId) {
+    const accountId = this.buyerSellerIndex.get(this.makeKey(buyerId, sellerId));
+    if (!accountId) return null;
+    return this.accounts.get(accountId) || null;
+  }
+  async updateAccount(accountId, updates) {
+    const account = this.accounts.get(accountId);
+    if (!account) {
+      throw new Error(`Account not found: ${accountId}`);
+    }
+    const updated = {
+      ...account,
+      ...updates,
+      accountId,
+      // Prevent overwriting ID
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.accounts.set(accountId, updated);
+    return updated;
+  }
+  async listAccounts(sellerId) {
+    const result = [];
+    for (const account of this.accounts.values()) {
+      if (account.sellerId === sellerId) {
+        result.push(account);
+      }
+    }
+    return result;
+  }
+  // ============ Deferred Payments ============
+  async createPayment(params) {
+    const paymentId = `dp_${randomUUID().slice(0, 8)}`;
+    const now = /* @__PURE__ */ new Date();
+    const dueDate = new Date(now);
+    dueDate.setDate(dueDate.getDate() + (params.dueInDays || 30));
+    const payment = {
+      paymentId,
+      accountId: params.accountId,
+      orderId: params.orderId,
+      service: params.service,
+      amount: params.amount,
+      paidAmount: 0,
+      status: "pending",
+      dueDate: dueDate.toISOString(),
+      chain: params.chain || "base",
+      buyerId: params.buyerId,
+      sellerAddress: params.sellerAddress,
+      plan: params.plan ? { ...params.plan, completedInstallments: 0 } : void 0,
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      settlements: [],
+      metadata: params.metadata
+    };
+    this.payments.set(paymentId, payment);
+    if (params.accountId) {
+      await this.addTransaction(params.accountId, {
+        type: "charge",
+        amount: params.amount,
+        balanceAfter: 0,
+        // Will be calculated
+        reference: params.orderId,
+        notes: params.service
+      });
+    }
+    return payment;
+  }
+  async getPayment(paymentId) {
+    return this.payments.get(paymentId) || null;
+  }
+  async updatePayment(paymentId, updates) {
+    const payment = this.payments.get(paymentId);
+    if (!payment) {
+      throw new Error(`Payment not found: ${paymentId}`);
+    }
+    const updated = {
+      ...payment,
+      ...updates,
+      paymentId,
+      // Prevent overwriting ID
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.payments.set(paymentId, updated);
+    return updated;
+  }
+  async listPayments(filter) {
+    const now = /* @__PURE__ */ new Date();
+    const result = [];
+    for (const payment of this.payments.values()) {
+      if (filter.accountId && payment.accountId !== filter.accountId) continue;
+      if (filter.buyerId && payment.buyerId !== filter.buyerId) continue;
+      if (filter.status) {
+        const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+        if (!statuses.includes(payment.status)) continue;
+      }
+      if (filter.overdueOnly) {
+        const dueDate = new Date(payment.dueDate);
+        if (dueDate >= now || payment.status === "paid" || payment.status === "settled") {
+          continue;
+        }
+      }
+      result.push(payment);
+    }
+    return result;
+  }
+  // ============ Transactions ============
+  async addTransaction(accountId, tx) {
+    const account = this.accounts.get(accountId);
+    if (!account) {
+      throw new Error(`Account not found: ${accountId}`);
+    }
+    let newBalance = account.balance;
+    if (tx.type === "charge" || tx.type === "late_fee") {
+      newBalance += tx.amount;
+    } else if (tx.type === "payment" || tx.type === "credit" || tx.type === "refund") {
+      newBalance -= Math.abs(tx.amount);
+    } else if (tx.type === "adjustment") {
+      newBalance += tx.amount;
+    }
+    const transaction = {
+      txId: `ctx_${randomUUID().slice(0, 8)}`,
+      ...tx,
+      balanceAfter: newBalance,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    account.balance = newBalance;
+    account.transactions.push(transaction);
+    account.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return transaction;
+  }
+  // ============ Utilities ============
+  /**
+   * Get all data (for debugging/export)
+   */
+  export() {
+    return {
+      accounts: Array.from(this.accounts.values()),
+      payments: Array.from(this.payments.values())
+    };
+  }
+  /**
+   * Import data (for restore)
+   */
+  import(data) {
+    this.accounts.clear();
+    this.payments.clear();
+    this.buyerSellerIndex.clear();
+    for (const account of data.accounts) {
+      this.accounts.set(account.accountId, account);
+      this.buyerSellerIndex.set(this.makeKey(account.buyerId, account.sellerId), account.accountId);
+    }
+    for (const payment of data.payments) {
+      this.payments.set(payment.paymentId, payment);
+    }
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.accounts.clear();
+    this.payments.clear();
+    this.buyerSellerIndex.clear();
+  }
+};
+
+// src/deferred/DeferredPaymentManager.ts
+var DeferredPaymentManager = class {
+  config;
+  constructor(config) {
+    this.config = {
+      sellerAddress: config.sellerAddress,
+      sellerId: config.sellerId,
+      chain: config.chain || "base",
+      store: config.store || new MemoryDeferredStore(),
+      autoVerify: config.autoVerify ?? true
+    };
+  }
+  // ============ Credit Account Management ============
+  /**
+   * Create a new credit account for a buyer
+   */
+  async createCreditAccount(params) {
+    const existing = await this.config.store.getAccountByBuyer(
+      params.buyerId,
+      this.config.sellerId
+    );
+    if (existing) {
+      throw new Error(`Credit account already exists for buyer: ${params.buyerId}`);
+    }
+    return this.config.store.createAccount({
+      buyerId: params.buyerId,
+      sellerId: this.config.sellerId,
+      creditLimit: params.creditLimit,
+      chain: this.config.chain,
+      terms: params.netDays ? { netDays: params.netDays, graceDays: 7, settlementFrequency: "on-demand" } : void 0,
+      metadata: params.metadata
+    });
+  }
+  /**
+   * Get or create a credit account for a buyer
+   */
+  async getOrCreateAccount(params) {
+    const existing = await this.config.store.getAccountByBuyer(
+      params.buyerId,
+      this.config.sellerId
+    );
+    if (existing) return existing;
+    return this.createCreditAccount({
+      buyerId: params.buyerId,
+      creditLimit: params.creditLimit || 100
+      // Default $100 credit limit
+    });
+  }
+  /**
+   * Get credit account by ID
+   */
+  async getAccount(accountId) {
+    return this.config.store.getAccount(accountId);
+  }
+  /**
+   * Get credit account by buyer ID
+   */
+  async getAccountByBuyer(buyerId) {
+    return this.config.store.getAccountByBuyer(buyerId, this.config.sellerId);
+  }
+  /**
+   * Update credit limit
+   */
+  async updateCreditLimit(accountId, newLimit) {
+    return this.config.store.updateAccount(accountId, { creditLimit: newLimit });
+  }
+  /**
+   * Suspend an account
+   */
+  async suspendAccount(accountId, reason) {
+    const account = await this.config.store.updateAccount(accountId, { status: "suspended" });
+    await this.config.store.addTransaction(accountId, {
+      type: "adjustment",
+      amount: 0,
+      balanceAfter: account.balance,
+      reference: "account_suspended",
+      notes: reason || "Account suspended"
+    });
+    return account;
+  }
+  /**
+   * Reactivate a suspended account
+   */
+  async reactivateAccount(accountId) {
+    return this.config.store.updateAccount(accountId, { status: "active" });
+  }
+  /**
+   * Get account summary with pending/overdue payments
+   */
+  async getAccountSummary(accountId) {
+    const account = await this.config.store.getAccount(accountId);
+    if (!account) return null;
+    const allPayments = await this.config.store.listPayments({ accountId });
+    const now = /* @__PURE__ */ new Date();
+    const pendingPayments = allPayments.filter(
+      (p) => p.status === "pending" || p.status === "partial"
+    );
+    const overduePayments = allPayments.filter((p) => {
+      if (p.status === "paid" || p.status === "settled" || p.status === "cancelled") {
+        return false;
+      }
+      return new Date(p.dueDate) < now;
+    });
+    return {
+      account,
+      pendingPayments,
+      overduePayments,
+      availableCredit: Math.max(0, account.creditLimit - account.balance),
+      totalOwed: account.balance
+    };
+  }
+  /**
+   * List all credit accounts for this seller
+   */
+  async listAccounts() {
+    return this.config.store.listAccounts(this.config.sellerId);
+  }
+  // ============ Deferred Payment Operations ============
+  /**
+   * Charge a service to a credit account (deferred payment)
+   */
+  async charge(params) {
+    let account = await this.getAccountByBuyer(params.buyerId);
+    if (!account) {
+      try {
+        account = await this.createCreditAccount({
+          buyerId: params.buyerId,
+          creditLimit: 100
+          // Default $100 limit
+        });
+      } catch (error) {
+        return {
+          success: false,
+          error: `Failed to create credit account: ${error}`
+        };
+      }
+    }
+    if (account.status !== "active") {
+      return {
+        success: false,
+        error: `Credit account is ${account.status}`
+      };
+    }
+    const newBalance = account.balance + params.amount;
+    if (newBalance > account.creditLimit) {
+      return {
+        success: false,
+        error: `Credit limit exceeded. Available: $${(account.creditLimit - account.balance).toFixed(2)}, Required: $${params.amount.toFixed(2)}`,
+        creditExceeded: true
+      };
+    }
+    const payment = await this.config.store.createPayment({
+      accountId: account.accountId,
+      orderId: params.orderId,
+      service: params.service,
+      amount: params.amount,
+      buyerId: params.buyerId,
+      sellerAddress: this.config.sellerAddress,
+      chain: this.config.chain,
+      dueInDays: params.dueInDays || account.terms.netDays,
+      metadata: params.metadata
+    });
+    const updatedAccount = await this.config.store.getAccount(account.accountId);
+    const lastTx = updatedAccount?.transactions[updatedAccount.transactions.length - 1];
+    return {
+      success: true,
+      payment,
+      transaction: lastTx
+    };
+  }
+  /**
+   * Create a deferred payment without a credit account (standalone)
+   */
+  async createDeferredPayment(params) {
+    return this.config.store.createPayment({
+      ...params,
+      sellerAddress: params.sellerAddress || this.config.sellerAddress,
+      chain: params.chain || this.config.chain
+    });
+  }
+  /**
+   * Get deferred payment by ID
+   */
+  async getPayment(paymentId) {
+    return this.config.store.getPayment(paymentId);
+  }
+  /**
+   * List deferred payments with filters
+   */
+  async listPayments(filter) {
+    return this.config.store.listPayments(filter || {});
+  }
+  /**
+   * Get overdue payments
+   */
+  async getOverduePayments() {
+    return this.config.store.listPayments({ overdueOnly: true });
+  }
+  // ============ Settlement ============
+  /**
+   * Record a settlement (payment received)
+   */
+  async recordSettlement(params) {
+    const payment = await this.config.store.getPayment(params.paymentId);
+    if (!payment) {
+      return { success: false, error: `Payment not found: ${params.paymentId}` };
+    }
+    let verified = false;
+    if (this.config.autoVerify) {
+      try {
+        const verification = await verifyPayment({
+          txHash: params.txHash,
+          chain: params.chain || payment.chain,
+          expectedTo: payment.sellerAddress,
+          expectedAmount: params.amount
+        });
+        verified = verification.verified;
+        if (!verified) {
+          return {
+            success: false,
+            error: `Payment verification failed: ${verification.error || "Unknown error"}`
+          };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: `Verification error: ${error}`
+        };
+      }
+    } else {
+      verified = true;
+    }
+    const settlement = {
+      settlementId: `stl_${randomUUID2().slice(0, 8)}`,
+      amount: params.amount,
+      txHash: params.txHash,
+      chain: params.chain || payment.chain,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      verified
+    };
+    const newPaidAmount = payment.paidAmount + params.amount;
+    const newStatus = newPaidAmount >= payment.amount ? "settled" : newPaidAmount > 0 ? "partial" : "pending";
+    const updatedPayment = await this.config.store.updatePayment(params.paymentId, {
+      paidAmount: newPaidAmount,
+      status: newStatus,
+      settlements: [...payment.settlements, settlement]
+    });
+    let transaction;
+    if (payment.accountId) {
+      transaction = await this.config.store.addTransaction(payment.accountId, {
+        type: "payment",
+        amount: params.amount,
+        balanceAfter: 0,
+        // Will be calculated by store
+        reference: payment.orderId,
+        onChainTxHash: params.txHash,
+        notes: `Settlement for ${payment.service}`
+      });
+    }
+    return {
+      success: true,
+      settlement,
+      payment: updatedPayment,
+      transaction
+    };
+  }
+  /**
+   * Settle all pending charges for an account
+   */
+  async settleAccount(accountId, txHash) {
+    const account = await this.config.store.getAccount(accountId);
+    if (!account) {
+      return { success: false, error: `Account not found: ${accountId}` };
+    }
+    if (account.balance <= 0) {
+      return { success: false, error: "No balance to settle" };
+    }
+    if (this.config.autoVerify) {
+      const verification = await verifyPayment({
+        txHash,
+        chain: account.chain,
+        expectedTo: this.config.sellerAddress,
+        expectedAmount: account.balance
+      });
+      if (!verification.verified) {
+        return {
+          success: false,
+          error: `Payment verification failed: ${verification.error || "Unknown error"}`
+        };
+      }
+    }
+    const transaction = await this.config.store.addTransaction(accountId, {
+      type: "payment",
+      amount: account.balance,
+      balanceAfter: 0,
+      reference: `account_settlement_${accountId}`,
+      onChainTxHash: txHash,
+      notes: "Full account settlement"
+    });
+    const pendingPayments = await this.config.store.listPayments({
+      accountId,
+      status: ["pending", "partial"]
+    });
+    const settlement = {
+      settlementId: `stl_${randomUUID2().slice(0, 8)}`,
+      amount: account.balance,
+      txHash,
+      chain: account.chain,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      verified: true
+    };
+    for (const payment of pendingPayments) {
+      await this.config.store.updatePayment(payment.paymentId, {
+        paidAmount: payment.amount,
+        status: "settled",
+        settlements: [...payment.settlements, settlement]
+      });
+    }
+    return {
+      success: true,
+      settlement,
+      transaction
+    };
+  }
+  // ============ Credit Operations ============
+  /**
+   * Issue a credit (reduce balance owed)
+   */
+  async issueCredit(params) {
+    return this.config.store.addTransaction(params.accountId, {
+      type: "credit",
+      amount: params.amount,
+      balanceAfter: 0,
+      reference: "credit_issued",
+      notes: params.reason
+    });
+  }
+  /**
+   * Issue a refund
+   */
+  async issueRefund(params) {
+    const payment = await this.config.store.getPayment(params.paymentId);
+    if (!payment) {
+      return { success: false, error: `Payment not found: ${params.paymentId}` };
+    }
+    const newPaidAmount = Math.max(0, payment.paidAmount - params.amount);
+    await this.config.store.updatePayment(params.paymentId, {
+      paidAmount: newPaidAmount,
+      status: newPaidAmount >= payment.amount ? "settled" : newPaidAmount > 0 ? "partial" : "pending"
+    });
+    let transaction;
+    if (payment.accountId) {
+      transaction = await this.config.store.addTransaction(payment.accountId, {
+        type: "refund",
+        amount: params.amount,
+        balanceAfter: 0,
+        reference: payment.orderId,
+        notes: params.reason
+      });
+    }
+    return { success: true, transaction };
+  }
+  // ============ Maintenance ============
+  /**
+   * Mark overdue payments
+   */
+  async markOverduePayments() {
+    const now = /* @__PURE__ */ new Date();
+    const pending = await this.config.store.listPayments({
+      status: ["pending", "partial"]
+    });
+    const overdue = [];
+    for (const payment of pending) {
+      if (new Date(payment.dueDate) < now) {
+        const updated = await this.config.store.updatePayment(payment.paymentId, {
+          status: "overdue"
+        });
+        overdue.push(updated);
+        if (payment.accountId) {
+          const account = await this.config.store.getAccount(payment.accountId);
+          if (account && account.status === "active") {
+            const graceEnd = new Date(payment.dueDate);
+            graceEnd.setDate(graceEnd.getDate() + account.terms.graceDays);
+            if (now > graceEnd) {
+              await this.suspendAccount(payment.accountId, "Overdue payment past grace period");
+            }
+          }
+        }
+      }
+    }
+    return overdue;
+  }
+  /**
+   * Apply late fees to overdue accounts
+   */
+  async applyLateFees() {
+    const accounts = await this.listAccounts();
+    const fees = [];
+    for (const account of accounts) {
+      if (account.terms.lateFeePercent && account.balance > 0) {
+        const overduePayments = await this.config.store.listPayments({
+          accountId: account.accountId,
+          status: "overdue"
+        });
+        if (overduePayments.length > 0) {
+          const feeAmount = account.balance * (account.terms.lateFeePercent / 100);
+          const tx = await this.config.store.addTransaction(account.accountId, {
+            type: "late_fee",
+            amount: feeAmount,
+            balanceAfter: 0,
+            reference: "late_fee",
+            notes: `${account.terms.lateFeePercent}% late fee on $${account.balance.toFixed(2)}`
+          });
+          fees.push(tx);
+        }
+      }
+    }
+    return fees;
+  }
+};
+
+// src/deferred/JsonStore.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname2 } from "path";
+var JsonDeferredStore = class {
+  memory;
+  config;
+  dirty = false;
+  constructor(config) {
+    this.config = {
+      filePath: config.filePath,
+      autoSave: config.autoSave ?? true,
+      prettyPrint: config.prettyPrint ?? true
+    };
+    this.memory = new MemoryDeferredStore();
+    this.load();
+  }
+  // ============ Persistence ============
+  /**
+   * Load data from file
+   */
+  load() {
+    if (!existsSync5(this.config.filePath)) {
+      return;
+    }
+    try {
+      const data = JSON.parse(readFileSync5(this.config.filePath, "utf-8"));
+      this.memory.import(data);
+    } catch (error) {
+      console.error(`Failed to load deferred store from ${this.config.filePath}:`, error);
+    }
+  }
+  /**
+   * Save data to file
+   */
+  save() {
+    try {
+      const dir = dirname2(this.config.filePath);
+      if (!existsSync5(dir)) {
+        mkdirSync5(dir, { recursive: true });
+      }
+      const data = this.memory.export();
+      const json = this.config.prettyPrint ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+      writeFileSync4(this.config.filePath, json, "utf-8");
+      this.dirty = false;
+    } catch (error) {
+      console.error(`Failed to save deferred store to ${this.config.filePath}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Mark as dirty and optionally auto-save
+   */
+  markDirty() {
+    this.dirty = true;
+    if (this.config.autoSave) {
+      this.save();
+    }
+  }
+  /**
+   * Check if there are unsaved changes
+   */
+  isDirty() {
+    return this.dirty;
+  }
+  // ============ Credit Accounts (delegate to memory store) ============
+  async createAccount(params) {
+    const result = await this.memory.createAccount(params);
+    this.markDirty();
+    return result;
+  }
+  async getAccount(accountId) {
+    return this.memory.getAccount(accountId);
+  }
+  async getAccountByBuyer(buyerId, sellerId) {
+    return this.memory.getAccountByBuyer(buyerId, sellerId);
+  }
+  async updateAccount(accountId, updates) {
+    const result = await this.memory.updateAccount(accountId, updates);
+    this.markDirty();
+    return result;
+  }
+  async listAccounts(sellerId) {
+    return this.memory.listAccounts(sellerId);
+  }
+  // ============ Deferred Payments ============
+  async createPayment(params) {
+    const result = await this.memory.createPayment(params);
+    this.markDirty();
+    return result;
+  }
+  async getPayment(paymentId) {
+    return this.memory.getPayment(paymentId);
+  }
+  async updatePayment(paymentId, updates) {
+    const result = await this.memory.updatePayment(paymentId, updates);
+    this.markDirty();
+    return result;
+  }
+  async listPayments(filter) {
+    return this.memory.listPayments(filter);
+  }
+  // ============ Transactions ============
+  async addTransaction(accountId, tx) {
+    const result = await this.memory.addTransaction(accountId, tx);
+    this.markDirty();
+    return result;
+  }
+  // ============ Utilities ============
+  /**
+   * Export all data
+   */
+  export() {
+    return this.memory.export();
+  }
+  /**
+   * Clear all data (including file)
+   */
+  clear() {
+    this.memory.clear();
+    this.markDirty();
+  }
+};
+
+// src/deferred/templates.ts
+var DeferredStatusMarkers = {
+  creditAccountCreated: (accountId, limit) => `[status:credit_account_created id=${accountId} limit=${limit} USDC]`,
+  chargeAdded: (paymentId, amount) => `[status:charge_added payment=${paymentId} amount=${amount} USDC]`,
+  settlementReceived: (paymentId, txHash, amount) => `[status:settlement_received payment=${paymentId} tx=${txHash} amount=${amount} USDC]`,
+  accountSettled: (accountId, txHash, amount) => `[status:account_settled id=${accountId} tx=${txHash} amount=${amount} USDC]`,
+  creditIssued: (accountId, amount) => `[status:credit_issued id=${accountId} amount=${amount} USDC]`,
+  accountSuspended: (accountId, reason) => `[status:account_suspended id=${accountId} reason="${reason}"]`,
+  paymentOverdue: (paymentId, amount) => `[status:payment_overdue payment=${paymentId} amount=${amount} USDC]`
+};
+var DeferredSellerTemplates = {
+  /**
+   * Offer deferred payment option
+   */
+  offerDeferredPayment: (params) => {
+    const days = params.netDays || 30;
+    return `I can offer you two payment options for ${params.service}:
+
+**Option A: Pay Now**
+- Price: ${params.price} USDC
+- Pay via on-chain transfer, service delivered immediately
+
+**Option B: Pay Later (Net-${days})**
+- Price: ${params.price} USDC
+- Service delivered now, pay within ${days} days
+- Requires a credit account (I can set one up for you)
+
+Which option do you prefer?`;
+  },
+  /**
+   * Explain credit account setup
+   */
+  explainCreditAccount: () => `
+To use deferred payment, I'll set up a credit account for you. Here's how it works:
+
+1. **Credit Limit** - I'll extend you a credit line (e.g., $100 USDC)
+2. **Use Services** - Each service gets charged to your account
+3. **Pay Later** - Settle your balance whenever you want, or by the due date
+4. **On-chain Settlement** - When you pay, send USDC to my address and share the tx hash
+
+Would you like me to set up a credit account for you?`,
+  /**
+   * Confirm credit account creation
+   */
+  creditAccountCreated: (account) => `Great! I've set up a credit account for you.
+
+**Account Details:**
+- Account ID: ${account.accountId}
+- Credit Limit: $${account.creditLimit.toFixed(2)} USDC
+- Payment Terms: Net-${account.terms.netDays}
+- Current Balance: $${account.balance.toFixed(2)}
+
+You can now use services on credit. I'll track charges and you can settle anytime.
+${DeferredStatusMarkers.creditAccountCreated(account.accountId, account.creditLimit)}`,
+  /**
+   * Charge confirmation
+   */
+  chargeConfirmation: (payment, availableCredit) => `Service charged to your account.
+
+**Charge Details:**
+- Service: ${payment.service}
+- Amount: $${payment.amount.toFixed(2)} USDC
+- Order ID: ${payment.orderId}
+- Due Date: ${new Date(payment.dueDate).toLocaleDateString()}
+
+**Account Status:**
+- Available Credit: $${availableCredit.toFixed(2)} USDC
+
+I'll proceed with your service now.
+${DeferredStatusMarkers.chargeAdded(payment.paymentId, payment.amount)}`,
+  /**
+   * Credit limit exceeded
+   */
+  creditLimitExceeded: (params) => `Sorry, this charge would exceed your credit limit.
+
+**Current Status:**
+- Credit Limit: $${params.limit.toFixed(2)} USDC
+- Current Balance: $${params.balance.toFixed(2)} USDC
+- Available Credit: $${params.available.toFixed(2)} USDC
+- Requested: $${params.requested.toFixed(2)} USDC
+
+You can either:
+1. **Settle some balance** - Pay down your balance to free up credit
+2. **Pay for this service directly** - Skip credit, pay on-chain now
+3. **Request credit increase** - Ask for a higher limit (subject to approval)
+
+What would you like to do?`,
+  /**
+   * Account summary/statement
+   */
+  accountStatement: (summary) => {
+    const { account, pendingPayments, overduePayments } = summary;
+    let statement = `**Account Statement**
+- Account ID: ${account.accountId}
+- Status: ${account.status.toUpperCase()}
+- Credit Limit: $${account.creditLimit.toFixed(2)} USDC
+- Current Balance: $${account.balance.toFixed(2)} USDC
+- Available Credit: $${summary.availableCredit.toFixed(2)} USDC
+
+`;
+    if (pendingPayments.length > 0) {
+      statement += `**Pending Charges (${pendingPayments.length}):**
+`;
+      for (const p of pendingPayments) {
+        statement += `- ${p.service}: $${p.amount.toFixed(2)} (due ${new Date(p.dueDate).toLocaleDateString()})
+`;
+      }
+      statement += "\n";
+    }
+    if (overduePayments.length > 0) {
+      statement += `**\u26A0\uFE0F OVERDUE (${overduePayments.length}):**
+`;
+      for (const p of overduePayments) {
+        statement += `- ${p.service}: $${p.amount.toFixed(2)} (was due ${new Date(p.dueDate).toLocaleDateString()})
+`;
+      }
+      statement += "\n";
+    }
+    if (account.balance > 0) {
+      statement += `**To Settle:**
+Send $${account.balance.toFixed(2)} USDC to my address and share the transaction hash.`;
+    }
+    return statement;
+  },
+  /**
+   * Settlement confirmation
+   */
+  settlementConfirmation: (params) => `Payment received and verified on-chain. Thank you!
+
+**Settlement Details:**
+- Amount: $${params.amount.toFixed(2)} USDC
+- Transaction: ${params.txHash}
+- New Balance: $${params.newBalance.toFixed(2)} USDC
+
+${params.paymentId ? DeferredStatusMarkers.settlementReceived(params.paymentId, params.txHash, params.amount) : ""}`,
+  /**
+   * Overdue notice
+   */
+  overdueNotice: (payments) => {
+    const total = payments.reduce((sum, p) => sum + (p.amount - p.paidAmount), 0);
+    let notice = `\u26A0\uFE0F **Payment Overdue Notice**
+
+You have ${payments.length} overdue payment(s) totaling $${total.toFixed(2)} USDC:
+
+`;
+    for (const p of payments) {
+      const overdueDays = Math.floor((Date.now() - new Date(p.dueDate).getTime()) / (1e3 * 60 * 60 * 24));
+      notice += `- ${p.service}: $${(p.amount - p.paidAmount).toFixed(2)} (${overdueDays} days overdue)
+`;
+    }
+    notice += `
+Please settle your balance to avoid account suspension. Send USDC to my address and share the transaction hash.`;
+    return notice;
+  },
+  /**
+   * Credit issued confirmation
+   */
+  creditIssued: (params) => `I've issued a credit to your account.
+
+**Credit Details:**
+- Amount: $${params.amount.toFixed(2)} USDC
+- Reason: ${params.reason}
+- New Balance: $${params.newBalance.toFixed(2)} USDC
+
+${DeferredStatusMarkers.creditIssued(params.accountId, params.amount)}`
+};
+var DeferredBuyerTemplates = {
+  /**
+   * Request deferred payment
+   */
+  requestDeferredPayment: (service) => `I'd like to use ${service}, but prefer to pay later. Do you offer deferred payment or credit terms?`,
+  /**
+   * Accept credit account offer
+   */
+  acceptCreditAccount: () => `Yes, please set up a credit account for me. I'll settle the balance by the due date.`,
+  /**
+   * Request credit limit increase
+   */
+  requestCreditIncrease: (currentLimit, requestedLimit) => `My current credit limit is $${currentLimit.toFixed(2)}. Could you increase it to $${requestedLimit.toFixed(2)}? I have a larger purchase coming up.`,
+  /**
+   * Request account statement
+   */
+  requestStatement: () => `Can you show me my current account balance and any pending charges?`,
+  /**
+   * Announce settlement payment
+   */
+  announceSettlement: (params) => `I've sent a payment to settle my balance.
+
+**Payment Details:**
+- Amount: $${params.amount.toFixed(2)} USDC
+- Transaction Hash: ${params.txHash}
+
+Please verify and update my account.
+${params.accountId ? `[status:settlement_sent account=${params.accountId} tx=${params.txHash} amount=${params.amount} USDC]` : ""}`,
+  /**
+   * Dispute a charge
+   */
+  disputeCharge: (paymentId, reason) => `I'd like to dispute charge ${paymentId}. Reason: ${reason}
+
+Please review and let me know how to resolve this.
+[status:charge_disputed payment=${paymentId}]`
+};
+function parseDeferredStatusMarker(text) {
+  const match = text.match(/\[status:(\w+)\s+(.+?)\]/);
+  if (!match) return null;
+  const type = match[1];
+  const dataStr = match[2];
+  const data = {};
+  const pairs = dataStr.match(/(\w+)=("[^"]+"|[\w.]+)/g);
+  if (pairs) {
+    for (const pair of pairs) {
+      const [key, ...valueParts] = pair.split("=");
+      let value = valueParts.join("=");
+      if (value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1);
+      }
+      data[key] = value;
+    }
+  }
+  return { type, data };
+}
 export {
   AgentWallet,
   AllowanceWallet,
@@ -3548,7 +4522,13 @@ export {
   BuyerTemplates,
   CDPWallet,
   CHAINS,
+  DeferredBuyerTemplates,
+  DeferredPaymentManager,
+  DeferredSellerTemplates,
+  DeferredStatusMarkers,
   ERC20_ABI,
+  JsonDeferredStore,
+  MemoryDeferredStore,
   MemoryOrderStore,
   OrderManager,
   PAYMENT_HEADER,
@@ -3594,6 +4574,7 @@ export {
   loadCDPWallet,
   loadWallet,
   networkToChain,
+  parseDeferredStatusMarker,
   parsePaymentRequired,
   parseStatusMarker,
   signEIP3009,