@leofcoin/chain 1.5.25 → 1.5.26

package/exports/chain.js

@@ -41,11 +41,11 @@ class Transaction extends Protocol {
         return new Promise(async (resolve, reject) => {
             let size = 0;
             const _transactions = [];
-            await Promise.all(transactions
-                .map(async (tx) => {
+            await Promise.all(transactions.map(async (tx) => {
                 tx = await new TransactionMessage(tx);
                 size += tx.encoded.length;
-                if (!formatBytes(size).includes('MB') || formatBytes(size).includes('MB') && Number(formatBytes(size).split(' MB')[0]) <= 0.75)
+                if (!formatBytes(size).includes('MB') ||
+                    (formatBytes(size).includes('MB') && Number(formatBytes(size).split(' MB')[0]) <= 0.75))
                     _transactions.push({ ...tx.decoded, hash: await tx.hash() });
                 else
                     resolve(_transactions);
@@ -59,7 +59,7 @@ class Transaction extends Protocol {
      * @returns {TransactionMessage}
      */
     async promiseTransactions(transactions) {
-        transactions = await Promise.all(transactions.map(tx => new TransactionMessage(tx.encoded || tx)));
+        transactions = await Promise.all(transactions.map((tx) => new TransactionMessage(tx.encoded || tx)));
         return transactions;
     }
     /**
@@ -68,7 +68,7 @@ class Transaction extends Protocol {
      * @returns {Object} {transaction.decoded, transaction.hash}
      */
     async promiseTransactionsContent(transactions) {
-        transactions = await Promise.all(transactions.map(tx => new Promise(async (resolve, reject) => {
+        transactions = await Promise.all(transactions.map((tx) => new Promise(async (resolve, reject) => {
             resolve({ ...tx.decoded, hash: await tx.hash() });
         })));
         return transactions;
@@ -81,7 +81,7 @@ class Transaction extends Protocol {
     async #getNonceFallback(address) {
         let transactions = await globalThis.transactionPoolStore.values();
         transactions = await this.promiseTransactions(transactions);
-        transactions = transactions.filter(tx => tx.decoded.from === address);
+        transactions = transactions.filter((tx) => tx.decoded.from === address);
         transactions = await this.promiseTransactionsContent(transactions);
         // @ts-ignore
         if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
@@ -92,11 +92,11 @@ class Transaction extends Protocol {
             //   tx = await peernet.get(tx, 'transaction')
             //   transactions.push(new TransactionMessage(tx))
             // }
-            transactions = transactions.filter(tx => tx.from === address);
+            transactions = transactions.filter((tx) => tx.from === address);
             while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== '0x0') {
                 block = await globalThis.blockStore.get(block.decoded.previousHash);
                 block = await new BlockMessage(block);
-                transactions = block.decoded.transactions.filter(tx => tx.from === address);
+                transactions = block.decoded.transactions.filter((tx) => tx.from === address);
             }
         }
         if (transactions.length === 0)
@@ -110,7 +110,7 @@ class Transaction extends Protocol {
      * @returns {Number} nonce
      */
     async getNonce(address) {
-        if (!await globalThis.accountsStore.has(address)) {
+        if (!(await globalThis.accountsStore.has(address))) {
             const nonce = await this.#getNonceFallback(address);
             await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce)));
         }
@@ -119,7 +119,7 @@ class Transaction extends Protocol {
         nonce = new TextDecoder().decode(nonce);
         let transactions = await globalThis.transactionPoolStore.values();
         transactions = await this.promiseTransactions(transactions);
-        transactions = transactions.filter(tx => tx.decoded.from === address);
+        transactions = transactions.filter((tx) => tx.decoded.from === address);
         transactions = await this.promiseTransactionsContent(transactions);
         for (const transaction of transactions) {
             if (transaction.nonce > nonce)
@@ -136,7 +136,7 @@ class Transaction extends Protocol {
             throw new Error(`a transaction with the same nonce already exists`);
         let transactions = await globalThis.transactionPoolStore.values();
         transactions = await this.promiseTransactions(transactions);
-        transactions = transactions.filter(tx => tx.decoded.from === address);
+        transactions = transactions.filter((tx) => tx.decoded.from === address);
         for (const transaction of transactions) {
             if (transaction.decoded.nonce > nonce)
                 throw new Error(`a transaction with a higher nonce already exists`);
@@ -215,8 +215,7 @@ class Contract extends Transaction {
     constructor() {
         super();
     }
-    async init() {
-    }
+    async init() { }
     /**
      *
      * @param {Address} creator
@@ -335,7 +334,10 @@ class Machine {
                 // browser env
                 pre = './';
             }
-            this.worker = await new EasyWorker(pre + 'workers/machine-worker.js', { serialization: 'advanced', type: 'module' });
+            this.worker = await new EasyWorker(pre + 'workers/machine-worker.js', {
+                serialization: 'advanced',
+                type: 'module'
+            });
             this.worker.onmessage(this.#onmessage.bind(this));
             // const blocks = await blockStore.values()
             const contracts = await Promise.all([
@@ -361,7 +363,7 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(message.error);
@@ -393,7 +395,7 @@ class Machine {
                 if (await this.has(parameters[0]))
                     throw new Error(`duplicate contract @${parameters[0]}`);
                 let message;
-                if (!await globalThis.contractStore.has(parameters[0])) {
+                if (!(await globalThis.contractStore.has(parameters[0]))) {
                     message = await peernet.get(parameters[0], 'contract');
                     message = await new ContractMessage(message);
                     await globalThis.contractStore.put(await message.hash(), message.encoded);
@@ -402,7 +404,7 @@ class Machine {
                     message = await globalThis.contractStore.get(parameters[0]);
                     message = await new ContractMessage(message);
                 }
-                if (!await this.has(await message.hash()))
+                if (!(await this.has(await message.hash())))
                     await this.#runContract(message);
             }
         }
@@ -412,7 +414,7 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(new ExecutionError(message.error));
@@ -434,7 +436,7 @@ class Machine {
     get(contract, method, parameters) {
         return new Promise((resolve, reject) => {
             const id = randombytes(20).toString();
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 resolve(message);
             };
@@ -454,7 +456,7 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(message.error);
@@ -480,7 +482,7 @@ class Machine {
      */
     async deleteAll() {
         let hashes = await globalThis.contractStore.keys();
-        hashes = Object.keys(hashes).map(hash => this.delete(hash));
+        hashes = Object.keys(hashes).map((hash) => this.delete(hash));
         return Promise.all(hashes);
     }
 }
@@ -635,20 +637,27 @@ class State extends Contract {
          */
         this.#totalTransactions = 0;
         this.#chainStateHandler = () => {
-            return new globalThis.peernet.protos['peernet-response']({ response: this.#chainState });
+            return new globalThis.peernet.protos['peernet-response']({
+                response: this.#chainState
+            });
         };
         this.#lastBlockHandler = async () => {
-            return new globalThis.peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
+            return new globalThis.peernet.protos['peernet-response']({
+                response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index }
+            });
         };
         this.#knownBlocksHandler = async () => {
-            return new globalThis.peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
+            return new globalThis.peernet.protos['peernet-response']({
+                response: { blocks: this.#blocks.map((block) => block.hash) }
+            });
         };
         this.#loadBlockTransactions = (transactions) => Promise.all(transactions.map((transaction) => new TransactionMessage(transaction)));
         this.#getLastTransactions = async () => {
-            let lastTransactions = (await Promise.all(this.#blocks.filter(block => block.loaded).slice(-128)
-                .map(block => this.#loadBlockTransactions(block.transactions))))
-                .reduce((all, transactions) => [...all, ...transactions], []);
-            return Promise.all(lastTransactions.map(transaction => transaction.hash()));
+            let lastTransactions = (await Promise.all(this.#blocks
+                .filter((block) => block.loaded)
+                .slice(-128)
+                .map((block) => this.#loadBlockTransactions(block.transactions)))).reduce((all, transactions) => [...all, ...transactions], []);
+            return Promise.all(lastTransactions.map((transaction) => transaction.hash()));
         };
     }
     async clearPool() {
@@ -686,7 +695,10 @@ class State extends Contract {
             if (localBlock && localBlock !== '0x0') {
                 localBlock = await globalThis.peernet.get(localBlock, 'block');
                 localBlock = await new BlockMessage(localBlock);
-                this.#lastBlock = { ...localBlock.decoded, hash: await localBlock.hash() };
+                this.#lastBlock = {
+                    ...localBlock.decoded,
+                    hash: await localBlock.hash()
+                };
             }
             else {
                 if (globalThis.peernet?.connections.length > 0) {
@@ -739,7 +751,7 @@ class State extends Contract {
             const { index } = block.decoded;
             if (this.#blocks[index - 1] && this.#blocks[index - 1].hash !== block.hash)
                 throw `invalid block ${hash} @${index}`;
-            if (!await globalThis.peernet.has(hash))
+            if (!(await globalThis.peernet.has(hash)))
                 await globalThis.peernet.put(hash, block.encoded, 'block');
         }
         return block;
@@ -841,8 +853,7 @@ class State extends Contract {
             // console.log(e);
         }
     }
-    destroyResolveJob() {
-    }
+    destroyResolveJob() { }
     async syncChain(lastBlock) {
         if (!this.shouldSync)
             return;
@@ -901,7 +912,7 @@ class State extends Contract {
                 console.log('ok');
                 let blocksSynced = localIndex > 0 ? (localIndex > index ? localIndex - index : index + -localIndex) : index;
                 globalThis.debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`);
-                const start = (this.#blocks.length - blocksSynced);
+                const start = this.#blocks.length - blocksSynced;
                 if (this.#machine)
                     await this.#loadBlocks(this.blocks.slice(start));
                 await this.updateState(new BlockMessage(this.#blocks[this.#blocks.length - 1]));
@@ -914,7 +925,9 @@ class State extends Contract {
     }
     async #getLatestBlock() {
         let promises = [];
-        let data = await new globalThis.peernet.protos['peernet-request']({ request: 'lastBlock' });
+        let data = await new globalThis.peernet.protos['peernet-request']({
+            request: 'lastBlock'
+        });
         let node = await globalThis.peernet.prepareMessage(data);
         for (const peer of globalThis.peernet?.connections) {
             // @ts-ignore
@@ -946,7 +959,9 @@ class State extends Contract {
             latest = { ...message.decoded, hash };
             const peer = promises[0].peer;
             if (peer.connected && peer.version === this.version) {
-                let data = await new globalThis.peernet.protos['peernet-request']({ request: 'knownBlocks' });
+                let data = await new globalThis.peernet.protos['peernet-request']({
+                    request: 'knownBlocks'
+                });
                 let node = await globalThis.peernet.prepareMessage(data);
                 let message = await peer.request(node);
                 message = await new globalThis.peernet.protos['peernet-response'](message);
@@ -1051,7 +1066,7 @@ class State extends Contract {
         if (this.#resolveErrored ||
             this.#syncState === 'errored' ||
             this.#syncState === 'connectionless' ||
-            !this.canSync && this.#lastResolvedTime + this.resolveTimeout > Date.now())
+            (!this.canSync && this.#lastResolvedTime + this.resolveTimeout > Date.now()))
             return true;
         return false;
     }
@@ -1071,7 +1086,7 @@ class VersionControl extends State {
         super();
     }
     async init() {
-        super.init && await super.init();
+        super.init && (await super.init());
         console.log('init');
         try {
             const version = await globalThis.chainStore.get('version');
@@ -1153,29 +1168,34 @@ class Chain extends VersionControl {
             console.error(error);
         }
         const end = Date.now();
-        console.log(((end - start) / 1000) + ' s');
+        console.log((end - start) / 1000 + ' s');
         if (await this.hasTransactionToHandle())
             return this.#runEpoch();
         this.#runningEpoch = false;
         // if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
     }
     async #setup() {
-        const contracts = [{
+        const contracts = [
+            {
                 address: addresses.contractFactory,
                 message: contractFactoryMessage
-            }, {
+            },
+            {
                 address: addresses.nativeToken,
                 message: nativeTokenMessage
-            }, {
+            },
+            {
                 address: addresses.validators,
                 message: validatorsMessage
-            }, {
+            },
+            {
                 address: addresses.nameService,
                 message: nameServiceMessage
-            }];
+            }
+        ];
         await Promise.all(contracts.map(async ({ address, message }) => {
             // @ts-ignore
-            message = await new ContractMessage(Uint8Array.from(message.split(',').map(string => Number(string))));
+            message = await new ContractMessage(Uint8Array.from(message.split(',').map((string) => Number(string))));
             // @ts-ignore
             await globalThis.contractStore.put(address, message.encoded);
         }));
@@ -1197,7 +1217,7 @@ class Chain extends VersionControl {
             return new BWMessage(globalThis.peernet.client.bw) || { up: 0, down: 0 };
         });
         // await globalThis.peernet.addRequestHandler('peerId', () => {
-        //   let node = 
+        //   let node =
         //   globalThis.peernet.protos['peernet-response']({response: node.encoded})
         // })
         await globalThis.peernet.addRequestHandler('transactionPool', this.#transactionPoolHandler.bind(this));
@@ -1253,7 +1273,7 @@ class Chain extends VersionControl {
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
         const higherThenCurrentLocal = lastBlock.index > this.lastBlock?.index;
-        const peerTransactionPool = higherThenCurrentLocal && await this.getPeerTransactionPool(peer) || [];
+        const peerTransactionPool = (higherThenCurrentLocal && (await this.getPeerTransactionPool(peer))) || [];
         if (Object.keys(lastBlock).length > 0) {
             if (!this.lastBlock || higherThenCurrentLocal) {
                 this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
@@ -1342,7 +1362,7 @@ class Chain extends VersionControl {
         // peerReputation(peerId)
         // {bandwith: {up, down}, uptime}
         this.#participating = true;
-        if (!await this.staticCall(addresses.validators, 'has', [address])) {
+        if (!(await this.staticCall(addresses.validators, 'has', [address]))) {
             const rawTransaction = {
                 from: address,
                 to: addresses.validators,
@@ -1354,13 +1374,13 @@ class Chain extends VersionControl {
             const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
             await this.sendTransaction(transaction);
         }
-        if (await this.hasTransactionToHandle() && !this.#runningEpoch && this.#participating)
+        if ((await this.hasTransactionToHandle()) && !this.#runningEpoch && this.#participating)
             await this.#runEpoch();
     }
     // todo filter tx that need to wait on prev nonce
     async #createBlock(limit = this.transactionLimit) {
         // vote for transactions
-        if (await globalThis.transactionPoolStore.size() === 0)
+        if ((await globalThis.transactionPoolStore.size()) === 0)
             return;
         let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
         for (const hash of await globalThis.transactionPoolStore.keys()) {
@@ -1453,7 +1473,7 @@ class Chain extends VersionControl {
                 }
             }
         }
-        block.validators = block.validators.map(validator => {
+        block.validators = block.validators.map((validator) => {
             validator.reward = block.fees;
             validator.reward = validator.reward.add(block.reward);
             validator.reward = validator.reward.div(block.validators.length);
@@ -1471,8 +1491,7 @@ class Chain extends VersionControl {
         // block.reward = block.reward.toString()
         // block.fees = block.fees.toString()
         try {
-            block.transactions = await Promise.all(block.transactions
-                .map(async (transaction) => {
+            block.transactions = await Promise.all(block.transactions.map(async (transaction) => {
                 await globalThis.transactionPoolStore.delete(await transaction.hash());
                 return transaction.decoded;
             }));

package/exports/contract.d.ts

@@ -1,4 +1,4 @@
-import Transaction from "./transaction.js";
+import Transaction from './transaction.js';
 import type MultiWallet from '@leofcoin/multi-wallet';
 /**
  * @extends {Transaction}

package/exports/node.js

@@ -16,7 +16,9 @@ class Node {
         stars: networks.leofcoin.peach.stars,
         autoStart: false
     }, password) {
-        this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
+        this.#node = globalThis.Peernet
+            ? await new globalThis.Peernet(config, password)
+            : await new Peernet(config, password);
         await nodeConfig(config);
         globalThis.pubsub.subscribe('chain:ready', async () => {
             // when autostart is false the node will only be started after the chain is ready (this is here so we can just use node for communication)

package/exports/transaction.d.ts

@@ -1,5 +1,5 @@
-import Protocol from "./protocol.js";
-import { TransactionMessage } from "@leofcoin/messages";
+import Protocol from './protocol.js';
+import { TransactionMessage } from '@leofcoin/messages';
 export default class Transaction extends Protocol {
     #private;
     constructor();

package/exports/version-control.d.ts

@@ -1,4 +1,4 @@
-import State from "./state.js";
+import State from './state.js';
 export declare class VersionControl extends State {
     constructor();
     init(): Promise<void>;

package/exports/workers/block-worker.js

@@ -1,29 +1,33 @@
-import { E as EasyWorker, B as BigNumber, a as BlockMessage, f as formatBytes } from './worker-0f66935f.js';
+import { E as EasyWorker, B as BigNumber, a as BlockMessage, f as formatBytes } from './worker-5b02efbe.js';
 
-const worker = new EasyWorker();
-
-globalThis.BigNumber = BigNumber;
-globalThis.contracts = {};
-
-const run = async (blocks) => {  
-  blocks = await Promise.all(blocks.map(block => new BlockMessage(block)));
-  blocks = blocks.sort((a, b) => a.decoded.timestamp - b.decoded.timestamp);
-
-  blocks = await Promise.all(blocks.map(block => new Promise(async (resolve, reject) => {
-    // todo: tx worker or nah?
-    await block.encode();
-    const size = block.encoded.length || block.encoded.byteLength;
-    console.log(`loaded block: ${await block.hash()} @${block.decoded.index} ${formatBytes(size)}`);
-    // todo we don't want this, need shared state
-    resolve(block.decoded);
-  })));
-  return blocks
-};
-
-const tasks = async blocks => {  
-  blocks = await run(blocks);
-  worker.postMessage(blocks);
-};
- 
-
-worker.onmessage(data => tasks(data));
+const worker = new EasyWorker();
+
+globalThis.BigNumber = BigNumber;
+globalThis.contracts = {};
+
+const run = async (blocks) => {
+  blocks = await Promise.all(blocks.map((block) => new BlockMessage(block)));
+  blocks = blocks.sort((a, b) => a.decoded.timestamp - b.decoded.timestamp);
+
+  blocks = await Promise.all(
+    blocks.map(
+      (block) =>
+        new Promise(async (resolve, reject) => {
+          // todo: tx worker or nah?
+          await block.encode();
+          const size = block.encoded.length || block.encoded.byteLength;
+          console.log(`loaded block: ${await block.hash()} @${block.decoded.index} ${formatBytes(size)}`);
+          // todo we don't want this, need shared state
+          resolve(block.decoded);
+        })
+    )
+  );
+  return blocks
+};
+
+const tasks = async (blocks) => {
+  blocks = await run(blocks);
+  worker.postMessage(blocks);
+};
+
+worker.onmessage((data) => tasks(data));