import assert from "node:assert/strict" import { test } from "node:test" import { createHmac, randomUUID } from "node:crypto" import { bandwidthRegistryEnrollmentSql, bandwidthRegistrySnapshotSql, parseBandwidthRegistrySnapshot, bandwidthRegistrySnapshotProofs, type BandwidthRegistryEnrollmentBatch, type BandwidthRegistryKind } from "./bandwidth-node-registry-batch.js" import { createBandwidthNodeRegistry } from "./bandwidth-node-registry.js" import { createBandwidthExternalNodeRegistry, BandwidthExternalNodeRegistryUnknown } from "./bandwidth-external-node-registry.js" import type { BandwidthNodeProofInput } from "./bandwidth-node-source.js" type Row=Record const canonical=(v:unknown):string=>Array.isArray(v)?"["+v.map(canonical).join(",")+"]":v&&typeof v==="object"?"{"+Object.entries(v).sort(([a],[b])=>ab?1:0).map(([k,v])=>JSON.stringify(k)+":"+canonical(v)).join(",")+"}":JSON.stringify(v) const mac=(purpose:string,value:unknown)=>createHmac("sha256","inert-batch-candidate-fixture-key").update("mmapp-bandwidth-node-"+purpose+"-v1:"+canonical(value)).digest("hex") const root={installationId:randomUUID(),issuerKeySha256:"a".repeat(64),quiescenceProof:"b".repeat(64)} const scope=()=>({deadlineAt:Date.now()+2000}) const material=(kind:BandwidthRegistryKind="managed"):BandwidthRegistryEnrollmentBatch=>({kind,subject:kind==="managed"?71:randomUUID(),insertNode:true,nodeId:randomUUID(),claimProof:"a".repeat(64),nodeMac:"b".repeat(64),incarnation:randomUUID(),aliasMac:"c".repeat(64),eventId:randomUUID(),authorityProof:"d".repeat(64),eventMac:"e".repeat(64)}) function fixture(atomic=false){ const nodes:Row[]=[],aliases:Row[]=[],events:Row[]=[],queries:string[]=[],releases:boolean[]=[],proofs:Array<{purpose:string;value:Row|unknown[];mac:string}>=[],occupancy={status:"unknown",owner:"original-attempt"},tokens=new WeakMap;expiresAt:number}>() let revoked=false,dropDoCommand=false,loseCommit=false,afterBatch=false,finalAuthority=false,finalInspections=0,revokeBeforeCommit=false let proofHook:((purpose:string)=>void)|undefined,queryHook:((sql:string)=>void)|undefined let batchCalls=0,batchHook:(()=>Promise)|undefined,batchFault:"short"|"long"|"malformed"|undefined const expiry=Date.now()+60000 const authorize=async()=>{if(revoked)throw Error("original grant revoked");return{...root,authorityProof:"d".repeat(64),authorityGeneration:"fixture-original-grant",expiresAt:expiry}} const inspect=(kind:BandwidthRegistryKind)=>async(token:unknown)=>{const source=token&&typeof token==="object"?tokens.get(token):undefined;assert(source&&source.kind===kind) if(revokeBeforeCommit&&finalAuthority&&++finalInspections===3)revoked=true return{version:kind==="managed"?1:2,...(kind==="managed"?{serverId:Number(source.id)}:{peerRef:{kind:"external",enrollmentId:String(source.id)}}),sourceProof:"e".repeat(64),authorityGeneration:"fixture-source",routingEndpointEpoch:root.installationId,observedAt:1,expiresAt:source.expiresAt,claims:source.claims,physicalUniquenessVerified:false,cloneResistanceVerified:false} as never } const connect=async()=>{const saved=structuredClone({nodes,aliases,events});let committed=false const restore=()=>{for(const [target,before]of[[nodes,saved.nodes],[aliases,saved.aliases],[events,saved.events]])target.splice(0,target.length,...before)} return{release(unsafe?:boolean){releases.push(unsafe===true);if(!committed)restore()},async query(sql:string,values:unknown[]=[]){ queries.push(sql);const result=(rows:Row[]=[],command?:string)=>({rows:structuredClone(rows),command}) if(sql==="BEGIN")return result([],"BEGIN") if(sql==="ROLLBACK"){restore();return result([],"ROLLBACK")} if(sql==="COMMIT"){committed=true;if(loseCommit)throw Error("fixture loss AFTER actual simulated commit");return result([],"COMMIT")} if(sql.includes("set_config")||sql.includes("pg_advisory_xact_lock"))return result([],"SELECT") if(sql.startsWith("SELECT installation_id")){if(afterBatch)finalAuthority=true;queryHook?.(sql);return result([{installation_id:root.installationId,issuer_key_sha256:root.issuerKeySha256,quiescence_proof:root.quiescenceProof,status:"active"}],"SELECT")} const external=sql.includes("bandwidth_external_node_aliases"),kind=external?"external":"managed",id=String(values[0]) if(sql.startsWith("WITH aliases AS MATERIALIZED")){ const found=aliases.filter(a=>a.kind===kind&&a.subject===id),current=nodes.filter(n=>found.some(a=>a.node_id===n.node_id)),chain=events.filter(e=>e.alias_kind===kind&&e.subject===id).map(({alias_kind:_k,subject:_id,...event})=>event) return result([{aliases:found.map(({kind:_k,...a})=>a),nodes:current,events:chain,claim_nodes:values[1]===null?[]:nodes.filter(n=>n.claim_proof===values[1])}],"SELECT") } if(sql.startsWith("DO $mmapp_bandwidth_register$")){ const latest=(purpose:string)=>{const proof=[...proofs].reverse().find(p=>p.purpose===purpose);assert(proof);return proof} const n=latest("node"),a=latest(external?"external-alias":"alias"),e=latest(external?"external-event":"event"),nm=n.value as Row,am=a.value as Row,em=e.value as Row,subject=String(external?am.enrollmentId:am.serverId) // Inert model only. It checks that the exact signed values are present in // the candidate's fixed DO text; actual PL/pgSQL visibility needs owned PG. for(const value of [nm.nodeId,nm.claimProof,n.mac,am.incarnation,a.mac,em.eventId,e.mac])assert(sql.includes(String(value))) if(sql.includes("IF true THEN")){assert(!nodes.some(node=>node.claim_proof===nm.claimProof));nodes.push({node_id:nm.nodeId,claim_proof:nm.claimProof,enrollment_mac:n.mac})} else assert(nodes.some(node=>node.node_id===nm.nodeId&&node.claim_proof===nm.claimProof&&node.enrollment_mac===n.mac)) assert(!aliases.some(alias=>alias.kind===kind&&alias.subject===subject));aliases.push({kind,subject,incarnation:am.incarnation,node_id:am.nodeId,status:"active",record_mac:a.mac}) events.push({alias_kind:kind,subject,event_id:em.eventId,incarnation:em.incarnation,node_id:em.nodeId,kind:"enroll",old_status:null,new_status:"active",authority_proof:em.authorityProof,event_mac:e.mac});afterBatch=true;queryHook?.(sql);return result([],dropDoCommand?undefined:"DO") } if(sql.startsWith("UPDATE")&&sql.includes("_aliases SET")){const row=aliases.find(a=>a.kind===kind&&a.subject===id&&a.status==="active"&&a.record_mac===values[3]);assert(row);row.status=values[1];row.record_mac=values[2];return result([{[external?"enrollment_id":"server_id"]:external?id:Number(id)}],"UPDATE")} if(sql.startsWith("INSERT")&&sql.includes("_events(")){const external=sql.includes("bandwidth_external_node_events"),kind=external?"external":"managed";events.push({alias_kind:kind,subject:String(values[1]),event_id:values[0],incarnation:values[2],node_id:values[3],kind:values[4],old_status:values[5],new_status:values[6],authority_proof:values[7],event_mac:values[8]});return result([{event_id:values[0]}],"INSERT")} throw Error("unexpected inert candidate SQL") }} } const keyedProof=async(purpose:string,value:unknown)=>{const digest=mac(purpose,value);proofs.push({purpose,value:structuredClone(value) as Row,mac:digest});proofHook?.(purpose);return digest} const batch=atomic?{keyedProofs:async(inputs:readonly BandwidthNodeProofInput[])=>{ batchCalls++;assert(Object.isFrozen(inputs));assert(inputs.every(Object.isFrozen)) await batchHook?.() const values=inputs.map(({purpose,value})=>{const digest=mac(purpose,value);proofs.push({purpose,value:structuredClone(value) as Row,mac:digest});return digest}) // No await between pure MACs; the hook models source revocation before return. inputs.forEach(({purpose})=>proofHook?.(purpose)) if(batchFault==="short")return values.slice(1) if(batchFault==="long")return [...values,"a".repeat(64)] if(batchFault==="malformed")return values.map((value,index)=>index===1?"bad":value) return Object.freeze(values) }}:{} const managed=createBandwidthNodeRegistry({now:Date.now,connect,authorize,inspect:inspect("managed"),keyedProof,...batch}),external=createBandwidthExternalNodeRegistry({now:Date.now,connect,authorize,inspect:inspect("external"),keyedProof,...batch}) const observe=(kind:BandwidthRegistryKind,id:number|string,claims:Array<{kind:"system-id"|"software-id";value:string}>=[{kind:"system-id",value:"SAME-NODE"}])=>{const token={};tokens.set(token,{kind,id,claims,expiresAt:expiry});return token} return{managed,external,observe,nodes,aliases,events,queries,releases,proofs,occupancy,dropDo:()=>{dropDoCommand=true},loseCommit:()=>{loseCommit=true},revoke:()=>{revoked=true},proofHook:(hook:typeof proofHook)=>{proofHook=hook},queryHook:(hook:typeof queryHook)=>{queryHook=hook},revokeBeforeCommit:()=>{revokeBeforeCommit=true},batchCalls:()=>batchCalls,batchHook:(hook:typeof batchHook)=>{batchHook=hook},batchFault:(fault:typeof batchFault)=>{batchFault=fault}} } test("fixed managed/external DO is invoker-only sequential SPI with STRICT returning and exact expected IDs",()=>{ for(const kind of ["managed","external"] as const)for(const insertNode of [true,false]){const p={...material(kind),insertNode},sql=bandwidthRegistryEnrollmentSql(p) assert(sql.startsWith("DO $mmapp_bandwidth_register$"));assert(sql.includes(`IF ${insertNode} THEN`));assert.equal((sql.match(/INSERT INTO/g)||[]).length,3);assert.equal((sql.match(/RETURNING .*INTO STRICT/g)||[]).length,3);assert(sql.includes("SELECT node_id,claim_proof,enrollment_mac INTO STRICT"));assert(sql.indexOf("INSERT INTO mmapp_control.bandwidth_nodes"){ for(const field of ["nodeId","incarnation","eventId","claimProof","nodeMac","aliasMac","authorityProof","eventMac"]){const p=material();(p as unknown as Row)[field]="'; DROP TABLE x; --";assert.throws(()=>bandwidthRegistryEnrollmentSql(p))} for(const value of [0,-1,1.5,Number.MAX_SAFE_INTEGER+1,NaN,Infinity,"71",randomUUID()])assert.throws(()=>bandwidthRegistryEnrollmentSql({...material(),subject:value as number})) assert.throws(()=>bandwidthRegistryEnrollmentSql({...material("external"),subject:71}));assert.throws(()=>bandwidthRegistryEnrollmentSql({...material(),insertNode:"true" as unknown as boolean}));assert.throws(()=>bandwidthRegistryEnrollmentSql({...material(),extra:true} as BandwidthRegistryEnrollmentBatch)) let reads=0;const p=material();Object.defineProperty(p,"nodeMac",{enumerable:true,get(){reads++;return"a".repeat(64)}});assert.throws(()=>bandwidthRegistryEnrollmentSql(p));assert.equal(reads,0) }) test("snapshot SQL variants remain fixed and bind IDs/hash; pure parser refuses missing/duplicate/current-node/event inconsistencies",()=>{ for(const kind of ["managed","external"] as const)for(const lock of [true,false]){const sql=bandwidthRegistrySnapshotSql(kind,lock);assert(sql.includes("WITH aliases AS MATERIALIZED"));assert(sql.includes("claim_proof=$2::pg_catalog.text"));assert.equal(sql.includes("FOR UPDATE"),lock);assert(!/\b(?:INSERT|DELETE|CREATE|ALTER|TRUNCATE)\b/.test(sql));assert(!sql.includes("bandwidth_node_occupancy"))} assert.throws(()=>bandwidthRegistrySnapshotSql("injected" as BandwidthRegistryKind,true));assert.throws(()=>bandwidthRegistrySnapshotSql("managed",1 as unknown as boolean)) const p=material(),empty={aliases:[],nodes:[],events:[],claim_nodes:[]};assert(Object.isFrozen(parseBandwidthRegistrySnapshot([empty],"managed",71,p.claimProof))) const node={node_id:p.nodeId,claim_proof:p.claimProof,enrollment_mac:p.nodeMac},snapshot=parseBandwidthRegistrySnapshot([{aliases:[{subject:"71",incarnation:p.incarnation,node_id:p.nodeId,status:"active",record_mac:p.aliasMac}],nodes:[node],events:[{event_id:p.eventId,incarnation:p.incarnation,node_id:p.nodeId,kind:"enroll",old_status:null,new_status:"active",authority_proof:p.authorityProof,event_mac:p.eventMac}],claim_nodes:[node]}],"managed",71,p.claimProof) const descriptors=bandwidthRegistrySnapshotProofs("managed",snapshot,root);assert.deepEqual(descriptors.map(value=>value.purpose),["alias","node","event"]);assert(Object.isFrozen(descriptors));assert(descriptors.every(value=>Object.isFrozen(value)&&Object.isFrozen(value.value))) for(const data of [[],[empty,empty],[{...empty,nodes:[{node_id:p.nodeId,claim_proof:p.claimProof,enrollment_mac:p.nodeMac}]}],[{...empty,events:[{}]}],[{...empty,claim_nodes:[{node_id:p.nodeId,claim_proof:"f".repeat(64),enrollment_mac:p.nodeMac}]}]])assert.throws(()=>parseBandwidthRegistrySnapshot(data,"managed",71,p.claimProof)) }) test("candidate managed/external register uses one snapshot SELECT and one DO; same typed claim issuer preserves node and unknown",async()=>{ const f=fixture(),managed=await f.managed.register(f.observe("managed",71),scope()),externalId=randomUUID(),external=await f.external.register(f.observe("external",externalId),scope()) assert.equal(managed.canonicalNodeId,external.canonicalNodeId);assert.notEqual(managed.incarnation,external.incarnation);assert.equal(f.nodes.length,1);assert.equal(f.aliases.length,2);assert.equal(f.events.length,2) assert.equal(f.queries.filter(q=>q.startsWith("WITH aliases AS MATERIALIZED")).length,2);assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,2);assert.equal(f.queries.length,18);assert.deepEqual(f.occupancy,{status:"unknown",owner:"original-attempt"});assert(!f.queries.some(q=>q.includes("bandwidth_node_occupancy"))) }) test("existing alias, resolve and retirement reuse one pure snapshot proof path; terminal alias never re-enrolls or changes canonical identity",async()=>{ const f=fixture(),id=randomUUID(),token=f.observe("external",id),first=await f.external.register(token,scope()) assert.equal((await f.external.register(token,scope())).outcome,"existing");assert.equal((await f.external.resolve(token,scope())).canonicalNodeId,first.canonicalNodeId) assert.equal((await f.external.retire(id,"tombstone",scope())).status,"tombstoned");assert.equal((await f.external.retire(id,"tombstone",scope())).outcome,"existing") await assert.rejects(f.external.register(token,scope()));await assert.rejects(f.external.resolve(token,scope()));await assert.rejects(f.external.retire(id,"quarantine",scope())) const replacement=await f.external.register(f.observe("external",randomUUID()),scope());assert.equal(replacement.canonicalNodeId,first.canonicalNodeId);assert.notEqual(replacement.incarnation,first.incarnation);assert.equal(f.nodes.length,1) }) test("snapshot node/alias/event MAC or full typed claim drift refuses without replacement node/event",async()=>{ for(const fault of ["node","alias","event","typed-claim"]){const f=fixture(),token=f.observe("managed",71);await f.managed.register(token,scope());if(fault==="node")f.nodes[0].enrollment_mac="f".repeat(64);if(fault==="alias")f.aliases[0].record_mac="f".repeat(64);if(fault==="event")f.events[0].event_mac="f".repeat(64) await assert.rejects(f.managed.register(fault==="typed-claim"?f.observe("managed",71,[{kind:"software-id",value:"SAME-NODE"}]):token,scope()));assert.equal(f.nodes.length,1);assert.equal(f.events.length,1) } }) test("rows-only DO completion cannot acknowledge the batch; outer transaction rolls back and does not COMMIT",async()=>{ const f=fixture();f.dropDo();await assert.rejects(f.external.register(f.observe("external",randomUUID()),scope()));assert.equal(f.nodes.length,0);assert.equal(f.aliases.length,0);assert.equal(f.events.length,0);assert(!f.queries.includes("COMMIT"));assert(f.queries.includes("ROLLBACK")) }) test("original grant revocation during event signing or after actual batch dispatch prevents COMMIT and preserves preexisting unknown",async()=>{ for(const boundary of ["event-proof","after-do"]){const f=fixture();if(boundary==="event-proof")f.proofHook(purpose=>{if(purpose==="external-event")f.revoke()});else f.queryHook(sql=>{if(sql.startsWith("DO $mmapp_bandwidth_register$"))f.revoke()}) await assert.rejects(f.external.register(f.observe("external",randomUUID()),scope()));assert(!f.queries.includes("COMMIT"));assert.equal(f.nodes.length,0);assert.equal(f.events.length,0);assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,boundary==="after-do"?1:0);assert.deepEqual(f.occupancy,{status:"unknown",owner:"original-attempt"}) } }) test("the original final pre-COMMIT inspection/authority boundary remains effective after DO, with no weakened late-grant fault",async()=>{ const f=fixture();f.revokeBeforeCommit();await assert.rejects(f.managed.register(f.observe("managed",71),scope()));assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,1);assert(!f.queries.includes("COMMIT"));assert.deepEqual(f.releases,[true]);assert.equal(f.nodes.length,0);assert.equal(f.aliases.length,0) }) test("existing external lost COMMIT ACK remains unknown/no replay even though node+alias+event writes are batched",async()=>{ const f=fixture();f.loseCommit();await assert.rejects(f.external.register(f.observe("external",randomUUID()),scope()),error=>error instanceof BandwidthExternalNodeRegistryUnknown&&error.automaticReplay===false);assert.equal(f.nodes.length,1);assert.equal(f.aliases.length,1);assert.equal(f.events.length,1);assert.equal(f.queries.filter(q=>q==="COMMIT").length,1);assert(!f.queries.includes("ROLLBACK")) }) test("trusted atomic signer preserves scalar domains and exact enrollment data for both participant kinds",async()=>{ for(const kind of ["managed","external"] as const){ const f=fixture(true),id=kind==="managed"?71:randomUUID(),token=f.observe(kind,id) const receipt=await (kind==="managed"?f.managed:f.external).register(token,scope()) assert.equal(receipt.status,"active");assert.equal(f.batchCalls(),1);assert.equal(f.proofs.length,4) assert.equal(f.proofs[0].purpose,"claim") assert.equal(f.queries.filter(q=>q.startsWith("DO $mmapp_bandwidth_register$")).length,1) assert.equal(f.nodes.length,1);assert.equal(f.events.length,1) assert.deepEqual(f.occupancy,{status:"unknown",owner:"original-attempt"}) } }) test("atomic signer result corruption and original authority loss refuse before enrollment DO",async()=>{ for(const kind of ["managed","external"] as const)for(const fault of ["short","long","malformed","revoke"] as const){ const f=fixture(true),id=kind==="managed"?71:randomUUID() if(fault==="revoke")f.proofHook(purpose=>{if(purpose.endsWith("event"))f.revoke()});else f.batchFault(fault) await assert.rejects((kind==="managed"?f.managed:f.external).register(f.observe(kind,id),scope())) assert.equal(f.batchCalls(),1);assert.equal(f.nodes.length,0);assert.equal(f.events.length,0) assert(!f.queries.some(q=>q.startsWith("DO $mmapp_bandwidth_register$")||q==="COMMIT")) } }) test("aborted pending atomic signing destroys its lease; late MACs cannot resume a write",async()=>{ const f=fixture(true),controller=new AbortController() let release!:()=>void,entered!:()=>void const waiting=new Promise(done=>{entered=done}),held=new Promise(done=>{release=done}) f.batchHook(async()=>{entered();await held}) const pending=f.external.register(f.observe("external",randomUUID()),{deadlineAt:Date.now()+2000,signal:controller.signal}) await waiting;controller.abort();await assert.rejects(pending) release();await new Promise(done=>setTimeout(done,10)) assert.deepEqual(f.releases,[true]);assert.equal(f.nodes.length,0) assert(!f.queries.some(q=>q.startsWith("DO $mmapp_bandwidth_register$")||q==="COMMIT")) })