@leofcoin/chain 1.8.2 → 1.8.3

package/exports/browser/{browser-Qcpp3EKK-DOtgsScX.js → browser-BHbuEZJu-DB_cOj5W.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8-BU8xakCv.js';
+import { g as getDefaultExportFromCjs } from './identity-B6BHwSTU-5rsAWMHo.js';
 
 var browser$2 = {};
 

package/exports/browser/{browser-CfYI-6aD-DHRKebpJ.js → browser-DQlwTLRn-h2IyYbfg.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs } from './identity-nIyW_Xm8-BU8xakCv.js';
+import { g as getDefaultExportFromCjs } from './identity-B6BHwSTU-5rsAWMHo.js';
 
 var global;
 var hasRequiredGlobal;

package/exports/browser/chain.js

@@ -1,33 +1,35 @@
 import { t as toBase58, T as TransactionMessage, C as ContractMessage, R as RawTransactionMessage, B as BlockMessage, a as BWMessage, b as BWRequestMessage } from './index-DUfUgiQY.js';
 
-let TARGETS = undefined;
-if (globalThis.localStorage && !TARGETS) {
-    const DEBUG = globalThis.localStorage.getItem("DEBUG");
-    if (DEBUG) {
-        TARGETS = JSON.parse(DEBUG);
-    }
-}
+const getTargets = () => Array.from([]);
+const isEnabled = (target) => {
+    return false;
+};
+
 const getLogger = (trace) => (trace ? console.trace : console.log);
-const debug$3 = (target, text, trace) => {
-    const _logger = getLogger(trace);
-    if (!TARGETS)
-        return;
-    if (TARGETS === true ||
-        TARGETS?.indexOf(target) !== -1 ||
-        TARGETS?.indexOf("*") !== -1 ||
-        TARGETS?.indexOf(target.split("/")[0]) !== -1)
+const createDebugger = (target) => {
+    // Cache the enabled check on first call
+    let enabled = null;
+    let lastTargets = undefined;
+    return (text, trace) => {
+        const targets = getTargets();
+        if (lastTargets !== targets) {
+            enabled = targets ? isEnabled() : false;
+            lastTargets = targets;
+        }
+        if (!enabled)
+            return;
         if (text)
-            _logger("\x1b[34m\x1b[1m%s", `${target}: ${text}`, "\x1b[0m");
+            getLogger(trace)('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
         else
-            _logger("\x1b[34m\x1b[1m%s", `${target}`, "\x1b[0m");
+            getLogger(trace)('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+    };
 };
-const createDebugger = (target) => (text, trace) => debug$3(target, text, trace);
 
 /* Do NOT modify this file; see /src.ts/_admin/update-version.ts */
 /**
  *  The current version of Ethers.
  */
-const version = "6.15.0";
+const version = "6.16.0";
 
 /**
  *  Property helper functions.
@@ -231,7 +233,8 @@ function _getBytes(value, name, copy) {
     if (value instanceof Uint8Array) {
         return value;
     }
-    if (typeof (value) === "string" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {
+    if (typeof (value) === "string" && (value.length % 2) === 0 &&
+        value.match(/^0x[0-9a-f]*$/i)) {
         const result = new Uint8Array((value.length - 2) / 2);
         let offset = 2;
         for (let i = 0; i < result.length; i++) {

package/exports/browser/{client-q0JXZnpu-ChkF_Pn_.js → client-DCeU_UX5-CR7iKpxy.js}

@@ -1,5 +1,5 @@
-import { L as LittlePubSub } from './node-browser-SPIwS-5O.js';
-import './identity-nIyW_Xm8-BU8xakCv.js';
+import { c as createDebugger, i as inflate_1, d as deflate_1, L as LittlePubSub } from './node-browser-Bv-OkGUJ.js';
+import './identity-B6BHwSTU-5rsAWMHo.js';
 import './index-DUfUgiQY.js';
 import './networks-BdMfU1ag.js';
 
@@ -232,7 +232,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-CfYI-6aD-DHRKebpJ.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-DQlwTLRn-h2IyYbfg.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);
@@ -318,6 +318,17 @@ const defaultOptions = {
     connectEvent: 'peer:connected'
 };
 
+// Simple CRC32 implementation
+const crc32$1 = (data) => {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
 const iceServers = [
     {
         urls: 'stun:stun.l.google.com:19302' // Google's public STUN server
@@ -336,37 +347,81 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-DTbjK0sK-BK_5FT46.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-DYdP5D9L-D_bByMvp.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;
     version;
+    compressionThreshold = 0.98;
     bw = { up: 0, down: 0 };
     get connected() {
         return super.connected;
     }
     constructor(options) {
-        const { from, to, initiator, trickle, config, version } = options;
+        const { from, to, initiator, trickle, config, version, wrtc, compressionThreshold } = options;
         const channelName = initiator ? `${from}:${to}` : `${to}:${from}`;
         super({
             channelName,
             initiator,
-            trickle: trickle || true,
+            trickle: trickle ?? true,
             config: { iceServers, ...config },
-            wrtc: globalThis.wrtc
+            wrtc: wrtc ?? globalThis.wrtc
         });
         this.version = String(version);
         this.peerId = to;
         this.channelName = channelName;
+        if (compressionThreshold !== undefined)
+            this.compressionThreshold = compressionThreshold;
     }
     async #chunkit(data, id) {
         this.bw.up = data.length;
-        const size = data.length;
+        // attempt compression; use compressed only if beneficial
+        let sendData = data;
+        try {
+            const c = deflate_1(data);
+            if (c?.length && c.length < data.length * this.compressionThreshold)
+                sendData = c;
+        }
+        catch (e) {
+            // ignore
+        }
+        const size = sendData.length;
+        const encodeFrame = (idStr, totalSize, index, count, payload, flags) => {
+            const te = new TextEncoder();
+            const idBytes = te.encode(idStr);
+            const crc = crc32$1(payload);
+            const headerLen = 1 + 1 + 4 + 4 + 4 + 4 + 2 + idBytes.length;
+            const buffer = new ArrayBuffer(headerLen + payload.length);
+            const view = new DataView(buffer);
+            const out = new Uint8Array(buffer);
+            let offset = 0;
+            view.setUint8(offset, 1); // version
+            offset += 1;
+            view.setUint8(offset, flags); // flags: bit0 chunked, bit1 compressed
+            offset += 1;
+            view.setUint32(offset, totalSize, true);
+            offset += 4;
+            view.setUint32(offset, index, true);
+            offset += 4;
+            view.setUint32(offset, count, true);
+            offset += 4;
+            view.setUint32(offset, crc, true); // CRC32
+            offset += 4;
+            view.setUint16(offset, idBytes.length, true);
+            offset += 2;
+            out.set(idBytes, offset);
+            offset += idBytes.length;
+            out.set(payload, offset);
+            return out;
+        };
         // no needles chunking, keep it simple, if data is smaller then max size just send it
-        if (data.length <= MAX_MESSAGE_SIZE) {
-            return super.send(JSON.stringify({ chunk: data, id, size: data.length }));
+        if (size <= MAX_MESSAGE_SIZE) {
+            const flags = ((size > MAX_MESSAGE_SIZE ? 1 : 0) << 0) |
+                ((sendData !== data ? 1 : 0) << 1);
+            super.send(encodeFrame(id, size, 0, 1, sendData, flags));
+            return;
         }
-        async function* chunks(data) {
+        function* chunks(data) {
             while (data.length !== 0) {
                 const amountToSlice = data.length >= MAX_MESSAGE_SIZE ? MAX_MESSAGE_SIZE : data.length;
                 const subArray = data.subarray(0, amountToSlice);
@@ -382,8 +437,27 @@ class Peer extends SimplePeer {
         //   data = data.subarray(amountToSlice, data.length)
         //   super.send(JSON.stringify({ chunk: subArray, id, size }))
         // }
-        for await (const chunk of chunks(data)) {
-            super.send(JSON.stringify({ chunk, id, size }));
+        // backpressure-aware send loop with indexed chunks
+        const count = Math.ceil(size / MAX_MESSAGE_SIZE);
+        let index = 0;
+        const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+        const threshold = 4 * 1024 * 1024; // 4MB bufferedAmount threshold
+        const flags = (1 << 0) | ((sendData !== data ? 1 : 0) << 1);
+        for (const chunk of chunks(sendData)) {
+            // wait while channel is congested
+            // eslint-disable-next-line no-await-in-loop
+            while (
+            // @ts-ignore underlying channel is not part of public types
+            this._channel?.bufferedAmount > threshold) {
+                // if connection closed, abort
+                // eslint-disable-next-line no-await-in-loop
+                if (!this.connected)
+                    return;
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(10);
+            }
+            super.send(encodeFrame(id, size, index, count, chunk, flags));
+            index += 1;
         }
     }
     /**
@@ -403,12 +477,16 @@ class Peer extends SimplePeer {
      */
     request(data, id = crypto.randomUUID()) {
         return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => reject(`request for ${id} timed out`), 30_000);
+            let timeout;
             const onrequest = ({ data }) => {
                 clearTimeout(timeout);
                 resolve(data);
                 globalThis.pubsub.unsubscribe(id, onrequest);
             };
+            timeout = setTimeout(() => {
+                globalThis.pubsub.unsubscribe(id, onrequest);
+                reject(`request for ${id} timed out`);
+            }, 30_000);
             globalThis.pubsub.subscribe(id, onrequest);
             this.send(data, id);
         });
@@ -423,7 +501,18 @@ class Peer extends SimplePeer {
     }
 }
 
-const debug = globalThis.createDebugger('@netpeer/swarm/client');
+// Simple CRC32 implementation
+const crc32 = (data) => {
+    let crc = 0xffffffff;
+    for (let i = 0; i < data.length; i++) {
+        crc ^= data[i];
+        for (let j = 0; j < 8; j++) {
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+};
+const debug = createDebugger('@netpeer/swarm/client');
 class Client {
     #peerId;
     #connections = {};
@@ -528,7 +617,7 @@ class Client {
     }
     async _init() {
         if (!globalThis.RTCPeerConnection)
-            globalThis.wrtc = (await import('./browser-Qcpp3EKK-DOtgsScX.js').then(function (n) { return n.b; })).default;
+            globalThis.wrtc = (await import('./browser-BHbuEZJu-DB_cOj5W.js').then(function (n) { return n.b; })).default;
         for (const star of this.starsConfig) {
             try {
                 await this.setupStar(star);
@@ -706,9 +795,12 @@ class Client {
         globalThis.pubsub.publishVerbose(this.#connectEvent, peer.peerId);
     };
     #noticeMessage = (message, id, from, peer) => {
+        const dataOut = message instanceof Uint8Array
+            ? message
+            : new Uint8Array(Object.values(message));
         if (globalThis.pubsub.subscribers[id]) {
             globalThis.pubsub.publish(id, {
-                data: new Uint8Array(Object.values(message)),
+                data: dataOut,
                 id,
                 from,
                 peer
@@ -716,7 +808,7 @@ class Client {
         }
         else {
             globalThis.pubsub.publish('peer:data', {
-                data: new Uint8Array(Object.values(message)),
+                data: dataOut,
                 id,
                 from,
                 peer
@@ -724,22 +816,124 @@ class Client {
         }
     };
     #peerData = (peer, data) => {
-        const { id, size, chunk } = JSON.parse(new TextDecoder().decode(data));
-        peer.bw.down += size;
-        if (size <= MAX_MESSAGE_SIZE) {
-            this.#noticeMessage(chunk, id, peer.peerId, peer);
+        const tryJson = () => {
+            const parsed = JSON.parse(new TextDecoder().decode(data));
+            const { id, size, chunk, index, count } = parsed;
+            chunk ? Object.values(chunk).length : size;
+            return {
+                id,
+                size: Number(size),
+                index: Number(index ?? 0),
+                count: Number(count ?? 1),
+                chunk: new Uint8Array(Object.values(chunk)),
+                flags: 0,
+                crc: 0
+            };
+        };
+        const decodeBinary = () => {
+            let u8;
+            if (typeof data === 'string') {
+                // should not happen when sending binary, fallback to JSON
+                return tryJson();
+            }
+            else if (data instanceof ArrayBuffer) {
+                u8 = new Uint8Array(data);
+            }
+            else if (ArrayBuffer.isView(data)) {
+                const view = data;
+                const byteOffset = view.byteOffset || 0;
+                const byteLength = view.byteLength || data.length;
+                u8 = new Uint8Array(view.buffer, byteOffset, byteLength);
+            }
+            else if (data?.buffer) {
+                u8 = new Uint8Array(data.buffer);
+            }
+            else {
+                // last resort: attempt JSON
+                return tryJson();
+            }
+            const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+            let offset = 0;
+            dv.getUint8(offset);
+            offset += 1;
+            const flags = dv.getUint8(offset);
+            offset += 1;
+            const size = dv.getUint32(offset, true);
+            offset += 4;
+            const index = dv.getUint32(offset, true);
+            offset += 4;
+            const count = dv.getUint32(offset, true);
+            offset += 4;
+            const expectedCrc = dv.getUint32(offset, true);
+            offset += 4;
+            const idLen = dv.getUint16(offset, true);
+            offset += 2;
+            const idBytes = u8.subarray(offset, offset + idLen);
+            offset += idLen;
+            const id = new TextDecoder().decode(idBytes);
+            const chunk = u8.subarray(offset);
+            return { id, size, index, count, chunk, flags, crc: expectedCrc };
+        };
+        const frame = decodeBinary();
+        peer.bw.down += frame.chunk.length;
+        // Single frame path: if compressed, inflate before publish
+        if (frame.count === 1) {
+            let payload = frame.chunk;
+            const compressed = Boolean(frame.flags & (1 << 1));
+            if (compressed) {
+                const actualCrc = crc32(payload);
+                if (actualCrc !== frame.crc) {
+                    console.warn(`CRC mismatch: expected ${frame.crc}, got ${actualCrc}`);
+                }
+                try {
+                    payload = inflate_1(payload);
+                }
+                catch (e) {
+                    console.warn('inflate failed, passing compressed payload');
+                }
+            }
+            this.#noticeMessage(payload, frame.id, peer.peerId, peer);
+            return;
         }
-        else {
-            if (!this.#messagesToHandle[id])
-                this.#messagesToHandle[id] = [];
-            this.#messagesToHandle[id] = [
-                ...this.#messagesToHandle[id],
-                ...Object.values(chunk)
-            ];
-            if (this.#messagesToHandle[id].length === Number(size)) {
-                this.#noticeMessage(this.#messagesToHandle[id], id, peer.peerId, peer);
-                delete this.#messagesToHandle[id];
+        // Chunked message handling with indexed reassembly
+        if (!this.#messagesToHandle[frame.id] ||
+            Array.isArray(this.#messagesToHandle[frame.id])) {
+            this.#messagesToHandle[frame.id] = {
+                chunks: new Array(frame.count),
+                receivedBytes: 0,
+                expectedSize: Number(frame.size),
+                expectedCount: Number(frame.count)
+            };
+        }
+        const state = this.#messagesToHandle[frame.id];
+        // Verify CRC for this chunk
+        const actualCrc = crc32(frame.chunk);
+        if (actualCrc !== frame.crc) {
+            console.warn(`Chunk CRC mismatch for ${frame.id}[${frame.index}]: expected ${frame.crc}, got ${actualCrc}`);
+        }
+        state.chunks[frame.index] = frame.chunk;
+        state.receivedBytes += frame.chunk.length;
+        // If all chunks present and total size matches, reassemble
+        const allPresent = state.chunks.every((c) => c instanceof Uint8Array);
+        if (allPresent && state.receivedBytes === state.expectedSize) {
+            const result = new Uint8Array(state.expectedSize);
+            let offset2 = 0;
+            for (const c of state.chunks) {
+                result.set(c, offset2);
+                offset2 += c.length;
+            }
+            let payload = result;
+            const compressed = Boolean(frame.flags & (1 << 1));
+            if (compressed) {
+                try {
+                    payload = inflate_1(result);
+                }
+                catch (e) {
+                    console.warn('inflate failed, passing compressed payload');
+                }
             }
+            this.#noticeMessage(payload, frame.id, peer.peerId, peer);
+            delete this.#messagesToHandle[frame.id];
         }
     };
     #peerError = (peer, error) => {

package/exports/browser/{identity-nIyW_Xm8-BU8xakCv.js → identity-B6BHwSTU-5rsAWMHo.js}

@@ -17150,7 +17150,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-ChRjMyiM-EjbBu23l.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ '@leofcoin/generate-account');
             const { identity, accounts } = await importee.default(password, this.network);
             await globalThis.accountStore.put('public', JSON.stringify({ walletId: identity.walletId }));
             await globalThis.walletStore.put('version', String(1));
@@ -17196,4 +17196,4 @@ class Identity {
     }
 }
 
-export { Identity as I, MultiWallet as M, index$5 as a, base$1 as b, base58$1 as c, index$3 as d, index$2 as e, encrypt as f, getDefaultExportFromCjs as g, commonjsGlobal as h, index$4 as i, requireInherits_browser as j, require$$3 as r };
+export { Identity as I, index$5 as a, base$1 as b, base58$1 as c, index$3 as d, index$2 as e, commonjsGlobal as f, getDefaultExportFromCjs as g, requireInherits_browser as h, index$4 as i, require$$3 as r };

package/exports/browser/{index-DTbjK0sK-BK_5FT46.js → index-DYdP5D9L-D_bByMvp.js}

@@ -1,4 +1,4 @@
-import { g as getDefaultExportFromCjs, h as commonjsGlobal, r as require$$3, j as requireInherits_browser } from './identity-nIyW_Xm8-BU8xakCv.js';
+import { g as getDefaultExportFromCjs, f as commonjsGlobal, r as require$$3, h as requireInherits_browser } from './identity-B6BHwSTU-5rsAWMHo.js';
 import require$$0 from 'events';
 
 var browser$2 = {exports: {}};

package/exports/browser/{messages-CC7UR5ol-BvFNyHjv.js → messages-CiR1YiV5-BOjOxVgq.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './node-browser-SPIwS-5O.js';
-import './identity-nIyW_Xm8-BU8xakCv.js';
+import { F as FormatInterface } from './node-browser-Bv-OkGUJ.js';
+import './identity-B6BHwSTU-5rsAWMHo.js';
 import './index-DUfUgiQY.js';
 import './networks-BdMfU1ag.js';
 

package/exports/browser/{node-browser-SPIwS-5O.js → node-browser-Bv-OkGUJ.js}

@@ -1,4 +1,4 @@
-import { b as base$1, I as Identity, i as index$4, a as index$5, c as base58$1, d as index$3, e as index$2 } from './identity-nIyW_Xm8-BU8xakCv.js';
+import { b as base$1, I as Identity, i as index$4, a as index$5, c as base58$1, d as index$3, e as index$2 } from './identity-B6BHwSTU-5rsAWMHo.js';
 import { F as FormatInterface$2, T as TransactionMessage, C as ContractMessage, B as BlockMessage, a as BWMessage, b as BWRequestMessage, V as ValidatorMessage } from './index-DUfUgiQY.js';
 import networks from './networks-BdMfU1ag.js';
 
@@ -126,42 +126,31 @@ class KeyValue {
     }
 }
 
-if (!globalThis.DEBUG) {
-  globalThis.DEBUG = [];
-  if (globalThis.localStorage) {
-    const DEBUG = globalThis.localStorage.getItem("DEBUG");
-    if (DEBUG) {
-      globalThis.DEBUG = DEBUG.startsWith("[")
-        ? JSON.parse(DEBUG).split(",")
-        : [DEBUG];
-    }
-  }
-}
+const getTargets = () => Array.from([]);
+const isEnabled = (target) => {
+    return false;
+};
 
 const getLogger = (trace) => (trace ? console.trace : console.log);
-
-const debug$1 = (target, text, trace) => {
-  const _logger = getLogger(trace);
-  if (!globalThis.DEBUG || globalThis.DEBUG?.length === 0) return;
-  if (
-    globalThis.DEBUG === "true" ||
-    globalThis.DEBUG === true ||
-    globalThis.DEBUG?.indexOf(target) !== -1 ||
-    globalThis.DEBUG?.indexOf("*") !== -1 ||
-    globalThis.DEBUG?.indexOf(target.split("/")[0]) !== -1
-  )
-    if (text) _logger("\x1b[34m\x1b[1m%s", `${target}: ${text}`, "\x1b[0m");
-    else _logger("\x1b[34m\x1b[1m%s", `${target}`, "\x1b[0m");
+const createDebugger = (target) => {
+    // Cache the enabled check on first call
+    let enabled = null;
+    let lastTargets = undefined;
+    return (text, trace) => {
+        const targets = getTargets();
+        if (lastTargets !== targets) {
+            enabled = targets ? isEnabled() : false;
+            lastTargets = targets;
+        }
+        if (!enabled)
+            return;
+        if (text)
+            getLogger(trace)('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+        else
+            getLogger(trace)('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+    };
 };
 
-const createDebugger = (target) => (text) => debug$1(target, text);
-
-if (!globalThis.debug) {
-  globalThis.debug = debug$1;
-  // todo: deprecate
-  globalThis.createDebugger = createDebugger;
-}
-
 class LittlePubSub {
     subscribers = {};
     verbose;
@@ -8491,7 +8480,7 @@ class Peernet {
         this.root = options.root;
         const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile
         // FolderMessageResponse
-         } = await import(/* webpackChunkName: "messages" */ './messages-CC7UR5ol-BvFNyHjv.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-CiR1YiV5-BOjOxVgq.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8585,7 +8574,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-q0JXZnpu-ChkF_Pn_.js');
+        const importee = await import('./client-DCeU_UX5-CR7iKpxy.js');
         /**
          * @access public
          * @type {PeernetClient}
@@ -9135,4 +9124,4 @@ class Node {
     }
 }
 
-export { FormatInterface as F, LittlePubSub as L, Node as N };
+export { FormatInterface as F, LittlePubSub as L, Node as N, createDebugger as c, deflate_1 as d, inflate_1 as i };

package/exports/browser/node-browser.js

@@ -1,4 +1,4 @@
-export { N as default } from './node-browser-SPIwS-5O.js';
-import './identity-nIyW_Xm8-BU8xakCv.js';
+export { N as default } from './node-browser-Bv-OkGUJ.js';
+import './identity-B6BHwSTU-5rsAWMHo.js';
 import './index-DUfUgiQY.js';
 import './networks-BdMfU1ag.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {
@@ -54,8 +54,8 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/semver": "^7.7.1",
-    "@vandeurenglenn/debug": "^1.2.7",
-    "rollup": "^4.53.4",
+    "@vandeurenglenn/debug": "^1.4.0",
+    "rollup": "^4.54.0",
     "rollup-plugin-modify": "^3.0.0",
     "tape": "^5.9.0",
     "tslib": "^2.8.1"
@@ -69,7 +69,7 @@
     "@leofcoin/messages": "^1.4.40",
     "@leofcoin/multi-wallet": "^3.1.8",
     "@leofcoin/networks": "^1.1.25",
-    "@leofcoin/peernet": "^1.1.105",
+    "@leofcoin/peernet": "^1.2.0",
     "@leofcoin/storage": "^3.5.38",
     "@leofcoin/utils": "^1.1.40",
     "@leofcoin/workers": "^1.5.27",

package/exports/browser/index-ChRjMyiM-EjbBu23l.js

@@ -1,36 +0,0 @@
-import { M as MultiWallet, f as encrypt, c as base58$1 } from './identity-nIyW_Xm8-BU8xakCv.js';
-
-/**
- * @params {String} network
- * @return {object} { identity, accounts, config }
- */
-var index = async (password, network) => {
-    if (!password)
-        throw new Error('wallets need to be password protected.');
-    let wallet = new MultiWallet(network);
-    /**
-     * @type {string}
-     */
-    let mnemonic = await wallet.generate(password);
-    wallet = new MultiWallet(network);
-    await wallet.recover(mnemonic, password, network);
-    mnemonic = new Uint8Array(await encrypt(password, mnemonic));
-    const multiWIF = new Uint8Array(await encrypt(password, await wallet.multiWIF));
-    /**
-     * @type {object}
-     */
-    const external = await wallet.account(1).external(1);
-    const externalAddress = await external.address;
-    const internal = await wallet.account(1).internal(1);
-    const internalAddress = await internal.address;
-    return {
-        identity: {
-            mnemonic: base58$1.encode(mnemonic),
-            multiWIF: base58$1.encode(multiWIF),
-            walletId: await external.id
-        },
-        accounts: [['main account', externalAddress, internalAddress]]
-    };
-};
-
-export { index as default };