uvd-x402-sdk 2.53.0 → 2.55.0

package/dist/index.js

@@ -1,8 +1,264 @@
 'use strict';
 
+var aes = require('@noble/ciphers/aes');
+var ed25519 = require('@noble/curves/ed25519');
+var secp256k1 = require('@noble/curves/secp256k1');
+var hkdf = require('@noble/hashes/hkdf');
+var sha3 = require('@noble/hashes/sha3');
+var sha2 = require('@noble/hashes/sha2');
+var utils = require('@noble/hashes/utils');
 var ethers = require('ethers');
 
-// src/client/X402Client.ts
+// src/dx402.ts
+var EVIDENCE_HEADER = "X-Durable-Evidence";
+var MAGIC = new Uint8Array([68, 88, 52, 48, 50]);
+var FORMAT_VERSION = 1;
+var NONCE_LEN = 12;
+var CEK_LEN = 32;
+var HKDF_INFO = new TextEncoder().encode("DX402-v1-wrap");
+var DX402Error = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DX402Error";
+  }
+};
+var EvidenceSkipped = class extends DX402Error {
+  constructor(reason) {
+    super(`no durable evidence was anchored: ${reason}`);
+    this.reason = reason;
+    this.name = "EvidenceSkipped";
+  }
+};
+var ContentHashMismatch = class extends DX402Error {
+  constructor(anchored, actual) {
+    super(`content hash mismatch: anchored ${anchored}, decrypted ${actual}`);
+    this.anchored = anchored;
+    this.actual = actual;
+    this.name = "ContentHashMismatch";
+  }
+};
+function isEndToEnd(evidence) {
+  return evidence.mode === "direct";
+}
+function b64urlDecode(value) {
+  const normalized = value.trim().replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+  return Uint8Array.from(atob(padded), (c) => c.charCodeAt(0));
+}
+function hexToBytes(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean.length % 2 !== 0) throw new DX402Error("odd-length hex string");
+  const out = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function contentHash(body) {
+  return "0x" + bytesToHex(sha3.keccak_256(body));
+}
+function paymentId(caip2Network, txHash) {
+  const enc = new TextEncoder();
+  const clean = txHash.startsWith("0x") ? txHash.slice(2) : txHash;
+  const preimage = new Uint8Array([...enc.encode(caip2Network), ...enc.encode(clean)]);
+  return "0x" + bytesToHex(sha3.keccak_256(preimage));
+}
+function parseEvidenceHeader(value) {
+  let payload;
+  try {
+    payload = JSON.parse(new TextDecoder().decode(b64urlDecode(value)));
+  } catch (err) {
+    throw new DX402Error(`malformed ${EVIDENCE_HEADER} header: ${String(err)}`);
+  }
+  if ("skipped" in payload) {
+    throw new EvidenceSkipped(String(payload.skipped));
+  }
+  if (!payload.paymentId || !payload.pointer || !payload.contentHash) {
+    throw new DX402Error(`malformed ${EVIDENCE_HEADER} header: missing required fields`);
+  }
+  return payload;
+}
+function evidenceFromHeaders(headers) {
+  let raw;
+  if (typeof headers.get === "function") {
+    raw = headers.get(EVIDENCE_HEADER);
+  } else {
+    const target = EVIDENCE_HEADER.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === target) {
+        raw = value;
+        break;
+      }
+    }
+  }
+  if (!raw) throw new DX402Error(`no ${EVIDENCE_HEADER} header on this response`);
+  return parseEvidenceHeader(raw);
+}
+function dereferencePointer(pointer) {
+  if (pointer.startsWith("s3+")) return pointer.slice(3);
+  if (pointer.startsWith("ipfs://")) return `https://ipfs.io/ipfs/${pointer.slice(7)}`;
+  if (pointer.startsWith("ar://")) return `https://arweave.net/${pointer.slice(5)}`;
+  return pointer;
+}
+function parseSealed(raw) {
+  let pos = 0;
+  const take = (n, what) => {
+    if (raw.length < pos + n) throw new DX402Error(`truncated DX402 sealed blob at ${what}`);
+    const chunk = raw.subarray(pos, pos + n);
+    pos += n;
+    return chunk;
+  };
+  const magic = take(MAGIC.length, "magic");
+  for (let i = 0; i < MAGIC.length; i++) {
+    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");
+  const bodyNonce = take(NONCE_LEN, "body nonce");
+  const ciphertext = raw.subarray(pos);
+  return {
+    alg: algByte === 1 ? "secp256k1" : "x25519",
+    ephemeral,
+    cekNonce,
+    wrappedCek,
+    bodyNonce,
+    ciphertext
+  };
+}
+function sharedSecret(sealed, privateKey) {
+  if (sealed.alg === "secp256k1") {
+    const full = secp256k1.secp256k1.getSharedSecret(privateKey, sealed.ephemeral, true);
+    return full.subarray(1);
+  }
+  const scalar = sha2.sha512(privateKey).subarray(0, 32);
+  const shared = ed25519.x25519.getSharedSecret(scalar, sealed.ephemeral);
+  if (shared.every((b) => b === 0)) {
+    throw new DX402Error("degenerate ECDH result (small-order public key)");
+  }
+  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}`);
+  }
+  return aes.gcm(cek, sealed.bodyNonce, aad).decrypt(sealed.ciphertext);
+}
+async function recoverEvidence(evidence, privateKey, options = {}) {
+  const key = typeof privateKey === "string" ? hexToBytes(privateKey) : privateKey;
+  if (key.length !== 32) {
+    throw new DX402Error(`private key must be 32 bytes, got ${key.length}`);
+  }
+  const doFetch = options.fetch ?? fetch;
+  const url = dereferencePointer(evidence.pointer);
+  const res = await doFetch(url);
+  if (!res.ok) {
+    throw new DX402Error(`could not fetch sealed evidence: HTTP ${res.status}`);
+  }
+  const blob = new Uint8Array(await res.arrayBuffer());
+  const sealed = parseSealed(blob);
+  const aad = new TextEncoder().encode(evidence.paymentId);
+  let plaintext;
+  try {
+    plaintext = unseal(sealed, key, aad);
+  } catch (err) {
+    if (err instanceof DX402Error) throw err;
+    throw new DX402Error(
+      "decryption failed -- wrong key, or the blob belongs to another payment"
+    );
+  }
+  const actual = contentHash(plaintext);
+  if (actual.toLowerCase() !== evidence.contentHash.toLowerCase()) {
+    throw new ContentHashMismatch(evidence.contentHash, actual);
+  }
+  return plaintext;
+}
+function ed25519ToX25519(pubkey) {
+  if (pubkey.length !== 32) {
+    throw new DX402Error(`ed25519 public key must be 32 bytes, got ${pubkey.length}`);
+  }
+  return ed25519.edwardsToMontgomeryPub(pubkey);
+}
+function payerKeyFromEvmSignature(signature, digest) {
+  const sig = typeof signature === "string" ? hexToBytes(signature) : signature;
+  if (sig.length !== 65) {
+    throw new DX402Error(`signature must be 65 bytes, got ${sig.length}`);
+  }
+  let v = sig[65 - 1];
+  if (v === 27 || v === 28) v -= 27;
+  else if (v >= 35) v = (v - 35) % 2;
+  if (v !== 0 && v !== 1) throw new DX402Error(`invalid recovery id ${sig[64]}`);
+  const parsed = secp256k1.secp256k1.Signature.fromCompact(sig.subarray(0, 64)).addRecoveryBit(v);
+  return parsed.recoverPublicKey(digest).toRawBytes(true);
+}
+function sealEvidence(body, payerKey, paymentIdValue) {
+  const aad = new TextEncoder().encode(paymentIdValue);
+  const cek = utils.randomBytes(32);
+  const bodyNonce = utils.randomBytes(NONCE_LEN);
+  const cekNonce = utils.randomBytes(NONCE_LEN);
+  const ciphertext = aes.gcm(cek, bodyNonce, aad).encrypt(body);
+  let algByte;
+  let ephemeral;
+  let shared;
+  if (payerKey.length === 33) {
+    algByte = 1;
+    const ephPriv = secp256k1.secp256k1.utils.randomPrivateKey();
+    ephemeral = secp256k1.secp256k1.getPublicKey(ephPriv, true);
+    shared = secp256k1.secp256k1.getSharedSecret(ephPriv, payerKey, true).subarray(1);
+  } else if (payerKey.length === 32) {
+    algByte = 2;
+    const ephPriv = utils.randomBytes(32);
+    ephemeral = ed25519.x25519.getPublicKey(ephPriv);
+    shared = ed25519.x25519.getSharedSecret(ephPriv, payerKey);
+    if (shared.every((b) => b === 0)) {
+      throw new DX402Error("degenerate ECDH result (small-order public key)");
+    }
+  } else {
+    throw new DX402Error(
+      `payer key must be 33 bytes (secp256k1) or 32 (X25519), got ${payerKey.length}`
+    );
+  }
+  const wrapKey = hkdf.hkdf(sha2.sha256, shared, aad, HKDF_INFO, 32);
+  const wrappedCek = aes.gcm(wrapKey, cekNonce, aad).encrypt(cek);
+  const out = new Uint8Array(
+    MAGIC.length + 3 + ephemeral.length + NONCE_LEN + 2 + wrappedCek.length + NONCE_LEN + ciphertext.length
+  );
+  let pos = 0;
+  out.set(MAGIC, pos);
+  pos += MAGIC.length;
+  out[pos++] = FORMAT_VERSION;
+  out[pos++] = algByte;
+  out[pos++] = ephemeral.length;
+  out.set(ephemeral, pos);
+  pos += ephemeral.length;
+  out.set(cekNonce, pos);
+  pos += NONCE_LEN;
+  out[pos++] = wrappedCek.length >> 8 & 255;
+  out[pos++] = wrappedCek.length & 255;
+  out.set(wrappedCek, pos);
+  pos += wrappedCek.length;
+  out.set(bodyNonce, pos);
+  pos += NONCE_LEN;
+  out.set(ciphertext, pos);
+  return out;
+}
 
 // src/types/index.ts
 var CAIP2_IDENTIFIERS = {
@@ -3781,14 +4037,18 @@ var ESCROW_TIMEOUT_MS = {
 
 exports.CAIP2_IDENTIFIERS = CAIP2_IDENTIFIERS;
 exports.CAIP2_TO_CHAIN = CAIP2_TO_CHAIN;
+exports.ContentHashMismatch = ContentHashMismatch;
 exports.DEFAULT_CHAIN = DEFAULT_CHAIN;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.DEFAULT_FACILITATOR_URL = DEFAULT_FACILITATOR_URL;
 exports.DEFAULT_PAYMENT_HEADER = DEFAULT_PAYMENT_HEADER;
+exports.DX402Error = DX402Error;
 exports.ESCROW_DEPOSIT_LIMIT_USD = ESCROW_DEPOSIT_LIMIT_USD;
 exports.ESCROW_TIER_WINDOWS = ESCROW_TIER_WINDOWS;
 exports.EVENT_KINDS = EVENT_KINDS;
+exports.EVIDENCE_HEADER = EVIDENCE_HEADER;
 exports.EnvKeyAdapter = EnvKeyAdapter;
+exports.EvidenceSkipped = EvidenceSkipped;
 exports.FACILITATOR_ADDRESSES = FACILITATOR_ADDRESSES;
 exports.FacilitatorClient = FacilitatorClient;
 exports.KEEPALIVE_INTERVAL_MS = KEEPALIVE_INTERVAL_MS;
@@ -3814,6 +4074,7 @@ exports.buildVerifyRequestV2 = buildVerifyRequestV2;
 exports.caip2ToChain = caip2ToChain;
 exports.chainToCAIP2 = chainToCAIP2;
 exports.computeEscrowNonce = computeEscrowNonce;
+exports.contentHash = contentHash;
 exports.convertX402Header = convertX402Header;
 exports.create402Response = create402Response;
 exports.createHonoMiddleware = createHonoMiddleware;
@@ -3825,10 +4086,14 @@ exports.createX402V1Header = createX402V1Header;
 exports.createX402V2Header = createX402V2Header;
 exports.decodeBase64Utf8 = decodeBase64Utf8;
 exports.decodeX402Header = decodeX402Header;
+exports.dereferencePointer = dereferencePointer;
 exports.detectX402Version = detectX402Version;
+exports.dx402PaymentId = paymentId;
+exports.ed25519ToX25519 = ed25519ToX25519;
 exports.encodeBase64Json = encodeBase64Json;
 exports.encodeBase64Utf8 = encodeBase64Utf8;
 exports.encodeX402Header = encodeX402Header;
+exports.evidenceFromHeaders = evidenceFromHeaders;
 exports.extractPaymentFromHeaders = extractPaymentFromHeaders;
 exports.fetchNonce = fetchNonce;
 exports.generatePaymentOptions = generatePaymentOptions;
@@ -3854,17 +4119,24 @@ exports.getXRPLChains = getXRPLChains;
 exports.isAlgorandChain = isAlgorandChain;
 exports.isCAIP2Format = isCAIP2Format;
 exports.isChainSupported = isChainSupported;
+exports.isEndToEnd = isEndToEnd;
 exports.isSVMChain = isSVMChain;
 exports.isSuiChain = isSuiChain;
 exports.isTokenSupported = isTokenSupported;
 exports.isXRPLChain = isXRPLChain;
 exports.matchesFilters = matchesFilters;
+exports.parseEvidenceHeader = parseEvidenceHeader;
 exports.parseNetworkIdentifier = parseNetworkIdentifier;
+exports.parseSealed = parseSealed;
 exports.parseTrafficEvent = parseTrafficEvent;
+exports.payerKeyFromEvmSignature = payerKeyFromEvmSignature;
+exports.recoverEvidence = recoverEvidence;
+exports.sealEvidence = sealEvidence;
 exports.signRequest = signRequest;
 exports.signRequestWithSigner = signRequestWithSigner;
 exports.signRequestWithWallet = signRequestWithWallet;
 exports.streamTrafficEvents = streamTrafficEvents;
+exports.unseal = unseal;
 exports.validateAmount = validateAmount;
 exports.validateRecipient = validateRecipient;
 //# sourceMappingURL=index.js.map