commerce_envelopes.mjs (13321B)
1 // Independent, deterministic synthetic interoperability data. These public 2 // fixture scalars/nonces/auxiliary bytes must never become runtime custody. 3 import {createHash} from 'node:crypto'; 4 import {readFileSync,writeFileSync} from 'node:fs'; 5 import assert from 'node:assert/strict'; 6 import {getEventHash,getPublicKey,verifyEvent} from 'nostr-tools/pure'; 7 import {v2} from 'nostr-tools/nip44'; 8 import {schnorr} from '@noble/curves/secp256k1.js'; 9 10 const root=new URL('../../',import.meta.url); 11 const read=path=>readFileSync(new URL(path,root),'utf8'); 12 const sha=value=>createHash('sha256').update(value).digest('hex'); 13 const secret=n=>Buffer.from(BigInt(n).toString(16).padStart(64,'0'),'hex'); 14 const hex=value=>Buffer.from(value).toString('hex'); 15 const nonce=name=>Buffer.from(sha('radroots synthetic fixture nonce/'+name),'hex'); 16 const scalarFor=pub=>{for(const n of [1,2])if(getPublicKey(secret(n))===pub)return n;throw new Error('Unknown synthetic actor');}; 17 const recordsText=read('crates/protocol/tests/fixtures/commerce_wire.v1.json'); 18 const records=JSON.parse(recordsText); 19 const reference=JSON.parse(read('crates/nostr/tests/fixtures/nip44_provider.v1.json')); 20 assert.equal(v2.encrypt(reference.plaintext,v2.utils.getConversationKey(Buffer.from(reference.secret_a,'hex'),getPublicKey(Buffer.from(reference.secret_b,'hex'))),Buffer.from(reference.nonce,'hex')),reference.ciphertext); 21 22 function canonical(value) { 23 if(value===null||typeof value==='string'||typeof value==='boolean')return JSON.stringify(value); 24 if(typeof value==='number'){assert(Number.isSafeInteger(value)&&value>=0);return JSON.stringify(value);} 25 if(Array.isArray(value))return '['+value.map(canonical).join(',')+']'; 26 const keys=Object.keys(value).sort();assert(keys.every(key=>/^[\x00-\x7f]*$/.test(key))); 27 return '{'+keys.map(key=>JSON.stringify(key)+':'+canonical(value[key])).join(',')+'}'; 28 } 29 function recordWire(body) { 30 const value=structuredClone(body);delete value.record_id; 31 return canonical({...value,record_id:sha(Buffer.concat([Buffer.from('radroots.record.v1\0'),Buffer.from(canonical(value))]))}); 32 } 33 function rumor(wire,overrides={}) { 34 const body=JSON.parse(wire); 35 const value={pubkey:body.author,created_at:Number(body.created_at),kind:8890,tags:[],content:wire,...overrides}; 36 return {id:getEventHash(value),...value}; 37 } 38 function sign(value,n) { 39 const unsigned={pubkey:getPublicKey(secret(n)),created_at:value.created_at,kind:value.kind,tags:value.tags,content:value.content}; 40 const id=getEventHash(unsigned); 41 const event={id,...unsigned,sig:hex(schnorr.sign(Buffer.from(id,'hex'),secret(n),new Uint8Array(32)))}; 42 assert(verifyEvent(JSON.parse(JSON.stringify(event)))); 43 return event; 44 } 45 function encrypt(text,sender,recipient,name) { 46 const key=v2.utils.getConversationKey(secret(sender),getPublicKey(secret(recipient))); 47 const output=v2.encrypt(text,key,nonce(name)); 48 const reverse=v2.utils.getConversationKey(secret(recipient),getPublicKey(secret(sender))); 49 assert.equal(v2.decrypt(output,reverse),text); 50 return output; 51 } 52 let sequence=1000; 53 function enclose(name,rawRumor,sender,recipient,{sealMutate,outerMutate,sealAuthor=sender}={}) { 54 let seal=sign({created_at:1_700_000_000-sequence,kind:13,tags:[],content:encrypt(rawRumor,sealAuthor,recipient,name+'/rumor')},sealAuthor); 55 if(sealMutate)seal=sealMutate(seal,sealAuthor); 56 const rawSeal=JSON.stringify(seal); 57 const ephemeral=sequence++; 58 let outer=sign({created_at:1_699_999_000-sequence,kind:1059,tags:[['p',getPublicKey(secret(recipient))]],content:encrypt(rawSeal,ephemeral,recipient,name+'/seal')},ephemeral); 59 if(outerMutate)outer=outerMutate(outer,ephemeral); 60 return {name,recipient_scalar:recipient,recipient:getPublicKey(secret(recipient)),rumor_id:JSON.parse(rawRumor).id,raw_rumor:rawRumor,raw_seal:rawSeal,raw_wrap:JSON.stringify(outer)}; 61 } 62 const positives=[]; 63 for(const row of records.vectors) { 64 const body=JSON.parse(row.wire);const sender=scalarFor(body.author); 65 const peer=scalarFor(body.author===body.seller?body.buyer:body.seller); 66 const unsigned=rumor(row.wire);const raw=JSON.stringify(unsigned); 67 assert(Buffer.byteLength(row.wire)<=16384&&Buffer.byteLength(raw)<=24576); 68 for(const [copy,recipient] of [['peer',peer],['self',sender]]) { 69 const item=enclose(row.name+'/'+copy,raw,sender,recipient); 70 assert(Buffer.byteLength(item.raw_seal)<=65536&&Buffer.byteLength(item.raw_wrap)<=65536); 71 positives.push({...item,record_fixture:row.name,record_id:row.record_id,expected:{outcome:'known'}}); 72 } 73 } 74 const base=records.vectors.find(r=>r.name==='decline');assert(base); 75 const baseBody=JSON.parse(base.wire);const baseRumor=rumor(base.wire);const rawBase=JSON.stringify(baseRumor); 76 const negatives=[]; 77 function negative(name,raw=rawBase,options={},expected={outcome:'error',reason:'invalid_input'},recipient=2) { 78 const item=enclose(name,raw,1,recipient,options);negatives.push({...item,expected});return item; 79 } 80 const error=reason=>({outcome:'error',reason}); 81 const rejected=reason=>({outcome:'rejected',reason}); 82 negative('outer_id',rawBase,{outerMutate:e=>({...e,id:'00'.repeat(32)})},error('unauthenticated')); 83 negative('outer_signature',rawBase,{outerMutate:e=>({...e,sig:'00'.repeat(64)})},error('unauthenticated')); 84 negative('outer_recipient',rawBase,{outerMutate:(e,n)=>sign({...e,tags:[['p',getPublicKey(secret(3))]]},n)},error('recipient_mismatch')); 85 negative('outer_duplicate_recipient',rawBase,{outerMutate:(e,n)=>sign({...e,tags:[...e.tags,...e.tags]},n)},error('recipient_mismatch')); 86 negative('outer_missing_recipient',rawBase,{outerMutate:(e,n)=>sign({...e,tags:[]},n)},error('recipient_mismatch')); 87 negative('outer_kind',rawBase,{outerMutate:(e,n)=>sign({...e,kind:13},n)},error('carrier_mismatch')); 88 negative('outer_wide_kind',rawBase,{outerMutate:(e,n)=>sign({...e,kind:65536},n)}); 89 negative('outer_unknown_field',rawBase,{outerMutate:e=>({...e,extra:true})}); 90 negative('outer_mac',rawBase,{outerMutate:(e,n)=>{const bytes=Buffer.from(e.content,'base64');bytes[bytes.length-1]^=1;return sign({...e,content:bytes.toString('base64')},n);}},error('provider_authentication_failed')); 91 negative('outer_encryption_version',rawBase,{outerMutate:(e,n)=>{const bytes=Buffer.from(e.content,'base64');bytes[0]=3;return sign({...e,content:bytes.toString('base64')},n);}},error('unsupported_version')); 92 negative('seal_id',rawBase,{sealMutate:e=>({...e,id:'00'.repeat(32)})},error('unauthenticated')); 93 negative('seal_signature',rawBase,{sealMutate:e=>({...e,sig:'00'.repeat(64)})},error('unauthenticated')); 94 negative('seal_kind',rawBase,{sealMutate:(e,n)=>sign({...e,kind:14},n)},error('carrier_mismatch')); 95 negative('seal_tags',rawBase,{sealMutate:(e,n)=>sign({...e,tags:[['p',getPublicKey(secret(2))]]},n)},error('carrier_mismatch')); 96 negative('seal_mac',rawBase,{sealMutate:(e,n)=>{const bytes=Buffer.from(e.content,'base64');bytes[bytes.length-1]^=1;return sign({...e,content:bytes.toString('base64')},n);}},error('provider_authentication_failed')); 97 negative('seal_encryption_version',rawBase,{sealMutate:(e,n)=>{const bytes=Buffer.from(e.content,'base64');bytes[0]=3;return sign({...e,content:bytes.toString('base64')},n);}},error('unsupported_version')); 98 negative('seal_author',rawBase,{sealAuthor:3},error('carrier_mismatch')); 99 negative('rumor_id',JSON.stringify({...baseRumor,id:'00'.repeat(32)}),{},error('unauthenticated')); 100 negative('rumor_wide_kind',JSON.stringify({...baseRumor,kind:65536})); 101 negative('rumor_duplicate_field','{"kind":8890,'+rawBase.slice(1)); 102 negative('rumor_unknown_field',JSON.stringify({...baseRumor,extra:true})); 103 negative('rumor_uppercase_author',JSON.stringify({...baseRumor,pubkey:baseRumor.pubkey.toUpperCase()})); 104 negative('rumor_time_range',JSON.stringify({...baseRumor,created_at:253402300800})); 105 negative('known_rumor_tags',JSON.stringify(rumor(base.wire,{tags:[['p',getPublicKey(secret(2))]]})),{},rejected('carrier_mismatch')); 106 negative('record_identity',JSON.stringify(rumor(canonical({...baseBody,payload:{...baseBody.payload,reason:'Changed synthetic private reason'}}))),{},rejected('record_identity_mismatch')); 107 negative('record_missing_field',JSON.stringify(rumor(canonical(Object.fromEntries(Object.entries(baseBody).filter(([key])=>key!=='buyer'))),{pubkey:baseBody.author,created_at:Number(baseBody.created_at)})),{},rejected('invalid_profile')); 108 const changedTime=recordWire({...baseBody,created_at:'451'}); 109 negative('record_time',JSON.stringify(rumor(changedTime,{created_at:450})),{},rejected('carrier_mismatch')); 110 const issue=JSON.parse(records.vectors.find(r=>r.name==='issue').wire); 111 assert.notEqual(issue.buyer,baseBody.author); 112 negative('record_author',JSON.stringify(rumor(recordWire({...issue,author:issue.buyer}),{pubkey:baseBody.author,created_at:450})),{},rejected('carrier_mismatch')); 113 negative('record_recipient',rawBase,{},rejected('recipient_mismatch'),3); 114 for(const [name,content] of [ 115 ['future_profile',{profile:'future.commerce',version:1,type:'future_record',private_future:{value:'Synthetic unknown data'}}], 116 ['future_version',{profile:'radroots.commerce',version:2,type:'future_record',private_future:{value:'Synthetic unknown data'}}], 117 ['future_type',{profile:'radroots.commerce',version:1,type:'future_record',private_future:{value:'Synthetic unknown data'}}], 118 ])negative(name,JSON.stringify(rumor(JSON.stringify(content),{pubkey:baseBody.author,created_at:450})),{},{outcome:'unsupported',reason:'profile'}); 119 negative('other_rumor_kind',JSON.stringify(rumor(base.wire,{kind:14,content:'Synthetic standard chat text'})),{},{outcome:'unsupported',reason:'carrier_kind'}); 120 negative('record_limit_plus_one',JSON.stringify(rumor(records.invalid[0].wire)),{},error('limit_exceeded')); 121 122 // Independently solve complete record/rumor bounds using escaped instructions. 123 const large=JSON.parse(records.vectors.find(r=>r.name==='exact_private_record_limit').wire); 124 function fillRecord(backslashes,time) { 125 const value=structuredClone(large);value.created_at=String(time); 126 value.payload.terms.fulfillment.forEach(g=>g.terms.instructions=''); 127 const fixed=Buffer.byteLength(recordWire(value)); 128 const ascii=16384-fixed-2*backslashes; 129 if(ascii<0||ascii+backslashes>8*2048)return null; 130 let text='\\'.repeat(backslashes)+'a'.repeat(ascii); 131 for(const group of value.payload.terms.fulfillment){group.terms.instructions=text.slice(0,2048);text=text.slice(2048);} 132 assert.equal(text,'');const wire=recordWire(value);assert.equal(Buffer.byteLength(wire),16384);return wire; 133 } 134 let exactRumor=null; 135 for(const time of [45,450]) { 136 for(let k=0;k<=8192;k++) { 137 const wire=fillRecord(k,time);if(wire===null)continue; 138 const raw=JSON.stringify(rumor(wire)); 139 if(Buffer.byteLength(raw)===24576){exactRumor={wire,raw};break;} 140 if(Buffer.byteLength(raw)>24576)break; 141 } 142 if(exactRumor)break; 143 } 144 assert(exactRumor,'No independently solved complete-rumor boundary'); 145 const exact=enclose('exact_rumor_limit',exactRumor.raw,1,2); 146 positives.push({...exact,record_fixture:null,record_id:JSON.parse(exactRumor.wire).record_id,expected:{outcome:'known'}}); 147 const overflowBody=JSON.parse(exactRumor.wire); 148 const extraGroup=overflowBody.payload.terms.fulfillment.find(g=>g.terms.instructions.length<2048);assert(extraGroup); 149 extraGroup.terms.instructions+='a'; 150 negative('rumor_limit_plus_one',JSON.stringify(rumor(recordWire(overflowBody))),{},error('limit_exceeded')); 151 assert.equal(Buffer.byteLength(negatives.at(-1).raw_rumor),24577); 152 153 const outerBound=enclose('exact_outer_limit',rawBase,1,2); 154 let outer=JSON.parse(outerBound.raw_wrap);const outerScalar=sequence-1; 155 const emptyTags=Array.from({length:16},()=>['alt','']);outer=sign({...outer,tags:[...outer.tags,...emptyTags]},outerScalar); 156 let remaining=65536-Buffer.byteLength(JSON.stringify(outer));assert(remaining>0); 157 for(let i=1;i<outer.tags.length;i++){const size=Math.min(remaining,4096);outer.tags[i][1]='a'.repeat(size);remaining-=size;} 158 assert.equal(remaining,0);outer=sign(outer,outerScalar);assert.equal(Buffer.byteLength(JSON.stringify(outer)),65536); 159 positives.push({...outerBound,raw_wrap:JSON.stringify(outer),record_fixture:'decline',record_id:base.record_id,expected:{outcome:'known'}}); 160 outer.tags.find(tag=>tag[0]==='alt'&&tag[1].length<4096)[1]+='a';outer=sign(outer,outerScalar); 161 negatives.push({...outerBound,name:'outer_limit_plus_one',raw_wrap:JSON.stringify(outer),expected:error('limit_exceeded')}); 162 assert.equal(Buffer.byteLength(negatives.at(-1).raw_wrap),65537); 163 const output=JSON.stringify({schema:'radroots.commerce.envelopes.v1',producer:{library:'nostr-tools',version:'2.23.5',git:'ed47ef8ef73d78c338fbaf530e48be0fd4282194',curve:'@noble/curves@2.0.1',primary_nip44_reference_equal:true,source_records_sha256:sha(recordsText),synthetic_only:true,production_entropy_claimed:false},positives,negatives},null,2)+'\n'; 164 const target=new URL('crates/nostr/tests/fixtures/commerce_envelopes.v1.json',root); 165 const args=process.argv.slice(2);assert(args.length===1&&['--write','--check'].includes(args[0])); 166 if(args[0]==='--write')writeFileSync(target,output);else assert.equal(sha(readFileSync(target)),sha(output),'Stale independently generated envelope fixture'); 167 console.log(JSON.stringify({positive:positives.length,negative:negatives.length,bytes:Buffer.byteLength(output),sha256:sha(output),primary_nip44_reference_equal:true}));