uvd-x402-sdk 2.56.0 → 2.58.0

package/dist/index.d.mts

@@ -193,6 +193,107 @@ declare function payerKeyFromEvmSignature(signature: Uint8Array | string, digest
  * Returns the bytes to upload. Nothing here touches the network.
  */
 declare function sealEvidence(body: Uint8Array, payerKey: Uint8Array, paymentIdValue: string): Uint8Array;
+/** The zero address, for the ed25519 form of the digest. */
+declare const ZERO_ADDRESS: string;
+/**
+ * The 32-byte digest a seller signs to prove an anchor is theirs.
+ *
+ * One canonical message across every curve. `payee` is the EVM address for a
+ * secp256k1 payee and the **zero address** for an ed25519 one — an ed25519
+ * address does not fit the `address` field, and the binding is already
+ * established by which key verifies the signature.
+ *
+ * `pointer` is whatever you send in the anchor, or the **empty string** when you
+ * send `sealed` and the facilitator issues the pointer itself: you cannot sign a
+ * value you have not seen.
+ *
+ * Getting this wrong throws nothing — it produces a signature that simply never
+ * verifies, and the anchor stays provisional with no clue why. The tests pin it
+ * against digests emitted by the facilitator's own Rust implementation.
+ */
+declare function anchorDigest(paymentId: string, contentHash: string, pointer: string, payee: string, chainId: number): Uint8Array;
+/**
+ * Sign an anchor authorization with a Solana / Stellar ed25519 key.
+ *
+ * A Solana payee cannot produce an EIP-712 signature at all — its address is an
+ * ed25519 key — so requiring one would leave that chain unable to prove
+ * authorship even once the on-chain gate is enforced. This closes it today, with
+ * no RPC.
+ */
+declare function signAnchorEd25519(privateKey: Uint8Array, paymentId: string, contentHash: string, pointer?: string): string;
+/**
+ * Sign an anchor authorization with an EVM secp256k1 key.
+ *
+ * `payee` must be the address of `privateKey` — the facilitator recovers the
+ * signer and compares, so declaring somebody else's address simply leaves the
+ * anchor provisional.
+ */
+declare function signAnchorEvm(privateKey: Uint8Array, paymentId: string, contentHash: string, pointer: string, payee: string, chainId: number): string;
+/**
+ * Derive the encryption target from a Solana (or Fogo) address.
+ *
+ * On ed25519 chains the address **is** the public key, so this needs no
+ * signature and no lookup. Rejects anything that does not decode to exactly 32
+ * bytes: a short decode silently padded up to 32 produces a small-order point,
+ * which fails a layer later with a message that points nowhere near the cause.
+ */
+declare function payerKeyFromSolanaAddress(address: string): Uint8Array;
+/**
+ * Seal `body` so every listed recipient can read it, and nobody else.
+ *
+ * The body is encrypted **once**; only the content key is wrapped per recipient,
+ * so adding the seller costs about sixty bytes rather than a second copy of the
+ * payload. That is what makes it practical for a seller to keep a readable copy
+ * of what it delivered — and answer a false "that is not what you sent" —
+ * instead of paying to anchor evidence it cannot open.
+ *
+ * A single payer recipient is emitted as format **v1, byte-for-byte**, so
+ * nothing already anchored becomes unreadable and readers still on v1 keep
+ * working.
+ */
+declare function sealEvidenceTo(body: Uint8Array, recipients: Array<{
+    role: RecipientRole;
+    key: Uint8Array;
+}>, paymentIdValue: string): Uint8Array;
+interface AnchorOptions {
+    paymentId: string;
+    network: string;
+    txHash: string;
+    payer: string;
+    payee: string;
+    /** The buyer's encryption key, from `payerKeyFromSolanaAddress` or similar. */
+    payerKey: Uint8Array;
+    /**
+     * Your **public** key, to keep a readable copy so you can answer a false
+     * "that is not what you sent".
+     *
+     * It does not have to be your payment key, and should not be — a custodial
+     * payment wallet works fine here, because this key only ever decrypts.
+     */
+    sellerEncryptionKey?: Uint8Array;
+    /**
+     * `(digest) => "0x..."`. A callable rather than a private key is what lets a
+     * custodian sign: it receives the digest and returns the signature without the
+     * seed ever leaving it.
+     *
+     * Without one the anchor is **provisional** — it holds the slot, but a signed
+     * anchor for the same payment supersedes it.
+     */
+    sign?: (digest: Uint8Array) => string | Promise<string>;
+    retention?: string;
+    facilitator?: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Seal a response body, anchor it, and return the `X-Durable-Evidence` value.
+ *
+ * **It never throws.** Every failure resolves to a skip notice, because evidence
+ * is an addition to the payment path and must never be a gate in front of it —
+ * an unreachable facilitator has to cost the receipt, never the sale.
+ */
+declare function anchorEvidence(body: Uint8Array, opts: AnchorOptions): Promise<Record<string, unknown>>;
+/** Encode an anchor result for the `X-Durable-Evidence` response header. */
+declare function evidenceHeader(evidence: unknown): string;
 
 /**
  * Facilitator wallet addresses by chain type
@@ -841,4 +942,4 @@ interface EscrowPreAuthParams {
  */
 declare function buildEscrowPreAuth(wallet: EscrowPreAuthSigner, params: EscrowPreAuthParams): Promise<string>;
 
-export { type AnchoredEvidence, ContentHashMismatch, type CreateSignedFetchConfig, DX402Error, type ERC8128RequestOptions, ESCROW_DEPOSIT_LIMIT_USD, ESCROW_TIER_WINDOWS, EVENT_KINDS, EVIDENCE_HEADER, type EscrowNetworkConfig, type EscrowPaymentInfo, type EscrowPreAuthParams, type EscrowPreAuthSigner, type EscrowTierWindows, type EvidenceMode, EvidenceSkipped, FACILITATOR_ADDRESSES, type FacilitatorAddresses, KEEPALIVE_INTERVAL_MS, OPERATOR_FEE_BPS, type RecipientRole, type SSEFrame, SSEParser, type SignRequestOptions, type SignRequestWithSignerOptions, type SignatureBaseParams, type SignatureHeaders, type SignatureParamsInput, SigningWalletAdapter, type StreamTrafficEventsOptions, type TrafficEvent, type TrafficEventKind, TrafficStreamError, buildEscrowPreAuth, buildSignatureBase, buildSignatureParams, computeEscrowNonce, contentHash, createSignedFetch, dereferencePointer, paymentId as dx402PaymentId, ed25519ToX25519, evidenceFromHeaders, fetchNonce, getFacilitatorAddress, isEndToEnd, matchesFilters, parseEvidenceHeader, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, recoverEvidence, sealEvidence, sealedRoles, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };
+export { type AnchorOptions, type AnchoredEvidence, ContentHashMismatch, type CreateSignedFetchConfig, DX402Error, type ERC8128RequestOptions, ESCROW_DEPOSIT_LIMIT_USD, ESCROW_TIER_WINDOWS, EVENT_KINDS, EVIDENCE_HEADER, type EscrowNetworkConfig, type EscrowPaymentInfo, type EscrowPreAuthParams, type EscrowPreAuthSigner, type EscrowTierWindows, type EvidenceMode, EvidenceSkipped, FACILITATOR_ADDRESSES, type FacilitatorAddresses, KEEPALIVE_INTERVAL_MS, OPERATOR_FEE_BPS, type RecipientRole, type SSEFrame, SSEParser, type SignRequestOptions, type SignRequestWithSignerOptions, type SignatureBaseParams, type SignatureHeaders, type SignatureParamsInput, SigningWalletAdapter, type StreamTrafficEventsOptions, type TrafficEvent, type TrafficEventKind, TrafficStreamError, ZERO_ADDRESS, anchorDigest, anchorEvidence, buildEscrowPreAuth, buildSignatureBase, buildSignatureParams, computeEscrowNonce, contentHash, createSignedFetch, dereferencePointer, paymentId as dx402PaymentId, ed25519ToX25519, evidenceFromHeaders, evidenceHeader, fetchNonce, getFacilitatorAddress, isEndToEnd, matchesFilters, parseEvidenceHeader, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, payerKeyFromSolanaAddress, recoverEvidence, sealEvidence, sealEvidenceTo, sealedRoles, signAnchorEd25519, signAnchorEvm, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };

package/dist/index.d.ts

@@ -193,6 +193,107 @@ declare function payerKeyFromEvmSignature(signature: Uint8Array | string, digest
  * Returns the bytes to upload. Nothing here touches the network.
  */
 declare function sealEvidence(body: Uint8Array, payerKey: Uint8Array, paymentIdValue: string): Uint8Array;
+/** The zero address, for the ed25519 form of the digest. */
+declare const ZERO_ADDRESS: string;
+/**
+ * The 32-byte digest a seller signs to prove an anchor is theirs.
+ *
+ * One canonical message across every curve. `payee` is the EVM address for a
+ * secp256k1 payee and the **zero address** for an ed25519 one — an ed25519
+ * address does not fit the `address` field, and the binding is already
+ * established by which key verifies the signature.
+ *
+ * `pointer` is whatever you send in the anchor, or the **empty string** when you
+ * send `sealed` and the facilitator issues the pointer itself: you cannot sign a
+ * value you have not seen.
+ *
+ * Getting this wrong throws nothing — it produces a signature that simply never
+ * verifies, and the anchor stays provisional with no clue why. The tests pin it
+ * against digests emitted by the facilitator's own Rust implementation.
+ */
+declare function anchorDigest(paymentId: string, contentHash: string, pointer: string, payee: string, chainId: number): Uint8Array;
+/**
+ * Sign an anchor authorization with a Solana / Stellar ed25519 key.
+ *
+ * A Solana payee cannot produce an EIP-712 signature at all — its address is an
+ * ed25519 key — so requiring one would leave that chain unable to prove
+ * authorship even once the on-chain gate is enforced. This closes it today, with
+ * no RPC.
+ */
+declare function signAnchorEd25519(privateKey: Uint8Array, paymentId: string, contentHash: string, pointer?: string): string;
+/**
+ * Sign an anchor authorization with an EVM secp256k1 key.
+ *
+ * `payee` must be the address of `privateKey` — the facilitator recovers the
+ * signer and compares, so declaring somebody else's address simply leaves the
+ * anchor provisional.
+ */
+declare function signAnchorEvm(privateKey: Uint8Array, paymentId: string, contentHash: string, pointer: string, payee: string, chainId: number): string;
+/**
+ * Derive the encryption target from a Solana (or Fogo) address.
+ *
+ * On ed25519 chains the address **is** the public key, so this needs no
+ * signature and no lookup. Rejects anything that does not decode to exactly 32
+ * bytes: a short decode silently padded up to 32 produces a small-order point,
+ * which fails a layer later with a message that points nowhere near the cause.
+ */
+declare function payerKeyFromSolanaAddress(address: string): Uint8Array;
+/**
+ * Seal `body` so every listed recipient can read it, and nobody else.
+ *
+ * The body is encrypted **once**; only the content key is wrapped per recipient,
+ * so adding the seller costs about sixty bytes rather than a second copy of the
+ * payload. That is what makes it practical for a seller to keep a readable copy
+ * of what it delivered — and answer a false "that is not what you sent" —
+ * instead of paying to anchor evidence it cannot open.
+ *
+ * A single payer recipient is emitted as format **v1, byte-for-byte**, so
+ * nothing already anchored becomes unreadable and readers still on v1 keep
+ * working.
+ */
+declare function sealEvidenceTo(body: Uint8Array, recipients: Array<{
+    role: RecipientRole;
+    key: Uint8Array;
+}>, paymentIdValue: string): Uint8Array;
+interface AnchorOptions {
+    paymentId: string;
+    network: string;
+    txHash: string;
+    payer: string;
+    payee: string;
+    /** The buyer's encryption key, from `payerKeyFromSolanaAddress` or similar. */
+    payerKey: Uint8Array;
+    /**
+     * Your **public** key, to keep a readable copy so you can answer a false
+     * "that is not what you sent".
+     *
+     * It does not have to be your payment key, and should not be — a custodial
+     * payment wallet works fine here, because this key only ever decrypts.
+     */
+    sellerEncryptionKey?: Uint8Array;
+    /**
+     * `(digest) => "0x..."`. A callable rather than a private key is what lets a
+     * custodian sign: it receives the digest and returns the signature without the
+     * seed ever leaving it.
+     *
+     * Without one the anchor is **provisional** — it holds the slot, but a signed
+     * anchor for the same payment supersedes it.
+     */
+    sign?: (digest: Uint8Array) => string | Promise<string>;
+    retention?: string;
+    facilitator?: string;
+    fetch?: typeof fetch;
+}
+/**
+ * Seal a response body, anchor it, and return the `X-Durable-Evidence` value.
+ *
+ * **It never throws.** Every failure resolves to a skip notice, because evidence
+ * is an addition to the payment path and must never be a gate in front of it —
+ * an unreachable facilitator has to cost the receipt, never the sale.
+ */
+declare function anchorEvidence(body: Uint8Array, opts: AnchorOptions): Promise<Record<string, unknown>>;
+/** Encode an anchor result for the `X-Durable-Evidence` response header. */
+declare function evidenceHeader(evidence: unknown): string;
 
 /**
  * Facilitator wallet addresses by chain type
@@ -841,4 +942,4 @@ interface EscrowPreAuthParams {
  */
 declare function buildEscrowPreAuth(wallet: EscrowPreAuthSigner, params: EscrowPreAuthParams): Promise<string>;
 
-export { type AnchoredEvidence, ContentHashMismatch, type CreateSignedFetchConfig, DX402Error, type ERC8128RequestOptions, ESCROW_DEPOSIT_LIMIT_USD, ESCROW_TIER_WINDOWS, EVENT_KINDS, EVIDENCE_HEADER, type EscrowNetworkConfig, type EscrowPaymentInfo, type EscrowPreAuthParams, type EscrowPreAuthSigner, type EscrowTierWindows, type EvidenceMode, EvidenceSkipped, FACILITATOR_ADDRESSES, type FacilitatorAddresses, KEEPALIVE_INTERVAL_MS, OPERATOR_FEE_BPS, type RecipientRole, type SSEFrame, SSEParser, type SignRequestOptions, type SignRequestWithSignerOptions, type SignatureBaseParams, type SignatureHeaders, type SignatureParamsInput, SigningWalletAdapter, type StreamTrafficEventsOptions, type TrafficEvent, type TrafficEventKind, TrafficStreamError, buildEscrowPreAuth, buildSignatureBase, buildSignatureParams, computeEscrowNonce, contentHash, createSignedFetch, dereferencePointer, paymentId as dx402PaymentId, ed25519ToX25519, evidenceFromHeaders, fetchNonce, getFacilitatorAddress, isEndToEnd, matchesFilters, parseEvidenceHeader, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, recoverEvidence, sealEvidence, sealedRoles, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };
+export { type AnchorOptions, type AnchoredEvidence, ContentHashMismatch, type CreateSignedFetchConfig, DX402Error, type ERC8128RequestOptions, ESCROW_DEPOSIT_LIMIT_USD, ESCROW_TIER_WINDOWS, EVENT_KINDS, EVIDENCE_HEADER, type EscrowNetworkConfig, type EscrowPaymentInfo, type EscrowPreAuthParams, type EscrowPreAuthSigner, type EscrowTierWindows, type EvidenceMode, EvidenceSkipped, FACILITATOR_ADDRESSES, type FacilitatorAddresses, KEEPALIVE_INTERVAL_MS, OPERATOR_FEE_BPS, type RecipientRole, type SSEFrame, SSEParser, type SignRequestOptions, type SignRequestWithSignerOptions, type SignatureBaseParams, type SignatureHeaders, type SignatureParamsInput, SigningWalletAdapter, type StreamTrafficEventsOptions, type TrafficEvent, type TrafficEventKind, TrafficStreamError, ZERO_ADDRESS, anchorDigest, anchorEvidence, buildEscrowPreAuth, buildSignatureBase, buildSignatureParams, computeEscrowNonce, contentHash, createSignedFetch, dereferencePointer, paymentId as dx402PaymentId, ed25519ToX25519, evidenceFromHeaders, evidenceHeader, fetchNonce, getFacilitatorAddress, isEndToEnd, matchesFilters, parseEvidenceHeader, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, payerKeyFromSolanaAddress, recoverEvidence, sealEvidence, sealEvidenceTo, sealedRoles, signAnchorEd25519, signAnchorEvm, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };

package/dist/index.js

@@ -289,6 +289,194 @@ function sealEvidence(body, payerKey, paymentIdValue) {
   out.set(ciphertext, pos);
   return out;
 }
+var ANCHOR_DOMAIN_NAME = "DX402 Anchor";
+var ANCHOR_DOMAIN_VERSION = "1";
+var ANCHOR_TYPE = "Dx402AnchorAuthorization(bytes32 paymentId,bytes32 contentHash,string pointer,address payee)";
+var EIP712_DOMAIN_TYPE = "EIP712Domain(string name,string version,uint256 chainId)";
+var ZERO_ADDRESS = "0x" + "00".repeat(20);
+function concatBytes(...parts) {
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const p of parts) {
+    out.set(p, pos);
+    pos += p.length;
+  }
+  return out;
+}
+function uint256(n) {
+  const out = new Uint8Array(32);
+  let v = BigInt(n);
+  for (let i = 31; i >= 0 && v > 0n; i--) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+function anchorDigest(paymentId2, contentHash2, pointer, payee, chainId) {
+  const b32 = (value, field) => {
+    const raw = hexToBytes(value);
+    if (raw.length !== 32) throw new DX402Error(`${field} must be 32 bytes, got ${raw.length}`);
+    return raw;
+  };
+  const addr = hexToBytes(payee);
+  if (addr.length !== 20) {
+    throw new DX402Error(`payee must be a 20-byte address, got ${addr.length}`);
+  }
+  const enc = new TextEncoder();
+  const domainSeparator = sha3.keccak_256(
+    concatBytes(
+      sha3.keccak_256(enc.encode(EIP712_DOMAIN_TYPE)),
+      sha3.keccak_256(enc.encode(ANCHOR_DOMAIN_NAME)),
+      sha3.keccak_256(enc.encode(ANCHOR_DOMAIN_VERSION)),
+      uint256(chainId)
+    )
+  );
+  const structHash = sha3.keccak_256(
+    concatBytes(
+      sha3.keccak_256(enc.encode(ANCHOR_TYPE)),
+      b32(paymentId2, "paymentId"),
+      b32(contentHash2, "contentHash"),
+      sha3.keccak_256(enc.encode(pointer)),
+      new Uint8Array(12),
+      addr
+    )
+  );
+  return sha3.keccak_256(concatBytes(new Uint8Array([25, 1]), domainSeparator, structHash));
+}
+function signAnchorEd25519(privateKey, paymentId2, contentHash2, pointer = "") {
+  if (privateKey.length !== 32) {
+    throw new DX402Error(`ed25519 seed must be 32 bytes, got ${privateKey.length}`);
+  }
+  const digest = anchorDigest(paymentId2, contentHash2, pointer, ZERO_ADDRESS, 0);
+  return "0x" + bytesToHex(ed25519.ed25519.sign(digest, privateKey));
+}
+function signAnchorEvm(privateKey, paymentId2, contentHash2, pointer, payee, chainId) {
+  const digest = anchorDigest(paymentId2, contentHash2, pointer, payee, chainId);
+  const sig = secp256k1.secp256k1.sign(digest, privateKey);
+  return "0x" + bytesToHex(sig.toCompactRawBytes()) + (sig.recovery === 1 ? "01" : "00");
+}
+function payerKeyFromSolanaAddress(address) {
+  if (!address || !address.trim()) throw new DX402Error("empty Solana address");
+  const alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  let num = 0n;
+  for (const ch of address) {
+    const idx = alphabet.indexOf(ch);
+    if (idx < 0) throw new DX402Error(`invalid base58 character '${ch}' in address`);
+    num = num * 58n + BigInt(idx);
+  }
+  let hex = num.toString(16);
+  if (hex.length % 2) hex = "0" + hex;
+  const body = hexToBytes(hex);
+  const leading = address.length - address.replace(/^1+/, "").length;
+  const decoded = new Uint8Array(leading + body.length);
+  decoded.set(body, leading);
+  if (decoded.length !== 32) {
+    throw new DX402Error(`Solana address decodes to ${decoded.length} bytes, expected 32`);
+  }
+  return ed25519ToX25519(decoded);
+}
+function sealEvidenceTo(body, recipients, paymentIdValue) {
+  if (recipients.length === 0) {
+    throw new DX402Error("an envelope with no recipients could never be opened");
+  }
+  const aad = new TextEncoder().encode(paymentIdValue);
+  const cek = utils.randomBytes(CEK_LEN);
+  const bodyNonce = utils.randomBytes(NONCE_LEN);
+  const ciphertext = aes.gcm(cek, bodyNonce, aad).encrypt(body);
+  const wrapped = recipients.map(({ role, key }) => {
+    let algByte;
+    let ephemeral;
+    let shared;
+    if (key.length === 33) {
+      algByte = 1;
+      const priv = secp256k1.secp256k1.utils.randomPrivateKey();
+      ephemeral = secp256k1.secp256k1.getPublicKey(priv, true);
+      shared = secp256k1.secp256k1.getSharedSecret(priv, key, true).subarray(1);
+    } else if (key.length === 32) {
+      algByte = 2;
+      const priv = utils.randomBytes(32);
+      ephemeral = ed25519.x25519.getPublicKey(priv);
+      shared = ed25519.x25519.getSharedSecret(priv, key);
+      if (shared.every((b) => b === 0)) {
+        throw new DX402Error("degenerate ECDH result (small-order public key)");
+      }
+    } else {
+      throw new DX402Error(
+        `public key must be 33 bytes (secp256k1) or 32 (X25519), got ${key.length}`
+      );
+    }
+    const wrapKey = hkdf.hkdf(sha2.sha256, shared, aad, HKDF_INFO, 32);
+    const cekNonce = utils.randomBytes(NONCE_LEN);
+    return {
+      role,
+      algByte,
+      ephemeral,
+      cekNonce,
+      wrappedCek: aes.gcm(wrapKey, cekNonce, aad).encrypt(cek)
+    };
+  });
+  const singlePayer = wrapped.length === 1 && wrapped[0].role === "payer";
+  const parts = [MAGIC, new Uint8Array([singlePayer ? FORMAT_V1 : FORMAT_V2])];
+  if (!singlePayer) parts.push(new Uint8Array([wrapped.length]));
+  for (const r of wrapped) {
+    if (!singlePayer) parts.push(new Uint8Array([ROLE_NAMES.indexOf(r.role)]));
+    parts.push(new Uint8Array([r.algByte, r.ephemeral.length]));
+    parts.push(r.ephemeral, r.cekNonce);
+    parts.push(new Uint8Array([r.wrappedCek.length >> 8 & 255, r.wrappedCek.length & 255]));
+    parts.push(r.wrappedCek);
+  }
+  parts.push(bodyNonce, ciphertext);
+  return concatBytes(...parts);
+}
+async function anchorEvidence(body, opts) {
+  try {
+    const recipients = [
+      { role: "payer", key: opts.payerKey }
+    ];
+    if (opts.sellerEncryptionKey) {
+      recipients.push({ role: "seller", key: opts.sellerEncryptionKey });
+    }
+    const blob = sealEvidenceTo(body, recipients, opts.paymentId);
+    const hash = contentHash(body);
+    const payload = {
+      paymentId: opts.paymentId,
+      network: opts.network,
+      txHash: opts.txHash,
+      payer: opts.payer,
+      payee: opts.payee,
+      sealed: btoa(String.fromCharCode(...blob)),
+      backend: "s3",
+      contentHash: hash,
+      keyAlg: opts.payerKey.length === 32 ? "ECIES-X25519" : "ECIES-secp256k1",
+      mode: "direct",
+      retention: opts.retention ?? "90d"
+    };
+    if (opts.sign) {
+      payload.sellerSignature = await opts.sign(
+        anchorDigest(opts.paymentId, hash, "", ZERO_ADDRESS, 0)
+      );
+    }
+    const base = (opts.facilitator ?? "https://facilitator.ultravioletadao.xyz").replace(
+      /\/+$/,
+      ""
+    );
+    const doFetch = opts.fetch ?? fetch;
+    const res = await doFetch(`${base}/dx402/anchor`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) return { v: 1, skipped: "anchor_failed" };
+    return await res.json();
+  } catch {
+    return { v: 1, skipped: "anchor_failed" };
+  }
+}
+function evidenceHeader(evidence) {
+  const json = JSON.stringify(evidence);
+  return btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
 
 // src/types/index.ts
 var CAIP2_IDENTIFIERS = {
@@ -3118,7 +3306,7 @@ function buildSignatureParams(params) {
   parts.push(`alg="${ALG}"`);
   return parts.join(";");
 }
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var USDC_DECIMALS = 6;
 var ESCROW_DEPOSIT_LIMIT_USD = 100;
 var OPERATOR_FEE_BPS = 1300;
@@ -3167,7 +3355,7 @@ function computeEscrowNonce(chainId, escrowAddress, paymentInfoTypehash, pi) {
   const coder = ethers.ethers.AbiCoder.defaultAbiCoder();
   const piTuple = [
     ethers.ethers.getAddress(pi.operator),
-    ZERO_ADDRESS,
+    ZERO_ADDRESS2,
     // payer = 0 for the payer-agnostic hash
     ethers.ethers.getAddress(pi.receiver),
     ethers.ethers.getAddress(pi.token),
@@ -4092,6 +4280,9 @@ exports.X402Client = X402Client;
 exports.X402Error = X402Error;
 exports.X402_CORS_HEADERS = X402_CORS_HEADERS;
 exports.X402_HEADER_NAMES = X402_HEADER_NAMES;
+exports.ZERO_ADDRESS = ZERO_ADDRESS;
+exports.anchorDigest = anchorDigest;
+exports.anchorEvidence = anchorEvidence;
 exports.buildEscrowPreAuth = buildEscrowPreAuth;
 exports.buildPaymentRequirements = buildPaymentRequirements;
 exports.buildSettleRequest = buildSettleRequest;
@@ -4124,6 +4315,7 @@ exports.encodeBase64Json = encodeBase64Json;
 exports.encodeBase64Utf8 = encodeBase64Utf8;
 exports.encodeX402Header = encodeX402Header;
 exports.evidenceFromHeaders = evidenceFromHeaders;
+exports.evidenceHeader = evidenceHeader;
 exports.extractPaymentFromHeaders = extractPaymentFromHeaders;
 exports.fetchNonce = fetchNonce;
 exports.generatePaymentOptions = generatePaymentOptions;
@@ -4160,9 +4352,13 @@ exports.parseNetworkIdentifier = parseNetworkIdentifier;
 exports.parseSealed = parseSealed;
 exports.parseTrafficEvent = parseTrafficEvent;
 exports.payerKeyFromEvmSignature = payerKeyFromEvmSignature;
+exports.payerKeyFromSolanaAddress = payerKeyFromSolanaAddress;
 exports.recoverEvidence = recoverEvidence;
 exports.sealEvidence = sealEvidence;
+exports.sealEvidenceTo = sealEvidenceTo;
 exports.sealedRoles = sealedRoles;
+exports.signAnchorEd25519 = signAnchorEd25519;
+exports.signAnchorEvm = signAnchorEvm;
 exports.signRequest = signRequest;
 exports.signRequestWithSigner = signRequestWithSigner;
 exports.signRequestWithWallet = signRequestWithWallet;