@leofcoin/chain 1.5.66 → 1.5.68

package/exports/browser/{_polyfill-node.child_process-rc1HO9Xs.js → _polyfill-node.child_process-CblghArn.js}

@@ -14499,55 +14499,56 @@ class ValidatorMessage extends FormatInterface {
 }
 
 var proto$4 = {
-  index: Number(),
-  previousHash: String(),
-  timestamp: Number(),
-  reward: BigNumber.from(0),
-  fees: BigNumber.from(0),
-  transactions: new Uint8Array(),
-  validators: new Uint8Array()
+    index: Number(),
+    previousHash: String(),
+    timestamp: Number(),
+    reward: BigNumber.from(0),
+    fees: BigNumber.from(0),
+    transactions: new Uint8Array(),
+    validators: new Uint8Array()
 };
 
 class BlockMessage extends FormatInterface {
-  get messageName() {
-    return 'BlockMessage'
-  }
-  constructor(buffer) {
-    if (buffer instanceof BlockMessage) return buffer
-    const name = 'block-message';
-    super(buffer, proto$4, { name });
-  }
-  encode(decoded) {
-    decoded = decoded || this.decoded;
-    const validators = [];
-    const transactions = [];
-    for (const validator of decoded.validators) {
-      if (validator instanceof ValidatorMessage) validators.push(validator.encode());
-      else validators.push(new ValidatorMessage(validator).encode());
-    }
-    for (const transaction of decoded.transactions) {
-      if (transaction instanceof TransactionMessage) transactions.push(transaction.encode());
-      else transactions.push(new TransactionMessage(transaction).encode());
-    }
-    return super.encode({
-      ...decoded,
-      validators: index$5(validators),
-      transactions: index$5(transactions)
-    })
-  }
-  decode(encoded) {
-    encoded = encoded || this.encoded;
-    super.decode(encoded);
-    // @ts-ignore
-    this.decoded.transactions = index$4(this.decoded.transactions).map(
-      (transaction) => new TransactionMessage(transaction).decoded
-    );
-    // @ts-ignore
-    this.decoded.validators = index$4(this.decoded.validators).map(
-      (validator) => new ValidatorMessage(validator).decoded
-    );
-    return this.decoded
-  }
+    get messageName() {
+        return 'BlockMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof BlockMessage)
+            return buffer;
+        const name = 'block-message';
+        super(buffer, proto$4, { name });
+    }
+    encode(decoded) {
+        decoded = decoded || this.decoded;
+        const validators = [];
+        const transactions = [];
+        for (const validator of decoded.validators) {
+            if (validator instanceof ValidatorMessage)
+                validators.push(validator.encode());
+            else
+                validators.push(new ValidatorMessage(validator).encode());
+        }
+        for (const transaction of decoded.transactions) {
+            if (transaction instanceof TransactionMessage)
+                transactions.push(transaction.encode());
+            else
+                transactions.push(new TransactionMessage(transaction).encode());
+        }
+        return super.encode({
+            ...decoded,
+            validators: index$5(validators),
+            transactions: index$5(transactions)
+        });
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        super.decode(encoded);
+        // @ts-ignore
+        this.decoded.transactions = index$4(this.decoded.transactions).map((transaction) => new TransactionMessage(transaction).decoded);
+        // @ts-ignore
+        this.decoded.validators = index$4(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
+        return this.decoded;
+    }
 }
 
 var proto$3 = {
@@ -14623,4 +14624,4 @@ var _polyfillNode_child_process = /*#__PURE__*/Object.freeze({
 	__proto__: null
 });
 
-export { BlockMessage as B, ContractMessage as C, Logger as L, RawTransactionMessage as R, TransactionMessage as T, ValidatorMessage as V, _polyfillNode_child_process as _, BWMessage as a, BWRequestMessage as b, BigNumber as c, arrayify as d, isBytes as e, getDefaultExportFromCjs as f, global$1 as g, hexZeroPad as h, isBigNumberish as i, toBase58 as t, version as v };
+export { BlockMessage as B, ContractMessage as C, FormatInterface as F, Logger as L, RawTransactionMessage as R, TransactionMessage as T, ValidatorMessage as V, _polyfillNode_child_process as _, BWMessage as a, BWRequestMessage as b, BigNumber as c, arrayify as d, isBytes as e, getDefaultExportFromCjs as f, global$1 as g, hexZeroPad as h, isBigNumberish as i, toBase58 as t, version as v };

package/exports/browser/{_polyfill-node.url-1q06MepH.js → _polyfill-node.url-BLK_MhDf.js}

@@ -1,4 +1,4 @@
-import { g as global } from './_polyfill-node.child_process-rc1HO9Xs.js';
+import { g as global } from './_polyfill-node.child_process-CblghArn.js';
 
 /*! https://mths.be/punycode v1.4.1 by @mathias */
 

package/exports/browser/{browser-Ei0BXMlu-irDJ6Blw.js → browser-Ei0BXMlu-C0woTcHa.js}

@@ -1,5 +1,5 @@
-import { g as getDefaultExportFromCjs } from './node-browser-TcXF8FDB.js';
-import './_polyfill-node.child_process-rc1HO9Xs.js';
+import { g as getDefaultExportFromCjs } from './node-browser-CeM_F-HL.js';
+import './_polyfill-node.child_process-CblghArn.js';
 
 var global;
 var hasRequiredGlobal;

package/exports/browser/browser-store.js

@@ -70,23 +70,56 @@ class KeyValue {
     }
 }
 
+if (!globalThis.DEBUG) {
+  let DEBUG = [];
+  if (globalThis.localStorage) {
+    DEBUG = globalThis.localStorage.getItem('DEBUG');
+    globalThis.DEBUG = DEBUG ? DEBUG.split(',') : [DEBUG];
+  }
+}
+
+const debug$1 = (target, text) => {
+  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) console.log('\x1b[34m\x1b[1m%s', `${target}: ${text}`, '\x1b[0m');
+    else console.log('\x1b[34m\x1b[1m%s', `${target}`, '\x1b[0m');
+};
+
+if (!globalThis.debug) {
+  globalThis.debug = debug$1;
+
+  globalThis.createDebugger = (target) => (text) => debug$1(target, text);
+}
+
+const debug = globalThis.createDebugger('leofcoin/storage');
 const opfsRoot = await navigator.storage.getDirectory();
 class BrowerStore {
     db;
     name;
     root;
+    inWorker;
     version;
-    async init(name = 'storage', root = '.leofcoin', version = '1') {
-        console.log('init');
+    busy;
+    queue = [];
+    async init(name = 'storage', root = '.leofcoin', version = '1', inWorker = false) {
         this.version = version;
         this.name = name;
         this.root = opfsRoot;
-        console.log(`${this.root}/${this.name}`);
+        this.inWorker = inWorker;
         let directoryHandle;
         try {
             directoryHandle = await opfsRoot.getDirectoryHandle(this.name, {
                 create: true
             });
+            if (inWorker) {
+                directoryHandle = await directoryHandle.createSyncAccessHandle();
+            }
         }
         catch (error) {
             console.error(error);
@@ -105,6 +138,7 @@ class BrowerStore {
         return value.uint8Array;
     }
     async has(key) {
+        debug(`has ${this.toKeyPath(key)}`);
         try {
             await this.db.getFileHandle(this.toKeyPath(key));
             return true;
@@ -114,34 +148,81 @@ class BrowerStore {
         }
     }
     async get(key) {
-        const handle = await this.db.getFileHandle(this.toKeyPath(key));
-        const file = await handle.getFile();
-        return new Uint8Array(await file.arrayBuffer());
+        debug(`get ${this.toKeyPath(key)}`);
+        let handle = await this.db.getFileHandle(this.toKeyPath(key));
+        let readBuffer;
+        if (this.inWorker) {
+            handle = await handle.createSyncAccessHandle();
+            const fileSize = handle.getSize();
+            // Read file content to a buffer.
+            const buffer = new DataView(new ArrayBuffer(fileSize));
+            readBuffer = handle.read(buffer, { at: 0 });
+            handle.close();
+        }
+        else {
+            const file = await handle.getFile();
+            readBuffer = await file.arrayBuffer();
+        }
+        return new Uint8Array(readBuffer);
     }
     async put(key, value) {
-        const handle = await this.db.getFileHandle(this.toKeyPath(key), { create: true });
-        const writeable = handle.createWritable();
-        (await writeable).write(this.toKeyValue(value));
-        (await writeable).close();
+        const promise = () => new Promise(async (resolve) => {
+            debug(`put ${this.toKeyPath(key)}`);
+            let handle = await this.db.getFileHandle(this.toKeyPath(key), { create: true });
+            let writeable;
+            if (this.inWorker) {
+                writeable = await handle.createSyncAccessHandle();
+            }
+            else {
+                writeable = await handle.createWritable();
+            }
+            (await writeable).write(this.toKeyValue(value));
+            (await writeable).close();
+            resolve(true);
+            if (this.queue.length > 0 && !this.busy) {
+                this.runQueue();
+            }
+        });
+        this.queue.push(promise);
+        this.runQueue();
+        return promise;
+    }
+    async runQueue() {
+        if (this.queue.length > 0) {
+            this.busy = true;
+            const next = this.queue.shift();
+            await next();
+            return this.runQueue();
+        }
+        else {
+            this.busy = false;
+        }
     }
     async delete(key) {
+        debug(`delete ${this.toKeyPath(key)}`);
         return this.db.removeEntry(this.toKeyPath(key));
     }
     async clear() {
+        debug(`clear ${this.toKeyPath(key)}`);
         for await (const key of this.db.keys()) {
             await this.db.removeEntry(key);
         }
     }
     async values(limit = -1) {
-        const values = [];
+        debug(`values ${limit}`);
+        let values = [];
         for await (const cursor of this.db.values()) {
-            values.push(cursor);
-            if (limit && values.length === limit)
-                return values;
+            values.push(cursor.getFile());
+            if (limit && values.length === limit) {
+                values = await Promise.all(values);
+                return Promise.all(values.map(async (file) => new Uint8Array(await file.arrayBuffer())));
+            }
         }
-        return values;
+        values = await Promise.all(values);
+        return Promise.all(values.map(async (file) => new Uint8Array(await file.arrayBuffer())));
     }
     async keys(limit = -1) {
+        debug(`keys ${limit}`);
         const keys = [];
         for await (const cursor of this.db.keys()) {
             keys.push(cursor);