@leofcoin/chain 1.6.11 → 1.6.13

package/exports/browser/{client-A009z8av-DavUUkay.js → client-A009z8av-Dw6NYFQr.js}

@@ -1,5 +1,5 @@
-import { L as LittlePubSub } from './node-browser-CC3grAN3.js';
-import './index-Bz6K16zr.js';
+import { L as LittlePubSub } from './node-browser-DRoVQRWp.js';
+import './index--C9N9ZXK.js';
 
 class Api {
     _pubsub;
@@ -206,7 +206,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket)
-                    globalThis.WebSocket = (await import('./browser-Ei0BXMlu-9eQR3AGp.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-Ei0BXMlu-_DPyExz0.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 client.onmessage = this.onmessage;
                 client.onerror = this.onerror;
@@ -280,7 +280,7 @@ const iceServers = [
         credential: 'openrelayproject'
     }
 ];
-const SimplePeer = (await import('./index-YQrIDBUQ-CbL47K_x.js').then(function (n) { return n.i; })).default;
+const SimplePeer = (await import('./index-YQrIDBUQ-CqYDmtzG.js').then(function (n) { return n.i; })).default;
 class Peer extends SimplePeer {
     peerId;
     channelName;

package/exports/browser/{index-Bz6K16zr.js → index--C9N9ZXK.js}

@@ -12458,37 +12458,6 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
 const FormatInterface = FormatInterface$1;
 
 var proto$6 = {
-    timestamp: Number(),
-    from: String(),
-    to: String(),
-    method: String(),
-    params: Array(),
-    signature: String(),
-    'nonce?': Number(),
-    'dependsOn?': Array(),
-    'priority?': Boolean()
-};
-
-class TransactionMessage extends FormatInterface {
-    get messageName() {
-        return 'TransactionMessage';
-    }
-    constructor(buffer) {
-        if (buffer instanceof TransactionMessage)
-            return buffer;
-        const name = 'transaction-message';
-        super(buffer, proto$6, { name });
-    }
-    beforeHashing(decoded) {
-        decoded = super.beforeHashing(decoded);
-        delete decoded.signature;
-        delete decoded.priority;
-        delete decoded.dependsOn;
-        return decoded;
-    }
-}
-
-var proto$5 = {
     address: String(),
     reward: BigNumber.from(0)
 };
@@ -12501,17 +12470,17 @@ class ValidatorMessage extends FormatInterface {
         if (buffer instanceof ValidatorMessage)
             return buffer;
         const name = 'validator-message';
-        super(buffer, proto$5, { name });
+        super(buffer, proto$6, { name });
     }
 }
 
-var proto$4 = {
+var proto$5 = {
     index: Number(),
     previousHash: String(),
     timestamp: Number(),
     reward: BigNumber.from(0),
     fees: BigNumber.from(0),
-    transactions: new Uint8Array(),
+    transactions: Array(),
     validators: new Uint8Array()
 };
 
@@ -12523,42 +12492,32 @@ class BlockMessage extends FormatInterface {
         if (buffer instanceof BlockMessage)
             return buffer;
         const name = 'block-message';
-        super(buffer, proto$4, { name });
+        super(buffer, proto$5, { 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)
+            validators: index$5(validators)
         });
     }
     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 = {
+var proto$4 = {
     up: Number(),
     down: Number()
 };
@@ -12571,11 +12530,11 @@ class BWMessage extends FormatInterface {
         if (buffer instanceof BWMessage)
             return buffer;
         const name = 'bw-message';
-        super(buffer, proto$3, { name });
+        super(buffer, proto$4, { name });
     }
 }
 
-var proto$2 = {};
+var proto$3 = {};
 
 class BWRequestMessage extends FormatInterface {
     get messageName() {
@@ -12585,11 +12544,11 @@ class BWRequestMessage extends FormatInterface {
         if (buffer instanceof BWRequestMessage)
             return buffer;
         const name = 'bw-request-message';
-        super(buffer, proto$2, { name });
+        super(buffer, proto$3, { name });
     }
 }
 
-var proto$1 = {
+var proto$2 = {
     creator: String(),
     contract: new Uint8Array(),
     constructorParameters: Array()
@@ -12602,7 +12561,38 @@ class ContractMessage extends FormatInterface {
     constructor(buffer) {
         if (buffer instanceof ContractMessage)
             return buffer;
-        super(buffer, proto$1, { name: 'contract-message' });
+        super(buffer, proto$2, { name: 'contract-message' });
+    }
+}
+
+var proto$1 = {
+    timestamp: Number(),
+    from: String(),
+    to: String(),
+    method: String(),
+    params: Array(),
+    signature: String(),
+    'nonce?': Number(),
+    'dependsOn?': Array(),
+    'priority?': Boolean()
+};
+
+class TransactionMessage extends FormatInterface {
+    get messageName() {
+        return 'TransactionMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof TransactionMessage)
+            return buffer;
+        const name = 'transaction-message';
+        super(buffer, proto$1, { name });
+    }
+    beforeHashing(decoded) {
+        decoded = super.beforeHashing(decoded);
+        delete decoded.signature;
+        delete decoded.priority;
+        delete decoded.dependsOn;
+        return decoded;
     }
 }
 

package/exports/browser/{index-G74WLzL7-d1Vs_wqe.js → index-G74WLzL7-BZ6_sy39.js}

@@ -1,5 +1,5 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-CC3grAN3.js';
-import './index-Bz6K16zr.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-DRoVQRWp.js';
+import './index--C9N9ZXK.js';
 
 /**
  * @params {String} network

package/exports/browser/{index-YQrIDBUQ-CbL47K_x.js → index-YQrIDBUQ-CqYDmtzG.js}

@@ -1,5 +1,5 @@
-import { i as inherits_browserExports, c as commonjsGlobal, g as getDefaultExportFromCjs, r as require$$3 } from './node-browser-CC3grAN3.js';
-import './index-Bz6K16zr.js';
+import { i as inherits_browserExports, c as commonjsGlobal, g as getDefaultExportFromCjs, r as require$$3 } from './node-browser-DRoVQRWp.js';
+import './index--C9N9ZXK.js';
 
 var browser$2 = {exports: {}};
 

package/exports/browser/{messages-lWRTai7t-Cs3eU5Cb.js → messages-lWRTai7t-3F-6Qszg.js}

@@ -1,5 +1,5 @@
-import { F as FormatInterface } from './node-browser-CC3grAN3.js';
-import './index-Bz6K16zr.js';
+import { F as FormatInterface } from './node-browser-DRoVQRWp.js';
+import './index--C9N9ZXK.js';
 
 var proto$b = {
   data: new Uint8Array(),

package/exports/browser/{node-browser-CC3grAN3.js → node-browser-DRoVQRWp.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface$3, C as ContractMessage, T as TransactionMessage, c as BlockMessage, d as BWMessage, e as BWRequestMessage, V as ValidatorMessage } from './index-Bz6K16zr.js';
+import { F as FormatInterface$3, C as ContractMessage, T as TransactionMessage, c as BlockMessage, d as BWMessage, e as BWRequestMessage, V as ValidatorMessage } from './index--C9N9ZXK.js';
 
 var proto = {
     lastblock: Object(),
@@ -27217,7 +27217,7 @@ class Identity {
             this.selectedAccount = new TextDecoder().decode(selected);
         }
         else {
-            const importee = await import(/* webpackChunkName: "generate-account" */ './index-G74WLzL7-d1Vs_wqe.js');
+            const importee = await import(/* webpackChunkName: "generate-account" */ './index-G74WLzL7-BZ6_sy39.js');
             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));
@@ -27409,7 +27409,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-lWRTai7t-Cs3eU5Cb.js');
+         } = await import(/* webpackChunkName: "messages" */ './messages-lWRTai7t-3F-6Qszg.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -27503,7 +27503,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-A009z8av-DavUUkay.js');
+        const importee = await import('./client-A009z8av-Dw6NYFQr.js');
         /**
          * @access public
          * @type {PeernetClient}

package/exports/browser/node-browser.js

@@ -1,2 +1,2 @@
-export { N as default } from './node-browser-CC3grAN3.js';
-import './index-Bz6K16zr.js';
+export { N as default } from './node-browser-DRoVQRWp.js';
+import './index--C9N9ZXK.js';

package/exports/browser/workers/block-worker.js

@@ -1,4 +1,4 @@
-import { E as EasyWorker, B as BigNumber, a as BlockMessage } from './worker-CFrwP8cD.js';
+import { E as EasyWorker, B as BigNumber, a as BlockMessage } from './worker-Cqj1ERFr.js';
 
 const worker = new EasyWorker();
 

package/exports/browser/workers/machine-worker.js

@@ -1,4 +1,4 @@
-import { E as EasyWorker, B as BigNumber, C as ContractMessage, T as TransactionMessage } from './worker-CFrwP8cD.js';
+import { E as EasyWorker, B as BigNumber, C as ContractMessage, T as TransactionMessage } from './worker-Cqj1ERFr.js';
 
 const byteFormats = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
 const formatBytes = (bytes, decimals = 2) => {
@@ -117,6 +117,10 @@ let nativeMints = 0;
 let nativeTransfers = 0;
 let totalTransactions = 0;
 
+let totalBurnAmount = 0;
+let totalMintAmount = 0;
+let totalTransferAmount = 0;
+
 let blocks = [];
 let contracts = {};
 const _ = {};
@@ -146,7 +150,9 @@ const get = ({ contract, method, params }) => {
   return result
 };
 
-const resolveContract = (address) => askFor('contract', address);
+const resolveContract = (hash) => askFor('contract', hash);
+
+const resolveTransaction = (hash) => askFor('transaction', hash);
 
 const respond = (id, value) => {
   worker.postMessage({
@@ -223,9 +229,18 @@ const _executeTransaction = async (transaction) => {
     await _.execute({ contract: to, method, params });
     if (to === nativeToken$2) {
       nativeCalls += 1;
-      if (method === 'burn') nativeBurns += 1;
-      if (method === 'mint') nativeMints += 1;
-      if (method === 'transfer') nativeTransfers += 1;
+      if (method === 'burn') {
+        nativeBurns += 1;
+        totalBurnAmount += params[0];
+      }
+      if (method === 'mint') {
+        nativeMints += 1;
+        totalMintAmount += params[0];
+      }
+      if (method === 'transfer') {
+        nativeTransfers += 1;
+        totalTransferAmount += params[0];
+      }
     }
     totalTransactions += 1;
 
@@ -241,10 +256,19 @@ const _executeTransaction = async (transaction) => {
 };
 
 _.init = async (message) => {
-  let { peerid, fromState, state } = message;
+  let { peerid, fromState, state, info } = message;
   globalThis.peerid = peerid;
   console.log({ fromState });
   if (fromState) {
+    nativeCalls = info.nativeCalls;
+    nativeBurns = info.nativeBurns;
+    nativeMints = info.nativeMints;
+    nativeTransfers = info.nativeTransfers;
+    totalTransactions = info.totalTransactions;
+    totalBurnAmount = info.totalBurnAmount;
+    totalMintAmount = info.totalMintAmount;
+    totalTransferAmount = info.totalTransferAmount;
+
     lastBlock = message.lastBlock;
     const setState = async (address, state) => {
       const contractBytes = await resolveContract(address);
@@ -284,23 +308,23 @@ _.init = async (message) => {
     );
     console.log({ blocks: message.blocks });
     if (message.blocks?.length > 0) {
-      let pre;
-
-      try {
-        const importee = await import('url');
-        const url = importee.default;
-        if (url) pre = url.fileURLToPath(new URL('.', import.meta.url));
-      } catch {
-        // browser env
-        pre = './';
-      }
+      // let pre
+
+      // try {
+      //   const importee = await import('url')
+      //   const url = importee.default
+      //   if (url) pre = url.fileURLToPath(new URL('.', import.meta.url))
+      // } catch {
+      //   // browser env
+      //   pre = './'
+      // }
 
-      let _worker = await new EasyWorker(pre + './block-worker.js', {
-        serialization: 'advanced',
-        type: 'module'
-      });
-      blocks = await _worker.once(message.blocks);
-      _worker = null;
+      // let _worker = await new EasyWorker(pre + './block-worker.js', {
+      //   serialization: 'advanced',
+      //   type: 'module'
+      // })
+      // blocks = await _worker.once(message.blocks)
+      // _worker = null
       // blocks = unique(globalThis.blocks ? globalThis : [], blocks)
       // for (let i = 0; i < blocks.length; i++) {
 
@@ -311,20 +335,25 @@ _.init = async (message) => {
         // this means contracts will be restored from this state
         // this also means devs NEED to make sure the state can be restored
         // on contract deploy an error will be thrown if state wasn't recoverable
-        if (block.index > 24) {
+        if (block.index >= blocks.length - 24) {
           const transactionCount = blocks[block.index - 1].transactions.length;
           latestTransactions.splice(-(transactionCount - 1), latestTransactions.length);
         }
 
         if (!block.loaded && !fromState) {
-          const priority = block.transactions.filter((transaction) => transaction.priority);
+          const transactions = await Promise.all(
+            block.transactions.map(async (transaction) =>
+              new TransactionMessage(await resolveTransaction(transaction)).decode()
+            )
+          );
+          const priority = transactions.filter((transaction) => transaction.priority)?.sort((a, b) => a.nonce - b.nonce);
           if (priority.length > 0)
-            await Promise.all(
-              priority.sort((a, b) => a.nonce - b.nonce).map((transaction) => _executeTransaction(transaction))
-            );
+            for (const transaction of priority) {
+              await _executeTransaction(transaction);
+            }
 
           await Promise.all(
-            block.transactions
+            transactions
               .filter((transaction) => !transaction.priority)
               .map(async (transaction) => _executeTransaction(transaction))
           );
@@ -418,6 +447,15 @@ worker.onmessage(({ id, type, input }) => {
     case 'nativeTransfers':
       respond(id, nativeTransfers);
       break
+    case 'totalBurnAmount':
+      respond(id, totalBurnAmount);
+      break
+    case 'totalMintAmount':
+      respond(id, totalMintAmount);
+      break
+    case 'totalTransferAmount':
+      respond(id, totalTransferAmount);
+      break
     case 'totalTransfers':
       respond(id, totalTransfers);
       break

package/exports/browser/workers/{worker-CFrwP8cD.js → worker-Cqj1ERFr.js}

@@ -12379,37 +12379,6 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
 const FormatInterface = FormatInterface$1;
 
 var proto$3 = {
-    timestamp: Number(),
-    from: String(),
-    to: String(),
-    method: String(),
-    params: Array(),
-    signature: String(),
-    'nonce?': Number(),
-    'dependsOn?': Array(),
-    'priority?': Boolean()
-};
-
-class TransactionMessage extends FormatInterface {
-    get messageName() {
-        return 'TransactionMessage';
-    }
-    constructor(buffer) {
-        if (buffer instanceof TransactionMessage)
-            return buffer;
-        const name = 'transaction-message';
-        super(buffer, proto$3, { name });
-    }
-    beforeHashing(decoded) {
-        decoded = super.beforeHashing(decoded);
-        delete decoded.signature;
-        delete decoded.priority;
-        delete decoded.dependsOn;
-        return decoded;
-    }
-}
-
-var proto$2 = {
     address: String(),
     reward: BigNumber.from(0)
 };
@@ -12422,17 +12391,17 @@ class ValidatorMessage extends FormatInterface {
         if (buffer instanceof ValidatorMessage)
             return buffer;
         const name = 'validator-message';
-        super(buffer, proto$2, { name });
+        super(buffer, proto$3, { name });
     }
 }
 
-var proto$1 = {
+var proto$2 = {
     index: Number(),
     previousHash: String(),
     timestamp: Number(),
     reward: BigNumber.from(0),
     fees: BigNumber.from(0),
-    transactions: new Uint8Array(),
+    transactions: Array(),
     validators: new Uint8Array()
 };
 
@@ -12444,42 +12413,32 @@ class BlockMessage extends FormatInterface {
         if (buffer instanceof BlockMessage)
             return buffer;
         const name = 'block-message';
-        super(buffer, proto$1, { name });
+        super(buffer, proto$2, { 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)
+            validators: index$5(validators)
         });
     }
     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 = {
+var proto$1 = {
     creator: String(),
     contract: new Uint8Array(),
     constructorParameters: Array()
@@ -12492,7 +12451,38 @@ class ContractMessage extends FormatInterface {
     constructor(buffer) {
         if (buffer instanceof ContractMessage)
             return buffer;
-        super(buffer, proto, { name: 'contract-message' });
+        super(buffer, proto$1, { name: 'contract-message' });
+    }
+}
+
+var proto = {
+    timestamp: Number(),
+    from: String(),
+    to: String(),
+    method: String(),
+    params: Array(),
+    signature: String(),
+    'nonce?': Number(),
+    'dependsOn?': Array(),
+    'priority?': Boolean()
+};
+
+class TransactionMessage extends FormatInterface {
+    get messageName() {
+        return 'TransactionMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof TransactionMessage)
+            return buffer;
+        const name = 'transaction-message';
+        super(buffer, proto, { name });
+    }
+    beforeHashing(decoded) {
+        decoded = super.beforeHashing(decoded);
+        delete decoded.signature;
+        delete decoded.priority;
+        delete decoded.dependsOn;
+        return decoded;
     }
 }