@leofcoin/peernet 2.0.0 → 3.1.0

package/exports/browser/{peernet-B2jRhqGI.js → peernet-DjddqiXc.js}

@@ -7090,23 +7090,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++) {
@@ -7163,8 +7163,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$4(uint8Array);
@@ -7179,13 +7179,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];
@@ -7196,7 +7196,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')
@@ -8662,6 +8662,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;
@@ -8688,7 +9121,7 @@ class Peernet {
     root;
     identity;
     stores = [];
-    peerId;
+    routingId;
     /**
      * @type {Object}
      * @property {Object} peer Instance of Peer
@@ -8723,6 +9156,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
@@ -8735,6 +9169,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;
@@ -8766,6 +9203,9 @@ class Peernet {
         return this._init(options, password);
     }
     get id() {
+        return this.routingId || this.identity.id;
+    }
+    get peerId() {
         return this.identity.id;
     }
     get selectedAccount() {
@@ -8787,6 +9227,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' ||
@@ -8840,7 +9283,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-Dw86z0zq.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-DCePyqKC.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8873,7 +9316,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
@@ -8887,7 +9329,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-CAC7RVMf.js');
+        const importee = await import('./client-DKKzPSlb.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -9681,4 +10123,4 @@ class Peernet {
 }
 globalThis.Peernet = Peernet;
 
-export { FormatInterface as F, LittlePubSub as L, Peernet as P, FileTransfer as a, createDebugger as c, deflate_1 as d, inflate_1 as i };
+export { FormatInterface as F, LittlePubSub as L, PeernetArchiveMode as P, FileTransfer as a, Peernet as b, createDebugger as c, deflate_1 as d, inflate_1 as i };

package/exports/browser/peernet.js

@@ -1,4 +1,4 @@
-export { a as FileTransfer, P as default } from './peernet-B2jRhqGI.js';
+export { a as FileTransfer, P as PeernetArchiveMode, b as default } from './peernet-DjddqiXc.js';
 import './identity-Cf8KKnho.js';
 import './value-C3vAp-wb.js';
 import 'crypto';