@wowok/wowok 2.2.16 → 2.3.1

package/dist/esm/w/messenger/pq/ratchet.mjs

@@ -0,0 +1 @@
+import{PQError}from'./types.mjs';import{aesGcmDecrypt,aesGcmEncrypt,concatBytes,generateX25519KeyPair,hkdfChainKey,hkdfMessageKey,x25519DH}from'./crypto.mjs';function encodeHeader(a){const b=new Uint8Array(0x28);b['set'](a['dhPublicKey'],0x0);const c=new DataView(b['buffer']);return c['setUint32'](0x20,a['previousSendingCount'],![]),c['setUint32'](0x24,a['messageCount'],![]),b;}function decodeHeader(a){const b=a['slice'](0x0,0x20),c=new DataView(a['buffer'],a['byteOffset'],a['byteLength']);return{'dhPublicKey':b,'previousSendingCount':c['getUint32'](0x20,![]),'messageCount':c['getUint32'](0x24,![])};}function makeSkipKey(a,b){const c=new Uint8Array(a['length']+0x4);return c['set'](a,0x0),new DataView(c['buffer'])['setUint32'](a['length'],b,![]),Buffer['from'](c)['toString']('base64');}function initRatchet(a,b,c,d,e){return{'rootKey':a,'sendingChainKey':b,'sendingMessageCount':0x0,'receivingChainKey':c,'receivingMessageCount':0x0,'ourDHKeyPair':d,'peerDHPublicKey':e,'previousSendingCount':0x0,'skipMessageKeys':new Map()};}function ratchetEncrypt(a,b){const c=cloneRatchetState(a),{messageKey:d,nextChainKey:e}=hkdfMessageKey(c['sendingChainKey']);c['sendingChainKey']=e;const f=encodeHeader({'dhPublicKey':c['ourDHKeyPair']['publicKey'],'previousSendingCount':c['previousSendingCount'],'messageCount':c['sendingMessageCount']}),{ciphertext:g,iv:h,tag:i}=aesGcmEncrypt(d,b,f),j=concatBytes(f,h,i,g);return c['sendingMessageCount']+=0x1,{'message':{'type':0x1,'body':j},'newState':c};}function ratchetDecrypt(a,b){const c=0x28;if(b['length']<0x44)throw new PQError('DECRYPTION_FAILED','Message\x20body\x20too\x20short');const d=b['slice'](0x0,c),e=decodeHeader(d),f=b['slice'](c,0x34),g=b['slice'](0x34,0x44),h=b['slice'](0x44),i=cloneRatchetState(a);let j;if(i['peerDHPublicKey']&&Buffer['from'](e['dhPublicKey'])['equals'](Buffer['from'](i['peerDHPublicKey']))){if(e['messageCount']<i['receivingMessageCount']){j=trySkippedMessageKeys(i,e);if(!j)throw new PQError('DECRYPTION_FAILED','Message\x20key\x20not\x20found\x20for\x20old\x20message');}else{while(i['receivingMessageCount']<e['messageCount']){const {messageKey:m,nextChainKey:n}=hkdfMessageKey(i['receivingChainKey']),o=makeSkipKey(e['dhPublicKey'],i['receivingMessageCount']);i['skipMessageKeys']['set'](o,m),i['receivingChainKey']=n,i['receivingMessageCount']+=0x1;}const {messageKey:k,nextChainKey:l}=hkdfMessageKey(i['receivingChainKey']);j=k,i['receivingChainKey']=l,i['receivingMessageCount']+=0x1;}}else{j=trySkippedMessageKeys(i,e);if(!j){const p=dhRatchetStep(i,e);Object['assign'](i,p['newState']),j=p['messageKey'];}}return{'plaintext':aesGcmDecrypt(j,h,f,g,d),'newState':i};}function dhRatchetStep(a,b){a['previousSendingCount']=a['sendingMessageCount'];const c=x25519DH(a['ourDHKeyPair']['privateKey'],b['dhPublicKey']),{rootKey:d,chainKey:e}=hkdfChainKey(a['rootKey'],c),f=generateX25519KeyPair(),{rootKey:g,chainKey:h}=hkdfChainKey(d,x25519DH(f['privateKey'],b['dhPublicKey'])),{messageKey:i}=hkdfMessageKey(e);return{'messageKey':i,'newState':{'rootKey':g,'sendingChainKey':e,'sendingMessageCount':0x0,'receivingChainKey':h,'receivingMessageCount':0x1,'ourDHKeyPair':f,'peerDHPublicKey':b['dhPublicKey'],'previousSendingCount':b['previousSendingCount']}};}function trySkippedMessageKeys(a,b){const c=makeSkipKey(b['dhPublicKey'],b['messageCount']),d=a['skipMessageKeys']['get'](c);if(d)return a['skipMessageKeys']['delete'](c),d;return null;}function cloneRatchetState(a){return{'rootKey':new Uint8Array(a['rootKey']),'sendingChainKey':new Uint8Array(a['sendingChainKey']),'sendingMessageCount':a['sendingMessageCount'],'receivingChainKey':new Uint8Array(a['receivingChainKey']),'receivingMessageCount':a['receivingMessageCount'],'ourDHKeyPair':{'publicKey':new Uint8Array(a['ourDHKeyPair']['publicKey']),'privateKey':new Uint8Array(a['ourDHKeyPair']['privateKey'])},'peerDHPublicKey':a['peerDHPublicKey']?new Uint8Array(a['peerDHPublicKey']):null,'previousSendingCount':a['previousSendingCount'],'skipMessageKeys':new Map(a['skipMessageKeys'])};}function serializeRatchetState(a){const b={};for(const [c,d]of a['skipMessageKeys'])b[c]=Buffer['from'](d)['toString']('base64');return{'rootKey':Buffer['from'](a['rootKey'])['toString']('base64'),'sendingChainKey':Buffer['from'](a['sendingChainKey'])['toString']('base64'),'sendingMessageCount':a['sendingMessageCount'],'receivingChainKey':Buffer['from'](a['receivingChainKey'])['toString']('base64'),'receivingMessageCount':a['receivingMessageCount'],'ourDHPrivateKey':Buffer['from'](a['ourDHKeyPair']['privateKey'])['toString']('base64'),'ourDHPublicKey':Buffer['from'](a['ourDHKeyPair']['publicKey'])['toString']('base64'),'peerDHPublicKey':a['peerDHPublicKey']?Buffer['from'](a['peerDHPublicKey'])['toString']('base64'):null,'previousSendingCount':a['previousSendingCount'],'skipMessageKeys':b};}function deserializeRatchetState(a){const b=new Map();for(const [c,d]of Object['entries'](a['skipMessageKeys']))b['set'](c,new Uint8Array(Buffer['from'](d,'base64')));return{'rootKey':new Uint8Array(Buffer['from'](a['rootKey'],'base64')),'sendingChainKey':new Uint8Array(Buffer['from'](a['sendingChainKey'],'base64')),'sendingMessageCount':a['sendingMessageCount'],'receivingChainKey':new Uint8Array(Buffer['from'](a['receivingChainKey'],'base64')),'receivingMessageCount':a['receivingMessageCount'],'ourDHKeyPair':{'publicKey':new Uint8Array(Buffer['from'](a['ourDHPublicKey'],'base64')),'privateKey':new Uint8Array(Buffer['from'](a['ourDHPrivateKey'],'base64'))},'peerDHPublicKey':a['peerDHPublicKey']?new Uint8Array(Buffer['from'](a['peerDHPublicKey'],'base64')):null,'previousSendingCount':a['previousSendingCount'],'skipMessageKeys':b};}export{deserializeRatchetState,initRatchet,ratchetDecrypt,ratchetEncrypt,serializeRatchetState};

