@leofcoin/chain 1.5.67 → 1.5.69

package/exports/browser/workers/{worker-CltAyHf1.js → worker-CbAak_hM.js}

@@ -12430,55 +12430,56 @@ class ValidatorMessage extends FormatInterface {
 }
 
 var proto$1 = {
-  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$1, { 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$1, { 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 = {

package/exports/chain.js

@@ -1,7 +1,7 @@
 import '@vandeurenglenn/debug';
 import { formatBytes, BigNumber, formatUnits, parseUnits } from '@leofcoin/utils';
 import { TransactionMessage, BlockMessage, ContractMessage, BWMessage, BWRequestMessage } from '@leofcoin/messages';
-import addresses, { contractFactory, nativeToken, validators, nameService } from '@leofcoin/addresses';
+import addresses, { contractFactory } from '@leofcoin/addresses';
 import { calculateFee, createContractMessage, signTransaction, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
 import semver from 'semver';
 import { randombytes } from '@leofcoin/crypto';
@@ -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
         };
@@ -273,19 +270,17 @@ class Contract extends Transaction {
 // import State from './state'
 const debug$2 = globalThis.createDebugger('leofcoin/machine');
 class Machine {
-    #contracts = {};
-    #nonces = {};
     constructor(blocks) {
+        this.states = {
+            states: {},
+            lastBlock: {
+                index: 0,
+                hash: ''
+            }
+        };
         // @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': {
@@ -336,12 +331,54 @@ class Machine {
                 pubsub.publish(data.id, data.value || false);
                 break;
             }
+            case 'ask': {
+                if (data.question === 'contract') {
+                    const input = await peernet.get(data.input, 'contract');
+                    this.worker.postMessage({ id: data.id, input });
+                }
+            }
+        }
+    }
+    async updateState() {
+        try {
+            if ((await this.lastBlock).index > this.states.lastBlock.index) {
+                // todo only get state for changed contracts
+                const blocks = (await this.blocks).slice(this.states.lastBlock.index);
+                const contractsToGet = blocks.reduce((set, current) => {
+                    for (const transaction of current.transactions) {
+                        const contract = transaction.to;
+                        if (!set.includes(contract))
+                            set.push(contract);
+                    }
+                    return set;
+                }, []);
+                const state = {};
+                console.log({ contractsToGet });
+                if (!contractsToGet.includes(addresses.contractFactory))
+                    contractsToGet.push(addresses.contractFactory);
+                if (!contractsToGet.includes(addresses.nativeToken))
+                    contractsToGet.push(addresses.nativeToken);
+                if (!contractsToGet.includes(addresses.nameService))
+                    contractsToGet.push(addresses.nameService);
+                if (!contractsToGet.includes(addresses.validators))
+                    contractsToGet.push(addresses.validators);
+                await Promise.all(contractsToGet.map(async (contract) => {
+                    const value = await this.#askWorker('get', { contract, method: 'state', params: [] });
+                    state[contract] = value;
+                }));
+                await stateStore.put('lastBlock', JSON.stringify(await this.lastBlock));
+                await stateStore.put('states', JSON.stringify(state));
+            }
+        }
+        catch (error) {
+            console.error(error);
         }
     }
     async #init(blocks) {
         return new Promise(async (resolve) => {
-            const machineReady = () => {
+            const machineReady = async () => {
                 pubsub.unsubscribe('machine.ready', machineReady);
+                await this.updateState();
                 resolve(this);
             };
             pubsub.subscribe('machine.ready', machineReady);
@@ -361,18 +398,18 @@ class Machine {
                 type: 'module'
             });
             this.worker.onmessage(this.#onmessage.bind(this));
-            // const blocks = await blockStore.values()
-            const contracts = await Promise.all([
-                globalThis.contractStore.get(contractFactory),
-                globalThis.contractStore.get(nativeToken),
-                globalThis.contractStore.get(validators),
-                globalThis.contractStore.get(nameService)
-            ]);
+            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({ balances: this.states.states[addresses.nativeToken].balances });
+            }
             const message = {
                 type: 'init',
                 input: {
-                    contracts,
                     blocks,
+                    fromState: this.states.lastBlock.index > 0,
+                    lastBlock: this.states.lastBlock,
+                    state: this.states.states,
                     // @ts-ignore
                     peerid: peernet.peerId
                 }
@@ -692,8 +729,10 @@ class State extends Contract {
         this.#loadBlockTransactions = (transactions) => Promise.all(transactions.map((transaction) => new TransactionMessage(transaction)));
         this.#getLastTransactions = async () => {
             let lastTransactions = (await Promise.all((await this.blocks)
+                // @ts-ignore
                 .filter((block) => block.loaded)
                 .slice(-24)
+                // @ts-ignore
                 .map((block) => this.#loadBlockTransactions(block.transactions)))).reduce((all, transactions) => [...all, ...transactions], []);
             return Promise.all(lastTransactions.map((transaction) => transaction.hash()));
         };
@@ -736,14 +775,40 @@ class State extends Contract {
             throw error;
         }
         try {
-            await this.resolveBlocks();
+            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'));
+                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));
+            console.log({ 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);
             }
@@ -760,6 +825,7 @@ class State extends Contract {
         catch (error) {
             console.error(error);
         }
+        await this.#machine.updateState();
     }
     getLatestBlock() {
         // @ts-ignore
@@ -780,9 +846,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;
@@ -793,11 +859,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) {
@@ -1209,7 +1275,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 {
@@ -1469,6 +1535,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;
@@ -1486,19 +1553,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({
@@ -1510,27 +1580,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) => {
@@ -1617,8 +1685,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
@@ -1633,7 +1702,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);
     }
     /**
@@ -1644,11 +1713,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/machine.d.ts

@@ -2,7 +2,15 @@ import EasyWorker from '@vandeurenglenn/easy-worker';
 export default class Machine {
     #private;
     worker: EasyWorker;
+    states: {
+        states: {};
+        lastBlock: {
+            index: number;
+            hash: string;
+        };
+    };
     constructor(blocks: any);
+    updateState(): Promise<void>;
     /**
      *
      * @param {Address} contract

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/simplifiers/state.d.ts

@@ -0,0 +1,3 @@
+export declare const shouldResolveBlocks: () => void;
+export declare const shouldLoadBlocks: () => void;
+export declare const shouldLoadFromState: () => void;

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;

package/exports/workers/block-worker.js

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