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

package/dist/chunk-KA6VN5FK.js

@@ -0,0 +1,245 @@
+import {
+  parseStoreValue,
+  stringifyStoreValue
+} from "./chunk-YG7G4DPZ.js";
+import {
+  withSdkInitLock
+} from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-ETXDTUJO.js";
+
+// src/sdk/server/tempo-charge-store.ts
+import { Credential } from "mppx";
+import { createHash } from "crypto";
+import { keccak256 } from "viem";
+var DEFAULT_TABLE_NAME = "mpp_tempo_charge_replays";
+var DEFAULT_RETENTION_MS = 60 * 60 * 1e3;
+var DEFAULT_GC_SAMPLE_RATE = 0.01;
+var VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function replayKeyFor(credential) {
+  const payload = credential.payload;
+  if (payload.type === "proof") return `mppx:charge:proof:${credential.challenge.id}`;
+  if (payload.type === "hash" && /^0x[0-9a-fA-F]{64}$/.test(payload.hash ?? "")) {
+    return `mppx:charge:${payload.hash.toLowerCase()}`;
+  }
+  if (payload.type === "transaction" && /^0x[0-9a-fA-F]+$/.test(payload.signature ?? "")) {
+    return `mppx:charge:${keccak256(payload.signature).toLowerCase()}`;
+  }
+  throw new Error("Hosted Tempo charge credential has no supported replay key");
+}
+function canonicalCredential(credential) {
+  const serialized = Credential.serialize(credential);
+  const encoded = serialized.slice(serialized.indexOf(" ") + 1);
+  const wire = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  const sorted = (value) => {
+    if (Array.isArray(value)) return value.map(sorted);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, field]) => [key, sorted(field)]));
+    }
+    return value;
+  };
+  return JSON.stringify(sorted(wire));
+}
+var PostgresTempoChargeStore = class {
+  hostingCleanupFence;
+  useHostingCleanupFence(fence) {
+    this.hostingCleanupFence = fence;
+  }
+  async reserveHostedCharge(serializedCredential, intent) {
+    if (!this.hostingCleanupFence) return;
+    const credential = Credential.deserialize(serializedCredential);
+    if (credential.challenge.intent !== "charge" || credential.challenge.method !== "tempo") {
+      throw new Error("Hosted Tempo charge credential is not a Tempo charge");
+    }
+    const challengeId = credential.challenge.id;
+    const replayKey = replayKeyFor(credential);
+    const artifactHash = createHash("sha256").update(serializedCredential).digest("hex");
+    await this.hostingCleanupFence.withNewIntent({
+      ...intent,
+      challengeId,
+      paymentArtifactHash: artifactHash
+    }, async (tx) => {
+      if (intent.paymentSeq !== void 0 && intent.jobId) {
+        const original = await tx.query(
+          `SELECT data->'content'->'tempo_credential' AS credential FROM job_messages
+           WHERE job_id=$1 AND seq=$2 AND status='pending-verification'`,
+          [intent.jobId, intent.paymentSeq]
+        );
+        const recorded = original.rows[0]?.credential;
+        if (!recorded || canonicalCredential(recorded) !== canonicalCredential(credential)) {
+          throw new Error("Hosted Tempo charge differs from the original inbound payment");
+        }
+      }
+      const prior = await tx.query(
+        `SELECT admission_id,job_id,payment_seq,replay_key,payment_artifact_hash FROM sdk_hosted_tempo_charge_intents
+         WHERE challenge_id=$1 FOR UPDATE`,
+        [challengeId]
+      );
+      if (prior.rows[0]) {
+        const row = prior.rows[0];
+        if (row.admission_id !== (intent.admissionId ?? null) || row.job_id !== (intent.jobId ?? null) || row.payment_seq !== (intent.paymentSeq ?? null) || row.replay_key !== replayKey || row.payment_artifact_hash !== artifactHash) {
+          throw new Error("Hosted Tempo charge identity conflicts with the original payment");
+        }
+        return;
+      }
+      await tx.query(
+        `INSERT INTO sdk_hosted_tempo_charge_intents
+         (challenge_id,admission_id,job_id,payment_seq,replay_key,payment_artifact_hash,status)
+         VALUES ($1,$2,$3,$4,$5,$6,'pending')`,
+        [
+          challengeId,
+          intent.admissionId ?? null,
+          intent.jobId ?? null,
+          intent.paymentSeq ?? null,
+          replayKey,
+          artifactHash
+        ]
+      );
+    });
+  }
+  async completeHostedCharge(challengeId) {
+    if (!this.hostingCleanupFence) return;
+    await this.pool.query(
+      `UPDATE sdk_hosted_tempo_charge_intents SET status='complete'
+       WHERE challenge_id=$1 AND status='pending' AND (
+         EXISTS (SELECT 1 FROM processed_payments p
+           WHERE p.payment_id=$1 AND p.rail='tempo' AND p.dvm_id=$2
+             AND p.job_id IS NOT DISTINCT FROM sdk_hosted_tempo_charge_intents.job_id)
+       )`,
+      [challengeId, this.hostingCleanupFence.dvmId]
+    );
+  }
+  pool;
+  tableName;
+  retentionMs;
+  gcSampleRate;
+  now;
+  constructor(pool, opts) {
+    const tableName = opts?.tableName ?? DEFAULT_TABLE_NAME;
+    if (!VALID_IDENTIFIER.test(tableName)) {
+      throw new Error(
+        `PostgresTempoChargeStore: tableName must match ${VALID_IDENTIFIER.source}, got "${tableName}"`
+      );
+    }
+    this.pool = pool;
+    this.tableName = tableName;
+    this.retentionMs = opts?.retentionMs ?? DEFAULT_RETENTION_MS;
+    this.gcSampleRate = opts?.gcSampleRate ?? DEFAULT_GC_SAMPLE_RATE;
+    this.now = opts?.now ?? (() => Date.now());
+    this.get = this.get.bind(this);
+    this.put = this.put.bind(this);
+    this.delete = this.delete.bind(this);
+    this.update = this.update.bind(this);
+  }
+  /** Run the CREATE TABLE migration. Idempotent — safe to call repeatedly. */
+  async init() {
+    await withSdkInitLock(this.pool, () => this.createTables());
+  }
+  /** Read one stored value, or `null` when absent — mppx's miss sentinel. */
+  async get(key) {
+    const { rows } = await this.pool.query(
+      `SELECT value_json FROM ${this.tableName} WHERE store_key = $1`,
+      [key]
+    );
+    return rows[0] ? parseStoreValue(rows[0].value_json) : null;
+  }
+  async put(key, value) {
+    await this.update(key, () => ({ op: "set", value, result: void 0 }));
+  }
+  /** Delete one stored value — mppx's compensating release on a failed broadcast. */
+  async delete(key) {
+    await this.update(key, () => ({ op: "delete", result: void 0 }));
+  }
+  /**
+   * Advisory locking covers the absent-row first write before the row lock.
+   * Both competing presentations of one credential and the shared sponsor
+   * budget need this serialization. The transaction contains no chain call.
+   */
+  async update(key, fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(`SELECT pg_advisory_xact_lock(hashtextextended($1, 2036))`, [key]);
+      const { rows } = await client.query(
+        `SELECT value_json FROM ${this.tableName} WHERE store_key = $1 FOR UPDATE`,
+        [key]
+      );
+      const current = rows[0] ? parseStoreValue(rows[0].value_json) : null;
+      const change = fn(current);
+      const now = this.now();
+      if (change.op === "set") {
+        if (this.hostingCleanupFence) {
+          const pending = await client.query(
+            `SELECT EXISTS (
+               SELECT 1 FROM sdk_hosted_tempo_charge_intents i
+               LEFT JOIN sdk_hosting_admissions a ON a.id=i.admission_id
+               LEFT JOIN jobs j ON j.id=i.job_id
+               WHERE i.status='pending' AND i.replay_key=$3 AND
+                 ((a.dvm_id=$1 AND a.scope=$2) OR j.dvm_id=$1)
+             ) AS reserved`,
+            [this.hostingCleanupFence.dvmId, this.hostingCleanupFence.scope, key]
+          );
+          if (!pending.rows[0]?.reserved) {
+            await this.hostingCleanupFence.assertNewIntent(client);
+          }
+        }
+        await client.query(
+          `INSERT INTO ${this.tableName} (store_key, value_json, expires_at)
+           VALUES ($1, $2, $3)
+           ON CONFLICT (store_key) DO UPDATE
+             SET value_json = EXCLUDED.value_json, expires_at = EXCLUDED.expires_at`,
+          [
+            key,
+            stringifyStoreValue(change.value, "Tempo charge store value"),
+            now + this.retentionMs
+          ]
+        );
+      } else if (change.op === "delete") {
+        await client.query(`DELETE FROM ${this.tableName} WHERE store_key = $1`, [key]);
+      }
+      await client.query("COMMIT");
+      if (change.op !== "noop") this.maybeSweep(now);
+      return change.result;
+    } catch (error) {
+      await client.query("ROLLBACK").catch(() => void 0);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async createTables() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        store_key  TEXT PRIMARY KEY,
+        value_json TEXT NOT NULL,
+        expires_at BIGINT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS ${this.tableName}_expires_at_idx
+        ON ${this.tableName} (expires_at);
+      CREATE TABLE IF NOT EXISTS sdk_hosted_tempo_charge_intents (
+        challenge_id TEXT PRIMARY KEY,
+        admission_id TEXT,
+        job_id TEXT,
+        payment_seq INTEGER,
+        replay_key TEXT,
+        payment_artifact_hash TEXT,
+        status TEXT NOT NULL CHECK (status IN ('pending','complete')),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
+      );
+      ALTER TABLE sdk_hosted_tempo_charge_intents
+        ADD COLUMN IF NOT EXISTS replay_key TEXT,
+        ADD COLUMN IF NOT EXISTS payment_artifact_hash TEXT;
+    `);
+  }
+  maybeSweep(now) {
+    if (this.gcSampleRate <= 0 || Math.random() >= this.gcSampleRate) return;
+    this.pool.query(`DELETE FROM ${this.tableName} WHERE expires_at < $1`, [now]).catch((err) => {
+      diagnosticConsole.error("PostgresTempoChargeStore GC sweep failed:", err);
+    });
+  }
+};
+
+export {
+  PostgresTempoChargeStore
+};

package/dist/{chunk-YRDA7EWN.js → chunk-LE74UEV7.js}

@@ -1,31 +1,27 @@
 import {
   fundingReachableAt,
-  info,
   listCredits,
   maxAdvertisedMicro,
   withinAdvertisedTolerance
-} from "./chunk-C2AGARLM.js";
+} from "./chunk-B2IROPQF.js";
 import {
   authorizeProtectedRemoval,
   isValidEvmPrivateKey,
   loadConfig,
   updateConfig
-} from "./chunk-MG67KXU7.js";
+} from "./chunk-MZRJR2CW.js";
 import {
   X402_DEFAULT_NETWORK,
   X402_V1_VERSION,
   X402_VERSION,
-  assertSupportedX402Network,
   buildPaymentRequirements,
   chainIdFromCaip2,
   encodePayment,
   usdcContractFor,
   usdcDomainNameFor,
   usdcDomainVersionFor,
-  x402NetworkByCaip2,
-  x402NetworkToCaip2,
-  x402SupportedNetworksHint
-} from "./chunk-Z4BNLUZF.js";
+  x402NetworkToCaip2
+} from "./chunk-IWQHUSMO.js";
 import {
   costAnchor,
   fetchBtcUsdRate,
@@ -34,18 +30,25 @@ import {
   getLastKnownBtcRate,
   msatsToUsdc,
   usdcToMsats
-} from "./chunk-A4CM2BD3.js";
+} from "./chunk-PAIM66YA.js";
 import {
-  DvmError,
   X402_CHANNELS_FILE,
   ensureConfigDir,
   resolveRpcHttpTransportOptions,
   resolveRpcOverride
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
 import {
   redactUrl,
   redactUrlsInText
 } from "./chunk-FUJ36YDV.js";
+import {
+  assertSupportedX402Network,
+  x402NetworkByCaip2,
+  x402SupportedNetworksHint
+} from "./chunk-RLTSCKRI.js";
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
 
 // src/lib/x402/asset.ts
 function resolveX402Asset(network = X402_DEFAULT_NETWORK) {
@@ -68,6 +71,42 @@ function x402WrongAssetHint(asset) {
   return `This rail reads only ${asset.label} (${asset.address}) on ${asset.networkLabel}. ${wrongToken} USDC on a different chain is invisible here too \u2014 this wallet reads ${asset.networkLabel} alone. If you funded the wrong one, swap it to ${asset.label} on ${asset.networkLabel}, or bridge the funds across to ${asset.networkLabel}; either way they land where this rail can spend them.`;
 }
 
+// src/lib/output.ts
+import { writeSync } from "fs";
+var _traceId = null;
+function setOutputTraceId(id) {
+  _traceId = id;
+}
+function getOutputTraceId() {
+  return _traceId;
+}
+function json(data) {
+  const out = _traceId !== null && typeof data === "object" && data !== null && !Array.isArray(data) && !("trace_id" in data) ? { trace_id: _traceId, ...data } : data;
+  writeAllSync(1, JSON.stringify(out) + "\n");
+}
+function info(msg) {
+  writeAllSync(2, msg + "\n");
+}
+function raw(msg) {
+  writeAllSync(1, msg + "\n");
+}
+function progress(event) {
+  writeAllSync(2, JSON.stringify(event) + "\n");
+}
+function writeAllSync(fd, text) {
+  const buf = Buffer.from(text, "utf8");
+  let offset = 0;
+  while (offset < buf.length) {
+    try {
+      offset += writeSync(fd, buf, offset, buf.length - offset);
+    } catch (err) {
+      const code = err.code;
+      if (code === "EAGAIN" || code === "EINTR") continue;
+      throw err;
+    }
+  }
+}
+
 // src/lib/btc-rate.ts
 async function resolveBtcUsdRate(purpose) {
   try {
@@ -596,18 +635,18 @@ function ensureX402ChannelFile() {
 function loadFile() {
   if (!existsSync(X402_CHANNELS_FILE)) return { ...EMPTY, channels: {}, pending: [], exact: [] };
   try {
-    const raw = JSON.parse(readFileSync(X402_CHANNELS_FILE, "utf8"));
-    if (raw.version !== 1 || !raw.channels || typeof raw.channels !== "object" || Array.isArray(raw.channels) || !Array.isArray(raw.pending)) {
+    const raw2 = JSON.parse(readFileSync(X402_CHANNELS_FILE, "utf8"));
+    if (raw2.version !== 1 || !raw2.channels || typeof raw2.channels !== "object" || Array.isArray(raw2.channels) || !Array.isArray(raw2.pending)) {
       throw new Error("unsupported x402 channel store shape");
     }
     return {
       version: 1,
-      channels: raw.channels,
-      pending: raw.pending,
+      channels: raw2.channels,
+      pending: raw2.pending,
       // Tolerated rather than required, unlike its two siblings: every file
       // written before lacks the key, and failing closed on it would
       // read as a corrupt journal on a store that is perfectly intact.
-      exact: Array.isArray(raw.exact) ? raw.exact : []
+      exact: Array.isArray(raw2.exact) ? raw2.exact : []
     };
   } catch (cause) {
     throw new DvmError(
@@ -982,6 +1021,12 @@ async function priceableRate(btcRate) {
 export {
   resolveX402Asset,
   x402WrongAssetHint,
+  setOutputTraceId,
+  getOutputTraceId,
+  json,
+  info,
+  raw,
+  progress,
   resolveBtcUsdRate,
   tryResolveBtcUsdRate,
   staleRateNotice,

package/dist/chunk-LIRAHP7B.js

@@ -0,0 +1,53 @@
+// src/lib/errors.ts
+var DvmError = class extends Error {
+  constructor(code, message, hint, data, display, proseSources) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.data = data;
+    this.display = display;
+    this.proseSources = proseSources;
+    this.name = "DvmError";
+  }
+  code;
+  hint;
+  data;
+  display;
+  proseSources;
+};
+function providerProseSources(...sources) {
+  const provenance = {};
+  for (const source of sources) {
+    if (!source) continue;
+    for (const field of ["message", "hint", "display"]) {
+      if (typeof source[field] === "string") provenance[field] = "provider";
+    }
+  }
+  return Object.keys(provenance).length > 0 ? provenance : void 0;
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+function transportErrorCode(err) {
+  let current = err;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 5 && isErrorLike(current) && !seen.has(current); depth++) {
+    seen.add(current);
+    const code = current.code;
+    if (typeof code === "string" && /^(?:E[A-Z0-9_]{1,63}|UND_ERR_[A-Z0-9_]{1,63})$/.test(code)) {
+      return code;
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
+function isErrorLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+
+export {
+  DvmError,
+  providerProseSources,
+  isAbortError,
+  transportErrorCode
+};

package/dist/{chunk-MG67KXU7.js → chunk-MZRJR2CW.js}

@@ -3,9 +3,11 @@ import {
   CONFIG_BACKUP_FILE,
   CONFIG_FILE,
   CONFIG_PINNED_FILE,
-  DvmError,
   ensureConfigDir
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
 
 // src/lib/evm-private-key.ts
 import { secp256k1 } from "@noble/curves/secp256k1.js";

package/dist/chunk-OFVV37XC.js

@@ -0,0 +1,57 @@
+// src/lib/cast-auth/canonical-json.ts
+function canonicalize(value) {
+  return JSON.stringify(sortDeep(value));
+}
+function canonicaliseForSigning(value) {
+  return new TextEncoder().encode(canonicalize(value));
+}
+function sortDeep(value) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new TypeError(`canonicalize: non-finite number is not JSON-serialisable`);
+    }
+    return value;
+  }
+  if (Array.isArray(value)) return value.map(sortDeep);
+  if (typeof value === "object") {
+    const sorted = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v === void 0) continue;
+      sorted[key] = sortDeep(v);
+    }
+    return sorted;
+  }
+  throw new TypeError(`canonicalize: unsupported value of type ${typeof value}`);
+}
+
+// src/lib/cast-auth/verify.ts
+import { schnorr } from "@noble/curves/secp256k1.js";
+function verifyCanonicalSignedRequest(payload, signatureHex, pubkeyHex) {
+  if (!/^[0-9a-f]{64}$/i.test(pubkeyHex) || !/^[0-9a-f]{128}$/i.test(signatureHex)) {
+    return false;
+  }
+  const data = canonicaliseForSigning(payload);
+  const signature = hexToBytes(signatureHex);
+  const pubkey = hexToBytes(pubkeyHex);
+  try {
+    return schnorr.verify(signature, data, pubkey);
+  } catch {
+    return false;
+  }
+}
+function hexToBytes(hex) {
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+
+export {
+  canonicalize,
+  canonicaliseForSigning,
+  verifyCanonicalSignedRequest
+};

package/dist/{chunk-A4CM2BD3.js → chunk-PAIM66YA.js}

@@ -1,7 +1,10 @@
 import {
   BTC_RATE_FILE,
   ensureConfigSubdir
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
+import {
+  canonicaliseForSigning
+} from "./chunk-OFVV37XC.js";
 import {
   formatFiat
 } from "./chunk-AT6V3SY7.js";
@@ -232,6 +235,82 @@ async function fetchFromApi() {
   return rate;
 }
 
+// src/lib/receipt.ts
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+function computeResultHash(summary, artifactContents) {
+  const artifactHashes = artifactContents.map(
+    (content) => bytesToHex(sha256(canonicaliseForSigning(content)))
+  );
+  return bytesToHex(
+    sha256(
+      canonicaliseForSigning({
+        summary: summary ?? null,
+        artifact_hashes: artifactHashes
+      })
+    )
+  );
+}
+function signReceipt(unsigned, secretHex) {
+  const bytes = canonicaliseForSigning(unsigned);
+  const signature = bytesToHex(schnorr.sign(bytes, hexToBytes(secretHex)));
+  return { ...unsigned, signature };
+}
+function verifyReceipt(receipt) {
+  try {
+    const { signature, ...unsigned } = receipt;
+    const bytes = canonicaliseForSigning(unsigned);
+    return schnorr.verify(hexToBytes(signature), bytes, hexToBytes(receipt.receipt_pubkey));
+  } catch {
+    return false;
+  }
+}
+function isSignedJobReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const r = value;
+  const paid = r.paid;
+  return r.v === 1 && typeof r.job_id === "string" && typeof r.dvm_id === "string" && typeof r.dvm === "string" && typeof r.capability === "string" && (r.outcome === "completed" || r.outcome === "failed" || r.outcome === "cancelled") && typeof r.seq === "number" && typeof r.issued_at === "number" && typeof r.receipt_pubkey === "string" && typeof r.signature === "string" && !!paid && typeof paid === "object" && !Array.isArray(paid) && typeof paid.msats === "number";
+}
+function signDrainReceipt(unsigned, secretHex) {
+  const bytes = canonicaliseForSigning(unsigned);
+  const signature = bytesToHex(schnorr.sign(bytes, hexToBytes(secretHex)));
+  return { ...unsigned, signature };
+}
+function signFundingReceipt(unsigned, secretHex) {
+  const bytes = canonicaliseForSigning(unsigned);
+  const signature = bytesToHex(schnorr.sign(bytes, hexToBytes(secretHex)));
+  return { ...unsigned, signature };
+}
+function isFundingReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const r = value;
+  return r.v === 1 && r.kind === "credit_funding" && typeof r.credit_id === "string" && typeof r.fund_id === "string" && typeof r.funded_micro === "number" && typeof r.balance_after_micro === "number" && typeof r.ledger_seq === "number" && typeof r.issued_at === "number" && typeof r.caller_pubkey === "string" && typeof r.dvm_id === "string" && typeof r.dvm === "string" && typeof r.receipt_pubkey === "string" && typeof r.signature === "string";
+}
+function verifyFundingReceipt(receipt) {
+  try {
+    const { signature, ...unsigned } = receipt;
+    const bytes = canonicaliseForSigning(unsigned);
+    return schnorr.verify(hexToBytes(signature), bytes, hexToBytes(receipt.receipt_pubkey));
+  } catch {
+    return false;
+  }
+}
+function isDrainReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const r = value;
+  return r.v === 1 && r.kind === "credit_drain" && typeof r.credit_id === "string" && typeof r.drain_id === "string" && (r.event === "requested" || r.event === "parked" || r.event === "picked_up" || r.event === "sent" || r.event === "released") && typeof r.method === "string" && typeof r.amount_micro === "number" && typeof r.issued_at === "number" && typeof r.caller_pubkey === "string" && typeof r.dvm_id === "string" && typeof r.dvm === "string" && typeof r.receipt_pubkey === "string" && typeof r.signature === "string";
+}
+function verifyDrainReceipt(receipt) {
+  try {
+    const { signature, ...unsigned } = receipt;
+    const bytes = canonicaliseForSigning(unsigned);
+    return schnorr.verify(hexToBytes(signature), bytes, hexToBytes(receipt.receipt_pubkey));
+  } catch {
+    return false;
+  }
+}
+
 export {
   IMPLICIT_CREDIT_TTL_MS,
   COINGECKO_SIMPLE_PRICE_URL,
@@ -254,5 +333,15 @@ export {
   fetchBtcUsdRate,
   getLastKnownBtcRate,
   formatStaleness,
-  formatAmountBestEffort
+  formatAmountBestEffort,
+  computeResultHash,
+  signReceipt,
+  verifyReceipt,
+  isSignedJobReceipt,
+  signDrainReceipt,
+  signFundingReceipt,
+  isFundingReceipt,
+  verifyFundingReceipt,
+  isDrainReceipt,
+  verifyDrainReceipt
 };