package/dist/esm/w/messenger/pq/session.d.mts

@@ -0,0 +1,46 @@
+import { EncryptedMessage, MLKEMKeyPair, PQIdentity, PQPreKeyBundle, SerializedPQSessionState, X25519KeyPair } from "./types.mjs";
+import { t as GeneratedPreKeyBundle } from "../../../pqxdh-CKkqzvPb.mjs";
+
+//#region src/w/messenger/pq/session.d.ts
+interface PQSessionStore {
+  getIdentityKeyPair(): Promise<X25519KeyPair | null>;
+  setIdentityKeyPair(keyPair: X25519KeyPair): Promise<void>;
+  getRegistrationId(): Promise<number | null>;
+  setRegistrationId(id: number): Promise<void>;
+  getSignedPreKey(keyId: number): Promise<X25519KeyPair | null>;
+  setSignedPreKey(keyId: number, keyPair: X25519KeyPair): Promise<void>;
+  getSignedPreKeySignature(keyId: number): Promise<Uint8Array | null>;
+  setSignedPreKeySignature(keyId: number, sig: Uint8Array): Promise<void>;
+  getOneTimePreKey(keyId: number): Promise<X25519KeyPair | null>;
+  setOneTimePreKey(keyId: number, keyPair: X25519KeyPair): Promise<void>;
+  removeOneTimePreKey(keyId: number): Promise<void>;
+  getPQPreKey(keyId: number): Promise<MLKEMKeyPair | null>;
+  setPQPreKey(keyId: number, keyPair: MLKEMKeyPair): Promise<void>;
+  getPQPreKeySignature(keyId: number): Promise<Uint8Array | null>;
+  setPQPreKeySignature(keyId: number, sig: Uint8Array): Promise<void>;
+  getSession(peerAddress: string, peerDeviceId: number): Promise<SerializedPQSessionState | null>;
+  setSession(peerAddress: string, peerDeviceId: number, state: SerializedPQSessionState): Promise<void>;
+  removeSession(peerAddress: string, peerDeviceId: number): Promise<void>;
+  getPeerIdentity(peerAddress: string): Promise<Uint8Array | null>;
+  setPeerIdentity(peerAddress: string, identityKey: Uint8Array): Promise<void>;
+}
+declare class PQSessionCipher {
+  private store;
+  private identity;
+  private getFalcon512KeyPair;
+  constructor(store: PQSessionStore, getFalcon512KeyPair?: () => Promise<{
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+  }>);
+  ensureIdentity(): Promise<PQIdentity>;
+  generatePreKeyBundle(signedPreKeyId: number, pqPreKeyId: number, oneTimePreKeyCount: number): Promise<GeneratedPreKeyBundle>;
+  processPreKeyBundle(peerAddress: string, peerDeviceId: number, bundle: PQPreKeyBundle): Promise<void>;
+  processInitialMessage(peerAddress: string, peerDeviceId: number, ephemeralPublicKey: Uint8Array, mlkemCiphertext: Uint8Array, peerIdentityKey: Uint8Array, signedPreKeyId: number, oneTimePreKeyId: number | null, pqPreKeyId: number): Promise<void>;
+  encryptMessage(peerAddress: string, plaintext: Uint8Array, peerDeviceId?: number): Promise<EncryptedMessage>;
+  decryptMessage(peerAddress: string, messageBody: Uint8Array, peerDeviceId?: number): Promise<Uint8Array>;
+  hasSession(peerAddress: string, peerDeviceId?: number): Promise<boolean>;
+  private loadSession;
+  private saveSession;
+}
+//#endregion
+export { PQSessionCipher, PQSessionStore };

package/dist/esm/w/messenger/pq/session.mjs

