@leofcoin/chain 1.5.68 → 1.6.0

package/exports/chain.js

@@ -9,7 +9,7 @@ import EasyWorker from '@vandeurenglenn/easy-worker';
 import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
 
 const limit = 1800;
-const transactionLimit = 1800;
+const transactionLimit = 1000;
 const requestTimeout = 30000;
 const syncTimeout = 30000;
 class Protocol {
@@ -158,10 +158,7 @@ class Transaction extends Protocol {
     }
     async createTransaction(transaction) {
         return {
-            from: transaction.from,
-            to: transaction.to,
-            method: transaction.method,
-            params: transaction.params,
+            ...transaction,
             timestamp: transaction.timestamp || Date.now(),
             nonce: transaction.nonce || (await this.getNonce(transaction.from)) + 1
         };
@@ -284,13 +281,6 @@ class Machine {
         // @ts-ignore
         return this.#init(blocks);
     }
-    #createMessage(sender = peernet.selectedAccount) {
-        return {
-            sender,
-            call: this.execute,
-            staticCall: this.get.bind(this)
-        };
-    }
     async #onmessage(data) {
         switch (data.type) {
             case 'transactionLoaded': {
@@ -411,8 +401,7 @@ class Machine {
             if (await stateStore.has('lastBlock')) {
                 this.states.lastBlock = JSON.parse(new TextDecoder().decode(await stateStore.get('lastBlock')));
                 this.states.states = JSON.parse(new TextDecoder().decode(await stateStore.get('states')));
-                console.log(await stateStore.get('states'));
-                console.log({ states: this.states });
+                console.log({ balances: this.states.states[addresses.nativeToken].balances });
             }
             const message = {
                 type: 'init',
@@ -786,25 +775,39 @@ class State extends Contract {
             throw error;
         }
         try {
-            const localBlock = await globalThis.chainStore.get('lastBlock');
-            console.log({ localBlock });
-            const localBlockHash = new TextDecoder().decode(localBlock);
-            if (localBlockHash !== '0x0') {
+            let localBlockHash;
+            try {
+                const localBlock = await globalThis.chainStore.get('lastBlock');
+                localBlockHash = new TextDecoder().decode(localBlock);
+            }
+            catch (error) { }
+            if (localBlockHash && localBlockHash !== '0x0') {
                 const blockMessage = new BlockMessage(await peernet.get(localBlockHash, 'block'));
-                const states = { lastBlock: JSON.parse(new TextDecoder().decode(await globalThis.stateStore.get('lastBlock'))) };
-                if (blockMessage.decoded.index > states.lastBlock.index)
+                try {
+                    const states = {
+                        lastBlock: JSON.parse(new TextDecoder().decode(await globalThis.stateStore.get('lastBlock')))
+                    };
+                    if (blockMessage.decoded.index > states.lastBlock.index)
+                        await this.resolveBlocks();
+                }
+                catch (error) {
+                    // no states found, try resolving blocks
                     await this.resolveBlocks();
+                }
             }
             else {
                 await this.resolveBlocks();
             }
             this.#machine = await new Machine(this.#blocks);
             const lastBlock = await this.#machine.lastBlock;
-            this.updateState(new BlockMessage(lastBlock));
+            if (lastBlock.hash !== '0x0') {
+                this.updateState(new BlockMessage(lastBlock));
+            }
             this.#loaded = true;
             // await this.#loadBlocks(this.#blocks)
         }
         catch (error) {
+            console.log('e');
             if (isResolveError(error)) {
                 console.error(error);
             }
@@ -814,14 +817,13 @@ class State extends Contract {
     async updateState(message) {
         try {
             const hash = await message.hash();
-            // await this.state.updateState(message)
             await globalThis.chainStore.put('lastBlock', hash);
             globalThis.pubsub.publish('lastBlock', message.encoded);
+            await this.#machine.updateState();
         }
         catch (error) {
             console.error(error);
         }
-        await this.#machine.updateState();
     }
     getLatestBlock() {
         // @ts-ignore
@@ -842,9 +844,9 @@ class State extends Contract {
     }
     async #resolveBlock(hash) {
         let index = this.#blockHashMap.get(hash);
-        if (this.#blocks[index - 1]) {
-            if (this.#blocks[index - 1].previousHash !== '0x0') {
-                return this.resolveBlock(this.#blocks[index - 1].previousHash);
+        if (this.#blocks[index]) {
+            if (this.#blocks[index].previousHash !== '0x0') {
+                return this.resolveBlock(this.#blocks[index].previousHash);
             }
             else {
                 return;
@@ -855,11 +857,11 @@ class State extends Contract {
             index = block.decoded.index;
             const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
             this.#totalSize += size;
-            this.#blocks[index - 1] = { hash, ...block.decoded };
+            this.#blocks[index] = { hash, ...block.decoded };
             this.#blockHashMap.set(hash, index);
             debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
             globalThis.pubsub.publish('block-resolved', { hash, index });
-            this.#lastResolved = this.#blocks[index - 1];
+            this.#lastResolved = this.#blocks[index];
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
@@ -1271,7 +1273,7 @@ class Chain extends VersionControl {
         console.log('epoch');
         const validators = await this.staticCall(addresses.validators, 'validators');
         console.log({ validators });
-        if (!validators[peernet.selectedAccount]?.active)
+        if (!validators.includes(peernet.selectedAccount))
             return;
         const start = Date.now();
         try {
@@ -1431,17 +1433,17 @@ class Chain extends VersionControl {
         await Promise.all(blockMessage.decoded.transactions
             // @ts-ignore
             .map(async (transaction) => {
+            // @ts-ignore
             let hash = transaction.hash;
             if (!hash) {
                 hash = await new TransactionMessage(transaction).hash();
+                // @ts-ignore
                 transaction.hash = hash;
             }
             (await transactionPoolStore.has(hash)) && (await transactionPoolStore.delete(hash));
             return transaction;
         }));
         await globalThis.blockStore.put(hash, blockMessage.encoded);
-        if ((await this.lastBlock).index < Number(blockMessage.decoded.index))
-            await this.updateState(blockMessage);
         debug(`added block: ${hash}`);
         let promises = [];
         let contracts = [];
@@ -1462,13 +1464,10 @@ class Chain extends VersionControl {
                     globalThis.pubsub.publish('account-transaction-processed', transaction);
                 await globalThis.accountsStore.put(transaction.from, String(transaction.nonce));
             }
-            // todo finish state
-            // for (const contract of contracts) {
-            //   const state = await this.machine.get(contract, 'state')
-            //   // await stateStore.put(contract, state)
-            //   console.log(state);
-            // }
-            // await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() })
+            if ((await this.lastBlock).index < Number(blockMessage.decoded.index)) {
+                await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() });
+                await this.updateState(blockMessage);
+            }
             globalThis.pubsub.publish('block-processed', blockMessage.decoded);
         }
         catch (error) {
@@ -1531,6 +1530,7 @@ class Chain extends VersionControl {
     }
     // todo filter tx that need to wait on prev nonce
     async #createBlock(limit = this.transactionLimit) {
+        console.log(await globalThis.transactionPoolStore.size());
         // vote for transactions
         if ((await globalThis.transactionPoolStore.size()) === 0)
             return;
@@ -1548,19 +1548,22 @@ class Chain extends VersionControl {
             index: 0
         };
         const latestTransactions = await this.machine.latestTransactions();
+        console.log({ latestTransactions });
         // exclude failing tx
         transactions = await this.promiseTransactions(transactions);
-        const priority = transactions.filter((transaction) => transaction.priority);
-        await Promise.all(priority
-            .sort((a, b) => a.nonce - b.nonce)
-            .map((transaction) => this.#handleTransaction(transaction, latestTransactions, block)));
+        const priority = transactions
+            .filter((transaction) => transaction.decoded.priority)
+            .sort((a, b) => a.decoded.nonce - b.decoded.nonce);
+        for (const transaction of priority) {
+            await this.#handleTransaction(transaction, latestTransactions, block);
+        }
         await Promise.all(transactions
-            .filter((transaction) => !transaction.priority)
+            .filter((transaction) => !transaction.decoded.priority)
             .map((transaction) => this.#handleTransaction(transaction, latestTransactions, block)));
         // don't add empty block
         if (block.transactions.length === 0)
             return;
-        const validators = await this.staticCall(addresses.validators, 'validators');
+        const validators = (await this.staticCall(addresses.validators, 'validators'));
         // block.validators = Object.keys(block.validators).reduce((set, key) => {
         //   if (block.validators[key].active) {
         //     push({
@@ -1572,27 +1575,25 @@ class Chain extends VersionControl {
         for (const entry of globalThis.peernet.peers) {
             peers[entry[0]] = entry[1];
         }
-        for (const validator of Object.keys(validators)) {
-            if (validators[validator].active) {
-                const peer = peers[validator];
-                if (peer && peer.connected && peer.version === this.version) {
-                    let data = await new BWRequestMessage();
-                    const node = await globalThis.peernet.prepareMessage(data.encoded);
-                    try {
-                        const bw = await peer.request(node.encoded);
-                        block.validators.push({
-                            address: validator,
-                            bw: bw.up + bw.down
-                        });
-                    }
-                    catch { }
-                }
-                else if (globalThis.peernet.selectedAccount === validator) {
+        for (const validator of validators) {
+            const peer = peers[validator];
+            if (peer && peer.connected && peer.version === this.version) {
+                let data = await new BWRequestMessage();
+                const node = await globalThis.peernet.prepareMessage(data.encoded);
+                try {
+                    const bw = await peer.request(node.encoded);
                     block.validators.push({
-                        address: globalThis.peernet.selectedAccount,
-                        bw: globalThis.peernet.bw.up + globalThis.peernet.bw.down
+                        address: validator,
+                        bw: bw.up + bw.down
                     });
                 }
+                catch { }
+            }
+            else if (globalThis.peernet.selectedAccount === validator) {
+                block.validators.push({
+                    address: globalThis.peernet.selectedAccount,
+                    bw: globalThis.peernet.bw.up + globalThis.peernet.bw.down
+                });
             }
         }
         block.validators = block.validators.map((validator) => {
@@ -1621,15 +1622,13 @@ class Chain extends VersionControl {
             let blockMessage = await new BlockMessage(block);
             const hash = await blockMessage.hash();
             await globalThis.peernet.put(hash, blockMessage.encoded, 'block');
-            await this.updateState(blockMessage);
             await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() });
+            await this.updateState(blockMessage);
             debug(`created block: ${hash} @${block.index}`);
             globalThis.peernet.publish('add-block', blockMessage.encoded);
             globalThis.pubsub.publish('add-block', blockMessage.decoded);
         }
         catch (error) {
-            console.log(error);
-            console.log('eeeee');
             throw new Error(`invalid block ${block}`);
         }
         // data = await this.machine.execute(to, method, params)
@@ -1647,8 +1646,6 @@ class Chain extends VersionControl {
                 this.#runEpoch();
         }
         catch (e) {
-            console.log(e);
-            console.log('rrrrr');
             globalThis.peernet.publish('invalid-transaction', hash);
             throw new Error('invalid transaction');
         }
@@ -1679,8 +1676,9 @@ class Chain extends VersionControl {
      * @param {Address} sender
      * @returns {globalMessage}
      */
-    #createMessage(sender = globalThis.peernet.selectedAccount) {
+    #createMessage(sender = globalThis.peernet.selectedAccount, contract) {
         return {
+            contract,
             sender,
             call: this.call,
             staticCall: this.staticCall
@@ -1695,7 +1693,7 @@ class Chain extends VersionControl {
      * @returns
      */
     internalCall(sender, contract, method, parameters) {
-        globalThis.msg = this.#createMessage(sender);
+        globalThis.msg = this.#createMessage(sender, contract);
         return this.machine.execute(contract, method, parameters);
     }
     /**
@@ -1706,11 +1704,11 @@ class Chain extends VersionControl {
      * @returns
      */
     call(contract, method, parameters) {
-        globalThis.msg = this.#createMessage();
+        globalThis.msg = this.#createMessage(peernet.selectedAccount, contract);
         return this.machine.execute(contract, method, parameters);
     }
     staticCall(contract, method, parameters) {
-        globalThis.msg = this.#createMessage();
+        globalThis.msg = this.#createMessage(peernet.selectedAccount, contract);
         return this.machine.get(contract, method, parameters);
     }
     mint(to, amount) {

package/exports/protocol.d.ts

@@ -1,6 +1,6 @@
 import type { ChainConfig } from './types.js';
 export declare const limit = 1800;
-export declare const transactionLimit = 1800;
+export declare const transactionLimit = 1000;
 export declare const requestTimeout = 30000;
 export declare const syncTimeout = 30000;
 export declare class Protocol {

package/exports/state.d.ts

@@ -38,7 +38,7 @@ export default class State extends Contract {
      */
     clearAll(): Promise<void>;
     init(): Promise<void>;
-    updateState(message: any): Promise<void>;
+    updateState(message: BlockMessage): Promise<void>;
     getLatestBlock(): Promise<BlockMessage['decoded']>;
     getAndPutBlock(hash: string): Promise<BlockMessage>;
     resolveBlock(hash: any): any;

package/exports/transaction.d.ts

@@ -30,14 +30,7 @@ export default class Transaction extends Protocol {
     validateNonce(address: any, nonce: any): Promise<void>;
     isTransactionMessage(message: any): boolean;
     createTransactionMessage(transaction: any, signature: any): Promise<TransactionMessage>;
-    createTransaction(transaction: any): Promise<{
-        from: any;
-        to: any;
-        method: any;
-        params: any;
-        timestamp: any;
-        nonce: any;
-    }>;
+    createTransaction(transaction: any): Promise<any>;
     sendTransaction(message: any): Promise<{
         hash: any;
         data: any;