Files
MikrotikManager/backend/src/services/bandwidth-peer-resolver.test.ts
T

222 lines
24 KiB
TypeScript

import assert from "node:assert/strict"
import { test } from "node:test"
import { createHmac, randomUUID } from "node:crypto"
import { performance } from "node:perf_hooks"
import { setTimeout as delay } from "node:timers/promises"
import { createBandwidthPeerResolver, BandwidthPeerResolverError, type BandwidthPeerResolverDependencies } from "./bandwidth-peer-resolver.js"
import type { BandwidthPeerObservationEvidence } from "./bandwidth-peer-observation.js"
import type { BandwidthPeerRef } from "./bandwidth-peer-reference.js"
import type { ProbeStorageConnection } from "./server-probe-journal-maintenance.js"
type Row=Record<string,unknown>
const canonical=(value:unknown):string=>Array.isArray(value)?"["+value.map(canonical).join(",")+"]":value&&typeof value==="object"?"{"+Object.entries(value).sort(([a],[b])=>a<b?-1:a>b?1:0).map(([key,value])=>JSON.stringify(key)+":"+canonical(value)).join(",")+"}":JSON.stringify(value)
const mac=(purpose:string,value:unknown)=>createHmac("sha256","synthetic-owned-resolver-issuer").update("mmapp-bandwidth-node-"+purpose+"-v1:"+canonical(value)).digest("hex")
const root={installationId:"11111111-1111-4111-8111-111111111111",issuerKeySha256:"a".repeat(64),quiescenceProof:"b".repeat(64)}
const canonicalNodeId="22222222-2222-4222-8222-222222222222"
const deferred=()=>{let resolve!:()=>void;const promise=new Promise<void>(done=>{resolve=done});return{promise,resolve}}
const scope=(ms=2000)=>({deadlineAt:Date.now()+ms})
const refused=(error:unknown)=>error instanceof BandwidthPeerResolverError&&error.automaticReplay===false
function fixture(kind:"server"|"external"="external"){
const peerRef:BandwidthPeerRef=kind==="server"?{kind:"server",serverId:71}:{kind:"external",enrollmentId:randomUUID()}
const token=Object.freeze({kind:"owned-private-observation"}),now=Date.now()
let evidence:BandwidthPeerObservationEvidence={version:2,peerRef,sourceProof:"c".repeat(64),authorityGeneration:"source-v2",routingEndpointEpoch:randomUUID(),observedAt:now,expiresAt:now+60000,claims:[{kind:"system-id",value:"SHARED-SYSTEM"},{kind:"software-id",value:"SHARED-SOFTWARE"}],physicalUniquenessVerified:false,cloneResistanceVerified:false}
let authority={...root,authorityProof:"d".repeat(64),authorityGeneration:"original-operator-grant",expiresAt:now+60000}
const subject=kind==="server"?71:(peerRef as {enrollmentId:string}).enrollmentId,incarnation=randomUUID(),eventId=randomUUID(),external=kind==="external"
const claimProof=mac("claim",evidence.claims),id=external?{enrollmentId:String(subject)}:{serverId:Number(subject)}
const event={event_id:eventId,incarnation,node_id:canonicalNodeId,kind:"enroll",old_status:null,new_status:"active",authority_proof:authority.authorityProof,event_mac:mac(external?"external-event":"event",{...root,eventId,...id,incarnation,nodeId:canonicalNodeId,kind:"enroll",oldStatus:null,newStatus:"active",authorityProof:authority.authorityProof})}
let rows:Row[]=[{subject:String(subject),incarnation,node_id:canonicalNodeId,status:"active",record_mac:mac(external?"external-alias":"alias",{...root,...id,incarnation,nodeId:canonicalNodeId,status:"active"}),claim_proof:claimProof,enrollment_mac:mac("node",{...root,nodeId:canonicalNodeId,claimProof}),installation_id:root.installationId,issuer_key_sha256:root.issuerKeySha256,quiescence_proof:root.quiescenceProof,authority_status:"active",events:[event]}]
let command:unknown="SELECT",revoked=false,inspections=0,authorizations=0,connections=0
const queries:Array<{text:string;values?:unknown[];options?:{signal?:AbortSignal;timeoutMs:number}}>=[],releases:unknown[]=[],proofs:Array<{purpose:string;value:unknown}>=[]
let inspectHook:((count:number)=>Promise<void>)|undefined,authorizeHook:((count:number,e:Readonly<BandwidthPeerObservationEvidence>)=>Promise<void>)|undefined,connectHook:(()=>Promise<void>)|undefined,queryHook:(()=>Promise<void>)|undefined,proofHook:((purpose:string)=>Promise<void>)|undefined
const connection:ProbeStorageConnection={release(unsafe){releases.push(unsafe)},async query(text,values,options){queries.push({text,values,options});await queryHook?.();return{rows:structuredClone(rows),command}}}
const dependencies:BandwidthPeerResolverDependencies={
async inspect(value){inspections++;await inspectHook?.(inspections);if(value!==token)throw Error("not genuine");return structuredClone(evidence)},
async authorize(peer,_scope,e){authorizations++;assert.deepEqual(peer,peerRef);await authorizeHook?.(authorizations,e);if(revoked)throw Error("original grant revoked");return{...authority}},
async connect(){connections++;await connectHook?.();return connection},
async keyedProof(purpose,value){proofs.push({purpose,value:structuredClone(value)});await proofHook?.(purpose);return mac(purpose,value)},
}
const resolver=createBandwidthPeerResolver(dependencies)
return{resolver,dependencies,token,peerRef,queries,releases,proofs,row:()=>rows[0],event:()=>((rows[0].events as Row[])[0]),
setRows:(value:Row[])=>{rows=value},command:(value:unknown)=>{command=value},revoke:()=>{revoked=true},
setEvidence:(change:Partial<BandwidthPeerObservationEvidence>)=>{evidence={...evidence,...change}},setAuthority:(change:Partial<typeof authority>)=>{authority={...authority,...change}},
onInspect:(hook:typeof inspectHook)=>{inspectHook=hook},onAuthorize:(hook:typeof authorizeHook)=>{authorizeHook=hook},onConnect:(hook:typeof connectHook)=>{connectHook=hook},onQuery:(hook:typeof queryHook)=>{queryHook=hook},onProof:(hook:typeof proofHook)=>{proofHook=hook},
inspections:()=>inspections,authorizations:()=>authorizations,connections:()=>connections}
}
test("managed/external genuine v2 refs resolve through exactly one SELECT snapshot, original MAC domains, and frozen existing receipt",async()=>{
const fixtures=[fixture("server"),fixture("external")]
for(const f of fixtures){const result=await f.resolver.resolve(f.token,scope());assert.equal(result.canonicalNodeId,canonicalNodeId);assert.equal(result.outcome,"existing");assert.equal(result.status,"active");assert.deepEqual(result.peerRef,f.peerRef);assert(Object.isFrozen(result));assert(Object.isFrozen(result.peerRef));assert.equal(f.connections(),1);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
const q=f.queries[0];assert(q.text.startsWith("WITH alias AS MATERIALIZED"));assert(q.text.includes("events AS MATERIALIZED"));assert(q.text.includes("JOIN mmapp_control.bandwidth_nodes"));assert(q.text.includes("JOIN mmapp_control.bandwidth_node_authority"));assert(!/\b(?:BEGIN|COMMIT|ROLLBACK|INSERT|UPDATE|DELETE|TRUNCATE|CREATE|ALTER)\b/.test(q.text));assert(!q.text.includes("bandwidth_node_occupancy"));assert.deepEqual(q.values,[f.peerRef.kind==="server"?f.peerRef.serverId:f.peerRef.enrollmentId]);assert(q.options?.signal instanceof AbortSignal);assert(q.options!.timeoutMs>0&&q.options!.timeoutMs<=5000)
const external=f.peerRef.kind==="external";assert(q.text.includes(external?"bandwidth_external_node_aliases":"bandwidth_node_aliases"));assert(q.text.includes(external?"$1::pg_catalog.uuid":"$1::pg_catalog.int8"));assert.deepEqual(f.proofs.map(p=>p.purpose),["claim","node",external?"external-alias":"alias",external?"external-event":"event"])
}
assert.deepEqual(fixtures[0].proofs[0],fixtures[1].proofs[0]);assert.deepEqual(fixtures[0].proofs[1],fixtures[1].proofs[1]);assert.notDeepEqual(fixtures[0].proofs[2],fixtures[1].proofs[2])
})
test("absent/duplicate snapshot, wrong SQL command and rows-only facade never auto-enroll or return a receipt",async()=>{
for(const mode of ["absent","duplicate","rows-only","wrong-command"]){const f=fixture();if(mode==="absent")f.setRows([]);if(mode==="duplicate")f.setRows([f.row(),structuredClone(f.row())]);if(mode==="rows-only")f.command(undefined);if(mode==="wrong-command")f.command("UPDATE");await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.equal(f.proofs.length,0);assert.deepEqual(f.releases,[true])}
})
test("typed evidence remains a private same-reader capability: copies, public evidence and another token refuse before checkout",async()=>{
const f=fixture();for(const token of [{...f.token},JSON.parse(JSON.stringify(f.token)),{version:2,peerRef:f.peerRef},fixture().token])await assert.rejects(f.resolver.resolve(token,scope()),refused)
assert.equal(f.connections(),0);assert.equal(f.queries.length,0)
})
test("snapshot authority/key/quiescence/status and original alias/node/event linkage are exact",async()=>{
for(const change of [
(f:ReturnType<typeof fixture>)=>{f.row().subject=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.row().installation_id=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.row().issuer_key_sha256="f".repeat(64)},(f:ReturnType<typeof fixture>)=>{f.row().quiescence_proof="f".repeat(64)},(f:ReturnType<typeof fixture>)=>{f.row().authority_status="quarantined"},(f:ReturnType<typeof fixture>)=>{f.row().status="tombstoned"},(f:ReturnType<typeof fixture>)=>{f.row().node_id=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.event().incarnation=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.event().node_id=randomUUID()},(f:ReturnType<typeof fixture>)=>{f.event().old_status="active"},(f:ReturnType<typeof fixture>)=>{f.event().kind="quarantine"},(f:ReturnType<typeof fixture>)=>{f.row().events=[]},(f:ReturnType<typeof fixture>)=>{f.row().events=[f.event(),structuredClone(f.event())]},(f:ReturnType<typeof fixture>)=>{f.row().unexpected="trusted"},
]){const f=fixture();change(f);await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])}
})
test("claim/node/managed-or-external alias/event MAC tampering cannot create a replacement identity",async()=>{
for(const kind of ["server","external"] as const)for(const field of ["claim_proof","enrollment_mac","record_mac","event_mac","authority_proof"]){const f=fixture(kind);if(field==="event_mac"||field==="authority_proof")f.event()[field]="f".repeat(64);else f.row()[field]="f".repeat(64);await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])}
})
test("source/native claim/routing epoch and original grant/key/generation/expiry drift during SELECT refuse before private proof or return",async()=>{
for(const mutate of [
(f:ReturnType<typeof fixture>)=>f.setEvidence({sourceProof:"f".repeat(64)}),
(f:ReturnType<typeof fixture>)=>f.setEvidence({claims:[{kind:"system-id",value:"CHANGED"}]}),
(f:ReturnType<typeof fixture>)=>f.setEvidence({routingEndpointEpoch:randomUUID()}),
(f:ReturnType<typeof fixture>)=>f.revoke(),
(f:ReturnType<typeof fixture>)=>f.setAuthority({issuerKeySha256:"f".repeat(64)}),
(f:ReturnType<typeof fixture>)=>f.setAuthority({authorityGeneration:"new-grant"}),
(f:ReturnType<typeof fixture>)=>f.setAuthority({expiresAt:Date.now()+120000}),
]){const f=fixture();f.onQuery(async()=>mutate(f));await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])}
})
test("the original grant is the last async guard after inspection and private signing; revocation does not admit another IO",async()=>{
for(const phase of ["inspect-after-sql","private-node-proof"]){const f=fixture();if(phase==="inspect-after-sql")f.onInspect(async()=>{if(f.queries.length)f.revoke()});else f.onProof(async purpose=>{if(purpose==="node")f.revoke()});await assert.rejects(f.resolver.resolve(f.token,scope()),refused);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true]);if(phase==="inspect-after-sql")assert.equal(f.proofs.length,0);else assert.deepEqual(f.proofs.map(p=>p.purpose),["claim","node"])}
})
test("genuine evidence is deeply immutable for authorizer/private claim proof; returned source objects cannot be rewritten",async()=>{
const f=fixture();let checked=0
f.onAuthorize(async(_count,evidence)=>{checked++;assert(Object.isFrozen(evidence));assert(Object.isFrozen(evidence.peerRef));assert(Object.isFrozen(evidence.claims));assert(evidence.claims.every(Object.isFrozen))})
await f.resolver.resolve(f.token,scope());assert(checked>2)
const hostile=fixture();hostile.onAuthorize(async(_count,evidence)=>{(evidence as unknown as Row).sourceProof="f".repeat(64)})
await assert.rejects(hostile.resolver.resolve(hostile.token,scope()),refused);assert.equal(hostile.connections(),0)
})
test("construction captures server-owned dependency methods once; later request-side field replacements cannot select a SQL/source/key callback",async()=>{
const f=fixture();const forbidden=async()=>{assert.fail("replacement callback executed")}
f.dependencies.inspect=forbidden;f.dependencies.authorize=forbidden;f.dependencies.connect=forbidden;f.dependencies.keyedProof=forbidden
assert.equal((await f.resolver.resolve(f.token,scope())).canonicalNodeId,canonicalNodeId);assert.equal(f.queries.length,1)
})
test("invalid, accessor-bearing, symbol-bearing, expired or already-aborted scopes refuse before source/SQL",async()=>{
const controller=new AbortController();controller.abort()
const inputs:unknown[]=[null,{}, {deadlineAt:NaN},{deadlineAt:Date.now()-1},{deadlineAt:Date.now()+1000,extra:true},{deadlineAt:Date.now()+1000,signal:controller.signal},{deadlineAt:Date.now()+1000,signal:{aborted:false}}]
let accessors=0;inputs.push(Object.defineProperty({},"deadlineAt",{enumerable:true,get(){accessors++;return Date.now()+1000}}));const symbolic={deadlineAt:Date.now()+1000};Object.defineProperty(symbolic,Symbol("proof"),{value:true});inputs.push(symbolic)
for(const raw of inputs){const f=fixture();await assert.rejects(f.resolver.resolve(f.token,raw as {deadlineAt:number}),refused);assert.equal(f.inspections(),0);assert.equal(f.connections(),0)}assert.equal(accessors,0)
})
test("a stalled authorizer is bounded; late successful original authority never checks out a connection",{timeout:2000},async()=>{
const f=fixture(),entered=deferred(),gate=deferred();f.onAuthorize(async()=>{entered.resolve();await gate.promise})
const pending=f.resolver.resolve(f.token,scope(60));await entered.promise;await assert.rejects(pending,refused);gate.resolve();await delay(10);assert.equal(f.connections(),0);assert.equal(f.queries.length,0)
})
test("abort during owned checkout destroys a late lease exactly once and sends no SQL",{timeout:2000},async()=>{
const f=fixture(),entered=deferred(),gate=deferred(),controller=new AbortController();f.onConnect(async()=>{entered.resolve();await gate.promise})
const pending=f.resolver.resolve(f.token,{...scope(),signal:controller.signal});await entered.promise;controller.abort();await assert.rejects(pending,refused);assert.deepEqual(f.releases,[]);gate.resolve();await delay(10);assert.deepEqual(f.releases,[true]);assert.equal(f.queries.length,0)
})
test("abort during blocked SELECT bounds the operation, destroys lease, and late rows cannot run proofs or return success",{timeout:2000},async()=>{
const f=fixture(),entered=deferred(),gate=deferred(),controller=new AbortController();f.onQuery(async()=>{entered.resolve();await gate.promise})
const pending=f.resolver.resolve(f.token,{...scope(),signal:controller.signal});await entered.promise;assert.notEqual(f.queries[0].options?.signal,controller.signal);controller.abort();await assert.rejects(pending,refused);assert.equal(f.queries[0].options?.signal?.aborted,true);assert.deepEqual(f.releases,[true]);gate.resolve();await delay(10);assert.equal(f.proofs.length,0);assert.deepEqual(f.releases,[true]);assert.equal(f.queries.length,1)
})
test("original monotonic expiry survives a 60-second wall clock rollback during blocked SQL; late result cannot renew budget",{timeout:2000},async()=>{
const f=fixture(),entered=deferred(),gate=deferred(),realNow=Date.now;f.onQuery(async()=>{entered.resolve();await gate.promise})
const began=performance.now(),pending=f.resolver.resolve(f.token,scope(100))
try{await entered.promise;Date.now=()=>realNow()-60000;await assert.rejects(pending,refused);assert(performance.now()-began<1000);assert.deepEqual(f.releases,[true]);gate.resolve();await delay(10);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1)}finally{Date.now=realNow;gate.resolve()}
})
test("an earlier inspected capability expiry reschedules the original timer and cannot be renewed by later authority",{timeout:2000},async()=>{
const f=fixture(),entered=deferred(),gate=deferred();f.setEvidence({expiresAt:Date.now()+80});f.onQuery(async()=>{entered.resolve();await gate.promise})
const pending=f.resolver.resolve(f.token,scope(1500));await entered.promise;await assert.rejects(pending,refused);assert.deepEqual(f.releases,[true]);f.setEvidence({expiresAt:Date.now()+10000});gate.resolve();await delay(10);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1)
})
test("earlier original grant expiry and captured input deadline cannot be extended while a lease or SQL is pending",{timeout:2500},async()=>{
for(const phase of ["grant-sql","input-checkout"] as const){
const f=fixture(),entered=deferred(),gate=deferred(),originalScope=scope(phase==="input-checkout"?80:1500)
if(phase==="grant-sql"){f.setAuthority({expiresAt:Date.now()+80});f.onQuery(async()=>{entered.resolve();await gate.promise})}
else f.onConnect(async()=>{entered.resolve();await gate.promise})
const pending=f.resolver.resolve(f.token,originalScope);await entered.promise;originalScope.deadlineAt=Date.now()+60000
await assert.rejects(pending,refused);f.setAuthority({expiresAt:Date.now()+60000});gate.resolve();await delay(10)
assert.equal(f.proofs.length,0);assert.equal(f.queries.length,phase==="grant-sql"?1:0);assert.deepEqual(f.releases,[true])
}
})
test("driver/source failure exposes only stable refusal, destroys lease and never retries SELECT",async()=>{
const f=fixture();f.onQuery(async()=>{throw Error("private endpoint/password/key")})
await assert.rejects(f.resolver.resolve(f.token,scope()),error=>refused(error)&&!String(error).includes("password"));assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true]);assert.equal(f.proofs.length,0)
})
test("managed/external atomic issuer uses one frozen four-material batch with identical scalar domains and linkage",async()=>{
for(const kind of ["server","external"] as const){
const f=fixture(kind),batches:Array<readonly {purpose:string;value:unknown}[]>=[]
const dependencies={...f.dependencies,keyedProofs:async(inputs:readonly Readonly<{purpose:string;value:unknown}>[],current:{deadlineAt:number;signal?:AbortSignal})=>{
assert(Object.isFrozen(inputs));assert.equal(inputs.length,4);assert(current.signal instanceof AbortSignal)
for(const input of inputs){assert(Object.isFrozen(input));assert(Object.isFrozen(input.value))}
const claims=inputs[0].value as readonly object[];assert(Object.isFrozen(claims));assert(claims.every(Object.isFrozen))
batches.push(structuredClone(inputs));return Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
}}
const resolver=createBandwidthPeerResolver(dependencies)
dependencies.keyedProofs=async()=>{assert.fail("replacement batch issuer executed")}
const receipt=await resolver.resolve(f.token,scope())
assert.equal(receipt.canonicalNodeId,canonicalNodeId);assert(Object.isFrozen(receipt));assert.equal(batches.length,1);assert.equal(f.proofs.length,0)
assert.deepEqual(batches[0].map(input=>input.purpose),["claim","node",kind==="external"?"external-alias":"alias",kind==="external"?"external-event":"event"])
const row=f.row(),event=f.event(),values=batches[0].map(input=>mac(input.purpose,input.value))
assert.deepEqual(values,[row.claim_proof,row.enrollment_mac,row.record_mac,event.event_mac]);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
assert.equal((batches[0][1].value as Row).claimProof,row.claim_proof)
}
})
test("atomic issuer rejects wrong length, mutable/sparse/accessor/symbol/nonenumerable outputs and invalid hashes without scalar fallback",async()=>{
let getterCalls=0
const outputs:Array<(values:string[])=>unknown>=[
values=>Object.freeze(values.slice(0,3)),values=>Object.freeze([...values,values[0]]),values=>values,
values=>Object.freeze([...values.slice(0,2),"g".repeat(64),values[3]]),values=>Object.freeze([...values.slice(0,2),null,values[3]]),
values=>{const result=[...values];delete result[1];return Object.freeze(result)},
values=>{const result=[...values];Object.defineProperty(result,"2",{get(){getterCalls++;return values[2]},enumerable:true});return Object.freeze(result)},
values=>{const result=[...values];Object.defineProperty(result,"2",{value:values[2],enumerable:false});return Object.freeze(result)},
values=>{const result=[...values];Object.defineProperty(result,Symbol("issuer-proof"),{value:true});return Object.freeze(result)},
]
for(const output of outputs){const f=fixture();let calls=0
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>{calls++;return output(inputs.map(input=>mac(input.purpose,input.value))) as readonly string[]}})
await assert.rejects(resolver.resolve(f.token,scope()),refused);assert.equal(calls,1);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
}
assert.equal(getterCalls,0)
})
test("atomic claim/node/alias/event MAC tampering still refuses every original material",async()=>{
for(const kind of ["server","external"] as const)for(const index of [0,1,2,3]){
const f=fixture(kind),resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>Object.freeze(inputs.map((input,i)=>i===index?"f".repeat(64):mac(input.purpose,input.value)))})
await assert.rejects(resolver.resolve(f.token,scope()),refused);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
}
})
test("atomic issuer captures parsed immutable materials before await; later driver object changes cannot rewrite them",async()=>{
const f=fixture(),entered=deferred(),gate=deferred();let inputsSeen:readonly Readonly<{purpose:string;value:unknown}>[]|undefined
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>{
inputsSeen=inputs;entered.resolve();await gate.promise
return Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
}})
const pending=resolver.resolve(f.token,scope());await entered.promise
const originalNode=(inputsSeen![1].value as Row).nodeId
f.row().node_id=randomUUID();f.row().claim_proof="f".repeat(64);f.event().authority_proof="f".repeat(64)
assert.equal((inputsSeen![1].value as Row).nodeId,originalNode)
assert.throws(()=>{(inputsSeen![1].value as Row).nodeId=randomUUID()})
gate.resolve();assert.equal((await pending).canonicalNodeId,canonicalNodeId);assert.deepEqual(f.releases,[true])
})
test("atomic post-batch original actor/key/generation/expiry and native evidence revocation cannot return a receipt",async()=>{
for(const drift of ["actor","key","generation","expiry","source"] as const){const f=fixture()
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async inputs=>{
const values=Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
if(drift==="actor")f.revoke()
if(drift==="key")f.setAuthority({issuerKeySha256:"f".repeat(64)})
if(drift==="generation")f.setAuthority({authorityGeneration:"replacement"})
if(drift==="expiry")f.setAuthority({expiresAt:Date.now()+120000})
if(drift==="source")f.setEvidence({sourceProof:"f".repeat(64)})
return values
}})
await assert.rejects(resolver.resolve(f.token,scope()),refused);assert.equal(f.proofs.length,0);assert.equal(f.queries.length,1);assert.deepEqual(f.releases,[true])
}
})
test("abort/expiry during blocked atomic issuer destroys lease once; late MACs cause zero new SQL or success",{timeout:2500},async()=>{
for(const kind of ["abort","expiry"] as const){const f=fixture(),entered=deferred(),gate=deferred(),controller=new AbortController();let calls=0,issuerScope:{signal?:AbortSignal}|undefined
const resolver=createBandwidthPeerResolver({...f.dependencies,keyedProofs:async(inputs,current)=>{
calls++;issuerScope=current;entered.resolve();await gate.promise;return Object.freeze(inputs.map(input=>mac(input.purpose,input.value)))
}})
const pending=resolver.resolve(f.token,{...scope(kind==="expiry"?80:2000),signal:controller.signal});await entered.promise
if(kind==="abort")controller.abort()
await assert.rejects(pending,refused);assert.equal(issuerScope!.signal!.aborted,true);assert.deepEqual(f.releases,[true])
gate.resolve();await delay(10);assert.equal(calls,1);assert.equal(f.queries.length,1);assert.equal(f.proofs.length,0);assert.deepEqual(f.releases,[true])
}
})