@leofcoin/chain 1.10.19 → 1.10.21

package/README.md

@@ -6,4 +6,21 @@
 
 - reachedOneZeroZero
 
+## Pending transaction propagation
+
+Transactions enter the local pending pool before canonical confirmation. Peers
+relay newly accepted transaction bytes using the existing `add-transaction`
+topic; duplicate and already-confirmed entries are not relayed again.
+
+On compatible peer reconnection, pending pools are reconciled even at equal
+block heights. Missing bodies are fetched from `transactionPool`, checked against
+their advertised hash, and admitted through the normal signature-validation and
+pending-nonce path. Unavailable or invalid entries are logged without preventing
+recovery of the remaining entries.
+
+Pool admission and pubsub publication are not validator acknowledgements.
+`sendTransaction().wait` resolves only after canonical block inclusion. Deploy
+the updated chain runtime to intermediate nodes and validators as well as the
+browser to enable relay and reconnect recovery throughout the network.
+
 <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/"><img alt="Creative Commons Licence" style="border-width:0" src="https://i.creativecommons.org/l/by-nc/4.0/88x31.png" /></a><br />This work is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc/4.0/">Creative Commons Attribution-NonCommercial 4.0 International License</a>.

package/exports/browser/{browser-CCfR9KOM-CpStHgTj.js → browser-CCfR9KOM-BGMMnVsR.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './node-browser-BNe-en1l.js';
+import { g as getDefaultExportFromCjs } from './node-browser-Ha4Lvntj.js';
 import './browser-crypto-CH0ua22L.js';
 import './index-CvKt4UDE.js';
 import './sha2-BKcEJzgd.js';

package/exports/browser/chain.js

@@ -3164,7 +3164,7 @@ class Transaction extends Protocol {
       await globalThis.transactionPoolStore.put(hash, message.encoded);
       this.addPendingNonce(message.decoded.from, message.decoded.nonce);
       try {
-        peernet.publish("add-transaction", message.encoded);
+        await peernet.publish("add-transaction", message.encoded);
       } catch (publishError) {
         console.warn("peernet publish failed: add-transaction", publishError?.message ?? publishError);
       }
@@ -6077,39 +6077,29 @@ class Chain extends VersionControl {
   }
   async getPeerTransactionPool(peer) {
     let transactionsInPool = await this.#makeRequest(peer, "transactionPool");
-    console.log("raw response for request transactionPool:", transactionsInPool);
     if (transactionsInPool instanceof Uint8Array) {
-      try {
-        transactionsInPool = JSON.parse(new TextDecoder().decode(transactionsInPool));
-      } catch {
-        debug("transactionPool response must be decoded array payload");
-        return [];
-      }
+      transactionsInPool = new TextDecoder().decode(transactionsInPool);
     }
     if (typeof transactionsInPool === "string") {
-      try {
-        transactionsInPool = JSON.parse(transactionsInPool);
-      } catch {
-        return [];
-      }
+      transactionsInPool = JSON.parse(transactionsInPool);
     }
-    if (!Array.isArray(transactionsInPool)) return [];
-    const localTransactions = new Set(await globalThis.transactionPoolStore.keys());
-    const transactionsToGet = [];
-    for (const key of transactionsInPool) {
-      if (!localTransactions.has(key)) {
-        let txData;
-        try {
-          txData = await globalThis.peernet.get(key, "transaction");
-        } catch (error) {
-          debug(`Failed to get transaction ${key}:`, error?.message ?? error);
-        }
-        if (txData !== void 0) {
-          transactionsToGet.push(transactionPoolStore.put(key, txData));
-        }
+    if (!Array.isArray(transactionsInPool) || transactionsInPool.some((hash) => typeof hash !== "string")) {
+      throw new Error("transactionPool response must be an array of transaction hashes");
+    }
+    const recovered = [];
+    for (const hash of new Set(transactionsInPool)) {
+      if (await globalThis.transactionPoolStore.has(hash)) continue;
+      if (await globalThis.transactionStore.has(hash)) continue;
+      try {
+        const txData = await globalThis.peernet.get(hash, "transactionPool");
+        if (txData === void 0) throw new Error("pending transaction body unavailable");
+        const transaction = await resolveTransactionReference(hash, txData);
+        recovered.push(await this.#sendTransaction(transaction));
+      } catch (error) {
+        debug(`Failed to recover transaction ${hash}:`, error?.message ?? error);
       }
     }
-    return Promise.all(transactionsToGet);
+    return recovered;
   }
   async #peerConnected(peerId) {
     if (typeof peerId !== "string" || !peerId.trim() || peerId === "undefined") {
@@ -6177,6 +6167,14 @@ class Chain extends VersionControl {
       await this.#recordPeerFailure(peerId, `unreasonable lastBlock index: ${lastBlock.index}`);
       return;
     }
+    setTimeout(async () => {
+      try {
+        await this.getPeerTransactionPool(peer);
+      } catch (error) {
+        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
+        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
+      }
+    }, 3e3);
     if (!lastBlock || !lastBlock.hash || lastBlock.hash === "0x0") {
       debug(`peer has no lastBlock: ${peerId}`);
       return;
@@ -6216,15 +6214,6 @@ class Chain extends VersionControl {
       }
       if (this.wantList.length === 0) await this.triggerSync();
     }
-    setTimeout(async () => {
-      try {
-        const peerTransactionPool = higherThenCurrentLocal && await this.getPeerTransactionPool(peer) || [];
-        if (this.#participating && peerTransactionPool.length > 0) return this.#runEpoch();
-      } catch (error) {
-        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
-      }
-    }, 3e3);
     try {
       let stateInfo = await this.#makeRequest(peer, "stateInfo");
       if (stateInfo instanceof Uint8Array) {
@@ -6601,18 +6590,32 @@ class Chain extends VersionControl {
     await this.validateTransactionSignature(transaction);
     let hash;
     try {
+      hash = await transaction.hash();
+      if (await globalThis.transactionStore.has(hash)) return hash;
+      const alreadyPending = await globalThis.transactionPoolStore.has(hash);
       hash = await enqueueTransaction(transaction, {
         putToPool: (txHash, data) => globalThis.transactionPoolStore.put(txHash, data),
         hasInPool: (txHash) => globalThis.transactionPoolStore.has(txHash),
         hasInStore: (txHash) => globalThis.transactionStore.has(txHash),
         addPendingNonce: (address, nonce) => this.addPendingNonce(address, nonce)
       });
-      if (this.#participating && !this.#runningEpoch) this.#runEpoch();
+      if (!alreadyPending) {
+        try {
+          await globalThis.peernet.publish("add-transaction", transaction.encoded);
+        } catch (publishError) {
+          debug("peernet publish failed: add-transaction relay", publishError?.message ?? publishError);
+        }
+      }
+      if (this.#participating && !this.#runningEpoch) {
+        void this.#runEpoch().catch((error) => {
+          debug("transaction epoch scheduling failed:", error?.message ?? error);
+        });
+      }
       return hash;
     } catch (e) {
       if (hash) {
         try {
-          globalThis.peernet.publish("invalid-transaction", hash);
+          await globalThis.peernet.publish("invalid-transaction", hash);
         } catch (publishError) {
           debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
         }
@@ -6630,7 +6633,7 @@ class Chain extends VersionControl {
     const event = await super.sendTransaction(transactionMessage);
     await this.#sendTransaction(transactionMessage.encoded);
     try {
-      globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
+      await globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
     } catch (publishError) {
       debug("peernet publish failed: send-transaction", publishError?.message ?? publishError);
     }

package/exports/browser/{client-C_pBoi1g-_pfKzCvX.js → client-DKKzPSlb-C_1ug6ux.js}

@@ -1,4 +1,4 @@
-import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-BNe-en1l.js';
+import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-Ha4Lvntj.js';
 import './browser-crypto-CH0ua22L.js';
 import './connection-monitor-D-krNiRH.js';
 import './index-CvKt4UDE.js';
@@ -233,7 +233,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-CCfR9KOM-CpStHgTj.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-CCfR9KOM-BGMMnVsR.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);

package/exports/browser/{index-dTQVgkpf-BbdshWB0.js → index-dTQVgkpf-DOL2rIjp.js}

@@ -1,4 +1,4 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-BNe-en1l.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-Ha4Lvntj.js';
 import './browser-crypto-CH0ua22L.js';
 import './connection-monitor-D-krNiRH.js';
 import './index-CvKt4UDE.js';

package/exports/browser/{messages-BGHaihSi-eHZVl0y9.js → messages-DCePyqKC-BSvJxDWZ.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface } from './node-browser-BNe-en1l.js';
+import { F as FormatInterface } from './node-browser-Ha4Lvntj.js';
 import './browser-crypto-CH0ua22L.js';
 import './connection-monitor-D-krNiRH.js';
 import './index-CvKt4UDE.js';

package/exports/browser/{node-browser-BNe-en1l.js → node-browser-Ha4Lvntj.js}

@@ -524,7 +524,7 @@ const concatAndDoubleHash = async (input) => {
     return new Uint8Array(await createDoubleHash(typedArrayConcat(input), 'SHA-256'));
 };
 
-const encode$2 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
+const encode$2$1 = async (source, prefix = new TextEncoder().encode('00'), hex) => {
     if (!(source instanceof Uint8Array) || !(prefix instanceof Uint8Array)) {
         throw new TypeError('Expected Uint8Array');
     }
@@ -568,10 +568,10 @@ const isBase58check = (string, hex) => {
         return false;
     }
 };
-const encodeHex$1 = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$2(uint8Array, prefix, true);
+const encodeHex$1 = (uint8Array, prefix = new TextEncoder().encode('00')) => encode$2$1(uint8Array, prefix, true);
 const decodeHex$1 = (string) => decode$3(string, true);
 const isBase58checkHex = (string) => isBase58check(string, true);
-var base58check = { encode: encode$2, decode: decode$3, encodeHex: encodeHex$1, decodeHex: decodeHex$1, isBase58check, isBase58checkHex };
+var base58check = { encode: encode$2$1, decode: decode$3, encodeHex: encodeHex$1, decodeHex: decodeHex$1, isBase58check, isBase58checkHex };
 
 /** @leofcoin/binary: dependency-free unsigned framing, with no global byte counters. */
 const MAX_BIGINT = (1n << 256n) - 1n;
@@ -798,7 +798,7 @@ var index$3 = (input, prefix) => encodeFrames(input.map(asBytes));
 
 var index$2 = (typedArray, prefix) => decodeFrames(typedArray, 0, { canonical: false });
 
-const decode$2 = (multiWif, expectedVersion, expectedCodec) => {
+const decode$2$1 = (multiWif, expectedVersion, expectedCodec) => {
     const decoded = base58$1.decode(multiWif);
     let [version, codec, privateKey] = index$2(decoded);
     version = Number(new TextDecoder().decode(version));
@@ -817,10 +817,10 @@ var index$1$1 = {
             privateKey
         ]));
     },
-    decode: decode$2,
+    decode: decode$2$1,
     isMultiWif: (multiWif) => {
         try {
-            const { version, codec, privateKey } = decode$2(multiWif);
+            const { version, codec, privateKey } = decode$2$1(multiWif);
             if (version === undefined)
                 return false;
             if (codec === undefined)
@@ -8510,7 +8510,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-BbdshWB0.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-dTQVgkpf-DOL2rIjp.js');
             const { identity, accounts } = await importee.default(password, this.network);
             if (fresh) {
                 await globalThis.accountStore.clear();
@@ -8573,12 +8573,12 @@ class Identity {
     }
 }
 
-const encode$1 = (string) => {
+const encode$2 = (string) => {
     if (typeof string === 'string')
         return new TextEncoder().encode(string);
     throw Error(`expected typeof String instead got ${string}`);
 };
-const decode$1 = (uint8Array) => {
+const decode$2 = (uint8Array) => {
     if (uint8Array instanceof Uint8Array)
         return new TextDecoder().decode(uint8Array);
     throw Error(`expected typeof uint8Array instead got ${uint8Array}`);
@@ -8589,7 +8589,7 @@ class KeyPath {
     uint8Array;
     constructor(input) {
         if (typeof input === 'string') {
-            this.uint8Array = encode$1(input);
+            this.uint8Array = encode$2(input);
         }
         else if (input instanceof Uint8Array) {
             this.uint8Array = input;
@@ -8605,7 +8605,7 @@ class KeyPath {
         return true;
     }
     toString() {
-        return decode$1(this.uint8Array);
+        return decode$2(this.uint8Array);
     }
     /**
      * Returns the `list` representation of this path.
@@ -8625,7 +8625,7 @@ class KeyValue {
     uint8Array;
     constructor(input) {
         if (typeof input === 'string') {
-            this.uint8Array = encode$1(input);
+            this.uint8Array = encode$2(input);
         }
         else if (input instanceof Uint8Array) {
             this.uint8Array = input;
@@ -8641,7 +8641,7 @@ class KeyValue {
         return true;
     }
     toString() {
-        return decode$1(this.uint8Array);
+        return decode$2(this.uint8Array);
     }
 }
 
@@ -15734,23 +15734,23 @@ const getTokens = (proto) => {
     return tokens;
 };
 
-const encoder = new TextEncoder();
+const encoder$1 = new TextEncoder();
 const toType = (data) => {
     if (data instanceof Uint8Array)
         return data;
     if (data instanceof ArrayBuffer)
         return new Uint8Array(data);
     if (typeof data === 'bigint')
-        return encoder.encode(data.toString());
+        return encoder$1.encode(data.toString());
     if (typeof data === 'string')
-        return encoder.encode(data);
+        return encoder$1.encode(data);
     if (typeof data === 'object')
-        return encoder.encode(JSON.stringify(data, jsonStringifyBigInt$1));
+        return encoder$1.encode(JSON.stringify(data, jsonStringifyBigInt$1));
     if (typeof data === 'number' || typeof data === 'boolean')
-        return encoder.encode(data.toString());
+        return encoder$1.encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
-const encode = (proto, input, compress) => {
+const encode$1 = (proto, input, compress) => {
     const tokens = getTokens(proto);
     const set = [];
     for (let i = 0; i < tokens.length; i++) {
@@ -15807,8 +15807,8 @@ var index$1 = {
     toString: toString$1};
 
 const { toString } = index$1;
-const decoder = new TextDecoder();
-const decode = (proto, uint8Array, compressed) => {
+const decoder$1 = new TextDecoder();
+const decode$1 = (proto, uint8Array, compressed) => {
     if (compressed)
         uint8Array = pako.inflate(uint8Array);
     let deconcated = index$2(uint8Array);
@@ -15823,13 +15823,13 @@ const decode = (proto, uint8Array, compressed) => {
         else if (token.type === 'string')
             output[token.key] = toString(deconcated[i]);
         else if (token.type === 'boolean')
-            output[token.key] = decoder.decode(deconcated[i]) === 'true';
+            output[token.key] = decoder$1.decode(deconcated[i]) === 'true';
         else if (token.type === 'number')
-            output[token.key] = Number(decoder.decode(deconcated[i]));
+            output[token.key] = Number(decoder$1.decode(deconcated[i]));
         else if (token.type === 'bigint')
-            output[token.key] = BigInt(decoder.decode(deconcated[i]));
+            output[token.key] = BigInt(decoder$1.decode(deconcated[i]));
         else if (token.type === 'object' || token.type === 'array')
-            output[token.key] = JSON.parse(decoder.decode(deconcated[i]), jsonParseBigInt$1);
+            output[token.key] = JSON.parse(decoder$1.decode(deconcated[i]), jsonParseBigInt$1);
         if (token.optional) {
             if (!output[token.key] || output[token.key].length === 0)
                 delete output[token.key];
@@ -15840,7 +15840,7 @@ const decode = (proto, uint8Array, compressed) => {
     return output;
 };
 
-var index = { encode, decode };
+var index = { encode: encode$1, decode: decode$1 };
 
 const jsonStringifyBigInt = (key, value) => {
     if (typeof value === 'bigint')
@@ -17306,6 +17306,439 @@ class FileTransfer {
     }
 }
 
+const VERSION = 1;
+const MAX_PACKET_BYTES = 64_000;
+const MAX_ENVELOPE_BYTES = 32_000;
+const MAX_ARCHIVES = 500;
+const MAX_OUTBOX = 500;
+const MAX_AGE = 30 * 24 * 60 * 60 * 1000;
+const MAX_CLOCK_SKEW = 10 * 60 * 1000;
+const MAX_HOPS = 8;
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function isUnsubscribe(value) {
+    return typeof value === 'function';
+}
+function encode(value) {
+    return encoder.encode(JSON.stringify(value));
+}
+function decode(payload) {
+    if (!(payload instanceof Uint8Array))
+        throw new TypeError('Archive packets must be encoded bytes.');
+    if (payload.byteLength > MAX_PACKET_BYTES)
+        throw new RangeError('Archive packet exceeds the size limit.');
+    return JSON.parse(decoder.decode(payload));
+}
+function randomId() {
+    if (typeof crypto.randomUUID === 'function')
+        return crypto.randomUUID();
+    return Array.from(crypto.getRandomValues(new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+function keyPrefix(network) {
+    return `peernet:archive:v1:${encodeURIComponent(network)}:`;
+}
+function recordKey(network, kind, id) {
+    return `${keyPrefix(network)}${kind}:${encodeURIComponent(id)}`;
+}
+function stateKey(network) {
+    return `${keyPrefix(network)}state`;
+}
+async function storeGet(store, key) {
+    if (store.has && !(await store.has(key)))
+        return undefined;
+    try {
+        return await store.get(key);
+    }
+    catch (error) {
+        if (error?.code === 'LEVEL_NOT_FOUND' ||
+            error?.name === 'NotFoundError')
+            return undefined;
+        throw error;
+    }
+}
+function validateEnvelope(envelope, network) {
+    const envelopeNetwork = envelope?.network ||
+        envelope?.senderCertificate?.network ||
+        envelope?.recipientCertificate?.network;
+    if (!envelope ||
+        typeof envelope !== 'object' ||
+        envelopeNetwork !== network ||
+        typeof envelope.id !== 'string' ||
+        !envelope.id ||
+        typeof envelope.recipientAccount !== 'string' ||
+        typeof envelope.recipientDeviceId !== 'string' ||
+        typeof envelope.ciphertext !== 'string' ||
+        !envelope.ciphertext ||
+        typeof envelope.signature !== 'string' ||
+        !Number.isFinite(envelope.timestamp) ||
+        envelope.timestamp < Date.now() - MAX_AGE ||
+        envelope.timestamp > Date.now() + MAX_CLOCK_SKEW)
+        throw new Error('Only a valid, network-scoped encrypted message envelope can be archived.');
+    if ('text' in envelope || 'plaintext' in envelope || 'message' in envelope)
+        throw new Error('Plaintext message fields cannot be archived.');
+    if (encode(envelope).byteLength > MAX_ENVELOPE_BYTES)
+        throw new RangeError('Encrypted message envelope exceeds the archive size limit.');
+}
+function validatePacket(value, network) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return;
+    const packet = value;
+    if (packet.version !== VERSION ||
+        packet.network !== network ||
+        typeof packet.id !== 'string' ||
+        !packet.id ||
+        typeof packet.origin !== 'string' ||
+        !packet.origin ||
+        !Number.isFinite(packet.timestamp) ||
+        packet.timestamp < Date.now() - MAX_AGE ||
+        packet.timestamp > Date.now() + MAX_CLOCK_SKEW ||
+        !Number.isInteger(packet.hopsRemaining) ||
+        packet.hopsRemaining < 0 ||
+        packet.hopsRemaining > MAX_HOPS ||
+        !['direct', 'inbox-request', 'archive-delivery', 'delivery-receipt'].includes(packet.type) ||
+        !packet.payload ||
+        typeof packet.payload !== 'object' ||
+        Array.isArray(packet.payload))
+        return;
+    return packet;
+}
+class PeernetArchiveMode {
+    #peernet;
+    #store;
+    #network;
+    #topic;
+    #verifyEnvelope;
+    #verifyInboxRequest;
+    #verifyReceipt;
+    #handlers = new Set();
+    #seen = new Map();
+    #archives = new Set();
+    #outbox = new Set();
+    #enabled = false;
+    #started = false;
+    #unsubscribe;
+    #retryTimer;
+    #account = '';
+    #deviceId = '';
+    constructor(options) {
+        if (!options?.peernet?.network || typeof options.peernet.publish !== 'function' ||
+            typeof options.peernet.subscribe !== 'function')
+            throw new Error('A Peernet instance is required for archive mode.');
+        const store = options.store || globalThis.messageStore;
+        if (!store || typeof store.get !== 'function' || typeof store.put !== 'function' ||
+            typeof store.delete !== 'function' || typeof store.keys !== 'function')
+            throw new Error('A persistent Peernet message store is required for archive mode.');
+        if (typeof options.verifyEnvelope !== 'function' ||
+            typeof options.verifyInboxRequest !== 'function' ||
+            typeof options.verifyReceipt !== 'function')
+            throw new Error('Archive mode requires envelope, inbox-request and receipt verification functions.');
+        this.#peernet = options.peernet;
+        this.#store = store;
+        this.#network = options.peernet.network;
+        this.#topic = `peernet:archive:v1:${this.#network}`;
+        this.#verifyEnvelope = options.verifyEnvelope;
+        this.#verifyInboxRequest = options.verifyInboxRequest;
+        this.#verifyReceipt = options.verifyReceipt;
+    }
+    get network() {
+        return this.#network;
+    }
+    get enabled() {
+        return this.#enabled;
+    }
+    get archiveCount() {
+        return this.#archives.size;
+    }
+    get pendingCount() {
+        return this.#outbox.size;
+    }
+    onMessage(handler) {
+        if (typeof handler !== 'function')
+            throw new TypeError('An archive message handler is required.');
+        this.#handlers.add(handler);
+        return () => this.#handlers.delete(handler);
+    }
+    async start({ account, deviceId }) {
+        if (this.#started)
+            return;
+        if (!account || !deviceId)
+            throw new Error('A local account and chat device ID are required.');
+        this.#account = account;
+        this.#deviceId = deviceId;
+        await this.#load();
+        const receiver = (payload) => {
+            this.#receive(payload).catch((error) => console.error('Peernet archive packet failed:', error));
+        };
+        const unsubscribe = await this.#peernet.subscribe(this.#topic, receiver);
+        this.#unsubscribe = isUnsubscribe(unsubscribe)
+            ? unsubscribe
+            : typeof globalThis.globalSub?.unsubscribe === 'function'
+                ? () => globalThis.globalSub.unsubscribe(this.#topic, receiver)
+                : undefined;
+        this.#started = true;
+        this.#retryTimer = setInterval(() => {
+            this.#retryOutbox().catch((error) => console.error('Peernet archive retry failed:', error));
+        }, 30_000);
+        try {
+            for (const id of this.#outbox) {
+                const bytes = await storeGet(this.#store, recordKey(this.#network, 'outbox', id));
+                if (bytes)
+                    await this.#publish('direct', { envelope: JSON.parse(decoder.decode(bytes)) });
+            }
+        }
+        catch (error) {
+            this.stop();
+            throw error;
+        }
+    }
+    stop() {
+        clearInterval(this.#retryTimer);
+        this.#retryTimer = undefined;
+        this.#unsubscribe?.();
+        this.#unsubscribe = undefined;
+        this.#started = false;
+        this.#account = '';
+        this.#deviceId = '';
+    }
+    async setEnabled(enabled) {
+        if (typeof enabled !== 'boolean')
+            throw new TypeError('Archive mode must be enabled or disabled explicitly.');
+        if (!this.#started)
+            await this.#load();
+        this.#enabled = enabled;
+        await this.#store.put(stateKey(this.#network), encode({ version: VERSION, enabled }));
+        if (!enabled) {
+            for (const id of this.#archives)
+                await this.#store.delete(recordKey(this.#network, 'archive', id));
+            this.#archives.clear();
+        }
+    }
+    async send(envelope) {
+        validateEnvelope(envelope, this.#network);
+        if (!(await this.#verifyEnvelope(envelope)))
+            throw new Error('Encrypted message signature verification failed.');
+        if (this.#outbox.has(envelope.id))
+            throw new Error('This encrypted message is already pending.');
+        await this.#store.put(recordKey(this.#network, 'outbox', envelope.id), encode(envelope));
+        this.#outbox.add(envelope.id);
+        if (this.#outbox.size > MAX_OUTBOX)
+            await this.#dropOldest('outbox');
+        await this.#publish('direct', { envelope });
+    }
+    async requestInbox(request) {
+        if (request.network !== this.#network ||
+            request.account !== this.#account ||
+            request.deviceId !== this.#deviceId ||
+            !(await this.#validInboxRequest(request)))
+            throw new Error('A valid signed inbox request for this Peernet network and device is required.');
+        await this.#publish('inbox-request', { request });
+    }
+    async acknowledge(receipt) {
+        if (receipt.network !== this.#network ||
+            receipt.recipientAccount !== this.#account ||
+            receipt.recipientDeviceId !== this.#deviceId ||
+            typeof receipt.signature !== 'string' ||
+            !Number.isFinite(receipt.timestamp) ||
+            Math.abs(Date.now() - receipt.timestamp) > MAX_CLOCK_SKEW)
+            throw new Error('Delivery receipt does not belong to this Peernet network and device.');
+        await this.#publish('delivery-receipt', { receipt });
+    }
+    async #load() {
+        const state = await storeGet(this.#store, stateKey(this.#network));
+        if (state) {
+            const saved = JSON.parse(decoder.decode(state));
+            if (saved?.version !== VERSION || typeof saved.enabled !== 'boolean')
+                throw new Error('Saved Peernet archive settings are invalid.');
+            this.#enabled = saved.enabled;
+        }
+        const prefix = keyPrefix(this.#network);
+        const keys = await this.#store.keys();
+        for (const keyInput of keys) {
+            const key = keyInput.toString().replace(/^\/+/, '');
+            if (!key.startsWith(prefix))
+                continue;
+            const archiveMarker = `${prefix}archive:`;
+            const outboxMarker = `${prefix}outbox:`;
+            if (key.startsWith(archiveMarker))
+                this.#archives.add(decodeURIComponent(key.slice(archiveMarker.length)));
+            if (key.startsWith(outboxMarker))
+                this.#outbox.add(decodeURIComponent(key.slice(outboxMarker.length)));
+        }
+        await this.#prune();
+    }
+    async #publish(type, payload, hopsRemaining = MAX_HOPS) {
+        if (!this.#started)
+            throw new Error('Peernet archive mode is not started.');
+        const packet = {
+            version: VERSION,
+            id: randomId(),
+            network: this.#network,
+            origin: this.#peernet.id,
+            timestamp: Date.now(),
+            hopsRemaining,
+            type,
+            payload
+        };
+        const bytes = encode(packet);
+        if (bytes.byteLength > MAX_PACKET_BYTES)
+            throw new RangeError('Peernet archive packet exceeds its size limit.');
+        this.#seen.set(packet.id, packet.timestamp);
+        await this.#peernet.publish(this.#topic, bytes);
+    }
+    async #receive(payload) {
+        const packet = validatePacket(decode(payload), this.#network);
+        if (!packet || packet.origin === this.#peernet.id || this.#wasSeen(packet.id))
+            return;
+        this.#markSeen(packet.id);
+        let forward = false;
+        switch (packet.type) {
+            case 'direct':
+            case 'archive-delivery': {
+                const envelope = packet.payload.envelope;
+                try {
+                    validateEnvelope(envelope, this.#network);
+                }
+                catch {
+                    break;
+                }
+                if (!(await this.#verifyEnvelope(envelope)))
+                    break;
+                forward = true;
+                if (packet.type === 'direct' && this.#enabled)
+                    await this.#saveArchive(envelope);
+                if (envelope.recipientAccount === this.#account && envelope.recipientDeviceId === this.#deviceId) {
+                    for (const handler of this.#handlers)
+                        handler({ type: 'message', envelope });
+                }
+                break;
+            }
+            case 'inbox-request': {
+                const request = packet.payload.request;
+                if (!(await this.#validInboxRequest(request)))
+                    break;
+                forward = true;
+                if (this.#enabled && !(request.account === this.#account && request.deviceId === this.#deviceId))
+                    await this.#deliverTo(request);
+                break;
+            }
+            case 'delivery-receipt': {
+                const receipt = packet.payload.receipt;
+                forward = await this.#receiveReceipt(receipt);
+                break;
+            }
+        }
+        if (forward && packet.hopsRemaining > 0) {
+            await this.#peernet.publish(this.#topic, encode({ ...packet, hopsRemaining: packet.hopsRemaining - 1 }));
+        }
+    }
+    async #validInboxRequest(request) {
+        return Boolean(request &&
+            request.network === this.#network &&
+            typeof request.account === 'string' &&
+            typeof request.deviceId === 'string' &&
+            Number.isFinite(request.timestamp) &&
+            Math.abs(Date.now() - request.timestamp) <= MAX_CLOCK_SKEW &&
+            typeof request.signature === 'string' &&
+            await this.#verifyInboxRequest(request));
+    }
+    async #saveArchive(envelope) {
+        if (this.#archives.has(envelope.id))
+            return;
+        await this.#store.put(recordKey(this.#network, 'archive', envelope.id), encode({
+            envelope,
+            storedAt: Date.now()
+        }));
+        this.#archives.add(envelope.id);
+        if (this.#archives.size > MAX_ARCHIVES)
+            await this.#dropOldest('archive');
+    }
+    async #deliverTo(request) {
+        for (const id of this.#archives) {
+            const bytes = await storeGet(this.#store, recordKey(this.#network, 'archive', id));
+            if (!bytes) {
+                this.#archives.delete(id);
+                continue;
+            }
+            const record = JSON.parse(decoder.decode(bytes));
+            const envelope = record?.envelope;
+            if (envelope?.recipientAccount === request.account && envelope.recipientDeviceId === request.deviceId)
+                await this.#publish('archive-delivery', { envelope });
+        }
+    }
+    async #receiveReceipt(receipt) {
+        if (!receipt || receipt.network !== this.#network ||
+            typeof receipt.messageId !== 'string' ||
+            !Number.isFinite(receipt.timestamp) ||
+            Math.abs(Date.now() - receipt.timestamp) > MAX_CLOCK_SKEW)
+            return false;
+        const keys = ['archive', 'outbox'];
+        let verified = false;
+        for (const kind of keys) {
+            const key = recordKey(this.#network, kind, receipt.messageId);
+            const bytes = await storeGet(this.#store, key);
+            if (!bytes)
+                continue;
+            const stored = JSON.parse(decoder.decode(bytes));
+            const envelope = kind === 'archive' ? stored.envelope : stored;
+            if (!(await this.#verifyReceipt(receipt, envelope)))
+                continue;
+            await this.#store.delete(key);
+            (kind === 'archive' ? this.#archives : this.#outbox).delete(receipt.messageId);
+            verified = true;
+        }
+        return verified;
+    }
+    async #retryOutbox() {
+        if (!this.#started)
+            return;
+        await this.#prune();
+        for (const id of this.#outbox) {
+            const bytes = await storeGet(this.#store, recordKey(this.#network, 'outbox', id));
+            if (bytes)
+                await this.#publish('direct', { envelope: JSON.parse(decoder.decode(bytes)) });
+        }
+    }
+    async #prune() {
+        const cutoff = Date.now() - MAX_AGE;
+        for (const [kind, ids] of [['archive', this.#archives], ['outbox', this.#outbox]]) {
+            for (const id of ids) {
+                const key = recordKey(this.#network, kind, id);
+                const bytes = await storeGet(this.#store, key);
+                if (!bytes) {
+                    ids.delete(id);
+                    continue;
+                }
+                const saved = JSON.parse(decoder.decode(bytes));
+                const timestamp = kind === 'archive' ? saved.storedAt : saved.timestamp;
+                if (!Number.isFinite(timestamp) || timestamp < cutoff) {
+                    await this.#store.delete(key);
+                    ids.delete(id);
+                }
+            }
+        }
+    }
+    async #dropOldest(kind) {
+        const ids = kind === 'archive' ? this.#archives : this.#outbox;
+        const id = ids.values().next().value;
+        if (!id)
+            return;
+        await this.#store.delete(recordKey(this.#network, kind, id));
+        ids.delete(id);
+    }
+    #wasSeen(id) {
+        const timestamp = this.#seen.get(id);
+        return timestamp !== undefined && Date.now() - timestamp < MAX_AGE;
+    }
+    #markSeen(id) {
+        this.#seen.set(id, Date.now());
+        if (this.#seen.size > 4_000) {
+            const oldestId = this.#seen.keys().next().value;
+            if (oldestId !== undefined)
+                this.#seen.delete(oldestId);
+        }
+    }
+}
+
 const DEFAULT_CHUNK_SIZE = 256 * 1024;
 const DEFAULT_BLOCK_CHUNK_SIZE = 256 * 1024;
 const DEFAULT_BLOCK_CHUNK_THRESHOLD = 1024 * 1024;
@@ -17332,7 +17765,7 @@ class Peernet {
     root;
     identity;
     stores = [];
-    peerId;
+    routingId;
     /**
      * @type {Object}
      * @property {Object} peer Instance of Peer
@@ -17367,6 +17800,7 @@ class Peernet {
      * @param {String} options.root - path to root directory
      * @param {String} options.version - path to root directory
      * @param {String} options.storePrefix - prefix for datatores (lfc)
+     * @param {String} options.routingId - optional transport identity, separate from the wallet identity
      * @param {Object} options.transport - transport selection and fallback options passed to @netpeer/swarm
      *
      * @return {Promise} instance of Peernet
@@ -17379,6 +17813,9 @@ class Peernet {
          * @property {String} network - current network
          */
         this.network = options.network || 'leofcoin';
+        if (options.routingId !== undefined && (typeof options.routingId !== 'string' || !options.routingId.trim()))
+            throw new TypeError('routingId must be a non-empty string');
+        this.routingId = options.routingId?.trim();
         this.autoStart = options.autoStart === undefined ? true : options.autoStart;
         this.stars = options.stars;
         this.transport = options.transport;
@@ -17410,6 +17847,9 @@ class Peernet {
         return this._init(options, password);
     }
     get id() {
+        return this.routingId || this.identity.id;
+    }
+    get peerId() {
         return this.identity.id;
     }
     get selectedAccount() {
@@ -17431,6 +17871,9 @@ class Peernet {
     addCodec(codec) {
         return utils.addCodec(codec);
     }
+    createArchiveMode(options) {
+        return new PeernetArchiveMode({ ...options, peernet: this });
+    }
     async addStore(name, prefix, root, isPrivate = true) {
         if (name === 'block' ||
             name === 'transaction' ||
@@ -17484,7 +17927,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-BGHaihSi-eHZVl0y9.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-DCePyqKC-BSvJxDWZ.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -17517,7 +17960,6 @@ class Peernet {
         this.identity = new Identity(this.network);
         await this.identity.load(password, options.freshIdentity === true);
         this._peerHandler = new PeerDiscovery(this.id);
-        this.peerId = this.id;
         /**
          * converts data -> message -> proto
          * @see DataHandler
@@ -17531,7 +17973,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-C_pBoi1g-_pfKzCvX.js');
+        const importee = await import('./client-DKKzPSlb-C_1ug6ux.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/node-browser.js

@@ -1,4 +1,4 @@
-export { N as default } from './node-browser-BNe-en1l.js';
+export { N as default } from './node-browser-Ha4Lvntj.js';
 import './browser-crypto-CH0ua22L.js';
 import './connection-monitor-D-krNiRH.js';
 import './index-CvKt4UDE.js';

package/exports/chain.js

@@ -266,7 +266,7 @@ class Transaction extends Protocol {
       await globalThis.transactionPoolStore.put(hash, message.encoded);
       this.addPendingNonce(message.decoded.from, message.decoded.nonce);
       try {
-        peernet.publish("add-transaction", message.encoded);
+        await peernet.publish("add-transaction", message.encoded);
       } catch (publishError) {
         console.warn("peernet publish failed: add-transaction", publishError?.message ?? publishError);
       }
@@ -2960,39 +2960,29 @@ class Chain extends VersionControl {
   }
   async getPeerTransactionPool(peer) {
     let transactionsInPool = await this.#makeRequest(peer, "transactionPool");
-    console.log("raw response for request transactionPool:", transactionsInPool);
     if (transactionsInPool instanceof Uint8Array) {
-      try {
-        transactionsInPool = JSON.parse(new TextDecoder().decode(transactionsInPool));
-      } catch {
-        debug("transactionPool response must be decoded array payload");
-        return [];
-      }
+      transactionsInPool = new TextDecoder().decode(transactionsInPool);
     }
     if (typeof transactionsInPool === "string") {
-      try {
-        transactionsInPool = JSON.parse(transactionsInPool);
-      } catch {
-        return [];
-      }
+      transactionsInPool = JSON.parse(transactionsInPool);
     }
-    if (!Array.isArray(transactionsInPool)) return [];
-    const localTransactions = new Set(await globalThis.transactionPoolStore.keys());
-    const transactionsToGet = [];
-    for (const key of transactionsInPool) {
-      if (!localTransactions.has(key)) {
-        let txData;
-        try {
-          txData = await globalThis.peernet.get(key, "transaction");
-        } catch (error) {
-          debug(`Failed to get transaction ${key}:`, error?.message ?? error);
-        }
-        if (txData !== void 0) {
-          transactionsToGet.push(transactionPoolStore.put(key, txData));
-        }
+    if (!Array.isArray(transactionsInPool) || transactionsInPool.some((hash) => typeof hash !== "string")) {
+      throw new Error("transactionPool response must be an array of transaction hashes");
+    }
+    const recovered = [];
+    for (const hash of new Set(transactionsInPool)) {
+      if (await globalThis.transactionPoolStore.has(hash)) continue;
+      if (await globalThis.transactionStore.has(hash)) continue;
+      try {
+        const txData = await globalThis.peernet.get(hash, "transactionPool");
+        if (txData === void 0) throw new Error("pending transaction body unavailable");
+        const transaction = await resolveTransactionReference(hash, txData);
+        recovered.push(await this.#sendTransaction(transaction));
+      } catch (error) {
+        debug(`Failed to recover transaction ${hash}:`, error?.message ?? error);
       }
     }
-    return Promise.all(transactionsToGet);
+    return recovered;
   }
   async #peerConnected(peerId) {
     if (typeof peerId !== "string" || !peerId.trim() || peerId === "undefined") {
@@ -3060,6 +3050,14 @@ class Chain extends VersionControl {
       await this.#recordPeerFailure(peerId, `unreasonable lastBlock index: ${lastBlock.index}`);
       return;
     }
+    setTimeout(async () => {
+      try {
+        await this.getPeerTransactionPool(peer);
+      } catch (error) {
+        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
+        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
+      }
+    }, 3e3);
     if (!lastBlock || !lastBlock.hash || lastBlock.hash === "0x0") {
       debug(`peer has no lastBlock: ${peerId}`);
       return;
@@ -3099,15 +3097,6 @@ class Chain extends VersionControl {
       }
       if (this.wantList.length === 0) await this.triggerSync();
     }
-    setTimeout(async () => {
-      try {
-        const peerTransactionPool = higherThenCurrentLocal && await this.getPeerTransactionPool(peer) || [];
-        if (this.#participating && peerTransactionPool.length > 0) return this.#runEpoch();
-      } catch (error) {
-        const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
-        debug(`transactionPool request failed: ${peerName}:`, error?.message ?? error);
-      }
-    }, 3e3);
     try {
       let stateInfo = await this.#makeRequest(peer, "stateInfo");
       if (stateInfo instanceof Uint8Array) {
@@ -3484,18 +3473,32 @@ class Chain extends VersionControl {
     await this.validateTransactionSignature(transaction);
     let hash;
     try {
+      hash = await transaction.hash();
+      if (await globalThis.transactionStore.has(hash)) return hash;
+      const alreadyPending = await globalThis.transactionPoolStore.has(hash);
       hash = await enqueueTransaction(transaction, {
         putToPool: (txHash, data) => globalThis.transactionPoolStore.put(txHash, data),
         hasInPool: (txHash) => globalThis.transactionPoolStore.has(txHash),
         hasInStore: (txHash) => globalThis.transactionStore.has(txHash),
         addPendingNonce: (address, nonce) => this.addPendingNonce(address, nonce)
       });
-      if (this.#participating && !this.#runningEpoch) this.#runEpoch();
+      if (!alreadyPending) {
+        try {
+          await globalThis.peernet.publish("add-transaction", transaction.encoded);
+        } catch (publishError) {
+          debug("peernet publish failed: add-transaction relay", publishError?.message ?? publishError);
+        }
+      }
+      if (this.#participating && !this.#runningEpoch) {
+        void this.#runEpoch().catch((error) => {
+          debug("transaction epoch scheduling failed:", error?.message ?? error);
+        });
+      }
       return hash;
     } catch (e) {
       if (hash) {
         try {
-          globalThis.peernet.publish("invalid-transaction", hash);
+          await globalThis.peernet.publish("invalid-transaction", hash);
         } catch (publishError) {
           debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
         }
@@ -3513,7 +3516,7 @@ class Chain extends VersionControl {
     const event = await super.sendTransaction(transactionMessage);
     await this.#sendTransaction(transactionMessage.encoded);
     try {
-      globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
+      await globalThis.peernet.publish("send-transaction", transactionMessage.encoded);
     } catch (publishError) {
       debug("peernet publish failed: send-transaction", publishError?.message ?? publishError);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.10.19",
+  "version": "1.10.21",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {
@@ -81,10 +81,10 @@
     "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-typescript": "^12.3.0",
+    "@rollup/plugin-typescript": "^12.3.1",
     "@types/semver": "^7.8.0",
     "@vandeurenglenn/debug": "^1.4.0",
-    "rollup": "^4.64.12",
+    "rollup": "^4.65.0",
     "rollup-plugin-esbuild": "^6.2.1",
     "rollup-plugin-modify": "^3.0.0",
     "tape": "^5.10.3",
@@ -99,14 +99,14 @@
     "@leofcoin/contracts": "^0.1.27",
     "@leofcoin/crypto": "^0.2.41",
     "@leofcoin/errors": "^1.0.30",
-    "@leofcoin/lib": "^1.3.15",
+    "@leofcoin/lib": "^1.3.16",
     "@leofcoin/messages": "^1.6.5",
     "@leofcoin/multi-wallet": "^3.1.11",
     "@leofcoin/networks": "^1.1.31",
-    "@leofcoin/peernet": "^3.0.0",
+    "@leofcoin/peernet": "^3.1.0",
     "@leofcoin/storage": "^3.5.38",
     "@leofcoin/utils": "^1.1.45",
-    "@leofcoin/workers": "^1.5.40",
+    "@leofcoin/workers": "^1.5.42",
     "@vandeurenglenn/base58": "^1.1.9",
     "@vandeurenglenn/easy-worker": "^1.0.3",
     "@vandeurenglenn/typed-array-utils": "^1.2.0",