@@ -0,0 +1 @@
+import{PQError}from'./types.mjs';import{base64ToBytes,bytesToBase64,concatBytes,deriveRegistrationId,generateX25519KeyPair}from'./crypto.mjs';import{generatePreKeyBundle,pqxdhInitiate,pqxdhReceive,verifyPreKeyBundle}from'./pqxdh.mjs';import{deserializeRatchetState,initRatchet,ratchetDecrypt,ratchetEncrypt,serializeRatchetState}from'./ratchet.mjs';import{packChunk}from'./erasure.mjs';import{deserializeSPQRState,initSPQR,serializeSPQRState,spqrGetNextChunk,spqrOnPeerPQPKReceived,spqrReceiveChunk}from'./spqr.mjs';var PQSessionCipher=class{constructor(a,b){this['identity']=null,this['store']=a,this['getFalcon512KeyPair']=b||(async()=>{throw new PQError('HANDSHAKE_FAILED','Falcon512\x20key\x20pair\x20not\x20available\x20for\x20signing');});}async['ensureIdentity'](){if(this['identity'])return this['identity'];let a=await this['store']['getIdentityKeyPair'](),b=await this['store']['getRegistrationId']();return(!a||!b)&&(a=generateX25519KeyPair(),b=deriveRegistrationId(a['publicKey']),await this['store']['setIdentityKeyPair'](a),await this['store']['setRegistrationId'](b)),this['identity']={'x25519KeyPair':a,'registrationId':b},this['identity'];}async['generatePreKeyBundle'](a,b,c){const d=await this['ensureIdentity'](),e=await this['getFalcon512KeyPair'](),f=generatePreKeyBundle(d['x25519KeyPair'],e,a,b,c);await this['store']['setSignedPreKey'](a,f['signedPreKey']['keyPair']),await this['store']['setSignedPreKeySignature'](a,f['signedPreKey']['signature']);for(const g of f['oneTimePreKeys'])await this['store']['setOneTimePreKey'](g['keyId'],g['keyPair']);return await this['store']['setPQPreKey'](b,f['pqPreKey']['keyPair']),await this['store']['setPQPreKeySignature'](b,f['pqPreKey']['signature']),f;}async['processPreKeyBundle'](a,b,c){const d=await this['ensureIdentity']();if(!verifyPreKeyBundle(c))throw new PQError('HANDSHAKE_FAILED','PreKey\x20bundle\x20signature\x20verification\x20failed');const e=pqxdhInitiate(d['x25519KeyPair'],c),f={'pqxdhComplete':!![],'ratchetState':initRatchet(e['result']['rootKey'],e['result']['chainKey'],new Uint8Array(0x20),e['result']['ourDHKeyPair'],e['result']['peerDHPublicKey']),'spqrState':initSPQR(),'peerIdentityKey':c['identityKey'],'peerRegistrationId':c['registrationId'],'peerDeviceId':b,'pendingInitialMessage':{'ephemeralPublicKey':e['initialMessage']['ephemeralPublicKey'],'mlkemCiphertext':e['initialMessage']['mlkemCiphertext'],'identityKey':e['initialMessage']['identityKey'],'signedPreKeyId':c['signedPreKey']['keyId'],'oneTimePreKeyId':c['oneTimePreKey']?.['keyId']??null,'pqPreKeyId':c['pqPreKey']['keyId']}};await this['store']['setPeerIdentity'](a,c['identityKey']),await this['saveSession'](a,b,f);}async['processInitialMessage'](a,b,c,d,e,f,g,h){const i=await this['ensureIdentity'](),j=await this['store']['getSignedPreKey'](f);if(!j)throw new PQError('HANDSHAKE_FAILED','Signed\x20pre-key\x20not\x20found');let k=null;if(g!==null){k=await this['store']['getOneTimePreKey'](g);if(k)await this['store']['removeOneTimePreKey'](g);}const l=await this['store']['getPQPreKey'](h);if(!l)throw new PQError('HANDSHAKE_FAILED','PQ\x20pre-key\x20not\x20found');const m=pqxdhReceive(i['x25519KeyPair'],j,k,l,c,e,d),n={'pqxdhComplete':!![],'ratchetState':initRatchet(m['rootKey'],new Uint8Array(0x20),m['chainKey'],m['ourDHKeyPair'],m['peerDHPublicKey']),'spqrState':initSPQR(),'peerIdentityKey':e,'peerRegistrationId':0x0,'peerDeviceId':b};await this['store']['setPeerIdentity'](a,e),await this['saveSession'](a,b,n);}async['encryptMessage'](a,b,c=0x1){const d=await this['loadSession'](a,c);if(!d)throw new PQError('SESSION_NOT_FOUND','No\x20session\x20established');const {message:e,newState:f}=ratchetEncrypt(d['ratchetState'],b),g=f['sendingMessageCount']+f['previousSendingCount'],{chunk:h,newState:i}=spqrGetNextChunk(d['spqrState'],g);let j;if(h){const l=packChunk(h);j=concatBytes(new Uint8Array([0x1]),e['body'],l);}else j=concatBytes(new Uint8Array([0x0]),e['body']);const k=d['pendingInitialMessage']!==void 0x0;if(d['pendingInitialMessage']){const m=d['pendingInitialMessage'],n=m['oneTimePreKeyId']??0xffffffff,o=new Uint8Array(0x48c),p=new DataView(o['buffer']);o['set'](m['ephemeralPublicKey'],0x0),o['set'](m['mlkemCiphertext'],0x20),o['set'](m['identityKey'],0x460),p['setUint32'](0x480,m['signedPreKeyId'],![]),p['setUint32'](0x484,n,![]),p['setUint32'](0x488,m['pqPreKeyId'],![]),j=concatBytes(o,j),d['pendingInitialMessage']=void 0x0;}return d['ratchetState']=f,d['spqrState']=i,await this['saveSession'](a,c,d),{'type':k?0x3:0x1,'body':j};}async['decryptMessage'](a,b,c=0x1){const d=0x48c;let e=await this['loadSession'](a,c);if(!e&&b['length']>=d){const m=new DataView(b['buffer'],b['byteOffset'],b['byteLength']),n=b['slice'](0x0,0x20),o=b['slice'](0x20,0x460),p=b['slice'](0x460,0x480),q=m['getUint32'](0x480,![]),r=m['getUint32'](0x484,![]),s=m['getUint32'](0x488,![]),t=r===0xffffffff?null:r;await this['processInitialMessage'](a,c,n,o,p,q,t,s),b=b['slice'](d),e=await this['loadSession'](a,c);}if(!e)throw new PQError('SESSION_NOT_FOUND','No\x20session\x20established');if(b['length']<0x1)throw new PQError('DECRYPTION_FAILED','Message\x20body\x20too\x20short');const f=b[0x0]===0x1,g=b['slice'](0x1);let h=null;if(f){if(g['length']<0x34)throw new PQError('DECRYPTION_FAILED','SPQR\x20chunk\x20missing');h=g['slice'](g['length']-0x34);}const i=f?g['slice'](0x0,g['length']-0x34):g,{plaintext:j,newState:k}=ratchetDecrypt(e['ratchetState'],i);let l=e['spqrState'];if(h){const u=spqrReceiveChunk(l,h);l=u['newState'];if(u['shouldSendCT']&&u['peerPQPK'])l=spqrOnPeerPQPKReceived(l,u['peerPQPK'])['newState'];}return e['ratchetState']=k,e['spqrState']=l,await this['saveSession'](a,c,e),j;}async['hasSession'](a,b=0x1){const c=await this['loadSession'](a,b);return c!==null&&c['pqxdhComplete'];}async['loadSession'](a,b){const c=await this['store']['getSession'](a,b);if(!c)return null;const d={'pqxdhComplete':c['pqxdhComplete'],'ratchetState':deserializeRatchetState(c['ratchetState']),'spqrState':deserializeSPQRState(c['spqrState']),'peerIdentityKey':base64ToBytes(c['peerIdentityKey']),'peerRegistrationId':c['peerRegistrationId'],'peerDeviceId':c['peerDeviceId']};if(c['pendingInitialMessage'])d['pendingInitialMessage']={'ephemeralPublicKey':base64ToBytes(c['pendingInitialMessage']['ephemeralPublicKey']),'mlkemCiphertext':base64ToBytes(c['pendingInitialMessage']['mlkemCiphertext']),'identityKey':base64ToBytes(c['pendingInitialMessage']['identityKey']),'signedPreKeyId':c['pendingInitialMessage']['signedPreKeyId'],'oneTimePreKeyId':c['pendingInitialMessage']['oneTimePreKeyId'],'pqPreKeyId':c['pendingInitialMessage']['pqPreKeyId']};return d;}async['saveSession'](a,b,c){const d={'pqxdhComplete':c['pqxdhComplete'],'ratchetState':serializeRatchetState(c['ratchetState']),'spqrState':serializeSPQRState(c['spqrState']),'peerIdentityKey':bytesToBase64(c['peerIdentityKey']),'peerRegistrationId':c['peerRegistrationId'],'peerDeviceId':c['peerDeviceId']};if(c['pendingInitialMessage'])d['pendingInitialMessage']={'ephemeralPublicKey':bytesToBase64(c['pendingInitialMessage']['ephemeralPublicKey']),'mlkemCiphertext':bytesToBase64(c['pendingInitialMessage']['mlkemCiphertext']),'identityKey':bytesToBase64(c['pendingInitialMessage']['identityKey']),'signedPreKeyId':c['pendingInitialMessage']['signedPreKeyId'],'oneTimePreKeyId':c['pendingInitialMessage']['oneTimePreKeyId'],'pqPreKeyId':c['pendingInitialMessage']['pqPreKeyId']};await this['store']['setSession'](a,b,d);}};export{PQSessionCipher};

package/dist/esm/w/messenger/pq/spqr.d.mts

@@ -0,0 +1,27 @@
+import { SPQRChunk, SPQRState, SerializedSPQRState } from "./types.mjs";
+
+//#region src/w/messenger/pq/spqr.d.ts
+declare function initSPQR(): SPQRState;
+declare function spqrGetNextChunk(state: SPQRState, messageCount: number): {
+  chunk: SPQRChunk | null;
+  newState: SPQRState;
+};
+declare function spqrProcessReceivedChunks(state: SPQRState, chunks: SPQRChunk[]): {
+  newState: SPQRState;
+  completed: boolean;
+};
+declare function spqrOnPeerPQPKReceived(state: SPQRState, peerPQPK: Uint8Array): {
+  newState: SPQRState;
+  ctChunks: Uint8Array[];
+};
+declare function spqrReceiveChunk(state: SPQRState, packedChunk: Uint8Array): {
+  newState: SPQRState;
+  peerPQPKReady: boolean;
+  peerPQPK: Uint8Array | null;
+  shouldSendCT: boolean;
+};
+declare function spqrGetCurrentKey(state: SPQRState): Uint8Array;
+declare function serializeSPQRState(state: SPQRState): SerializedSPQRState;
+declare function deserializeSPQRState(serialized: SerializedSPQRState): SPQRState;
+//#endregion
+export { deserializeSPQRState, initSPQR, serializeSPQRState, spqrGetCurrentKey, spqrGetNextChunk, spqrOnPeerPQPKReceived, spqrProcessReceivedChunks, spqrReceiveChunk };

package/dist/esm/w/messenger/pq/spqr.mjs

