lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

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}));