mycomesh-consumer 0.1.53 → 0.2.1

package/src/consumer-request-journal.mjs

@@ -1,189 +0,0 @@
-import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
-import { closeSync, constants, existsSync, fchmodSync, fsyncSync, fstatSync, lstatSync, mkdirSync,
-  openSync, readFileSync, renameSync, unlinkSync, writeSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
-
-const SCHEMA = 'mycomesh.consumer.request-journal.v1';
-const HASH = /^0x[0-9a-f]{64}$/;
-const ADDRESS = /^0x[0-9a-f]{40}$/i;
-const MAX_REQUEST_BYTES = 16 * 1024 * 1024;
-const SAFE_HEADERS = new Set(['content-type', 'x-request-id', 'x-mycomesh-request-id', 'x-mycomesh-session-id',
-  'x-mycomesh-content-verification', 'x-mycomesh-history-status', 'x-should-retry']);
-const PAYMENT_FIELDS = new Set(['payment-response', 'payment_response', 'payment_v7', 'payment_v8', 'payment_v9', 'payment_v10',
-  'mycomesh_v7_settlement', 'mycomesh_v8_settlement', 'mycomesh_v9_settlement', 'mycomesh_v10_settlement', 'settlement_v10',
-  'signed_receipt', 'relay_dispatch', 'key_signature', 'provider_signature', 'relay_signature', 'authorization',
-  'api_key', 'payment_key', 'private_key', 'signature']);
-const SECRET_VALUE = /myco_(?:sk|local|share)_[a-z0-9_-]+|\bbearer\s+\S+/i;
-const sha256 = value => createHash('sha256').update(value).digest('hex');
-
-export class RequestJournalError extends Error {
-  constructor(code, message, requestId) {
-    super(message); this.name = 'RequestJournalError'; this.code = code; this.statusCode = 422;
-    this.requestId = requestId; this.retryable = false;
-  }
-}
-
-function canonical(value, ancestors = new Set()) {
-  if (value === null || typeof value === 'string' || typeof value === 'boolean') return JSON.stringify(value);
-  if (typeof value === 'number' && Number.isFinite(value)) return JSON.stringify(value);
-  if (!value || typeof value !== 'object' || ancestors.has(value)) throw new TypeError('journal input must be finite canonical JSON');
-  if (!Array.isArray(value) && ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new TypeError('journal input must be plain JSON');
-  ancestors.add(value);
-  try {
-    if (Array.isArray(value)) return '[' + Array.from(value, item => canonical(item, ancestors)).join(',') + ']';
-    return '{' + Object.keys(value).sort().map(key => JSON.stringify(key) + ':' + canonical(value[key], ancestors)).join(',') + '}';
-  } finally { ancestors.delete(value); }
-}
-
-/** Hash only; the original request (including its prompt) is never persisted. */
-export function requestPayloadHash(value) {
-  const encoded = canonical(value);
-  if (Buffer.byteLength(encoded) > MAX_REQUEST_BYTES) throw new RequestJournalError('request_too_large', 'Request exceeds the idempotency journal size bound');
-  return '0x' + sha256(encoded);
-}
-
-function syncDirectory(path) {
-  const fd = openSync(path, constants.O_RDONLY);
-  try { fsyncSync(fd); } finally { closeSync(fd); }
-}
-function privateDirectory(path) {
-  if (existsSync(path) && !lstatSync(path).isDirectory()) throw new Error('request journal must use regular directories');
-  mkdirSync(path, { recursive: true, mode: 0o700 });
-  if (!lstatSync(path).isDirectory()) throw new Error('request journal directory changed');
-  const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
-  try { fchmodSync(fd, 0o700); } finally { closeSync(fd); }
-}
-function writeAll(fd, bytes) {
-  fchmodSync(fd, 0o600);
-  let offset = 0;
-  while (offset < bytes.length) {
-    const written = writeSync(fd, bytes, offset, bytes.length - offset);
-    if (!written) throw new Error('incomplete request journal write');
-    offset += written;
-  }
-  fsyncSync(fd);
-}
-function cleanValue(value) {
-  if (typeof value === 'string') {
-    if (SECRET_VALUE.test(value)) throw new RequestJournalError('unsafe_cached_response', 'Response contains credential-like text; it cannot be cached');
-    return value;
-  }
-  if (Array.isArray(value)) return value.map(cleanValue);
-  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value)
-    .filter(([key]) => !PAYMENT_FIELDS.has(key.toLowerCase())).map(([key, item]) => [key, cleanValue(item)]));
-  return value;
-}
-/** Cache API output only, excluding payment proofs and top-level echoed input. */
-export function protectedCachedResult(result) {
-  if (!result || !Number.isInteger(result.status) || result.status < 100 || result.status > 599) throw new TypeError('invalid cached HTTP status');
-  canonical(result.payload); // Validate before traversing; rejects cycles/non-JSON.
-  const payload = cleanValue(result.payload);
-  if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
-    for (const key of ['input', 'messages', 'prompt', 'instructions', 'system_prompt', 'metadata']) delete payload[key];
-  }
-  const headers = Object.fromEntries(Object.entries(result.headers || {}).flatMap(([key, value]) => {
-    const name = key.toLowerCase();
-    if (!SAFE_HEADERS.has(name)) return [];
-    if (typeof value !== 'string' || value.length > 2048 || /[\r\n]/.test(value) || SECRET_VALUE.test(value)) throw new TypeError('invalid cached response header');
-    return [[name, value]];
-  }));
-  return { status: result.status, headers, payload };
-}
-
-/**
- * A permanent per-key O_EXCL claim is the execution fence. No TTL or stale-lock
- * recovery ever removes a claim. Missing/corrupt state fails closed. Filesystem
- * loss is outside this guarantee: retain this directory across restarts.
- */
-export class ConsumerRequestJournal {
-  constructor({ directory, chainId, contract, paymentKeyAddress, maxResponseBytes = 8 * 1024 * 1024 }) {
-    if (!directory || !Number.isSafeInteger(chainId) || chainId <= 0 || !ADDRESS.test(contract || '') || !ADDRESS.test(paymentKeyAddress || '')) throw new TypeError('invalid request journal scope');
-    if (!Number.isSafeInteger(maxResponseBytes) || maxResponseBytes < 1 || maxResponseBytes > 16 * 1024 * 1024) throw new TypeError('invalid response size bound');
-    this.scopeHash = sha256(canonical({ chainId, contract: contract.toLowerCase(), paymentKeyAddress: paymentKeyAddress.toLowerCase() }));
-    this.root = resolve(directory); this.directory = join(this.root, this.scopeHash); this.maxResponseBytes = maxResponseBytes;
-    privateDirectory(this.root); privateDirectory(this.directory); syncDirectory(this.root); syncDirectory(dirname(this.root));
-  }
-
-  _path(entryKey) {
-    if (typeof entryKey !== 'string' || !/^[0-9a-f]{64}$/.test(entryKey)) throw new TypeError('invalid journal entry key');
-    return join(this.directory, entryKey + '.json');
-  }
-  _read(entryKey) {
-    let fd;
-    try {
-      fd = openSync(this._path(entryKey), constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
-      const info = fstatSync(fd);
-      if (!info.isFile() || info.size > this.maxResponseBytes + 16384 || (info.mode & 0o077)) throw new Error('invalid journal file');
-      const value = JSON.parse(readFileSync(fd, 'utf8'));
-      if (value.schema !== SCHEMA || value.scope_hash !== this.scopeHash || value.key_hash !== entryKey
-          || !HASH.test(value.request_id || '') || !HASH.test(value.payload_hash || '') || !/^[0-9a-f]{64}$/.test(value.owner_hash || '')
-          || !['in_progress', 'complete', 'outcome_unknown'].includes(value.phase)) throw new Error('invalid journal record');
-      if (value.phase === 'complete' && (!value.result || value.result_hash !== sha256(canonical(value.result)))) throw new Error('invalid cached result');
-      return value;
-    } catch {
-      throw new RequestJournalError('idempotency_state_unknown', 'Existing idempotency state is unavailable or incomplete; do not execute again');
-    } finally { if (fd !== undefined) closeSync(fd); }
-  }
-
-  claim({ idempotencyKey, payloadHash }) {
-    if (typeof idempotencyKey !== 'string' || !idempotencyKey.trim() || Buffer.byteLength(idempotencyKey) > 1024 || /[\u0000-\u001f\u007f]/.test(idempotencyKey)) throw new RequestJournalError('invalid_idempotency_key', 'Idempotency-Key must be nonempty and at most 1024 bytes');
-    if (!HASH.test(payloadHash || '')) throw new TypeError('payloadHash must be a canonical SHA-256 value');
-    const entryKey = sha256(idempotencyKey), path = this._path(entryKey);
-    const requestId = '0x' + randomBytes(32).toString('hex'), claimToken = randomBytes(32).toString('hex');
-    const now = Math.floor(Date.now() / 1000);
-    const record = { schema: SCHEMA, scope_hash: this.scopeHash, key_hash: entryKey, payload_hash: payloadHash,
-      request_id: requestId, owner_hash: sha256(claimToken), phase: 'in_progress', created_at: now, updated_at: now };
-    let fd;
-    try {
-      fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0), 0o600);
-    } catch (error) {
-      if (error.code !== 'EEXIST') throw error;
-      const existing = this._read(entryKey);
-      if (existing.payload_hash !== payloadHash) throw new RequestJournalError('idempotency_conflict', 'Idempotency-Key was already bound to different request content', existing.request_id);
-      if (existing.phase === 'complete') return { action: 'replay', requestId: existing.request_id, result: existing.result };
-      throw new RequestJournalError('idempotency_outcome_unknown', 'This request is in progress or has an unknown outcome; automatic execution is forbidden', existing.request_id);
-    }
-    try {
-      writeAll(fd, Buffer.from(canonical(record))); syncDirectory(this.directory);
-    } finally { closeSync(fd); } // Never remove an incomplete exclusive claim.
-    return { action: 'execute', requestId, claimToken, entryKey };
-  }
-
-  _update(claim, update) {
-    if (!claim || !/^[0-9a-f]{64}$/.test(claim.claimToken || '') || !HASH.test(claim.requestId || '')) throw new TypeError('invalid execution claim');
-    const path = this._path(claim.entryKey), lockPath = path + '.update-lock';
-    let lock;
-    try { lock = openSync(lockPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0), 0o600); }
-    catch { throw new RequestJournalError('idempotency_update_locked', 'Request journal update is unavailable; retain the original execution fence', claim.requestId); }
-    let temporary;
-    try {
-      const record = this._read(claim.entryKey);
-      if (record.request_id !== claim.requestId || !timingSafeEqual(Buffer.from(record.owner_hash, 'hex'), Buffer.from(sha256(claim.claimToken), 'hex'))) throw new RequestJournalError('idempotency_claim_mismatch', 'This process does not own the execution claim', record.request_id);
-      const next = update(record);
-      if (next === record) return;
-      temporary = path + '.' + randomBytes(12).toString('hex') + '.tmp';
-      const fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | (constants.O_NOFOLLOW || 0), 0o600);
-      try { writeAll(fd, Buffer.from(canonical(next))); } finally { closeSync(fd); }
-      renameSync(temporary, path); temporary = null; syncDirectory(this.directory);
-    } finally {
-      if (temporary) { try { unlinkSync(temporary); } catch {} }
-      closeSync(lock); unlinkSync(lockPath); syncDirectory(this.directory);
-    }
-  }
-
-  complete(claim, result) {
-    const cleaned = protectedCachedResult(result), encoded = canonical(cleaned);
-    if (Buffer.byteLength(encoded) > this.maxResponseBytes) throw new RequestJournalError('cached_response_too_large', 'Response exceeds the protected cache bound; the execution remains fenced', claim?.requestId);
-    this._update(claim, record => {
-      if (record.phase === 'complete') {
-        if (record.result_hash !== sha256(encoded)) throw new RequestJournalError('idempotency_completion_conflict', 'A completed response cannot be replaced', record.request_id);
-        return record;
-      }
-      return { ...record, phase: 'complete', updated_at: Math.floor(Date.now() / 1000), result: cleaned, result_hash: sha256(encoded) };
-    });
-    return cleaned;
-  }
-  markOutcomeUnknown(claim) {
-    this._update(claim, record => record.phase === 'complete' ? record : { ...record, phase: 'outcome_unknown', updated_at: Math.floor(Date.now() / 1000) });
-  }
-}