@@ -0,0 +1 @@
+import{MLKEM_CIPHERTEXT_SIZE,MLKEM_PUBLIC_KEY_SIZE}from'./types.mjs';import{concatBytes,generateMLKEMKeyPair,hkdfDerive,mlkemDecapsulate,mlkemEncapsulate}from'./crypto.mjs';import{decodeShards,encodeShards,unpackChunk}from'./erasure.mjs';const SPQR_CYCLE_INTERVAL=0x32;function initSPQR(){return{'cycleId':0x0,'sendingPQKeys':null,'sendingChunks':[],'sendingChunkIndex':0x0,'sendingPhase':'idle','receivedChunks':new Map(),'receivingPhase':'idle','expectedTotalChunks':0x0,'receivedSharedSecret':null,'currentSPQRKey':new Uint8Array(0x20),'spqrChainKey':new Uint8Array(0x20),'spqrMessageCount':0x0};}function spqrGetNextChunk(a,b){const c=cloneSPQRState(a);c['sendingPhase']==='idle'&&b>0x0&&b%SPQR_CYCLE_INTERVAL===0x0&&(c['cycleId']+=0x1,c['sendingPQKeys']=generateMLKEMKeyPair(),c['sendingPhase']='sending_pk',c['sendingChunks']=encodeShards(c['sendingPQKeys']['publicKey']),c['sendingChunkIndex']=0x0);if(c['sendingPhase']==='idle')return{'chunk':null,'newState':c};if(c['sendingChunkIndex']>=c['sendingChunks']['length']){if(c['sendingPhase']==='sending_pk')c['sendingPhase']='waiting_for_ct',c['sendingChunkIndex']=0x0,c['sendingChunks']=[];else{if(c['sendingPhase']==='sending_ct_pk')return c['sendingPhase']='idle',c['sendingPQKeys']=null,c['sendingChunks']=[],c['sendingChunkIndex']=0x0,{'chunk':null,'newState':c};}}if(c['sendingPhase']==='waiting_for_ct')return{'chunk':null,'newState':c};const d=c['sendingChunks'][c['sendingChunkIndex']],e={'cycleId':c['cycleId'],'chunkIndex':c['sendingChunkIndex'],'totalChunks':c['sendingChunks']['length'],'data':d};return c['sendingChunkIndex']+=0x1,{'chunk':e,'newState':c};}function spqrProcessReceivedChunks(a,b){const c=cloneSPQRState(a);for(const d of b){c['receivingPhase']==='idle'&&(c['receivingPhase']='receiving_ct',c['expectedTotalChunks']=d['totalChunks'],c['receivedChunks']=new Map());if(d['cycleId']!==c['cycleId'])continue;c['receivedChunks']['set'](d['chunkIndex'],d['data']);}if(c['receivingPhase']==='receiving_ct'&&c['receivedChunks']['size']>=0x1c){const e=decodeShards(c['receivedChunks'],c['expectedTotalChunks'])['slice'](0x0,MLKEM_CIPHERTEXT_SIZE);if(c['sendingPQKeys']){const f=mlkemDecapsulate(e,c['sendingPQKeys']['secretKey']);return c['receivedSharedSecret']=f,c['currentSPQRKey']=hkdfDerive(concatBytes(c['currentSPQRKey'],f),new TextEncoder()['encode']('WowokSPQRUpdate'),0x20),c['receivingPhase']='done',c['receivedChunks']=new Map(),{'newState':c,'completed':!![]};}}return{'newState':c,'completed':![]};}function spqrOnPeerPQPKReceived(a,b){const c=cloneSPQRState(a),{ciphertext:d,sharedSecret:e}=mlkemEncapsulate(b);c['currentSPQRKey']=hkdfDerive(concatBytes(c['currentSPQRKey'],e),new TextEncoder()['encode']('WowokSPQRUpdate'),0x20);const f=encodeShards(d);return c['sendingChunks']=f,c['sendingChunkIndex']=0x0,c['sendingPhase']='sending_ct_pk',{'newState':c,'ctChunks':f};}function spqrReceiveChunk(a,b){const c=cloneSPQRState(a),d=unpackChunk(b);c['receivingPhase']==='idle'&&(c['receivingPhase']='receiving_pk',c['expectedTotalChunks']=d['totalChunks'],c['receivedChunks']=new Map(),c['cycleId']=d['cycleId']);if(d['cycleId']!==c['cycleId'])return{'newState':c,'peerPQPKReady':![],'peerPQPK':null,'shouldSendCT':![]};c['receivedChunks']['set'](d['chunkIndex'],d['data']);if(c['receivingPhase']==='receiving_pk'&&c['receivedChunks']['size']>=0x1c){const e=decodeShards(c['receivedChunks'],c['expectedTotalChunks'])['slice'](0x0,MLKEM_PUBLIC_KEY_SIZE);return c['receivingPhase']='receiving_ct',c['receivedChunks']=new Map(),{'newState':c,'peerPQPKReady':!![],'peerPQPK':e,'shouldSendCT':!![]};}if(c['receivingPhase']==='receiving_ct'&&c['receivedChunks']['size']>=0x1c){const f=decodeShards(c['receivedChunks'],c['expectedTotalChunks'])['slice'](0x0,MLKEM_CIPHERTEXT_SIZE);if(c['sendingPQKeys']){const g=mlkemDecapsulate(f,c['sendingPQKeys']['secretKey']);c['currentSPQRKey']=hkdfDerive(concatBytes(c['currentSPQRKey'],g),new TextEncoder()['encode']('WowokSPQRUpdate'),0x20),c['receivingPhase']='done',c['receivedChunks']=new Map(),c['sendingPQKeys']=null,c['sendingPhase']='idle',c['sendingChunks']=[],c['sendingChunkIndex']=0x0;}return{'newState':c,'peerPQPKReady':![],'peerPQPK':null,'shouldSendCT':![]};}return{'newState':c,'peerPQPKReady':![],'peerPQPK':null,'shouldSendCT':![]};}function spqrGetCurrentKey(a){return a['currentSPQRKey'];}function cloneSPQRState(a){return{'cycleId':a['cycleId'],'sendingPQKeys':a['sendingPQKeys']?{'publicKey':new Uint8Array(a['sendingPQKeys']['publicKey']),'secretKey':new Uint8Array(a['sendingPQKeys']['secretKey'])}:null,'sendingChunks':a['sendingChunks']['map'](b=>new Uint8Array(b)),'sendingChunkIndex':a['sendingChunkIndex'],'sendingPhase':a['sendingPhase'],'receivedChunks':new Map(a['receivedChunks']),'receivingPhase':a['receivingPhase'],'expectedTotalChunks':a['expectedTotalChunks'],'receivedSharedSecret':a['receivedSharedSecret']?new Uint8Array(a['receivedSharedSecret']):null,'currentSPQRKey':new Uint8Array(a['currentSPQRKey']),'spqrChainKey':new Uint8Array(a['spqrChainKey']),'spqrMessageCount':a['spqrMessageCount']};}function serializeSPQRState(a){const b={};for(const [c,d]of a['receivedChunks'])b[c['toString']()]=Buffer['from'](d)['toString']('base64');return{'cycleId':a['cycleId'],'sendingPQPublicKey':a['sendingPQKeys']?Buffer['from'](a['sendingPQKeys']['publicKey'])['toString']('base64'):null,'sendingPQSecretKey':a['sendingPQKeys']?Buffer['from'](a['sendingPQKeys']['secretKey'])['toString']('base64'):null,'sendingChunks':a['sendingChunks']['map'](e=>Buffer['from'](e)['toString']('base64')),'sendingChunkIndex':a['sendingChunkIndex'],'sendingPhase':a['sendingPhase'],'receivedChunks':b,'receivingPhase':a['receivingPhase'],'expectedTotalChunks':a['expectedTotalChunks'],'receivedSharedSecret':a['receivedSharedSecret']?Buffer['from'](a['receivedSharedSecret'])['toString']('base64'):null,'currentSPQRKey':Buffer['from'](a['currentSPQRKey'])['toString']('base64'),'spqrChainKey':Buffer['from'](a['spqrChainKey'])['toString']('base64'),'spqrMessageCount':a['spqrMessageCount']};}function deserializeSPQRState(a){const b=new Map();for(const [c,d]of Object['entries'](a['receivedChunks']))b['set'](parseInt(c),new Uint8Array(Buffer['from'](d,'base64')));return{'cycleId':a['cycleId'],'sendingPQKeys':a['sendingPQPublicKey']&&a['sendingPQSecretKey']?{'publicKey':new Uint8Array(Buffer['from'](a['sendingPQPublicKey'],'base64')),'secretKey':new Uint8Array(Buffer['from'](a['sendingPQSecretKey'],'base64'))}:null,'sendingChunks':a['sendingChunks']['map'](e=>new Uint8Array(Buffer['from'](e,'base64'))),'sendingChunkIndex':a['sendingChunkIndex'],'sendingPhase':a['sendingPhase'],'receivedChunks':b,'receivingPhase':a['receivingPhase'],'expectedTotalChunks':a['expectedTotalChunks'],'receivedSharedSecret':a['receivedSharedSecret']?new Uint8Array(Buffer['from'](a['receivedSharedSecret'],'base64')):null,'currentSPQRKey':new Uint8Array(Buffer['from'](a['currentSPQRKey'],'base64')),'spqrChainKey':new Uint8Array(Buffer['from'](a['spqrChainKey'],'base64')),'spqrMessageCount':a['spqrMessageCount']};}export{deserializeSPQRState,initSPQR,serializeSPQRState,spqrGetCurrentKey,spqrGetNextChunk,spqrOnPeerPQPKReceived,spqrProcessReceivedChunks,spqrReceiveChunk};

