uvd-x402-sdk 2.53.0 → 2.55.0

package/dist/index.mjs

@@ -1,6 +1,262 @@
+import { gcm } from '@noble/ciphers/aes';
+import { edwardsToMontgomeryPub, x25519 } from '@noble/curves/ed25519';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { hkdf } from '@noble/hashes/hkdf';
+import { keccak_256 } from '@noble/hashes/sha3';
+import { sha256, sha512 } from '@noble/hashes/sha2';
+import { randomBytes } from '@noble/hashes/utils';
 import { ethers } from '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(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(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.getSharedSecret(privateKey, sealed.ephemeral, true);
+    return full.subarray(1);
+  }
+  const scalar = sha512(privateKey).subarray(0, 32);
+  const shared = 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(sha256, shared, aad, HKDF_INFO, 32);
+  const cek = 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 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 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.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 = randomBytes(32);
+  const bodyNonce = randomBytes(NONCE_LEN);
+  const cekNonce = randomBytes(NONCE_LEN);
+  const ciphertext = gcm(cek, bodyNonce, aad).encrypt(body);
+  let algByte;
+  let ephemeral;
+  let shared;
+  if (payerKey.length === 33) {
+    algByte = 1;
+    const ephPriv = secp256k1.utils.randomPrivateKey();
+    ephemeral = secp256k1.getPublicKey(ephPriv, true);
+    shared = secp256k1.getSharedSecret(ephPriv, payerKey, true).subarray(1);
+  } else if (payerKey.length === 32) {
+    algByte = 2;
+    const ephPriv = randomBytes(32);
+    ephemeral = x25519.getPublicKey(ephPriv);
+    shared = 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(sha256, shared, aad, HKDF_INFO, 32);
+  const wrappedCek = 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 = {
@@ -3777,6 +4033,6 @@ var ESCROW_TIMEOUT_MS = {
   // Monad: 90s
 };
 
-export { CAIP2_IDENTIFIERS, CAIP2_TO_CHAIN, DEFAULT_CHAIN, DEFAULT_CONFIG, DEFAULT_FACILITATOR_URL, DEFAULT_PAYMENT_HEADER, ESCROW_DEPOSIT_LIMIT_USD, ESCROW_TIER_WINDOWS, EVENT_KINDS, EnvKeyAdapter, FACILITATOR_ADDRESSES, FacilitatorClient, KEEPALIVE_INTERVAL_MS, OPERATOR_FEE_BPS, OWSWalletAdapter, PAYMENT_HEADER_NAMES, SSEParser, SUPPORTED_CHAINS, TrafficStreamError, X402Client, X402Error, X402_CORS_HEADERS, X402_HEADER_NAMES, buildEscrowPreAuth, buildPaymentRequirements, buildSettleRequest, buildSettleRequestV2, buildSignatureBase, buildSignatureParams, buildTokenMetadata, buildVerifyRequest, buildVerifyRequestV2, caip2ToChain, chainToCAIP2, computeEscrowNonce, convertX402Header, create402Response, createHonoMiddleware, createPaymentHeaders, createPaymentMiddleware, createSignedFetch, createX402Header, createX402V1Header, createX402V2Header, decodeBase64Utf8, decodeX402Header, detectX402Version, encodeBase64Json, encodeBase64Utf8, encodeX402Header, extractPaymentFromHeaders, fetchNonce, generatePaymentOptions, getAlgorandChains, getChainById, getChainByName, getChainsByNetworkType, getChainsByToken, getCorsHeaders, getEVMChainIds, getEnabledChains, getExplorerAddressUrl, getExplorerTxUrl, getFacilitatorAddress, getNetworkType, getPaymentHeader, getSVMChains, getSuiChains, getSupportedTokens, getTokenByAddress, getTokenConfig, getXRPLChains, isAlgorandChain, isCAIP2Format, isChainSupported, isSVMChain, isSuiChain, isTokenSupported, isXRPLChain, matchesFilters, parseNetworkIdentifier, parseTrafficEvent, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, validateAmount, validateRecipient };
+export { CAIP2_IDENTIFIERS, CAIP2_TO_CHAIN, ContentHashMismatch, DEFAULT_CHAIN, DEFAULT_CONFIG, DEFAULT_FACILITATOR_URL, DEFAULT_PAYMENT_HEADER, DX402Error, ESCROW_DEPOSIT_LIMIT_USD, ESCROW_TIER_WINDOWS, EVENT_KINDS, EVIDENCE_HEADER, EnvKeyAdapter, EvidenceSkipped, FACILITATOR_ADDRESSES, FacilitatorClient, KEEPALIVE_INTERVAL_MS, OPERATOR_FEE_BPS, OWSWalletAdapter, PAYMENT_HEADER_NAMES, SSEParser, SUPPORTED_CHAINS, TrafficStreamError, X402Client, X402Error, X402_CORS_HEADERS, X402_HEADER_NAMES, buildEscrowPreAuth, buildPaymentRequirements, buildSettleRequest, buildSettleRequestV2, buildSignatureBase, buildSignatureParams, buildTokenMetadata, buildVerifyRequest, buildVerifyRequestV2, caip2ToChain, chainToCAIP2, computeEscrowNonce, contentHash, convertX402Header, create402Response, createHonoMiddleware, createPaymentHeaders, createPaymentMiddleware, createSignedFetch, createX402Header, createX402V1Header, createX402V2Header, decodeBase64Utf8, decodeX402Header, dereferencePointer, detectX402Version, paymentId as dx402PaymentId, ed25519ToX25519, encodeBase64Json, encodeBase64Utf8, encodeX402Header, evidenceFromHeaders, extractPaymentFromHeaders, fetchNonce, generatePaymentOptions, getAlgorandChains, getChainById, getChainByName, getChainsByNetworkType, getChainsByToken, getCorsHeaders, getEVMChainIds, getEnabledChains, getExplorerAddressUrl, getExplorerTxUrl, getFacilitatorAddress, getNetworkType, getPaymentHeader, getSVMChains, getSuiChains, getSupportedTokens, getTokenByAddress, getTokenConfig, getXRPLChains, isAlgorandChain, isCAIP2Format, isChainSupported, isEndToEnd, isSVMChain, isSuiChain, isTokenSupported, isXRPLChain, matchesFilters, parseEvidenceHeader, parseNetworkIdentifier, parseSealed, parseTrafficEvent, payerKeyFromEvmSignature, recoverEvidence, sealEvidence, signRequest, signRequestWithSigner, signRequestWithWallet, streamTrafficEvents, unseal, validateAmount, validateRecipient };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map