@dvmkit/sdk 0.3.4-rc.10 → 0.5.0-rc.1

package/dist/{chunk-2SD2W2BG.js → chunk-JH3SX3LY.js}

@@ -4,6 +4,9 @@ import {
 import {
   applyRetryToPool
 } from "./chunk-P6QON7ER.js";
+import {
+  x402NetworkByCaip2
+} from "./chunk-RLTSCKRI.js";
 import {
   diagnosticConsole
 } from "./chunk-ETXDTUJO.js";
@@ -62,6 +65,7 @@ function lotSats(lot, micro) {
 // src/sdk/server/x402-channel-store.ts
 import { AsyncLocalStorage } from "async_hooks";
 import { isDeepStrictEqual } from "util";
+import { BATCH_SETTLEMENT_ADDRESS } from "@x402/evm";
 var X402SettlementRaceError = class extends Error {
 };
 var X402RelaySubmissionLockError = class extends Error {
@@ -99,21 +103,45 @@ var PostgresX402ChannelStorage = class {
     this.pool = pool;
     this.relayLockTimeoutMs = opts?.relaySubmissionLockTimeoutMs ?? RELAY_SUBMISSION_LOCK_TIMEOUT_MS;
     this.terminalizeUnbackedCredit = opts?.terminalizeUnbackedCredit;
+    this.hostedNetwork = opts?.hostedNetwork;
+    if (this.hostedNetwork && !x402NetworkByCaip2(this.hostedNetwork)) {
+      throw new Error("Hosted x402 batch channel network is unsupported");
+    }
     if (!Number.isInteger(this.relayLockTimeoutMs) || this.relayLockTimeoutMs <= 0) {
       throw new Error("relaySubmissionLockTimeoutMs must be a positive integer number of ms");
     }
   }
   pool;
+  hostingCleanupFence;
+  useHostingCleanupFence(fence) {
+    this.hostingCleanupFence = fence;
+  }
+  async assertHostingFundingReservation(reservation) {
+    if (!this.hostingCleanupFence) return;
+    if (!reservation) throw new Error("Hosted x402 funding requires an original admission");
+    await this.hostingCleanupFence.withNewIntent({
+      admissionId: reservation.admissionId,
+      creditId: reservation.creditId,
+      fundId: reservation.fundId,
+      callerPubkey: reservation.callerPubkey,
+      fundingCommitment: reservation.commitment
+    }, (tx) => this.hostingCleanupFence.assertFundingReservation(tx, reservation));
+  }
   transaction = new AsyncLocalStorage();
+  hostedFunding = /* @__PURE__ */ new WeakMap();
   refundBase = new AsyncLocalStorage();
   settlementPool;
   fleetLock = Promise.resolve();
   fleetLockQueueDepth = 0;
   relayLockTimeoutMs;
   terminalizeUnbackedCredit;
+  hostedNetwork;
   async init() {
     this.settlementPool ??= createSettlementPool(this.pool);
     await withSdkInitLock(this.pool, async () => {
+      const before = await this.pool.query(
+        "SELECT to_regclass('x402_batch_channels') IS NOT NULL AS existed"
+      );
       await this.pool.query(`
         CREATE TABLE IF NOT EXISTS x402_batch_channels (
           channel_id                  TEXT PRIMARY KEY,
@@ -127,9 +155,35 @@ var PostgresX402ChannelStorage = class {
           refund_nonce                 BIGINT NOT NULL,
           onchain_synced_at             BIGINT,
           last_request_timestamp       BIGINT NOT NULL,
-          pending_request              JSONB
+          pending_request              JSONB,
+          hosting_binding              JSONB
+        )
+      `);
+      await this.pool.query(
+        `ALTER TABLE x402_batch_channels ADD COLUMN IF NOT EXISTS hosting_binding JSONB`
+      );
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS x402_batch_channel_tombstones (
+          channel_id TEXT PRIMARY KEY,
+          hosting_binding JSONB,
+          charged_cumulative_amount NUMERIC(78,0) NOT NULL,
+          signed_max_claimable NUMERIC(78,0) NOT NULL,
+          refund_nonce BIGINT NOT NULL,
+          pending_request JSONB,
+          deleted_at_ms BIGINT NOT NULL
         )
       `);
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS x402_batch_channel_history (
+          singleton BOOLEAN PRIMARY KEY CHECK (singleton),
+          complete BOOLEAN NOT NULL
+        )
+      `);
+      await this.pool.query(
+        `INSERT INTO x402_batch_channel_history (singleton,complete) VALUES (TRUE,$1)
+         ON CONFLICT (singleton) DO NOTHING`,
+        [!before.rows[0].existed]
+      );
       await this.pool.query(
         `CREATE INDEX IF NOT EXISTS idx_x402_batch_channels_withdrawal
            ON x402_batch_channels(withdraw_requested_at)
@@ -379,9 +433,9 @@ var PostgresX402ChannelStorage = class {
     return existing ? { intent: existing, written: false } : void 0;
   }
   /** Persist the reconciliation identity, refreshing a prepared retry's transient reservation. */
-  async prepareSettlement(intent) {
+  async prepareSettlement(intent, hostingFunding) {
     const settlements = await this.settlementWriter();
-    await settlements.query(
+    const insert = (q) => q.query(
       `INSERT INTO x402_batch_settlements (
          settlement_id, channel_id, operation, effect_id, payment_id,
          payment_payload, payment_requirements, channel_before, pending_id, status
@@ -399,6 +453,27 @@ var PostgresX402ChannelStorage = class {
         intent.pendingId ?? null
       ]
     );
+    if (this.hostingCleanupFence && intent.operation === "fund") {
+      if (!hostingFunding || intent.effectId !== `${hostingFunding.creditId}:${hostingFunding.fundId}`) {
+        throw new Error("Hosted x402 settlement has no matching original funding admission");
+      }
+      await this.hostingCleanupFence.withNewIntentOn(
+        await this.settlementPoolRef(),
+        {
+          admissionId: hostingFunding.admissionId,
+          creditId: hostingFunding.creditId,
+          fundId: hostingFunding.fundId,
+          callerPubkey: hostingFunding.callerPubkey,
+          fundingCommitment: hostingFunding.commitment
+        },
+        async (tx) => {
+          await this.hostingCleanupFence.assertFundingReservation(tx, hostingFunding);
+          await insert(tx);
+        }
+      );
+    } else {
+      await insert(settlements);
+    }
     const { rows } = await settlements.query(
       `SELECT * FROM x402_batch_settlements
         WHERE settlement_id = $1
@@ -597,10 +672,14 @@ var PostgresX402ChannelStorage = class {
   withSanctionedRefundBase(base, operation) {
     return this.refundBase.run(base, operation);
   }
-  async withChannelTransaction(channelId, operation) {
+  async withChannelTransaction(channelId, operation, hostingFunding) {
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
+      if (this.hostingCleanupFence && hostingFunding) {
+        await this.hostingCleanupFence.assertFundingReservation(client, hostingFunding);
+        this.hostedFunding.set(client, hostingFunding);
+      }
       await lockChannel(client, channelId);
       const result = await this.transaction.run(client, () => operation(client));
       await client.query("COMMIT");
@@ -608,6 +687,22 @@ var PostgresX402ChannelStorage = class {
     } catch (error) {
       await client.query("ROLLBACK").catch(() => void 0);
       throw error;
+    } finally {
+      this.hostedFunding.delete(client);
+      client.release();
+    }
+  }
+  /** Durable effect bookkeeping reached while a caller already holds a host-pool client. */
+  async withSettlementTransaction(operation) {
+    const client = await (await this.settlementPoolRef()).connect();
+    try {
+      await client.query("BEGIN");
+      const result = await operation(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK").catch(() => void 0);
+      throw error;
     } finally {
       client.release();
     }
@@ -758,10 +853,36 @@ var PostgresX402ChannelStorage = class {
     const next = update(current);
     if (next === void 0) {
       if (!current) return { channel: void 0, status: "unchanged" };
+      await client.query(
+        `INSERT INTO x402_batch_channel_tombstones
+         (channel_id,hosting_binding,charged_cumulative_amount,signed_max_claimable,refund_nonce,pending_request,deleted_at_ms)
+         VALUES ($1,$2,$3,$4,$5,$6,$7)
+         ON CONFLICT (channel_id) DO UPDATE SET
+           charged_cumulative_amount=GREATEST(x402_batch_channel_tombstones.charged_cumulative_amount,
+             EXCLUDED.charged_cumulative_amount),
+           signed_max_claimable=GREATEST(x402_batch_channel_tombstones.signed_max_claimable,
+             EXCLUDED.signed_max_claimable),
+           refund_nonce=GREATEST(x402_batch_channel_tombstones.refund_nonce,EXCLUDED.refund_nonce),
+           pending_request=COALESCE(x402_batch_channel_tombstones.pending_request,EXCLUDED.pending_request)`,
+        [
+          normalized,
+          rows[0].hosting_binding,
+          rows[0].charged_cumulative_amount,
+          rows[0].signed_max_claimable,
+          rows[0].refund_nonce,
+          rows[0].pending_request,
+          Date.now()
+        ]
+      );
       await client.query(`DELETE FROM x402_batch_channels WHERE channel_id = $1`, [normalized]);
       return { channel: void 0, status: "deleted" };
     }
     assertChannelTransition(current, next, normalized, this.refundBase.getStore());
+    if (this.hostingCleanupFence && (!current || BigInt(next.chargedCumulativeAmount) > BigInt(current.chargedCumulativeAmount) || BigInt(next.signedMaxClaimable) > BigInt(current.signedMaxClaimable))) {
+      const funding = this.hostedFunding.get(client);
+      if (funding) await this.hostingCleanupFence.assertFundingReservation(client, funding);
+      else await this.hostingCleanupFence.assertNewIntent(client);
+    }
     if (this.terminalizeUnbackedCredit && next.onchainSyncedAt !== void 0 && next.onchainSyncedAt !== current?.onchainSyncedAt && next.withdrawRequestedAt === 0 && BigInt(next.balance) === BigInt(next.totalClaimed)) {
       await this.terminalizeUnbackedCredit(
         {
@@ -776,7 +897,17 @@ var PostgresX402ChannelStorage = class {
     if (current && sameChannel(current, next)) {
       return { channel: current, status: "unchanged" };
     }
-    await writeChannel(client, normalized, next);
+    const prior = !current && this.hostedNetwork ? await client.query(
+      "SELECT hosting_binding FROM x402_batch_channel_tombstones WHERE channel_id=$1",
+      [normalized]
+    ) : void 0;
+    await writeChannel(
+      client,
+      normalized,
+      next,
+      this.hostedNetwork,
+      prior?.rows[0] ? prior.rows[0].hosting_binding : void 0
+    );
     return { channel: cloneChannel(next), status: "updated" };
   }
 };
@@ -893,13 +1024,20 @@ async function lockChannel(client, channelId) {
     normalizeChannelId(channelId)
   ]);
 }
-async function writeChannel(client, channelId, channel) {
+async function writeChannel(client, channelId, channel, hostedNetwork, priorBinding) {
+  const binding = priorBinding !== void 0 ? priorBinding : hostedNetwork ? {
+    network: hostedNetwork,
+    chainId: Number(x402NetworkByCaip2(hostedNetwork)?.caip2.split(":")[1]),
+    contract: BATCH_SETTLEMENT_ADDRESS.toLowerCase(),
+    version: "x402-batch-settlement-v1",
+    channelId
+  } : null;
   await client.query(
     `INSERT INTO x402_batch_channels (
        channel_id, channel_config, charged_cumulative_amount, signed_max_claimable,
        signature, balance, total_claimed, withdraw_requested_at, refund_nonce,
-       onchain_synced_at, last_request_timestamp, pending_request
-     ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       onchain_synced_at, last_request_timestamp, pending_request, hosting_binding
+     ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
      ON CONFLICT (channel_id) DO UPDATE SET
        channel_config = EXCLUDED.channel_config,
        charged_cumulative_amount = EXCLUDED.charged_cumulative_amount,
@@ -924,7 +1062,8 @@ async function writeChannel(client, channelId, channel) {
       channel.refundNonce,
       channel.onchainSyncedAt ?? null,
       channel.lastRequestTimestamp,
-      channel.pendingRequest ?? null
+      channel.pendingRequest ?? null,
+      binding
     ]
   );
 }
@@ -1003,6 +1142,8 @@ var CreditLedger = class {
   durable = true;
   x402Settlements;
   expiryReleaseOutbox;
+  hostingCleanupFence;
+  invoiceSettlementClients = /* @__PURE__ */ new WeakSet();
   /**
    * Bound after construction because the settlement store shares this ledger and is
    * initialized separately. Ledger effects and route preflights use the same refund gate.
@@ -1018,6 +1159,9 @@ var CreditLedger = class {
   useCreditExpiryReleaseOutbox(outbox) {
     this.expiryReleaseOutbox = outbox;
   }
+  useHostingCleanupFence(fence) {
+    this.hostingCleanupFence = fence;
+  }
   async init() {
     await withSdkInitLock(this.pool, () => this.createTables());
   }
@@ -1248,6 +1392,8 @@ var CreditLedger = class {
         expires_at    BIGINT NOT NULL,
         created_at    BIGINT NOT NULL,
         settled_at    BIGINT,
+        hosting_admission_id TEXT,
+        created_at_db_us BIGINT NOT NULL DEFAULT FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000000)::bigint,
         PRIMARY KEY (credit_id, fund_id)
       );
     `);
@@ -1266,6 +1412,13 @@ var CreditLedger = class {
     await this.pool.query(
       `ALTER TABLE credit_invoices ADD COLUMN IF NOT EXISTS write_off_note TEXT`
     );
+    await this.pool.query(
+      `ALTER TABLE credit_invoices ADD COLUMN IF NOT EXISTS hosting_admission_id TEXT`
+    );
+    await this.pool.query(
+      `ALTER TABLE credit_invoices ADD COLUMN IF NOT EXISTS created_at_db_us BIGINT NOT NULL
+       DEFAULT FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000000)::bigint`
+    );
     await this.pool.query(
       `CREATE UNIQUE INDEX IF NOT EXISTS credit_invoices_hash_uidx
          ON credit_invoices(payment_hash);`
@@ -1379,6 +1532,20 @@ var CreditLedger = class {
     }
   }
   async fundOn(q, args, b, nowMs, creditId) {
+    if (this.hostingCleanupFence && (args.hostingInvoicePaymentHash || args.hostingInvoiceRepairPaymentHash) && !this.invoiceSettlementClients.has(q)) {
+      throw new Error("Hosted invoice settlement must use its original locked transaction");
+    }
+    await this.hostingCleanupFence?.assertNewIntent(q, {
+      admissionId: args.hostingAdmissionId,
+      jobId: args.hostingJobId,
+      paymentSeq: args.hostingPaymentSeq,
+      creditId: args.hostingJobId ? void 0 : creditId,
+      fundId: args.hostingFundId,
+      callerPubkey: args.hostingJobId ? void 0 : args.callerPubkey,
+      invoicePaymentHash: args.hostingInvoicePaymentHash,
+      invoiceRepairPaymentHash: args.hostingInvoiceRepairPaymentHash,
+      amountMicro: args.amountMicro
+    });
     const wedged = await this.blockingX402Refund(
       b.x402Channel?.channelId,
       X402_SPEND_BLOCKING_SETTLEMENT_STATUSES
@@ -1734,6 +1901,11 @@ var CreditLedger = class {
       });
       const ledgerSeq = toSafeInt(credit.last_ledger_seq) + 1;
       const balanceAfterMicro = available - args.amountMicro;
+      await this.hostingCleanupFence?.assertNewIntent(client, {
+        admissionId: args.hostingAdmissionId,
+        jobId: args.jobId,
+        paymentSeq: args.hostingPaymentSeq
+      });
       await client.query(`UPDATE credits SET last_ledger_seq = $2 WHERE credit_id = $1`, [
         args.creditId,
         ledgerSeq
@@ -2008,7 +2180,34 @@ var CreditLedger = class {
    */
   async recordFunding(args) {
     assertAmount(args.amountMicro, { min: 1 });
+    if (this.hostingCleanupFence && (args.hostingInvoicePaymentHash || args.hostingInvoiceRepairPaymentHash) && (!args.tx || !this.invoiceSettlementClients.has(args.tx))) {
+      throw new Error("Hosted invoice settlement must use its original locked transaction");
+    }
+    if (this.hostingCleanupFence && !args.tx) {
+      return this.hostingCleanupFence.withNewIntent({
+        admissionId: args.hostingAdmissionId,
+        jobId: args.hostingJobId,
+        paymentSeq: args.hostingPaymentSeq,
+        creditId: args.hostingJobId ? void 0 : args.creditId,
+        fundId: args.hostingJobId ? void 0 : args.fundId,
+        callerPubkey: args.hostingJobId ? void 0 : args.hostingCallerPubkey,
+        invoicePaymentHash: args.hostingInvoicePaymentHash,
+        amountMicro: args.amountMicro,
+        invoiceRepairPaymentHash: args.hostingInvoiceRepairPaymentHash
+      }, (tx) => this.recordFunding({ ...args, tx }));
+    }
     const q = args.tx ?? this.pool;
+    if (args.tx) await this.hostingCleanupFence?.assertNewIntent(args.tx, {
+      admissionId: args.hostingAdmissionId,
+      jobId: args.hostingJobId,
+      paymentSeq: args.hostingPaymentSeq,
+      creditId: args.hostingJobId ? void 0 : args.creditId,
+      fundId: args.hostingJobId ? void 0 : args.fundId,
+      callerPubkey: args.hostingJobId ? void 0 : args.hostingCallerPubkey,
+      invoicePaymentHash: args.hostingInvoicePaymentHash,
+      amountMicro: args.amountMicro,
+      invoiceRepairPaymentHash: args.hostingInvoiceRepairPaymentHash
+    });
     const nowMs = args.nowMs ?? Date.now();
     const { rows } = await q.query(
       `INSERT INTO credit_fundings (credit_id, fund_id, amount_micro, rail, created_at)
@@ -2089,25 +2288,40 @@ var CreditLedger = class {
     const nowMs = args.nowMs ?? Date.now();
     let rows;
     try {
-      ({ rows } = await this.pool.query(
-        `INSERT INTO credit_invoices (credit_id, fund_id, caller_pubkey, currency, amount_micro,
-                                      amount_msats, payment_hash, bolt11, status, expires_at, created_at)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'pending', $9, $10)
-         ON CONFLICT (credit_id, fund_id) DO NOTHING
-         RETURNING *`,
-        [
+      const insert = async (q) => {
+        const hostingAdmissionId = this.hostingCleanupFence ? await this.hostingCleanupFence.fundingAdmission(
+          q,
           args.creditId,
           args.fundId,
-          args.callerPubkey,
-          args.currency,
-          args.amountMicro,
-          args.amountMsats,
-          args.paymentHash,
-          args.bolt11,
-          args.expiresAt,
-          nowMs
-        ]
-      ));
+          args.callerPubkey
+        ) : null;
+        return q.query(
+          `INSERT INTO credit_invoices (credit_id, fund_id, caller_pubkey, currency, amount_micro,
+                                      amount_msats, payment_hash, bolt11, status, expires_at, created_at,
+                                      hosting_admission_id)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'pending', $9, $10, $11)
+         ON CONFLICT (credit_id, fund_id) DO NOTHING
+         RETURNING *`,
+          [
+            args.creditId,
+            args.fundId,
+            args.callerPubkey,
+            args.currency,
+            args.amountMicro,
+            args.amountMsats,
+            args.paymentHash,
+            args.bolt11,
+            args.expiresAt,
+            nowMs,
+            hostingAdmissionId
+          ]
+        );
+      };
+      ({ rows } = this.hostingCleanupFence ? await this.hostingCleanupFence.withNewIntent({
+        creditId: args.creditId,
+        fundId: args.fundId,
+        callerPubkey: args.callerPubkey
+      }, insert) : await insert(this.pool));
     } catch (err) {
       if (isUniqueViolation(err)) {
         throw new CreditLedgerError(
@@ -2184,11 +2398,14 @@ var CreditLedger = class {
         ]);
         return { invoice, funding: funding2, credit: credit2, replayed: true };
       }
+      this.invoiceSettlementClients.add(client);
       const funding = await this.recordFunding({
         creditId: invoice.creditId,
         fundId: invoice.fundId,
         amountMicro: invoice.amountMicro,
         rail: "lightning",
+        hostingInvoicePaymentHash: invoice.paymentHash,
+        hostingCallerPubkey: invoice.callerPubkey,
         tx: client,
         nowMs
       });
@@ -2199,6 +2416,8 @@ var CreditLedger = class {
         amountMicro: invoice.amountMicro,
         expiryMs: args.expiryMs,
         basis: args.basis,
+        hostingInvoicePaymentHash: invoice.paymentHash,
+        hostingFundId: invoice.fundId,
         tx: client,
         nowMs
       });
@@ -2233,6 +2452,7 @@ var CreditLedger = class {
       }
       throw err;
     } finally {
+      this.invoiceSettlementClients.delete(client);
       client.release();
     }
   }
@@ -2338,11 +2558,14 @@ var CreditLedger = class {
           `invoice ${args.paymentHash} is ${invoice.status}; only a blocked or written-off invoice can be reconciled`
         );
       }
+      this.invoiceSettlementClients.add(client);
       const funding = await this.recordFunding({
         creditId: args.targetCreditId,
         fundId: invoice.paymentHash,
         amountMicro: invoice.amountMicro,
         rail: "lightning",
+        hostingInvoiceRepairPaymentHash: invoice.paymentHash,
+        hostingCallerPubkey: invoice.callerPubkey,
         tx: client,
         nowMs
       });
@@ -2353,6 +2576,8 @@ var CreditLedger = class {
         amountMicro: invoice.amountMicro,
         expiryMs: args.expiryMs,
         basis: args.basis,
+        hostingInvoiceRepairPaymentHash: invoice.paymentHash,
+        hostingFundId: invoice.paymentHash,
         tx: client,
         nowMs
       });
@@ -2398,6 +2623,7 @@ var CreditLedger = class {
       }
       throw err;
     } finally {
+      this.invoiceSettlementClients.delete(client);
       client.release();
     }
   }