package/dist/esm/w/messenger/pq/store-adapter.d.mts

@@ -0,0 +1,35 @@
+import { MLKEMKeyPair, SerializedPQSessionState, X25519KeyPair } from "./types.mjs";
+import { PQSessionStore } from "./session.mjs";
+import Database from "libsql";
+
+//#region src/w/messenger/pq/store-adapter.d.ts
+declare class PQSessionStoreAdapter implements PQSessionStore {
+  private db;
+  private userAddress;
+  constructor(db: Database.Database, userAddress: string);
+  private getValue;
+  private putValue;
+  private delValue;
+  getIdentityKeyPair(): Promise<X25519KeyPair | null>;
+  setIdentityKeyPair(keyPair: X25519KeyPair): Promise<void>;
+  getRegistrationId(): Promise<number | null>;
+  setRegistrationId(id: number): Promise<void>;
+  getSignedPreKey(keyId: number): Promise<X25519KeyPair | null>;
+  setSignedPreKey(keyId: number, keyPair: X25519KeyPair): Promise<void>;
+  getSignedPreKeySignature(keyId: number): Promise<Uint8Array | null>;
+  setSignedPreKeySignature(keyId: number, sig: Uint8Array): Promise<void>;
+  getOneTimePreKey(keyId: number): Promise<X25519KeyPair | null>;
+  setOneTimePreKey(keyId: number, keyPair: X25519KeyPair): Promise<void>;
+  removeOneTimePreKey(keyId: number): Promise<void>;
+  getPQPreKey(keyId: number): Promise<MLKEMKeyPair | null>;
+  setPQPreKey(keyId: number, keyPair: MLKEMKeyPair): Promise<void>;
+  getPQPreKeySignature(keyId: number): Promise<Uint8Array | null>;
+  setPQPreKeySignature(keyId: number, sig: Uint8Array): Promise<void>;
+  getSession(peerAddress: string, peerDeviceId: number): Promise<SerializedPQSessionState | null>;
+  setSession(peerAddress: string, peerDeviceId: number, state: SerializedPQSessionState): Promise<void>;
+  removeSession(peerAddress: string, peerDeviceId: number): Promise<void>;
+  getPeerIdentity(peerAddress: string): Promise<Uint8Array | null>;
+  setPeerIdentity(peerAddress: string, identityKey: Uint8Array): Promise<void>;
+}
+//#endregion
+export { PQSessionStoreAdapter };

package/dist/esm/w/messenger/pq/store-adapter.mjs

@@ -0,0 +1 @@
+const PQ_STORE_PREFIX='pq';function arrayBufferToBase64(a){return Buffer['from'](a)['toString']('base64');}function base64ToUint8Array(a){return new Uint8Array(Buffer['from'](a,'base64'));}var PQSessionStoreAdapter=class{constructor(a,b){this['db']=a,this['userAddress']=b;}['getValue'](a){return this['db']['prepare']('SELECT\x20value\x20FROM\x20signal_store\x20WHERE\x20store_type\x20=\x20?\x20AND\x20key\x20=\x20?')['get'](PQ_STORE_PREFIX,a)?.['value'];}['putValue'](a,b){this['db']['prepare']('INSERT\x20INTO\x20signal_store\x20(store_type,\x20key,\x20value,\x20updated_at)\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x20VALUES\x20(?,\x20?,\x20?,\x20strftime(\x27%s\x27,\x20\x27now\x27))\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x20ON\x20CONFLICT(store_type,\x20key)\x20DO\x20UPDATE\x20SET\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20value\x20=\x20excluded.value,\x0a\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20updated_at\x20=\x20excluded.updated_at')['run'](PQ_STORE_PREFIX,a,b);}['delValue'](a){this['db']['prepare']('DELETE\x20FROM\x20signal_store\x20WHERE\x20store_type\x20=\x20?\x20AND\x20key\x20=\x20?')['run'](PQ_STORE_PREFIX,a);}async['getIdentityKeyPair'](){const a=this['getValue']('identity_x25519');if(!a)return null;const b=JSON['parse'](a);return{'publicKey':base64ToUint8Array(b['pubKey']),'privateKey':base64ToUint8Array(b['privKey'])};}async['setIdentityKeyPair'](a){const b={'pubKey':arrayBufferToBase64(a['publicKey']),'privKey':arrayBufferToBase64(a['privateKey'])};this['putValue']('identity_x25519',JSON['stringify'](b));}async['getRegistrationId'](){const a=this['getValue']('registration_id');return a?parseInt(a,0xa):null;}async['setRegistrationId'](a){this['putValue']('registration_id',a['toString']());}async['getSignedPreKey'](a){const b=this['getValue']('signed_prekey:'+a);if(!b)return null;const c=JSON['parse'](b);return{'publicKey':base64ToUint8Array(c['pubKey']),'privateKey':base64ToUint8Array(c['privKey'])};}async['setSignedPreKey'](a,b){const c={'pubKey':arrayBufferToBase64(b['publicKey']),'privKey':arrayBufferToBase64(b['privateKey'])};this['putValue']('signed_prekey:'+a,JSON['stringify'](c));}async['getSignedPreKeySignature'](a){const b=this['getValue']('signed_prekey_sig:'+a);return b?base64ToUint8Array(b):null;}async['setSignedPreKeySignature'](a,b){this['putValue']('signed_prekey_sig:'+a,arrayBufferToBase64(b));}async['getOneTimePreKey'](a){const b=this['getValue']('onetime_prekey:'+a);if(!b)return null;const c=JSON['parse'](b);return{'publicKey':base64ToUint8Array(c['pubKey']),'privateKey':base64ToUint8Array(c['privKey'])};}async['setOneTimePreKey'](a,b){const c={'pubKey':arrayBufferToBase64(b['publicKey']),'privKey':arrayBufferToBase64(b['privateKey'])};this['putValue']('onetime_prekey:'+a,JSON['stringify'](c));}async['removeOneTimePreKey'](a){this['delValue']('onetime_prekey:'+a);}async['getPQPreKey'](a){const b=this['getValue']('pq_prekey:'+a);if(!b)return null;const c=JSON['parse'](b);return{'publicKey':base64ToUint8Array(c['pubKey']),'secretKey':base64ToUint8Array(c['secKey'])};}async['setPQPreKey'](a,b){const c={'pubKey':arrayBufferToBase64(b['publicKey']),'secKey':arrayBufferToBase64(b['secretKey'])};this['putValue']('pq_prekey:'+a,JSON['stringify'](c));}async['getPQPreKeySignature'](a){const b=this['getValue']('pq_prekey_sig:'+a);return b?base64ToUint8Array(b):null;}async['setPQPreKeySignature'](a,b){this['putValue']('pq_prekey_sig:'+a,arrayBufferToBase64(b));}async['getSession'](a,b){const c='session:'+a+'.'+b,d=this['getValue'](c);if(!d)return null;return JSON['parse'](d);}async['setSession'](a,b,c){const d='session:'+a+'.'+b;this['putValue'](d,JSON['stringify'](c));}async['removeSession'](a,b){const c='session:'+a+'.'+b;this['delValue'](c);}async['getPeerIdentity'](a){const b=this['getValue']('peer_identity:'+a);return b?base64ToUint8Array(b):null;}async['setPeerIdentity'](a,b){this['putValue']('peer_identity:'+a,arrayBufferToBase64(b));}};export{PQSessionStoreAdapter};

