@leofcoin/chain 1.4.73 → 1.4.75

package/exports/chain.js

@@ -1,242 +1,18 @@
 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 { calculateFee, createContractMessage, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, signTransaction } from '@leofcoin/lib';
+import PQueue from 'p-queue';
 import { randombytes } from '@leofcoin/crypto';
 import EasyWorker from '@vandeurenglenn/easy-worker';
-import { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } from '@leofcoin/messages';
-import { calculateFee, createContractMessage, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, signTransaction } from '@leofcoin/lib';
-import pako from 'pako';
-
-// import State from './state'
-class Machine {
-    #contracts = {};
-    #nonces = {};
-    lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
-    constructor(blocks) {
-        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 'contractError': {
-                console.warn(`removing contract ${await data.hash()}`);
-                await contractStore.delete(await data.hash());
-                break;
-            }
-            case 'initError': {
-                console.error(`init error: ${data.message}`);
-                break;
-            }
-            case 'executionError': {
-                // console.warn(`error executing transaction ${data.message}`);
-                pubsub.publish(data.id, { error: data.message });
-                break;
-            }
-            case 'debug': {
-                for (const message of data.messages)
-                    debug(message);
-                break;
-            }
-            case 'machine-ready': {
-                this.lastBlock = data.lastBlock;
-                pubsub.publish('machine.ready', true);
-                break;
-            }
-            case 'response': {
-                pubsub.publish(data.id, data.value || false);
-                break;
-            }
-        }
-    }
-    async #init(blocks) {
-        return new Promise(async (resolve) => {
-            const machineReady = () => {
-                pubsub.unsubscribe('machine.ready', machineReady);
-                resolve(this);
-            };
-            pubsub.subscribe('machine.ready', machineReady);
-            this.worker = await new EasyWorker('node_modules/@leofcoin/workers/src/machine-worker.js', { serialization: 'advanced', type: 'module' });
-            this.worker.onmessage(this.#onmessage.bind(this));
-            // const blocks = await blockStore.values()
-            const contracts = await Promise.all([
-                contractStore.get(contractFactory),
-                contractStore.get(nativeToken),
-                contractStore.get(validators),
-                contractStore.get(nameService)
-            ]);
-            const message = {
-                type: 'init',
-                input: {
-                    contracts,
-                    blocks,
-                    peerid: peernet.peerId
-                }
-            };
-            this.worker.postMessage(message);
-        });
-    }
-    async #runContract(contractMessage) {
-        const hash = await contractMessage.hash();
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString('hex');
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                if (message?.error)
-                    reject(message.error);
-                else
-                    resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'run',
-                id,
-                input: {
-                    decoded: contractMessage.decoded,
-                    encoded: contractMessage.encoded,
-                    hash
-                }
-            });
-        });
-    }
-    /**
-     *
-     * @param {Address} contract
-     * @param {String} method
-     * @param {Array} parameters
-     * @returns Promise<message>
-     */
-    async execute(contract, method, parameters) {
-        try {
-            if (contract === contractFactory && method === 'registerContract') {
-                if (await this.has(parameters[0]))
-                    throw new Error(`duplicate contract @${parameters[0]}`);
-                let message;
-                if (!await contractStore.has(parameters[0])) {
-                    message = await peernet.get(parameters[0], 'contract');
-                    message = await new ContractMessage(message);
-                    await contractStore.put(await message.hash(), message.encoded);
-                }
-                if (!message) {
-                    message = await contractStore.get(parameters[0]);
-                    message = await new ContractMessage(message);
-                }
-                if (!await this.has(await message.hash()))
-                    await this.#runContract(message);
-            }
-        }
-        catch (error) {
-            throw new Error(`contract deployment failed for ${parameters[0]}\n${error.message}`);
-        }
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString('hex');
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                if (message?.error)
-                    reject(message.error);
-                else
-                    resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'execute',
-                id,
-                input: {
-                    contract,
-                    method,
-                    params: parameters
-                }
-            });
-        });
-    }
-    get(contract, method, parameters) {
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString();
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'get',
-                id,
-                input: {
-                    contract,
-                    method,
-                    params: parameters
-                }
-            });
-        });
-    }
-    async has(address) {
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString('hex');
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                if (message?.error)
-                    reject(message.error);
-                else
-                    resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'has',
-                id,
-                input: {
-                    address
-                }
-            });
-        });
-    }
-    async delete(hash) {
-        return contractStore.delete(hash);
-    }
-    /**
-     *
-     * @returns Promise
-     */
-    async deleteAll() {
-        let hashes = await contractStore.get();
-        hashes = Object.keys(hashes).map(hash => this.delete(hash));
-        return Promise.all(hashes);
-    }
-}
-
-class State {
-    constructor() {
-        // return this.#init()
-    }
-    // async #init() {
-    //   const state = await stateStore.get()
-    //   for (const [key, value] of Object.entries(state)) {
-    //
-    //   }
-    //
-    //   return this
-    // }
-    async put(key, value, isCompressed = true) {
-        value = isCompressed ? value : await pako.deflate(value);
-        await stateStore.put(key, value);
-    }
-    async get(key, isCompressed = true) {
-        const value = await stateStore.get(key);
-        return isCompressed = pako.inflate(value) ;
-    }
-    updateState(block) {
-        // block.decoded.index
-        // this.#isUpdateNeeded()
-    }
-}
 
 const limit = 1800;
 const transactionLimit = 1800;
 const requestTimeout = 30_000;
 const syncTimeout = 30_000;
 class Protocol {
+    version;
+    resolveTimeout = 30_000;
     get limit() {
         return limit;
     }
@@ -425,6 +201,8 @@ class Contract extends Transaction {
     constructor() {
         super();
     }
+    async init() {
+    }
     /**
      *
      * @param {Address} creator
@@ -466,98 +244,588 @@ class Contract extends Transaction {
     }
 }
 
-globalThis.BigNumber = BigNumber;
-// check if browser or local
-class Chain extends Contract {
-    #lastBlockInQue;
-    #syncErrorCount = 0;
-    version;
-    #resolveErrored;
-    #state;
-    #lastResolved;
-    #slotTime = 10000;
-    id;
-    utils;
-    /** {Address[]} */
-    #validators = [];
-    /** {Block[]} */
-    #blocks = [];
-    #blockHashMap = new Map();
-    #machine;
-    /** {Boolean} */
-    #runningEpoch = false;
-    /** {Boolean} */
-    #chainSyncing = false;
-    /** {Number} */
-    #totalSize = 0;
-    /**
-     * {Block} {index, hash, previousHash}
-     */
-    #lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
-    /**
-     * amount the native token has been iteracted with
-     */
-    #nativeCalls = 0;
-    /**
-     * amount the native token has been iteracted with
-     */
-    #nativeTransfers = 0;
-    /**
-     * amount of native token burned
-     * {Number}
-     */
-    #nativeBurns = 0;
-    /**
-     * amount of native tokens minted
-     * {Number}
-     */
-    #nativeMints = 0;
-    /**
-     * total amount of transactions
-     * {Number}
-     */
-    #totalTransactions = 0;
-    #participants = [];
+// import State from './state'
+class Machine {
+    #contracts = {};
+    #nonces = {};
+    lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
+    constructor(blocks) {
+        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 'contractError': {
+                console.warn(`removing contract ${await data.hash()}`);
+                await contractStore.delete(await data.hash());
+                break;
+            }
+            case 'initError': {
+                console.error(`init error: ${data.message}`);
+                break;
+            }
+            case 'executionError': {
+                // console.warn(`error executing transaction ${data.message}`);
+                pubsub.publish(data.id, { error: data.message });
+                break;
+            }
+            case 'debug': {
+                for (const message of data.messages)
+                    debug(message);
+                break;
+            }
+            case 'machine-ready': {
+                this.lastBlock = data.lastBlock;
+                pubsub.publish('machine.ready', true);
+                break;
+            }
+            case 'response': {
+                pubsub.publish(data.id, data.value || false);
+                break;
+            }
+        }
+    }
+    async #init(blocks) {
+        return new Promise(async (resolve) => {
+            const machineReady = () => {
+                pubsub.unsubscribe('machine.ready', machineReady);
+                resolve(this);
+            };
+            pubsub.subscribe('machine.ready', machineReady);
+            this.worker = await new EasyWorker('node_modules/@leofcoin/workers/src/machine-worker.js', { serialization: 'advanced', type: 'module' });
+            this.worker.onmessage(this.#onmessage.bind(this));
+            // const blocks = await blockStore.values()
+            const contracts = await Promise.all([
+                contractStore.get(contractFactory),
+                contractStore.get(nativeToken),
+                contractStore.get(validators),
+                contractStore.get(nameService)
+            ]);
+            const message = {
+                type: 'init',
+                input: {
+                    contracts,
+                    blocks,
+                    peerid: peernet.peerId
+                }
+            };
+            this.worker.postMessage(message);
+        });
+    }
+    async #runContract(contractMessage) {
+        const hash = await contractMessage.hash();
+        return new Promise((resolve, reject) => {
+            const id = randombytes(20).toString('hex');
+            const onmessage = message => {
+                pubsub.unsubscribe(id, onmessage);
+                if (message?.error)
+                    reject(message.error);
+                else
+                    resolve(message);
+            };
+            pubsub.subscribe(id, onmessage);
+            this.worker.postMessage({
+                type: 'run',
+                id,
+                input: {
+                    decoded: contractMessage.decoded,
+                    encoded: contractMessage.encoded,
+                    hash
+                }
+            });
+        });
+    }
+    /**
+     *
+     * @param {Address} contract
+     * @param {String} method
+     * @param {Array} parameters
+     * @returns Promise<message>
+     */
+    async execute(contract, method, parameters) {
+        try {
+            if (contract === contractFactory && method === 'registerContract') {
+                if (await this.has(parameters[0]))
+                    throw new Error(`duplicate contract @${parameters[0]}`);
+                let message;
+                if (!await contractStore.has(parameters[0])) {
+                    message = await peernet.get(parameters[0], 'contract');
+                    message = await new ContractMessage(message);
+                    await contractStore.put(await message.hash(), message.encoded);
+                }
+                if (!message) {
+                    message = await contractStore.get(parameters[0]);
+                    message = await new ContractMessage(message);
+                }
+                if (!await this.has(await message.hash()))
+                    await this.#runContract(message);
+            }
+        }
+        catch (error) {
+            throw new Error(`contract deployment failed for ${parameters[0]}\n${error.message}`);
+        }
+        return new Promise((resolve, reject) => {
+            const id = randombytes(20).toString('hex');
+            const onmessage = message => {
+                pubsub.unsubscribe(id, onmessage);
+                if (message?.error)
+                    reject(message.error);
+                else
+                    resolve(message);
+            };
+            pubsub.subscribe(id, onmessage);
+            this.worker.postMessage({
+                type: 'execute',
+                id,
+                input: {
+                    contract,
+                    method,
+                    params: parameters
+                }
+            });
+        });
+    }
+    get(contract, method, parameters) {
+        return new Promise((resolve, reject) => {
+            const id = randombytes(20).toString();
+            const onmessage = message => {
+                pubsub.unsubscribe(id, onmessage);
+                resolve(message);
+            };
+            pubsub.subscribe(id, onmessage);
+            this.worker.postMessage({
+                type: 'get',
+                id,
+                input: {
+                    contract,
+                    method,
+                    params: parameters
+                }
+            });
+        });
+    }
+    async has(address) {
+        return new Promise((resolve, reject) => {
+            const id = randombytes(20).toString('hex');
+            const onmessage = message => {
+                pubsub.unsubscribe(id, onmessage);
+                if (message?.error)
+                    reject(message.error);
+                else
+                    resolve(message);
+            };
+            pubsub.subscribe(id, onmessage);
+            this.worker.postMessage({
+                type: 'has',
+                id,
+                input: {
+                    address
+                }
+            });
+        });
+    }
+    async delete(hash) {
+        return contractStore.delete(hash);
+    }
+    /**
+     *
+     * @returns Promise
+     */
+    async deleteAll() {
+        let hashes = await contractStore.get();
+        hashes = Object.keys(hashes).map(hash => this.delete(hash));
+        return Promise.all(hashes);
+    }
+}
+
+const queue = new PQueue({ concurrency: 1, throwOnTimeout: true });
+class State extends Contract {
+    #resolveErrored;
+    #lastResolvedTime;
+    #lastResolved;
+    #resolving = false;
+    #resolveErrorCount = 0;
+    #syncState;
+    #lastBlockInQue;
+    #syncErrorCount = 0;
+    #blockHashMap = new Map();
+    #chainSyncing = false;
+    #lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
+    #blocks = [];
+    #knownBlocks = [];
+    #totalSize = 0;
+    #machine;
+    /**
+     * amount the native token has been iteracted with
+     */
+    #nativeCalls = 0;
+    /**
+     * amount the native token has been iteracted with
+     */
+    #nativeTransfers = 0;
+    /**
+     * amount of native token burned
+     * {Number}
+     */
+    #nativeBurns = 0;
+    /**
+     * amount of native tokens minted
+     * {Number}
+     */
+    #nativeMints = 0;
+    /**
+     * total amount of transactions
+     * {Number}
+     */
+    #totalTransactions = 0;
+    get nativeMints() {
+        return this.#nativeMints;
+    }
+    get nativeBurns() {
+        return this.#nativeBurns;
+    }
+    get nativeTransfers() {
+        return this.#nativeTransfers;
+    }
+    get totalTransactions() {
+        return this.#totalTransactions;
+    }
+    get nativeCalls() {
+        return this.#nativeCalls;
+    }
+    get blocks() {
+        return [...this.#blocks];
+    }
+    get lastBlock() {
+        return this.#lastBlock;
+    }
+    get totalSize() {
+        return this.#totalSize;
+    }
+    get machine() {
+        return this.#machine;
+    }
+    constructor() {
+        super();
+    }
+    async init() {
+        if (super.init)
+            await super.init();
+        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
+        try {
+            let localBlock;
+            try {
+                localBlock = await globalThis.chainStore.get('lastBlock');
+            }
+            catch {
+                await globalThis.chainStore.put('lastBlock', '0x0');
+                localBlock = await globalThis.chainStore.get('lastBlock');
+            }
+            localBlock = new TextDecoder().decode(localBlock);
+            if (localBlock && localBlock !== '0x0') {
+                localBlock = await globalThis.peernet.get(localBlock, 'block');
+                localBlock = await new BlockMessage(localBlock);
+                this.#lastBlock = { ...localBlock.decoded, hash: await localBlock.hash() };
+            }
+            else {
+                if (globalThis.peernet?.connections.length > 0) {
+                    const latestBlock = await this.#getLatestBlock();
+                    await this.#syncChain(latestBlock);
+                }
+            }
+        }
+        catch (error) {
+            console.log({ e: error });
+        }
+        // load local blocks
+        await this.resolveBlocks();
+        this.#machine = await new Machine(this.#blocks);
+        await this.#loadBlocks(this.#blocks);
+    }
+    async updateState(message) {
+        const hash = await message.hash();
+        this.#lastBlock = { hash, ...message.decoded };
+        // await this.state.updateState(message)
+        await globalThis.chainStore.put('lastBlock', hash);
+    }
+    async #lastBlockHandler() {
+        return new globalThis.peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
+    }
+    async #knownBlocksHandler() {
+        return new globalThis.peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
+    }
+    getLatestBlock() {
+        return this.#getLatestBlock();
+    }
+    async getAndPutBlock(hash) {
+        // todo peernet resolves undefined blocks....
+        let block = await globalThis.peernet.get(hash, 'block');
+        if (block !== undefined) {
+            block = await new BlockMessage(block);
+            const { index } = block.decoded;
+            if (this.#blocks[index] && this.#blocks[index].hash !== block.hash)
+                throw `invalid block ${hash} @${index}`;
+            if (!await globalThis.peernet.has(hash, 'block'))
+                await globalThis.peernet.put(hash, block.encoded, 'block');
+        }
+        return block;
+    }
+    async #resolveBlock(hash) {
+        let index = this.#blockHashMap.get(hash);
+        if (this.#blocks[index]) {
+            if (this.#blocks[index].previousHash !== '0x0') {
+                return this.resolveBlock(this.#blocks[index].previousHash);
+            }
+            else {
+                return;
+            }
+        }
+        const block = await this.getAndPutBlock(hash);
+        index = block.decoded.index;
+        const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
+        this.#totalSize += size;
+        this.#blocks[index] = { hash, ...block.decoded };
+        this.#blockHashMap.set(hash, index);
+        globalThis.debug(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
+        this.#lastResolved = this.#blocks[index];
+        this.#lastResolvedTime = Date.now();
+        return;
+    }
+    async resolveBlock(hash) {
+        if (!hash)
+            throw new Error(`expected hash, got: ${hash}`);
+        if (hash === '0x0')
+            return;
+        if (this.#resolving)
+            return 'already resolving';
+        this.#resolving = true;
+        await queue.add(() => this.#resolveBlock(hash));
+        this.#resolving = false;
+        if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
+            return this.resolveBlock(this.#lastResolved.previousHash);
+        return;
+    }
+    async resolveBlocks() {
+        try {
+            const localBlock = await globalThis.chainStore.get('lastBlock');
+            const hash = new TextDecoder().decode(localBlock);
+            if (hash && hash !== '0x0')
+                await this.resolveBlock(hash);
+            this.#lastBlock = this.#blocks[this.#blocks.length - 1];
+        }
+        catch {
+            this.#resolveErrored = true;
+            this.#resolveErrorCount += 1;
+            this.#resolving = false;
+            // console.log(e);
+        }
+    }
+    async syncChain(lastBlock) {
+        if (!this.shouldSync) {
+            return;
+        }
+        await queue.clear();
+        this.#chainSyncing = true;
+        if (!lastBlock)
+            lastBlock = await this.#getLatestBlock();
+        console.log('starting sync');
+        if (globalThis.peernet.connections.length === 0)
+            return 'connectionless';
+        try {
+            await this.#syncChain(lastBlock);
+        }
+        catch (error) {
+            this.#syncErrorCount += 1;
+            if (this.#syncErrorCount < 3)
+                await this.#syncChain(lastBlock);
+            this.#chainSyncing = false;
+            this.#syncErrorCount = 0;
+            return 'errored';
+        }
+        if (lastBlock.index === this.#lastBlockInQue?.index)
+            this.#lastBlockInQue = undefined;
+        this.#syncErrorCount = 0;
+        this.#chainSyncing = false;
+        if (this.#lastBlockInQue)
+            return this.syncChain(this.#lastBlockInQue);
+        return 'synced';
+    }
+    async #syncChain(lastBlock) {
+        try {
+            if (this.#knownBlocks?.length === Number(lastBlock.index) + 1) {
+                let promises = [];
+                promises = await Promise.allSettled(this.#knownBlocks.map(async (address) => {
+                    const has = await globalThis.peernet.has(address, 'block');
+                    return { has, address };
+                }));
+                promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has);
+                await Promise.allSettled(promises.map(({ value }) => this.getAndPutBlock(value.address)));
+            }
+            if (!this.#lastBlock || Number(this.#lastBlock.index) < Number(lastBlock.index)) {
+                // TODO: check if valid
+                const localIndex = this.#lastBlock ? this.lastBlock.index : 0;
+                const index = lastBlock.index;
+                await this.resolveBlock(lastBlock.hash);
+                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) - 1;
+                if (this.#machine)
+                    await this.#loadBlocks(this.blocks.slice(start));
+                await this.updateState(new BlockMessage(this.#blocks[this.#blocks.length - 1]));
+            }
+        }
+        catch (error) {
+            console.log(error);
+            throw error;
+        }
+    }
+    async #getLatestBlock() {
+        let promises = [];
+        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) {
+            if (peer.connected && peer.version === this.version) {
+                promises.push(async () => {
+                    try {
+                        const result = await peer.request(node.encoded);
+                        return { result, peer };
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                });
+            }
+        }
+        promises = await this.promiseRequests(promises);
+        let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
+        promises = promises.sort((a, b) => b.index - a.index);
+        if (promises.length > 0)
+            latest = promises[0].value;
+        if (latest.hash && latest.hash !== '0x0') {
+            let message = await globalThis.peernet.get(latest.hash, 'block');
+            message = await new BlockMessage(message);
+            const hash = await message.hash();
+            if (hash !== latest.hash)
+                throw new Error('invalid block @getLatestBlock');
+            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 node = await globalThis.peernet.prepareMessage(data);
+                let message = await peer.request(node);
+                message = await new globalThis.peernet.protos['peernet-response'](message);
+                this.#knownBlocks = message.decoded.response;
+            }
+        }
+        return latest;
+    }
+    /**
+     *
+     * @param {Block[]} blocks
+     */
+    async #loadBlocks(blocks) {
+        let poolTransactionKeys = await globalThis.transactionPoolStore.keys();
+        for (const block of blocks) {
+            if (block && !block.loaded) {
+                for (const transaction of block.transactions) {
+                    if (poolTransactionKeys.includes(transaction.hash))
+                        await globalThis.transactionPoolStore.delete(transaction.hash);
+                    try {
+                        await this.#machine.execute(transaction.to, transaction.method, transaction.params);
+                        if (transaction.to === nativeToken) {
+                            this.#nativeCalls += 1;
+                            if (transaction.method === 'burn')
+                                this.#nativeBurns += 1;
+                            if (transaction.method === 'mint')
+                                this.#nativeMints += 1;
+                            if (transaction.method === 'transfer')
+                                this.#nativeTransfers += 1;
+                        }
+                        this.#totalTransactions += 1;
+                    }
+                    catch (error) {
+                        console.log(error);
+                        return false;
+                    }
+                }
+                this.#blocks[block.index].loaded = true;
+                globalThis.debug(`loaded block: ${block.hash} @${block.index}`);
+            }
+        }
+        return true;
+    }
+    promiseRequests(promises) {
+        return new Promise(async (resolve, reject) => {
+            const timeout = setTimeout(() => {
+                resolve([{ index: 0, hash: '0x0' }]);
+                globalThis.debug('sync timed out');
+            }, this.requestTimeout);
+            promises = await Promise.allSettled(promises);
+            promises = promises.filter(({ status }) => status === 'fulfilled');
+            clearTimeout(timeout);
+            if (promises.length > 0) {
+                promises = promises.map(async ({ value }) => {
+                    const node = await new globalThis.peernet.protos['peernet-response'](value);
+                    return { value: node.decoded.response, peer: value.peer };
+                });
+                promises = await Promise.all(promises);
+                resolve(promises);
+            }
+            else {
+                resolve([]);
+            }
+        });
+    }
+    get canSync() {
+        if (this.#chainSyncing)
+            return false;
+        return true;
+    }
+    get shouldSync() {
+        if (this.canSync ||
+            this.#resolveErrored ||
+            !this.canSync && this.#lastResolvedTime + this.resolveTimeout > new Date().getTime())
+            return true;
+        return false;
+    }
+    async triggerSync() {
+        const latest = await this.#getLatestBlock();
+        return this.syncChain(latest);
+    }
+}
+
+globalThis.BigNumber = BigNumber;
+// check if browser or local
+class Chain extends State {
+    #state;
+    #slotTime = 10000;
+    id;
+    utils;
+    /** {Address[]} */
+    #validators = [];
+    /** {Boolean} */
+    #runningEpoch = false;
+    #participants = [];
     #participating = false;
     #jail = [];
-    #knownBlocks = [];
     constructor() {
         super();
         return this.#init();
     }
-    get nativeMints() {
-        return this.#nativeMints;
-    }
-    get nativeBurns() {
-        return this.#nativeBurns;
-    }
-    get nativeTransfers() {
-        return this.#nativeTransfers;
-    }
-    get totalTransactions() {
-        return this.#totalTransactions;
-    }
-    get nativeCalls() {
-        return this.#nativeCalls;
-    }
-    get totalSize() {
-        return this.#totalSize;
-    }
-    get lib() {
-        return lib;
-    }
-    get lastBlock() {
-        return this.#lastBlock;
-    }
     get nativeToken() {
         return addresses.nativeToken;
     }
     get validators() {
         return [...this.#validators];
     }
-    get blocks() {
-        return [...this.#blocks];
-    }
     async hasTransactionToHandle() {
         const size = await globalThis.transactionPoolStore.size();
         if (size > 0)
@@ -607,71 +875,6 @@ class Chain extends Contract {
         console.log('handle native contracts');
         // handle native contracts
     }
-    promiseRequests(promises) {
-        return new Promise(async (resolve, reject) => {
-            const timeout = setTimeout(() => {
-                resolve([{ index: 0, hash: '0x0' }]);
-                globalThis.debug('sync timed out');
-            }, this.requestTimeout);
-            promises = await Promise.allSettled(promises);
-            promises = promises.filter(({ status }) => status === 'fulfilled');
-            clearTimeout(timeout);
-            if (promises.length > 0) {
-                promises = promises.map(async ({ value }) => {
-                    const node = await new globalThis.peernet.protos['peernet-response'](value.result);
-                    return { value: node.decoded.response, peer: value.peer };
-                });
-                promises = await Promise.all(promises);
-                resolve(promises);
-            }
-            else {
-                resolve([]);
-            }
-        });
-    }
-    getLatestBlock() {
-        return this.#getLatestBlock();
-    }
-    async #getLatestBlock() {
-        let promises = [];
-        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) {
-            if (peer.connected && peer.version === this.version) {
-                promises.push(async () => {
-                    try {
-                        const result = await peer.request(node.encoded);
-                        return { result, peer };
-                    }
-                    catch (error) {
-                        throw error;
-                    }
-                });
-            }
-        }
-        promises = await this.promiseRequests(promises);
-        let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
-        promises = promises.sort((a, b) => b.index - a.index);
-        if (promises.length > 0)
-            latest = promises[0].value;
-        if (latest.hash && latest.hash !== '0x0') {
-            let message = await globalThis.peernet.get(latest.hash, 'block');
-            message = await new BlockMessage(message);
-            const hash = await message.hash();
-            if (hash !== latest.hash)
-                throw new Error('invalid block @getLatestBlock');
-            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 node = await globalThis.peernet.prepareMessage(data);
-                let message = await peer.request(node);
-                message = await new globalThis.peernet.protos['peernet-response'](message);
-                this.#knownBlocks = message.decoded.response;
-            }
-        }
-        return latest;
-    }
     async #clearPool() {
         await globalThis.transactionPoolStore.clear();
     }
@@ -703,7 +906,7 @@ class Chain extends Contract {
         if (!initialized)
             await this.#setup();
         this.utils = { BigNumber, formatUnits, parseUnits };
-        this.#state = new State();
+        // this.#state = new State()
         await globalThis.peernet.addRequestHandler('bw-request-message', () => {
             return new BWMessage(globalThis.peernet.client.bw) || { up: 0, down: 0 };
         });
@@ -713,43 +916,13 @@ class Chain extends Contract {
         // })
         await globalThis.peernet.addRequestHandler('transactionPool', this.#transactionPoolHandler.bind(this));
         await globalThis.peernet.addRequestHandler('version', this.#versionHandler.bind(this));
-        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
-        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
         globalThis.peernet.subscribe('add-block', this.#addBlock.bind(this));
         globalThis.peernet.subscribe('invalid-transaction', this.#invalidTransaction.bind(this));
         globalThis.peernet.subscribe('send-transaction', this.#sendTransaction.bind(this));
         globalThis.peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
         globalThis.pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
         // todo some functions rely on state
-        try {
-            let localBlock;
-            try {
-                localBlock = await globalThis.chainStore.get('lastBlock');
-            }
-            catch {
-                await globalThis.chainStore.put('lastBlock', '0x0');
-                localBlock = await globalThis.chainStore.get('lastBlock');
-            }
-            localBlock = new TextDecoder().decode(localBlock);
-            if (localBlock && localBlock !== '0x0') {
-                localBlock = await globalThis.peernet.get(localBlock, 'block');
-                localBlock = await new BlockMessage(localBlock);
-                this.#lastBlock = { ...localBlock.decoded, hash: await localBlock.hash() };
-            }
-            else {
-                if (globalThis.peernet?.connections.length > 0) {
-                    const latestBlock = await this.#getLatestBlock();
-                    await this.#syncChain(latestBlock);
-                }
-            }
-        }
-        catch (error) {
-            console.log({ e: error });
-        }
-        // load local blocks
-        await this.resolveBlocks();
-        this.#machine = await new Machine(this.#blocks);
-        await this.#loadBlocks(this.#blocks);
+        await super.init();
         globalThis.globalThis.pubsub.publish('chain:ready', true);
         return this;
     }
@@ -763,82 +936,6 @@ class Chain extends Contract {
         }, validatorInfo.timeout);
         this.#jail.push(validatorInfo.address);
     }
-    async triggerSync() {
-        const latest = await this.#getLatestBlock();
-        return this.syncChain(latest);
-    }
-    async syncChain(lastBlock) {
-        if (!lastBlock)
-            lastBlock = await this.#getLatestBlock();
-        if (this.#chainSyncing) {
-            console.log('already syncing');
-            if (!this.#lastBlockInQue || lastBlock.index > this.#lastBlockInQue.index)
-                this.#lastBlockInQue = lastBlock;
-            return 'syncing';
-        }
-        console.log('starting sync');
-        this.#chainSyncing = true;
-        const syncPromise = (lastBlock) => new Promise(async (resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.#chainSyncing = false;
-                this.#syncErrorCount = 0;
-                reject('timedOut');
-            }, 60000);
-            try {
-                await this.#syncChain(lastBlock);
-                clearTimeout(timeout);
-                resolve(true);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-        if (globalThis.peernet.connections.length === 0)
-            return 'connectionless';
-        try {
-            await syncPromise(lastBlock);
-        }
-        catch (error) {
-            console.log(error);
-            this.#syncErrorCount += 1;
-            if (this.#syncErrorCount < 3)
-                await syncPromise(lastBlock);
-            this.#chainSyncing = false;
-            this.#syncErrorCount = 0;
-            return 'errored';
-        }
-        if (lastBlock.index === this.#lastBlockInQue?.index)
-            this.#lastBlockInQue = undefined;
-        this.#syncErrorCount = 0;
-        this.#chainSyncing = false;
-        if (this.#lastBlockInQue)
-            return this.syncChain(this.#lastBlockInQue);
-        return 'synced';
-    }
-    async #syncChain(lastBlock) {
-        if (this.#knownBlocks?.length === Number(lastBlock.index) + 1) {
-            let promises = [];
-            promises = await Promise.allSettled(this.#knownBlocks.map(async (address) => {
-                const has = await globalThis.peernet.has(address, 'block');
-                return { has, address };
-            }));
-            promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has);
-            await Promise.allSettled(promises.map(({ value }) => this.getAndPutBlock(value.address)));
-        }
-        if (!this.lastBlock || Number(this.lastBlock.index) < Number(lastBlock.index)) {
-            // TODO: check if valid
-            const localIndex = this.lastBlock ? this.lastBlock.index : 0;
-            const index = lastBlock.index;
-            await this.resolveBlock(lastBlock.hash);
-            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) - 1;
-            if (this.#machine)
-                await this.#loadBlocks(this.blocks.slice(start));
-            await this.#updateState(new BlockMessage(this.#blocks[this.#blocks.length - 1]));
-        }
-    }
     async #prepareRequest(request) {
         let node = await new globalThis.peernet.protos['peernet-request']({ request });
         return globalThis.peernet.prepareMessage(node);
@@ -854,12 +951,10 @@ class Chain extends Contract {
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
         if (Object.keys(lastBlock).length > 0) {
-            if (this.#resolveErrored || !this.#lastBlock || lastBlock && lastBlock.index > this.#lastBlock?.index) {
+            if (!this.lastBlock || !this.blocks[this.blocks.length - 1].loaded || lastBlock && lastBlock.index > this.lastBlock?.index) {
                 // this.#knownBlocks = await this.#makeRequest(peer, 'knownBlocks')
-                this.#resolveErrored = false;
                 await this.syncChain(lastBlock);
-                if (await this.hasTransactionToHandle() && !this.#resolveErrored && this.#participating)
-                    this.#runEpoch();
+                // if (await this.hasTransactionToHandle() && this.#participating) this.#runEpoch()
             }
         }
     }
@@ -871,110 +966,10 @@ class Chain extends Contract {
     async #versionHandler() {
         return new globalThis.peernet.protos['peernet-response']({ response: { version: this.version } });
     }
-    async #lastBlockHandler() {
-        return new globalThis.peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
-    }
-    async #knownBlocksHandler() {
-        return new globalThis.peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
-    }
-    async getAndPutBlock(hash) {
-        // todo peernet resolves undefined blocks....
-        let block = await globalThis.peernet.get(hash, 'block');
-        if (block !== undefined) {
-            block = await new BlockMessage(block);
-            const { index } = block.decoded;
-            if (this.#blocks[index] && this.#blocks[index].hash !== block.hash)
-                throw `invalid block ${hash} @${index}`;
-            if (!await globalThis.peernet.has(hash, 'block'))
-                await globalThis.peernet.put(hash, block.encoded, 'block');
-        }
-        return block;
-    }
-    async resolveBlock(hash) {
-        if (!hash)
-            throw new Error(`expected hash, got: ${hash}`);
-        if (hash === '0x0')
-            return;
-        const index = this.#blockHashMap.get(hash);
-        if (this.#blocks[index]) {
-            if (this.#blocks[index].previousHash !== '0x0') {
-                return this.resolveBlock(this.#blocks[index].previousHash);
-            }
-            else {
-                return;
-            }
-        }
-        try {
-            const block = await this.getAndPutBlock(hash);
-            const { previousHash, index } = block.decoded;
-            const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
-            this.#totalSize += size;
-            this.#blocks[index] = { hash, ...block.decoded };
-            this.#blockHashMap.set(hash, index);
-            console.log(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
-            this.#lastResolved = Date.now();
-            if (previousHash !== '0x0') {
-                return this.resolveBlock(previousHash);
-            }
-        }
-        catch (error) {
-            this.#resolveErrored = true;
-            console.error(error);
-        }
-    }
-    async resolveBlocks() {
-        try {
-            const localBlock = await globalThis.chainStore.get('lastBlock');
-            const hash = new TextDecoder().decode(localBlock);
-            if (hash && hash !== '0x0')
-                await this.resolveBlock(hash);
-            this.#lastBlock = this.#blocks[this.#blocks.length - 1];
-        }
-        catch {
-            await globalThis.chainStore.put('lastBlock', new TextEncoder().encode('0x0'));
-            return this.resolveBlocks();
-            // console.log(e);
-        }
-    }
-    /**
-     *
-     * @param {Block[]} blocks
-     */
-    async #loadBlocks(blocks) {
-        let poolTransactionKeys = await globalThis.transactionPoolStore.keys();
-        for (const block of blocks) {
-            if (block && !block.loaded) {
-                for (const transaction of block.transactions) {
-                    if (poolTransactionKeys.includes(transaction.hash))
-                        await globalThis.transactionPoolStore.delete(transaction.hash);
-                    try {
-                        await this.#machine.execute(transaction.to, transaction.method, transaction.params);
-                        if (transaction.to === nativeToken) {
-                            this.#nativeCalls += 1;
-                            if (transaction.method === 'burn')
-                                this.#nativeBurns += 1;
-                            if (transaction.method === 'mint')
-                                this.#nativeMints += 1;
-                            if (transaction.method === 'transfer')
-                                this.#nativeTransfers += 1;
-                        }
-                        this.#totalTransactions += 1;
-                    }
-                    catch (error) {
-                        console.log(error);
-                        return false;
-                    }
-                }
-                this.#blocks[block.index].loaded = true;
-                globalThis.debug(`loaded block: ${block.hash} @${block.index}`);
-            }
-        }
-        return true;
-    }
     async #executeTransaction({ hash, from, to, method, params, nonce }) {
         try {
-            let result = await this.#machine.execute(to, method, params, from, nonce);
-            // if (!result) result = this.#machine.state
+            let result = await this.machine.execute(to, method, params);
+            // if (!result) result = this.machine.state
             globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fulfilled', hash });
             return result || 'no state change';
         }
@@ -992,7 +987,7 @@ class Chain extends Contract {
         const hash = await blockMessage.hash();
         await globalThis.blockStore.put(hash, blockMessage.encoded);
         if (this.lastBlock.index < blockMessage.decoded.index)
-            await this.#updateState(blockMessage);
+            await this.updateState(blockMessage);
         globalThis.debug(`added block: ${hash}`);
         let promises = [];
         let contracts = [];
@@ -1014,7 +1009,7 @@ class Chain extends Contract {
             }
             // todo finish state
             // for (const contract of contracts) {
-            //   const state = await this.#machine.get(contract, 'state')
+            //   const state = await this.machine.get(contract, 'state')
             //   // await stateStore.put(contract, state)
             //   console.log(state);
             // }
@@ -1024,12 +1019,6 @@ class Chain extends Contract {
             console.log({ e: error });
         }
     }
-    async #updateState(message) {
-        const hash = await message.hash();
-        this.#lastBlock = { hash, ...message.decoded };
-        // await this.state.updateState(message)
-        await globalThis.chainStore.put('lastBlock', hash);
-    }
     async participate(address) {
         // TODO: validate participant
         // hold min amount of 50k ART for 7 days
@@ -1077,7 +1066,7 @@ class Chain extends Contract {
         for (let transaction of transactions) {
             const hash = await transaction.hash();
             const doubleTransactions = [];
-            for (const block of this.#blocks) {
+            for (const block of this.blocks) {
                 for (const transaction of block.transactions) {
                     if (transaction.hash === hash) {
                         doubleTransactions.push(hash);
@@ -1168,7 +1157,7 @@ class Chain extends Contract {
             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.updateState(blockMessage);
             globalThis.debug(`created block: ${hash}`);
             globalThis.peernet.publish('add-block', blockMessage.encoded);
             globalThis.pubsub.publish('add-block', blockMessage.decoded);
@@ -1177,7 +1166,7 @@ class Chain extends Contract {
             console.log(error);
             throw new Error(`invalid block ${block}`);
         }
-        // data = await this.#machine.execute(to, method, params)
+        // data = await this.machine.execute(to, method, params)
         // transactionStore.put(message.hash, message.encoded)
     }
     async #sendTransaction(transaction) {
@@ -1241,7 +1230,7 @@ class Chain extends Contract {
      */
     internalCall(sender, contract, method, parameters) {
         globalThis.msg = this.#createMessage(sender);
-        return this.#machine.execute(contract, method, parameters);
+        return this.machine.execute(contract, method, parameters);
     }
     /**
      *
@@ -1252,19 +1241,19 @@ class Chain extends Contract {
      */
     call(contract, method, parameters) {
         globalThis.msg = this.#createMessage();
-        return this.#machine.execute(contract, method, parameters);
+        return this.machine.execute(contract, method, parameters);
     }
     staticCall(contract, method, parameters) {
         globalThis.msg = this.#createMessage();
-        return this.#machine.get(contract, method, parameters);
+        return this.machine.get(contract, method, parameters);
     }
     delegate(contract, method, parameters) {
         globalThis.msg = this.#createMessage();
-        return this.#machine.execute(contract, method, parameters);
+        return this.machine.execute(contract, method, parameters);
     }
     staticDelegate(contract, method, parameters) {
         globalThis.msg = this.#createMessage();
-        return this.#machine.get(contract, method, parameters);
+        return this.machine.get(contract, method, parameters);
     }
     mint(to, amount) {
         return this.call(addresses.nativeToken, 'mint', [to, amount]);
@@ -1279,7 +1268,7 @@ class Chain extends Contract {
         return this.staticCall(addresses.contractFactory, 'contracts');
     }
     deleteAll() {
-        return this.#machine.deleteAll();
+        return this.machine.deleteAll();
     }
     /**
      * lookup an address for a registered name using the builtin nameService