uvd-x402-sdk 2.55.0 → 2.57.0

package/dist/index.d.mts

@@ -29,6 +29,8 @@ export { FacilitatorClient, FacilitatorClientOptions, HonoMiddlewareOptions, Pay
  * Specification: `docs/plans/dx402/02-SPEC-v0.1.md` in x402-rs.
  */
 declare const EVIDENCE_HEADER = "X-Durable-Evidence";
+/** Why a party holds a key to this evidence. */
+type RecipientRole = 'payer' | 'seller' | 'auditor';
 declare class DX402Error extends Error {
     constructor(message: string);
 }
@@ -103,14 +105,26 @@ declare function evidenceFromHeaders(headers: Headers | Record<string, string>):
  * a caller with their own resolver is not blocked by this function.
  */
 declare function dereferencePointer(pointer: string): string;
-interface SealedEnvelope {
+interface Recipient {
+    role: RecipientRole;
     alg: 'secp256k1' | 'x25519';
     ephemeral: Uint8Array;
     cekNonce: Uint8Array;
     wrappedCek: Uint8Array;
+}
+interface SealedEnvelope {
+    recipients: Recipient[];
     bodyNonce: Uint8Array;
     ciphertext: Uint8Array;
 }
+/**
+ * Who can open this blob, without decrypting anything.
+ *
+ * Worth surfacing: a buyer has to be able to see that the seller — or a
+ * designated auditor — also holds a key to what they bought. Finding that out
+ * afterwards would destroy the privacy property.
+ */
+declare function sealedRoles(raw: Uint8Array): RecipientRole[];
 /**
  * Parse the sealed-blob layout.
  *
@@ -121,7 +135,13 @@ interface SealedEnvelope {
  * rather than an out-of-range surprise later.
  */
 declare function parseSealed(raw: Uint8Array): SealedEnvelope;
-/** Decrypt a sealed envelope with the payer's private key. */
+/**
+ * Decrypt a sealed envelope with whichever recipient slot belongs to `privateKey`.
+ *
+ * Tries every slot: a holder does not necessarily know which one is theirs, and
+ * in a multi-recipient envelope the payer is not always first. A slot that does
+ * not open is skipped, not reported — "that one was not for me" is not an error.
+ */
 declare function unseal(sealed: SealedEnvelope, privateKey: Uint8Array, aad: Uint8Array): Uint8Array;
 /**
  * Fetch, decrypt and verify the body behind `evidence`.
@@ -173,6 +193,42 @@ 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;
 
 /**
  * Facilitator wallet addresses by chain type
@@ -821,4 +877,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 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, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };
+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, ZERO_ADDRESS, anchorDigest, buildEscrowPreAuth, buildSignatureBase, buildSignatureParams, computeEscrowNonce, contentHash, createSignedFetch, dereferencePointer, paymentId as dx402PaymentId, ed25519ToX25519, evidenceFromHeaders, fetchNonce, getFacilitatorAddress, isEndToEnd, matchesFilters, parseEvidenceHeader, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, recoverEvidence, sealEvidence, sealedRoles, signAnchorEd25519, signAnchorEvm, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };

package/dist/index.d.ts

@@ -29,6 +29,8 @@ export { FacilitatorClient, FacilitatorClientOptions, HonoMiddlewareOptions, Pay
  * Specification: `docs/plans/dx402/02-SPEC-v0.1.md` in x402-rs.
  */
 declare const EVIDENCE_HEADER = "X-Durable-Evidence";
+/** Why a party holds a key to this evidence. */
+type RecipientRole = 'payer' | 'seller' | 'auditor';
 declare class DX402Error extends Error {
     constructor(message: string);
 }
@@ -103,14 +105,26 @@ declare function evidenceFromHeaders(headers: Headers | Record<string, string>):
  * a caller with their own resolver is not blocked by this function.
  */
 declare function dereferencePointer(pointer: string): string;
-interface SealedEnvelope {
+interface Recipient {
+    role: RecipientRole;
     alg: 'secp256k1' | 'x25519';
     ephemeral: Uint8Array;
     cekNonce: Uint8Array;
     wrappedCek: Uint8Array;
+}
+interface SealedEnvelope {
+    recipients: Recipient[];
     bodyNonce: Uint8Array;
     ciphertext: Uint8Array;
 }
+/**
+ * Who can open this blob, without decrypting anything.
+ *
+ * Worth surfacing: a buyer has to be able to see that the seller — or a
+ * designated auditor — also holds a key to what they bought. Finding that out
+ * afterwards would destroy the privacy property.
+ */
+declare function sealedRoles(raw: Uint8Array): RecipientRole[];
 /**
  * Parse the sealed-blob layout.
  *
@@ -121,7 +135,13 @@ interface SealedEnvelope {
  * rather than an out-of-range surprise later.
  */
 declare function parseSealed(raw: Uint8Array): SealedEnvelope;
-/** Decrypt a sealed envelope with the payer's private key. */
+/**
+ * Decrypt a sealed envelope with whichever recipient slot belongs to `privateKey`.
+ *
+ * Tries every slot: a holder does not necessarily know which one is theirs, and
+ * in a multi-recipient envelope the payer is not always first. A slot that does
+ * not open is skipped, not reported — "that one was not for me" is not an error.
+ */
 declare function unseal(sealed: SealedEnvelope, privateKey: Uint8Array, aad: Uint8Array): Uint8Array;
 /**
  * Fetch, decrypt and verify the body behind `evidence`.
@@ -173,6 +193,42 @@ 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;
 
 /**
  * Facilitator wallet addresses by chain type
@@ -821,4 +877,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 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, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };
+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, ZERO_ADDRESS, anchorDigest, buildEscrowPreAuth, buildSignatureBase, buildSignatureParams, computeEscrowNonce, contentHash, createSignedFetch, dereferencePointer, paymentId as dx402PaymentId, ed25519ToX25519, evidenceFromHeaders, fetchNonce, getFacilitatorAddress, isEndToEnd, matchesFilters, parseEvidenceHeader, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, recoverEvidence, sealEvidence, sealedRoles, signAnchorEd25519, signAnchorEvm, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal };

package/dist/index.js

@@ -12,7 +12,9 @@ var ethers = require('ethers');
 // src/dx402.ts
 var EVIDENCE_HEADER = "X-Durable-Evidence";
 var MAGIC = new Uint8Array([68, 88, 52, 48, 50]);
-var FORMAT_VERSION = 1;
+var FORMAT_V1 = 1;
+var FORMAT_V2 = 2;
+var ROLE_NAMES = ["payer", "seller", "auditor"];
 var NONCE_LEN = 12;
 var CEK_LEN = 32;
 var HKDF_INFO = new TextEncoder().encode("DX402-v1-wrap");
@@ -103,6 +105,9 @@ function dereferencePointer(pointer) {
   if (pointer.startsWith("ar://")) return `https://arweave.net/${pointer.slice(5)}`;
   return pointer;
 }
+function sealedRoles(raw) {
+  return parseSealed(raw).recipients.map((r) => r.role);
+}
 function parseSealed(raw) {
   let pos = 0;
   const take = (n, what) => {
@@ -116,29 +121,38 @@ function parseSealed(raw) {
     if (magic[i] !== MAGIC[i]) throw new DX402Error("not a DX402 sealed blob");
   }
   const version = take(1, "version")[0];
-  if (version !== FORMAT_VERSION) {
-    throw new DX402Error(`unsupported sealed-blob version ${version}`);
-  }
-  const algByte = take(1, "algorithm")[0];
-  if (algByte !== 1 && algByte !== 2) {
-    throw new DX402Error(`unknown key algorithm ${algByte}`);
-  }
-  const ephLen = take(1, "ephemeral key length")[0];
-  const ephemeral = take(ephLen, "ephemeral key");
-  const cekNonce = take(NONCE_LEN, "cek nonce");
-  const lenBytes = take(2, "wrapped key length");
-  const wrappedLen = lenBytes[0] << 8 | lenBytes[1];
-  const wrappedCek = take(wrappedLen, "wrapped cek");
+  let count;
+  if (version === FORMAT_V1) count = 1;
+  else if (version === FORMAT_V2) count = take(1, "recipient count")[0];
+  else throw new DX402Error(`unsupported sealed-blob version ${version}`);
+  if (count === 0) throw new DX402Error("DX402 sealed blob has no recipients");
+  const recipients = [];
+  for (let i = 0; i < count; i++) {
+    let role = "payer";
+    if (version === FORMAT_V2) {
+      const b = take(1, "role")[0];
+      if (b >= ROLE_NAMES.length) throw new DX402Error(`unknown role ${b}`);
+      role = ROLE_NAMES[b];
+    }
+    const algByte = take(1, "algorithm")[0];
+    if (algByte !== 1 && algByte !== 2) {
+      throw new DX402Error(`unknown key algorithm ${algByte}`);
+    }
+    const ephLen = take(1, "ephemeral key length")[0];
+    const ephemeral = take(ephLen, "ephemeral key");
+    const cekNonce = take(NONCE_LEN, "cek nonce");
+    const lenBytes = take(2, "wrapped key length");
+    const wrappedCek = take(lenBytes[0] << 8 | lenBytes[1], "wrapped cek");
+    recipients.push({
+      role,
+      alg: algByte === 1 ? "secp256k1" : "x25519",
+      ephemeral,
+      cekNonce,
+      wrappedCek
+    });
+  }
   const bodyNonce = take(NONCE_LEN, "body nonce");
-  const ciphertext = raw.subarray(pos);
-  return {
-    alg: algByte === 1 ? "secp256k1" : "x25519",
-    ephemeral,
-    cekNonce,
-    wrappedCek,
-    bodyNonce,
-    ciphertext
-  };
+  return { recipients, bodyNonce, ciphertext: raw.subarray(pos) };
 }
 function sharedSecret(sealed, privateKey) {
   if (sealed.alg === "secp256k1") {
@@ -153,13 +167,29 @@ function sharedSecret(sealed, privateKey) {
   return shared;
 }
 function unseal(sealed, privateKey, aad) {
-  const shared = sharedSecret(sealed, privateKey);
-  const wrapKey = hkdf.hkdf(sha2.sha256, shared, aad, HKDF_INFO, 32);
-  const cek = aes.gcm(wrapKey, sealed.cekNonce, aad).decrypt(sealed.wrappedCek);
-  if (cek.length !== CEK_LEN) {
-    throw new DX402Error(`unwrapped CEK is ${cek.length} bytes, expected ${CEK_LEN}`);
+  for (const recipient of sealed.recipients) {
+    let shared;
+    try {
+      shared = sharedSecret(recipient, privateKey);
+    } catch (err) {
+      if (err instanceof DX402Error) throw err;
+      continue;
+    }
+    const wrapKey = hkdf.hkdf(sha2.sha256, shared, aad, HKDF_INFO, 32);
+    let cek;
+    try {
+      cek = aes.gcm(wrapKey, recipient.cekNonce, aad).decrypt(recipient.wrappedCek);
+    } catch {
+      continue;
+    }
+    if (cek.length !== CEK_LEN) {
+      throw new DX402Error(`unwrapped CEK is ${cek.length} bytes, expected ${CEK_LEN}`);
+    }
+    return aes.gcm(cek, sealed.bodyNonce, aad).decrypt(sealed.ciphertext);
   }
-  return aes.gcm(cek, sealed.bodyNonce, aad).decrypt(sealed.ciphertext);
+  throw new DX402Error(
+    "no recipient slot opened -- wrong key, or the blob belongs to another payment"
+  );
 }
 async function recoverEvidence(evidence, privateKey, options = {}) {
   const key = typeof privateKey === "string" ? hexToBytes(privateKey) : privateKey;
@@ -243,7 +273,7 @@ function sealEvidence(body, payerKey, paymentIdValue) {
   let pos = 0;
   out.set(MAGIC, pos);
   pos += MAGIC.length;
-  out[pos++] = FORMAT_VERSION;
+  out[pos++] = FORMAT_V1;
   out[pos++] = algByte;
   out[pos++] = ephemeral.length;
   out.set(ephemeral, pos);
@@ -259,6 +289,73 @@ 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");
+}
 
 // src/types/index.ts
 var CAIP2_IDENTIFIERS = {
@@ -3088,7 +3185,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;
@@ -3137,7 +3234,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),
@@ -4062,6 +4159,8 @@ 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.buildEscrowPreAuth = buildEscrowPreAuth;
 exports.buildPaymentRequirements = buildPaymentRequirements;
 exports.buildSettleRequest = buildSettleRequest;
@@ -4132,6 +4231,9 @@ exports.parseTrafficEvent = parseTrafficEvent;
 exports.payerKeyFromEvmSignature = payerKeyFromEvmSignature;
 exports.recoverEvidence = recoverEvidence;
 exports.sealEvidence = sealEvidence;
+exports.sealedRoles = sealedRoles;
+exports.signAnchorEd25519 = signAnchorEd25519;
+exports.signAnchorEvm = signAnchorEvm;
 exports.signRequest = signRequest;
 exports.signRequestWithSigner = signRequestWithSigner;
 exports.signRequestWithWallet = signRequestWithWallet;