package/dist/esm/w/messenger/pq/types.d.mts

@@ -0,0 +1,189 @@
+//#region src/w/messenger/pq/types.d.ts
+/**
+ * PQ (Post-Quantum) 密码学类型定义
+ *
+ * 基于 @noble/post-quantum (MIT) 实现 Signal Protocol 兼容的
+ * PQXDH 握手 + Triple Ratchet (SPQR) 端到端加密
+ */
+interface KeyPair {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+}
+interface X25519KeyPair {
+  publicKey: Uint8Array;
+  privateKey: Uint8Array;
+}
+interface Falcon512KeyPair {
+  publicKey: Uint8Array;
+  privateKey: Uint8Array;
+}
+interface MLKEMKeyPair {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+}
+interface PQPreKeyBundle {
+  registrationId: number;
+  deviceId: number;
+  identityKey: Uint8Array;
+  falcon512PublicKey: Uint8Array;
+  signedPreKey: {
+    keyId: number;
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+  };
+  oneTimePreKey?: {
+    keyId: number;
+    publicKey: Uint8Array;
+  };
+  pqPreKey: {
+    keyId: number;
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+  };
+}
+interface PQXDHResult {
+  rootKey: Uint8Array;
+  chainKey: Uint8Array;
+  ourDHKeyPair: X25519KeyPair;
+  peerDHPublicKey: Uint8Array;
+  peerIdentityKey: Uint8Array;
+  pqSharedSecret: Uint8Array;
+}
+interface RatchetState {
+  rootKey: Uint8Array;
+  sendingChainKey: Uint8Array;
+  sendingMessageCount: number;
+  receivingChainKey: Uint8Array;
+  receivingMessageCount: number;
+  ourDHKeyPair: X25519KeyPair;
+  peerDHPublicKey: Uint8Array | null;
+  previousSendingCount: number;
+  skipMessageKeys: Map<string, Uint8Array>;
+}
+interface EncryptedMessage {
+  type: MessageType;
+  body: Uint8Array;
+  registrationId?: number;
+}
+declare enum MessageType {
+  PREKEY_MESSAGE = 3,
+  NORMAL_MESSAGE = 1
+}
+type SPQRPhase = "idle" | "sending_pk" | "waiting_for_ct" | "sending_ct_pk" | "done";
+type SPQRReceivePhase = "idle" | "receiving_pk" | "receiving_ct" | "done";
+interface SPQRState {
+  cycleId: number;
+  sendingPQKeys: MLKEMKeyPair | null;
+  sendingChunks: Uint8Array[];
+  sendingChunkIndex: number;
+  sendingPhase: SPQRPhase;
+  receivedChunks: Map<number, Uint8Array>;
+  receivingPhase: SPQRReceivePhase;
+  expectedTotalChunks: number;
+  receivedSharedSecret: Uint8Array | null;
+  currentSPQRKey: Uint8Array;
+  spqrChainKey: Uint8Array;
+  spqrMessageCount: number;
+}
+interface SPQRChunk {
+  cycleId: number;
+  chunkIndex: number;
+  totalChunks: number;
+  data: Uint8Array;
+}
+interface PQSessionState {
+  pqxdhComplete: boolean;
+  ratchetState: RatchetState;
+  spqrState: SPQRState;
+  peerIdentityKey: Uint8Array;
+  peerRegistrationId: number;
+  peerDeviceId: number;
+  pendingInitialMessage?: {
+    ephemeralPublicKey: Uint8Array;
+    mlkemCiphertext: Uint8Array;
+    identityKey: Uint8Array;
+    signedPreKeyId: number;
+    oneTimePreKeyId: number | null;
+    pqPreKeyId: number;
+  };
+}
+interface PQIdentity {
+  x25519KeyPair: X25519KeyPair;
+  registrationId: number;
+}
+interface SerializedRatchetState {
+  rootKey: string;
+  sendingChainKey: string;
+  sendingMessageCount: number;
+  receivingChainKey: string;
+  receivingMessageCount: number;
+  ourDHPrivateKey: string;
+  ourDHPublicKey: string;
+  peerDHPublicKey: string | null;
+  previousSendingCount: number;
+  skipMessageKeys: Record<string, string>;
+}
+interface SerializedSPQRState {
+  cycleId: number;
+  sendingPQPublicKey: string | null;
+  sendingPQSecretKey: string | null;
+  sendingChunks: string[];
+  sendingChunkIndex: number;
+  sendingPhase: string;
+  receivedChunks: Record<string, string>;
+  receivingPhase: string;
+  expectedTotalChunks: number;
+  receivedSharedSecret: string | null;
+  currentSPQRKey: string;
+  spqrChainKey: string;
+  spqrMessageCount: number;
+}
+interface SerializedPQSessionState {
+  pqxdhComplete: boolean;
+  ratchetState: SerializedRatchetState;
+  spqrState: SerializedSPQRState;
+  peerIdentityKey: string;
+  peerRegistrationId: number;
+  peerDeviceId: number;
+  pendingInitialMessage?: {
+    ephemeralPublicKey: string;
+    mlkemCiphertext: string;
+    identityKey: string;
+    signedPreKeyId: number;
+    oneTimePreKeyId: number | null;
+    pqPreKeyId: number;
+  };
+}
+declare enum PQErrorCode {
+  INVALID_KEY = "INVALID_KEY",
+  HANDSHAKE_FAILED = "HANDSHAKE_FAILED",
+  ENCRYPTION_FAILED = "ENCRYPTION_FAILED",
+  DECRYPTION_FAILED = "DECRYPTION_FAILED",
+  SESSION_NOT_FOUND = "SESSION_NOT_FOUND",
+  SPQR_ERROR = "SPQR_ERROR",
+  ERASURE_ERROR = "ERASURE_ERROR",
+  SERIALIZATION_ERROR = "SERIALIZATION_ERROR"
+}
+declare class PQError extends Error {
+  code: PQErrorCode;
+  constructor(code: PQErrorCode, message: string);
+}
+declare const DEFAULT_DEVICE_ID = 1;
+declare const ROOT_KEY_SIZE = 32;
+declare const CHAIN_KEY_SIZE = 32;
+declare const MESSAGE_KEY_SIZE = 32;
+declare const DH_KEY_SIZE = 32;
+declare const SIGNATURE_SIZE = 666;
+declare const MLKEM_PUBLIC_KEY_SIZE = 1184;
+declare const MLKEM_SECRET_KEY_SIZE = 2400;
+declare const MLKEM_CIPHERTEXT_SIZE = 1088;
+declare const MLKEM_SHARED_SECRET_SIZE = 32;
+declare const AES_GCM_IV_SIZE = 12;
+declare const AES_GCM_TAG_SIZE = 16;
+declare const SPQR_CHUNK_DATA_SIZE = 34;
+declare const SPQR_CHUNK_HEADER_SIZE = 8;
+declare const SPQR_CHUNK_SIZE: number;
+declare const SPQR_DATA_CHUNKS = 28;
+declare const SPQR_TOTAL_CHUNKS = 56;
+//#endregion
+export { AES_GCM_IV_SIZE, AES_GCM_TAG_SIZE, CHAIN_KEY_SIZE, DEFAULT_DEVICE_ID, DH_KEY_SIZE, EncryptedMessage, Falcon512KeyPair, KeyPair, MESSAGE_KEY_SIZE, MLKEMKeyPair, MLKEM_CIPHERTEXT_SIZE, MLKEM_PUBLIC_KEY_SIZE, MLKEM_SECRET_KEY_SIZE, MLKEM_SHARED_SECRET_SIZE, MessageType, PQError, PQErrorCode, PQIdentity, PQPreKeyBundle, PQSessionState, PQXDHResult, ROOT_KEY_SIZE, RatchetState, SIGNATURE_SIZE, SPQRChunk, SPQRPhase, SPQRReceivePhase, SPQRState, SPQR_CHUNK_DATA_SIZE, SPQR_CHUNK_HEADER_SIZE, SPQR_CHUNK_SIZE, SPQR_DATA_CHUNKS, SPQR_TOTAL_CHUNKS, SerializedPQSessionState, SerializedRatchetState, SerializedSPQRState, X25519KeyPair };

