@leofcoin/chain 1.5.67 → 1.5.68

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';
@@ -273,9 +273,14 @@ 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);
     }
@@ -336,12 +341,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 +408,19 @@ 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(await stateStore.get('states'));
+                console.log({ states: this.states });
+            }
             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 +740,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,7 +786,18 @@ class State extends Contract {
             throw error;
         }
         try {
-            await this.resolveBlocks();
+            const localBlock = await globalThis.chainStore.get('lastBlock');
+            console.log({ localBlock });
+            const localBlockHash = new TextDecoder().decode(localBlock);
+            if (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)
+                    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));
@@ -760,6 +821,7 @@ class State extends Contract {
         catch (error) {
             console.error(error);
         }
+        await this.#machine.updateState();
     }
     getLatestBlock() {
         // @ts-ignore

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/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/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();