VCX PR

export function canonicalizeBytes(obj: unknown): Uint8Array {
  return new TextEncoder().encode(canonicalize(obj));
}

export function canonicalJsonBytes(value: unknown): Uint8Array {
  const json = canonicalize(value);
  if (typeof json !== "string") {
    throw new Error("JCS canonicalization returned non-string");
  }
  return new TextEncoder().encode(json);
}

export function sha256Jcs(obj: unknown): string {
  return createHash('sha256').update(canonicalize(obj)).digest('hex');
}

export function jcsSha256(value: unknown): string {
  const bytes = canonicalJsonBytes(value);
  return "sha256:" + createHash("sha256").update(bytes).digest("hex");
}

if (!/^sha256:[0-9a-f]{64}$/.test(obj.didDocumentHash)) {
  throw new Error(`Trust-list entry didDocumentHash MUST be "sha256:<lowercase-hex>"`);
}

// Build: content-address each audit row
content_hash: sha256Jcs(payload),
prev_hash: prevHash,

// Verify: recompute and compare
const recomputed = sha256Jcs(row.payload);
if (row.content_hash !== recomputed) { /* throw AuditChainError */ }

// canonicalize.ts — content-address an envelope
export function envelopeDigest(envelope: IdentityEnvelope): string {
  return jcsSha256(envelope);
}

// trustlist.ts — same build-then-compare pattern for DID documents
const computed = jcsSha256(result.didDocument);
if (computed !== opts.expectedHash) {
  return { ok: false, reason: `didDocumentHash mismatch...` };
}

export interface SettlementAttestation {
  settled_payment_ref: string;   // "sha256:<hex>" content-addressed ref
  settlement_result: SettlementResult;
  settlement_timestamp_ms: number;
  // ...
}

{
  "settled_payment_ref": "...",
  "vcx": {
    "envelopeDigest": "sha256:<lowercase-hex>",
    "issuerDid": "did:web:paypal.com"
  }
}

function validateTypes(obj: unknown, path = '$'): void {
  // walks the object tree; throws CanonicalizationError on non-canonicalisable type
}

export function canonicalize(obj: unknown): string {
  validateTypes(obj);
  const out = canonicalizeLib(obj);
  if (out === undefined) {
    throw new CanonicalizationError('object is not JCS-canonicalisable');
  }
  return out;
}

export function canonicalJsonBytes(value: unknown): Uint8Array {
  const json = canonicalize(value);
  if (typeof json !== "string") {
    throw new Error("JCS canonicalization returned non-string");
  }
  return new TextEncoder().encode(json);
}

import canonicalizeLib from 'canonicalize';

import canonicalize from "canonicalize";

export interface ComplianceReceipt {
  payer_ref: string;              // "sha256:<hex>" content-addressed identity
  screen_provider_did: string;   // DID URI of compliance provider
  jurisdiction_flags: string[];  // ordered array — ["UK","EU"] ≠ ["EU","UK"]
  canon_version: string;         // in-band discipline pin
  screen_result: ScreenResult;   // closed enum: ALLOW / REFER / DENY
  screen_timestamp_ms: number;   // integer epoch-ms
}

export interface PaymentSourceLayer {
  accountId: string;
  sourceId: string;   // content-addressed identity reference
  network: string;
  asset?: string;
}
export interface PrincipalLayer {
  did: string;        // DID URI of identity provider
  credentialJwt: string;
  // ...
}
export interface AgentLayer {
  did: string;        // DID URI of agent
  // ...
}

export const SETTLEMENT_RESULTS = [
  'SETTLED',
  'PENDING_FINALITY',
  'REVERSED',
] as const;
export type SettlementResult = (typeof SETTLEMENT_RESULTS)[number];

export interface AuditChainRow {
  chain_position: number;
  content_hash: string;       // SHA-256(JCS(payload))
  prev_hash: string | null;   // null at head; links to previous content_hash
  payload: unknown;
}

export const CANON_VERSION = 'jcs-rfc8785-v1' as const;
// emitted as canon_version field in every AlgoVoi receipt format