package/dist/esm/w/messenger/pq/types.mjs

@@ -0,0 +1 @@
+let MessageType=function(a){return a[a['PREKEY_MESSAGE']=0x3]='PREKEY_MESSAGE',a[a['NORMAL_MESSAGE']=0x1]='NORMAL_MESSAGE',a;}({}),PQErrorCode=function(a){return a['INVALID_KEY']='INVALID_KEY',a['HANDSHAKE_FAILED']='HANDSHAKE_FAILED',a['ENCRYPTION_FAILED']='ENCRYPTION_FAILED',a['DECRYPTION_FAILED']='DECRYPTION_FAILED',a['SESSION_NOT_FOUND']='SESSION_NOT_FOUND',a['SPQR_ERROR']='SPQR_ERROR',a['ERASURE_ERROR']='ERASURE_ERROR',a['SERIALIZATION_ERROR']='SERIALIZATION_ERROR',a;}({});var PQError=class extends Error{constructor(a,b){super(b),this['code']=a,this['name']='PQError';}};const DEFAULT_DEVICE_ID=0x1,ROOT_KEY_SIZE=0x20,CHAIN_KEY_SIZE=0x20,MESSAGE_KEY_SIZE=0x20,DH_KEY_SIZE=0x20,SIGNATURE_SIZE=0x29a,MLKEM_PUBLIC_KEY_SIZE=0x4a0,MLKEM_SECRET_KEY_SIZE=0x960,MLKEM_CIPHERTEXT_SIZE=0x440,MLKEM_SHARED_SECRET_SIZE=0x20,AES_GCM_IV_SIZE=0xc,AES_GCM_TAG_SIZE=0x10,SPQR_CHUNK_DATA_SIZE=0x22,SPQR_CHUNK_HEADER_SIZE=0x8,SPQR_CHUNK_SIZE=0x2a,SPQR_DATA_CHUNKS=0x1c,SPQR_TOTAL_CHUNKS=0x38;export{AES_GCM_IV_SIZE,AES_GCM_TAG_SIZE,CHAIN_KEY_SIZE,DEFAULT_DEVICE_ID,DH_KEY_SIZE,MESSAGE_KEY_SIZE,MLKEM_CIPHERTEXT_SIZE,MLKEM_PUBLIC_KEY_SIZE,MLKEM_SECRET_KEY_SIZE,MLKEM_SHARED_SECRET_SIZE,MessageType,PQError,PQErrorCode,ROOT_KEY_SIZE,SIGNATURE_SIZE,SPQR_CHUNK_DATA_SIZE,SPQR_CHUNK_HEADER_SIZE,SPQR_CHUNK_SIZE,SPQR_DATA_CHUNKS,SPQR_TOTAL_CHUNKS};

package/dist/esm/w/messenger/storage.d.mts