package/src/consumer-reserved.mjs

@@ -1,112 +0,0 @@
-import { secp256k1 } from '@noble/curves/secp256k1';
-import { keccak_256 } from '@noble/hashes/sha3.js';
-
-// These types are shared with MycoSettlementV10.sol and gateway/chain_v10.py.
-export const RESERVED_AUTH_SCHEMA = 'mycomesh.x402.myco-credit-v4';
-export const RESERVED_SIGNED_SCHEMA = 'mycomesh.settlement.v10.signed.v1';
-const AUTH_TYPE = 'ReservedPaymentAuthorization(bytes32 channelId,bytes32 requestId,bytes32 requestHash,address key,uint256 maxFee,uint64 issuedAt,uint64 executeBy,uint64 deadline)';
-const RECEIPT_TYPE = 'ReservedUsageReceipt(bytes32 channelId,bytes32 authorizationHash,bytes32 dispatchHash,bytes32 responseHash,uint256 inputTokens,uint256 outputTokens,uint256 actualFee)';
-const DISPATCH_TYPE = 'RelayDispatch(bytes32 authorizationHash,bytes32 channelId)';
-const OPEN_TYPE = 'OpenCapacityChannel(address consumerOwner,address consumerKey,address providerOwner,address providerSigner,address relay,address relaySigner,address pool,bytes32 channel,uint64 pricingVersion,bytes32 pricingHash,uint256 capacity,uint256 maxFeePerRequest,uint64 validFrom,uint64 admitUntil,uint64 claimUntil,uint256 consumerNonce,uint256 providerNonce,uint64 permitDeadline)';
-const AUTH_FIELDS = [['channel_id','b'],['request_id','b'],['request_hash','b'],['key','a'],['max_fee',256],['issued_at',64],['execute_by',64],['deadline',64]];
-const RECEIPT_FIELDS = [['channel_id','b'],['authorization_hash','b'],['dispatch_hash','b'],['response_hash','b'],['input_tokens',256],['output_tokens',256],['actual_fee',256]];
-export const CHANNEL_FIELDS = [['consumer_owner','a'],['consumer_key','a'],['provider_owner','a'],['provider_signer','a'],['relay','a'],['relay_signer','a'],['pool','a'],['channel','b'],['pricing_version',64],['pricing_hash','b'],['capacity',256],['max_fee_per_request',256],['valid_from',64],['admit_until',64],['claim_until',64],['consumer_nonce',256],['provider_nonce',256],['permit_deadline',64]];
-const hash = bytes => '0x' + Buffer.from(keccak_256(bytes)).toString('hex');
-const bytes = value => Buffer.from(value.slice(2), 'hex');
-const textHash = value => bytes(hash(Buffer.from(value)));
-const integer = value => value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
-function record(raw, fields) {
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error('missing V10 record');
-  return Object.fromEntries(fields.map(([name, kind]) => {
-    let value = raw[name];
-    if (kind === 'a' || kind === 'b') {
-      if (typeof value !== 'string' || !(kind === 'a' ? /^0x[\da-f]{40}$/i : /^0x[\da-f]{64}$/i).test(value)
-          || (name !== 'pool' && /^0x0+$/.test(value))) throw new Error(`invalid V10 ${name}`);
-      value = value.toLowerCase();
-    } else {
-      if (!(typeof value === 'number' && Number.isSafeInteger(value)) && !(typeof value === 'string' && /^\d+$/.test(value))) throw new Error(`invalid V10 ${name}`);
-      const n = BigInt(value);
-      if (n < 0n || n >= (1n << BigInt(kind))) throw new Error(`invalid V10 ${name}`);
-      value = integer(n);
-    }
-    return [name, value];
-  }));
-}
-const word = value => Buffer.from((typeof value === 'string' && value.startsWith('0x') ? value.slice(2) : BigInt(value).toString(16)).padStart(64, '0'), 'hex');
-const structHash = (type, raw, fields) => hash(Buffer.concat([textHash(type), ...Object.values(record(raw, fields)).map(word)]));
-function digest(struct, chainId, contract) {
-  const c = record({key:contract}, [['key','a']]).key;
-  if (!Number.isSafeInteger(Number(chainId)) || BigInt(chainId) <= 0n) throw new Error('invalid V10 chain ID');
-  const domain = hash(Buffer.concat([textHash('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'), textHash('MycoMesh Settlement'), textHash('10'), word(chainId), word(c)]));
-  return bytes(hash(Buffer.concat([Buffer.from([25,1]), bytes(domain), bytes(struct)])));
-}
-function privateBytes(key) {
-  return String(key).startsWith('myco_sk_') ? Buffer.from(key.slice(8), 'base64url') : Buffer.from(key.replace(/^0x/, ''), 'hex');
-}
-function recover(d, sig) {
-  if (typeof sig !== 'string' || !/^0x[\da-f]{130}$/i.test(sig)) throw new Error('invalid V10 signature');
-  const raw = bytes(sig), recovery = raw[64] >= 27 ? raw[64]-27 : raw[64];
-  if (recovery > 1) throw new Error('invalid V10 signature recovery');
-  const s = secp256k1.Signature.fromCompact(raw.subarray(0,64));
-  if (s.hasHighS()) throw new Error('noncanonical V10 signature');
-  return '0x'+hash(s.addRecoveryBit(recovery).recoverPublicKey(d).toRawBytes(false).slice(1)).slice(-40);
-}
-export function capacityChannelId(config, chainId, contract) { return '0x' + digest(structHash(OPEN_TYPE, config, CHANNEL_FIELDS), chainId, contract).toString('hex'); }
-export function reservedSettlementKey(channelId, requestId) {
-  const normalized = record({channel_id:channelId,request_id:requestId},AUTH_FIELDS.slice(0,2));
-  return hash(Buffer.concat(Object.values(normalized).map(word)));
-}
-export function decodeCapacityChannel(output, channelId, chainId, contract) {
-  if (typeof output !== 'string' || !/^0x[\da-f]{1408}$/i.test(output)) throw new Error('invalid channelInfo response');
-  const words = output.slice(2).match(/.{64}/g);
-  const raw = Object.fromEntries(CHANNEL_FIELDS.map(([name,kind],i) => {
-    if (kind === 'a' && !/^0{24}/.test(words[i])) throw new Error('noncanonical channel address');
-    return [name,kind === 'a' ? '0x'+words[i].slice(24) : kind === 'b' ? '0x'+words[i] : BigInt('0x'+words[i]).toString()];
-  }));
-  const config = record(raw, CHANNEL_FIELDS);
-  const [settled,credit,stake,closed] = words.slice(18).map(w=>BigInt('0x'+w));
-  if (closed > 1n || BigInt(config.capacity) === 0n || [settled,credit,stake].some(n=>n>BigInt(config.capacity))) throw new Error('invalid channel accounting');
-  if (capacityChannelId(config,chainId,contract) !== channelId.toLowerCase()) throw new Error('channel identity mismatch');
-  return {...config,channel_id:channelId.toLowerCase(),settled_max_fee:integer(settled),credit_remaining:integer(credit),stake_remaining:integer(stake),closed:closed===1n};
-}
-export function buildReservedAuthorization({paymentKey,chainId,settlementContract,channelId,requestId,requestHash,maxFee,issuedAt,executeBy,deadline}) {
-  const keyBytes=privateBytes(paymentKey);
-  const key='0x'+hash(secp256k1.getPublicKey(keyBytes,false).slice(1)).slice(-40);
-  const authorization=record({channel_id:channelId,request_id:requestId,request_hash:requestHash,key,max_fee:maxFee,issued_at:issuedAt,execute_by:executeBy,deadline},AUTH_FIELDS);
-  const h=structHash(AUTH_TYPE,authorization,AUTH_FIELDS), d=digest(h,chainId,settlementContract);
-  const sig=secp256k1.sign(d,keyBytes,{lowS:true,prehash:false});
-  const envelope={schema:RESERVED_AUTH_SCHEMA,protocol_version:10,chain_id:Number(chainId),settlement_contract:settlementContract.toLowerCase(),authorization,authorization_hash:h,authorization_digest:'0x'+d.toString('hex'),key_signature:'0x'+Buffer.concat([Buffer.from(sig.toCompactRawBytes()),Buffer.from([27+sig.recovery])]).toString('hex')};
-  verifyReservedAuthorization(envelope,{now:issuedAt});
-  return envelope;
-}
-export function verifyReservedAuthorization(value, expected={}) {
-  if (value?.schema!==RESERVED_AUTH_SCHEMA || value.protocol_version!==10) throw new Error('unsupported reserved authorization');
-  if (expected.protocolVersion!==undefined && expected.protocolVersion!==10) throw new Error('settlement protocol version mismatch');
-  const a=record(value.authorization,AUTH_FIELDS), now=BigInt(expected.now ?? Math.floor(Date.now()/1000));
-  if (!(BigInt(a.max_fee)>0n && BigInt(a.issued_at)<=now && now<=BigInt(a.deadline) && BigInt(a.issued_at)<=BigInt(a.execute_by) && BigInt(a.execute_by)<BigInt(a.deadline) && BigInt(a.deadline)-BigInt(a.issued_at)<=10800n)) throw new Error('V10 authorization time/fee invalid');
-  for (const [wanted,actual] of [[expected.chainId,value.chain_id],[expected.contract,value.settlement_contract],[expected.channelId,a.channel_id],[expected.requestId,a.request_id],[expected.requestHash,a.request_hash]]) {
-    if (wanted!==undefined && String(wanted).toLowerCase()!==String(actual).toLowerCase()) throw new Error('V10 authorization scope mismatch');
-  }
-  const h=structHash(AUTH_TYPE,a,AUTH_FIELDS),d=digest(h,value.chain_id,value.settlement_contract);
-  if (value.authorization_hash!==h || value.authorization_digest!=='0x'+d.toString('hex') || recover(d,value.key_signature)!==a.key) throw new Error('V10 authorization signature/hash mismatch');
-  return {...value,authorization:a};
-}
-export function verifyReservedReceipt(value, expected={}) {
-  if (value?.schema!==RESERVED_SIGNED_SCHEMA || value.protocol_version!==10) throw new Error('unsupported reserved receipt');
-  const a=verifyReservedAuthorization(value.authorization,expected),c=expected.channel;
-  // Role identities must come from a pinned on-chain channel, never the Relay's envelope.
-  if (!c || capacityChannelId(c,a.chain_id,a.settlement_contract)!==a.authorization.channel_id || c.closed!==false || c.consumer_key!==a.authorization.key) throw new Error('verified capacity channel required');
-  const auth=a.authorization;
-  if (!(BigInt(c.valid_from)<=BigInt(auth.issued_at) && BigInt(auth.execute_by)<=BigInt(c.admit_until) && BigInt(auth.deadline)<=BigInt(c.claim_until) && BigInt(auth.max_fee)<=BigInt(c.max_fee_per_request))) throw new Error('authorization exceeds channel terms');
-  const d=value.dispatch;
-  if (d?.schema!=='mycomesh.settlement.v10.dispatch.v1' || d.protocol_version!==10 || d.authorization?.authorization_hash!==a.authorization_hash || d.authorization?.key_signature!==a.key_signature) throw new Error('invalid Relay dispatch');
-  verifyReservedAuthorization(d.authorization,expected);
-  for (const envelope of [value,d]) if (envelope.chain_id!==a.chain_id || envelope.settlement_contract!==a.settlement_contract) throw new Error('V10 receipt deployment mismatch');
-  const dh=hash(Buffer.concat([textHash(DISPATCH_TYPE),word(a.authorization_hash),word(auth.channel_id)]));
-  const dd=digest(dh,a.chain_id,a.settlement_contract);
-  if (d.dispatch_hash!==dh || d.dispatch_digest!=='0x'+dd.toString('hex') || d.relay_signer!==c.relay_signer || recover(dd,d.relay_signature)!==c.relay_signer || value.relay_signature!==d.relay_signature) throw new Error('V10 Relay dispatch signature mismatch');
-  const r=record(value.receipt,RECEIPT_FIELDS);
-  if (r.channel_id!==auth.channel_id || r.authorization_hash!==a.authorization_hash || r.dispatch_hash!==dh || BigInt(r.actual_fee)<=0n || BigInt(r.actual_fee)>BigInt(auth.max_fee) || value.key_signature!==a.key_signature || value.provider_signer!==c.provider_signer) throw new Error('V10 receipt binding mismatch');
-  if (recover(digest(structHash(RECEIPT_TYPE,r,RECEIPT_FIELDS),a.chain_id,a.settlement_contract),value.provider_signature)!==c.provider_signer) throw new Error('V10 Provider signature mismatch');
-  return {authorization:a,receipt:{...r,provider:c.provider_owner,provider_signer:c.provider_signer,relay:c.relay,pool:c.pool}};
-}