@@ -0,0 +1,256 @@
+import { Wn as SessionState, hn as Message, wn as MessengerConfig } from "../../index-D8z18cO-.mjs";
+import Database from "libsql";
+
+//#region src/w/messenger/storage.d.ts
+type KeyPairType = {
+  pubKey: ArrayBuffer;
+  privKey: ArrayBuffer;
+};
+interface StorageType {
+  getIdentityKeyPair(): Promise<KeyPairType | undefined>;
+  getLocalRegistrationId(): Promise<number | undefined>;
+  isTrustedIdentity(identifier: string, identityKey: ArrayBuffer, direction?: number): Promise<boolean>;
+  saveIdentity(encodedAddress: string, publicKey: ArrayBuffer): Promise<boolean>;
+  loadIdentity(address: string): Promise<ArrayBuffer | undefined>;
+  loadPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+  storePreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+  removePreKey(keyId: string | number): Promise<void>;
+  loadSignedPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+  storeSignedPreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+  removeSignedPreKey(keyId: string | number): Promise<void>;
+  loadSession(encodedAddress: string): Promise<string | undefined>;
+  storeSession(encodedAddress: string, record: string): Promise<void>;
+  removeSession(encodedAddress: string): Promise<void>;
+}
+declare function getDatabase(userAddress: string): Database.Database;
+/**
+ * 重置数据库连接
+ * 用于测试时清理数据后重新创建连接
+ */
+declare function resetDbConnection(): void;
+interface PersistedMeta {
+  nextPreKeyId: number;
+}
+/**
+ * Signal Protocol SQLite 存储
+ * 兼容 libsignal-protocol-typescript 的 StorageType 接口
+ */
+declare class SignalProtocolStorage implements StorageType {
+  private storePrefix;
+  private userAddress;
+  constructor(userAddress: string, storeType?: string);
+  private get db();
+  setIdentity(identity: KeyPairType, registrationId: number): Promise<void>;
+  getIdentityKeyPair(): Promise<KeyPairType | undefined>;
+  getLocalRegistrationId(): Promise<number | undefined>;
+  isTrustedIdentity(identifier: string, identityKey: ArrayBuffer): Promise<boolean>;
+  saveIdentity(encodedAddress: string, publicKey: ArrayBuffer): Promise<boolean>;
+  loadIdentity(address: string): Promise<ArrayBuffer | undefined>;
+  loadPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+  storePreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+  removePreKey(keyId: string | number): Promise<void>;
+  loadSignedPreKey(keyId: string | number): Promise<KeyPairType | undefined>;
+  storeSignedPreKey(keyId: string | number, keyPair: KeyPairType): Promise<void>;
+  removeSignedPreKey(keyId: string | number): Promise<void>;
+  loadSignedPreKeyWithSignature(keyId: string | number): Promise<(KeyPairType & {
+    signature: ArrayBuffer;
+  }) | undefined>;
+  storeSignedPreKeyWithSignature(keyId: string | number, keyPair: KeyPairType, signature: ArrayBuffer): Promise<void>;
+  /**
+   * 【核心改进】加载会话，支持发送/接收会话映射
+   * encodedAddress 格式: "peerAddress.deviceId"
+   * 我们会同时检查默认key和带前缀的key
+   */
+  loadSession(encodedAddress: string): Promise<string | undefined>;
+  /**
+   * 【关键修复】保存会话时，如果是默认key格式，同时保存到接收会话key
+   * 这样Signal Protocol的SessionCipher保存的会话可以被我们的recv:key找到
+   */
+  storeSession(encodedAddress: string, record: string): Promise<void>;
+  /**
+   * 【关键修复】删除会话时，同时删除对应的recv:key
+   */
+  removeSession(encodedAddress: string): Promise<void>;
+  getMeta(): Promise<PersistedMeta>;
+  setMeta(meta: Partial<PersistedMeta>): Promise<void>;
+  listPreKeys(): number[];
+  private getValue;
+  private putValue;
+  private delValue;
+}
+declare class MessageStorage {
+  private userAddress;
+  constructor(userAddress: string);
+  private get db();
+  saveMessage(message: Message): void;
+  getMessage(messageId: string): Message | undefined;
+  getMessagesBySession(myAddress: string, peerAddress: string): Message[];
+  getPendingMessages(myAddress: string): Message[];
+  updateMessageStatus(messageId: string, status: Message["status"], updates?: Partial<Message>): void;
+  /**
+   * 更新消息查看状态
+   * 将消息标记为已查看，设置 viewed_at 为当前时间戳
+   *
+   * @param messageId 消息 ID
+   * @param viewedAt 查看时间戳（可选，默认当前时间）
+   * @returns 是否更新成功
+   */
+  updateMessageViewed(messageId: string, viewedAt?: number): boolean;
+  /**
+   * 批量更新消息查看状态
+   *
+   * @param messageIds 消息 ID 列表
+   * @param viewedAt 查看时间戳（可选，默认当前时间）
+   * @returns 成功更新的消息数量
+   */
+  updateMessagesViewed(messageIds: string[], viewedAt?: number): number;
+  /**
+   * 获取用户的所有消息
+   *
+   * @param userAddress 用户地址
+   * @returns 所有相关消息（发送和接收的）
+   */
+  getAllMessages(userAddress: string): Message[];
+  /**
+   * 通过消息 ID 获取消息
+   *
+   * @param messageId 消息 ID
+   * @returns 消息对象或 undefined
+   */
+  getMessageById(messageId: string): Message | undefined;
+  /**
+   * 更新消息 ID（用于 Guard 消息确认后更新 messageId）
+   *
+   * 由于 message_id 是主键，需要通过删除旧记录并插入新记录来实现
+   *
+   * @param oldMessageId 旧消息 ID（internal_id）
+   * @param newMessageId 新消息 ID（正式的 message_id）
+   * @param updates 可选的更新字段
+   * @returns 是否成功更新
+   */
+  updateMessageId(oldMessageId: string, newMessageId: string, updates?: Partial<Message>): boolean;
+  private rowToMessage;
+  /**
+   * 获取最后收到的消息序号（用于消息同步确认）
+   *
+   * 查询指定会话中，用户作为接收者时，发送者最后收到的消息序号
+   * 用于在发送新消息时，告诉对方我已经收到了哪些消息
+   *
+   * @param myAddress 当前用户地址
+   * @param peerAddress 对方地址
+   * @returns 最后收到的消息序号（leafIndex），如果没有则返回 -1
+   */
+  getLastReceivedLeafIndex(myAddress: string, peerAddress: string): number;
+}
+declare class SessionStateStorage {
+  private userAddress;
+  constructor(userAddress: string);
+  private get db();
+  private getSessionId;
+  getSessionState(myAddress: string, peerAddress: string): SessionState | undefined;
+  updateSessionState(myAddress: string, peerAddress: string, updates: Partial<Omit<SessionState, "sessionId" | "myAddress" | "peerAddress">>): void;
+  getCurrentRoot(myAddress: string, peerAddress: string): string;
+}
+interface PersistedMessengerState {
+  /** 版本 */
+  version: string;
+  /** 管理的账号列表（名称或地址） */
+  accounts: string[];
+  /** Messenger 配置 */
+  config: Partial<MessengerConfig>;
+  /** 最后更新时间 */
+  updatedAt: number;
+}
+/**
+ * MessengerManager 持久化存储类
+ *
+ * 使用 SQLite 存储 MessengerManager 的配置和状态
+ */
+declare class MessengerPersistStorage {
+  private initialized;
+  private get db();
+  /**
+   * 初始化存储表
+   */
+  private initTable;
+  /**
+   * 保存 Messenger 配置和账号信息
+   *
+   * @param instanceId 实例标识（用于区分不同的 MessengerManager 实例）
+   * @param state 要保存的状态
+   */
+  saveState(instanceId: string, state: PersistedMessengerState): void;
+  /**
+   * 加载 Messenger 配置和账号信息
+   *
+   * @param instanceId 实例标识
+   * @returns 保存的状态，如果不存在返回 null
+   */
+  loadState(instanceId: string): PersistedMessengerState | null;
+  /**
+   * 删除保存的状态
+   *
+   * @param instanceId 实例标识
+   */
+  deleteState(instanceId: string): void;
+  /**
+   * 获取所有实例ID列表
+   */
+  getAllInstanceIds(): string[];
+  private get processId();
+  /**
+   * 尝试获取指定账号的 SSE 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   * @returns 是否成功获取锁
+   */
+  tryAcquireSSELock(accountAddress: string, instanceId: string): boolean;
+  /**
+   * 更新 SSE 连接锁的心跳
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   */
+  updateSSELockHeartbeat(accountAddress: string, instanceId: string): void;
+  /**
+   * 释放指定账号的 SSE 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   */
+  releaseSSELock(accountAddress: string, instanceId: string): void;
+  /**
+   * 检查是否持有指定账号的 SSE 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   * @returns 是否持有锁
+   */
+  holdsSSELock(accountAddress: string, instanceId: string): boolean;
+  /**
+   * 尝试获取指定账号的 Polling 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   * @returns 是否成功获取锁
+   */
+  tryAcquirePollingLock(accountAddress: string, instanceId: string): boolean;
+  /**
+   * 更新 Polling 连接锁的心跳
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   */
+  updatePollingLockHeartbeat(accountAddress: string, instanceId: string): void;
+  /**
+   * 释放指定账号的 Polling 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   */
+  releasePollingLock(accountAddress: string, instanceId: string): void;
+  /**
+   * 检查是否持有指定账号的 Polling 连接锁
+   * @param accountAddress 账号地址
+   * @param instanceId 当前实例ID
+   * @returns 是否持有锁
+   */
+  holdsPollingLock(accountAddress: string, instanceId: string): boolean;
+}
+declare const defaultPersistStorage: MessengerPersistStorage;
+//#endregion
+export { MessageStorage, MessengerPersistStorage, PersistedMessengerState, SessionStateStorage, SignalProtocolStorage, defaultPersistStorage, getDatabase, resetDbConnection };