@leofcoin/chain 1.4.22 → 1.4.23

package/exports/chain.js

@@ -0,0 +1,1071 @@
+import { formatBytes, BigNumber, formatUnits, parseUnits } from '@leofcoin/utils';
+import addresses, { contractFactory, nativeToken, validators, nameService } from '@leofcoin/addresses';
+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()
+    }
+}
+
+class Protocol {
+    limit = 1800;
+    transactionLimit = 1800;
+}
+
+class Transaction extends Protocol {
+    constructor() {
+        super();
+    }
+    /**
+     *
+     * @param {Address[]} transactions
+     * @returns transactions to include
+     */
+    async getTransactions(transactions) {
+        return new Promise(async (resolve, reject) => {
+            let size = 0;
+            const _transactions = [];
+            await Promise.all(transactions
+                .map(async (tx) => {
+                tx = await new TransactionMessage(tx);
+                size += tx.encoded.length;
+                if (!formatBytes(size).includes('MB') || formatBytes(size).includes('MB') && Number(formatBytes(size).split(' MB')[0]) <= 0.75)
+                    _transactions.push({ ...tx.decoded, hash: await tx.hash() });
+                else
+                    resolve(_transactions);
+            }));
+            return resolve(_transactions);
+        });
+    }
+    /**
+     *
+     * @param {Transaction[]} transactions An array containing Transactions
+     * @returns {TransactionMessage}
+     */
+    async promiseTransactions(transactions) {
+        transactions = await Promise.all(transactions.map(tx => new TransactionMessage(tx)));
+        return transactions;
+    }
+    /**
+     *
+     * @param {Transaction[]} transactions An array containing Transactions
+     * @returns {Object} {transaction.decoded, transaction.hash}
+     */
+    async promiseTransactionsContent(transactions) {
+        transactions = await Promise.all(transactions.map(tx => new Promise(async (resolve, reject) => {
+            resolve({ ...tx.decoded, hash: await tx.hash() });
+        })));
+        return transactions;
+    }
+    /**
+     * When a nonce isn't found for an address fallback to just checking the transactionnPoolStore
+     * @param {Address} address
+     * @returns {Number} nonce
+     */
+    async #getNonceFallback(address) {
+        let transactions = await globalThis.transactionPoolStore.values();
+        transactions = await this.promiseTransactions(transactions);
+        transactions = transactions.filter(tx => tx.decoded.from === address);
+        transactions = await this.promiseTransactionsContent(transactions);
+        if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
+            let block = await peernet.get(this.lastBlock.hash);
+            block = await new BlockMessage(block);
+            // for (let tx of block.decoded?.transactions) {
+            //   tx = await peernet.get(tx, 'transaction')
+            //   transactions.push(new TransactionMessage(tx))
+            // }
+            transactions = transactions.filter(tx => tx.from === address);
+            while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== '0x0') {
+                block = await globalThis.blockStore.get(block.decoded.previousHash);
+                block = await new BlockMessage(block);
+                transactions = block.decoded.transactions.filter(tx => tx.from === address);
+            }
+        }
+        if (transactions.length === 0)
+            return 0;
+        transactions = transactions.sort((a, b) => a.timestamp - b.timestamp);
+        return transactions[transactions.length - 1].nonce;
+    }
+    /**
+     * Get amount of transactions by address
+     * @param {Address} address The address to get the nonce for
+     * @returns {Number} nonce
+     */
+    async getNonce(address) {
+        if (!await globalThis.accountsStore.has(address)) {
+            const nonce = await this.#getNonceFallback(address);
+            await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce)));
+        }
+        // todo: are those in the pool in cluded also ? they need to be included!!!
+        let nonce = await globalThis.accountsStore.get(address);
+        nonce = new TextDecoder().decode(nonce);
+        let transactions = await globalThis.transactionPoolStore.values();
+        transactions = await this.promiseTransactions(transactions);
+        transactions = transactions.filter(tx => tx.decoded.from === address);
+        transactions = await this.promiseTransactionsContent(transactions);
+        for (const transaction of transactions) {
+            if (transaction.nonce > nonce)
+                nonce = transaction.nonce;
+        }
+        return Number(nonce);
+    }
+    async validateNonce(address, nonce) {
+        let previousNonce = await globalThis.accountsStore.get(address);
+        previousNonce = Number(new TextDecoder().decode(previousNonce));
+        if (previousNonce > nonce)
+            throw new Error(`a transaction with a higher nonce already exists`);
+        if (previousNonce === nonce)
+            throw new Error(`a transaction with the same nonce already exists`);
+        let transactions = await globalThis.transactionPoolStore.values();
+        transactions = await this.promiseTransactions(transactions);
+        transactions = transactions.filter(tx => tx.decoded.from === address);
+        for (const transaction of transactions) {
+            if (transaction.decoded.nonce > nonce)
+                throw new Error(`a transaction with a higher nonce already exists`);
+            if (transaction.decoded.nonce === nonce)
+                throw new Error(`a transaction with the same nonce already exists`);
+        }
+    }
+    isTransactionMessage(message) {
+        if (message instanceof TransactionMessage)
+            return true;
+        return false;
+    }
+    async createTransaction(transaction) {
+        return {
+            from: transaction.from,
+            to: transaction.to,
+            method: transaction.method,
+            params: transaction.params,
+            timestamp: transaction.timestamp || Date.now(),
+            nonce: transaction.nonce || (await this.getNonce(transaction.from)) + 1
+        };
+    }
+    async sendTransaction(message) {
+        if (!this.isTransactionMessage(message))
+            message = new TransactionMessage(message);
+        if (!message.decoded.signature)
+            throw new Error(`transaction not signed`);
+        if (message.decoded.nonce === undefined)
+            throw new Error(`nonce required`);
+        try {
+            await this.validateNonce(message.decoded.from, message.decoded.nonce);
+            // todo check if signature is valid
+            const hash = await message.hash();
+            let data;
+            const wait = new Promise(async (resolve, reject) => {
+                if (pubsub.subscribers[`transaction.completed.${hash}`]) {
+                    const result = pubsub.subscribers[`transaction.completed.${hash}`].value;
+                    result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
+                }
+                else {
+                    const completed = async (result) => {
+                        result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
+                        setTimeout(async () => {
+                            pubsub.unsubscribe(`transaction.completed.${hash}`, completed);
+                        }, 10_000);
+                    };
+                    pubsub.subscribe(`transaction.completed.${hash}`, completed);
+                }
+            });
+            await globalThis.transactionPoolStore.put(hash, message.encoded);
+            // debug(`Added ${hash} to the transaction pool`)
+            peernet.publish('add-transaction', message.encoded);
+            return { hash: hash, data, fee: await calculateFee(message.decoded), wait, message };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+
+/**
+ * @extends {Transaction}
+ */
+class Contract extends Transaction {
+    constructor() {
+        super();
+    }
+    /**
+     *
+     * @param {Address} creator
+     * @param {String} contract
+     * @param {Array} constructorParameters
+     * @returns lib.createContractMessage
+     */
+    async createContractMessage(creator, contract, constructorParameters = []) {
+        return createContractMessage(creator, contract, constructorParameters);
+    }
+    /**
+     *
+     * @param {Address} creator
+     * @param {String} contract
+     * @param {Array} constructorParameters
+     * @returns {Address}
+     */
+    async createContractAddress(creator, contract, constructorParameters = []) {
+        contract = await this.createContractMessage(creator, contract, constructorParameters);
+        return contract.hash();
+    }
+    /**
+     *
+     * @param {String} contract
+     * @param {Array} parameters
+     * @returns
+     */
+    async deployContract(contract, constructorParameters = []) {
+        const message = await createContractMessage(peernet.selectedAccount, contract, constructorParameters);
+        try {
+            await contractStore.put(await message.hash(), message.encoded);
+        }
+        catch (error) {
+            throw error;
+        }
+        return this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'registerContract', [await message.hash()]);
+    }
+}
+
+globalThis.BigNumber = BigNumber;
+// check if browser or local
+class Chain extends Contract {
+    /** {Address[]} */
+    #validators = [];
+    /** {Block[]} */
+    #blocks = [];
+    #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 = [];
+    #participating = false;
+    #jail = [];
+    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 transactionPoolStore.size();
+        if (size > 0)
+            return true;
+        return false;
+    }
+    async #runEpoch() {
+        this.#runningEpoch = true;
+        console.log('epoch');
+        const validators = await this.staticCall(addresses.validators, 'validators');
+        console.log({ validators });
+        if (!validators[globalThis.peernet.selectedAccount]?.active)
+            return;
+        const start = Date.now();
+        try {
+            await this.#createBlock();
+        }
+        catch (error) {
+            console.error(error);
+        }
+        const end = Date.now();
+        console.log(((end - start) / 1000) + ' s');
+        if (await this.hasTransactionToHandle())
+            return this.#runEpoch();
+        this.#runningEpoch = false;
+        // if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
+    }
+    async #setup() {
+        const contracts = [{
+                address: addresses.contractFactory,
+                message: contractFactoryMessage
+            }, {
+                address: addresses.nativeToken,
+                message: nativeTokenMessage
+            }, {
+                address: addresses.validators,
+                message: validatorsMessage
+            }, {
+                address: addresses.nameService,
+                message: nameServiceMessage
+            }];
+        await Promise.all(contracts.map(async ({ address, message }) => {
+            // console.log({message});
+            message = await new ContractMessage(Uint8Array.from(message.split(',').map(string => Number(string))));
+            await contractStore.put(address, message.encoded);
+        }));
+        console.log('handle native contracts');
+        // handle native contracts
+    }
+    promiseRequests(promises) {
+        return new Promise(async (resolve, reject) => {
+            const timeout = setTimeout(() => {
+                resolve([{ index: 0, hash: '0x0' }]);
+                debug('sync timed out');
+            }, 10_000);
+            promises = await Promise.allSettled(promises);
+            promises = promises.filter(({ status }) => status === 'fulfilled');
+            clearTimeout(timeout);
+            promises = promises.map(({ value }) => new peernet.protos['peernet-response'](value));
+            promises = await Promise.all(promises);
+            promises = promises.map(node => node.decoded.response);
+            resolve(promises);
+        });
+    }
+    getLatestBlock() {
+        return this.#getLatestBlock();
+    }
+    async #getLatestBlock() {
+        let promises = [];
+        let data = await new peernet.protos['peernet-request']({ request: 'lastBlock' });
+        const node = await peernet.prepareMessage(data);
+        for (const peer of peernet.connections) {
+            if (peer.connected && peer.readyState === 'open' && peer.peerId !== this.id) {
+                promises.push(peer.request(node.encoded));
+            }
+            else if (!peer.connected || peer.readyState !== 'open') ;
+        }
+        promises = await this.promiseRequests(promises);
+        let latest = { index: 0, hash: '0x0' };
+        for (const value of promises) {
+            if (value.index > latest.index) {
+                latest.index = value.index;
+                latest.hash = await value.hash();
+            }
+        }
+        if (latest.hash && latest.hash !== '0x0') {
+            latest = await peernet.get(latest.hash, block);
+            latest = await new BlockMessage(latest);
+        }
+        return latest;
+    }
+    async #init() {
+        // this.node = await new Node()
+        this.#participants = [];
+        this.#participating = false;
+        const initialized = await contractStore.has(addresses.contractFactory);
+        if (!initialized)
+            await this.#setup();
+        this.utils = { BigNumber, formatUnits, parseUnits };
+        this.state = new State();
+        try {
+            let localBlock;
+            try {
+                localBlock = await chainStore.get('lastBlock');
+            }
+            catch {
+                await chainStore.put('lastBlock', '0x0');
+                localBlock = await chainStore.get('lastBlock');
+            }
+            localBlock = new TextDecoder().decode(localBlock);
+            if (localBlock && localBlock !== '0x0') {
+                localBlock = await peernet.get(localBlock, 'block');
+                localBlock = await new BlockMessage(localBlock);
+                this.#lastBlock = { ...localBlock.decoded, hash: await localBlock.hash() };
+            }
+            else {
+                const latestBlock = await this.#getLatestBlock();
+                await this.#syncChain(latestBlock);
+            }
+        }
+        catch (error) {
+            console.log({ e: error });
+        }
+        await peernet.addRequestHandler('bw-request-message', () => {
+            return new BWMessage(peernet.client.bw) || { up: 0, down: 0 };
+        });
+        await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+        peernet.subscribe('add-block', this.#addBlock.bind(this));
+        peernet.subscribe('add-transaction', this.#addTransaction.bind(this));
+        peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
+        pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
+        // load local blocks
+        await this.resolveBlocks();
+        this.#machine = await new Machine(this.#blocks);
+        await this.#loadBlocks(this.#blocks);
+        return this;
+    }
+    async #validatorTimeout(validatorInfo) {
+        setTimeout(() => {
+            this.#jail.splice(this.jail.indexOf(validatorInfo.address), 1);
+        }, validatorInfo.timeout);
+        this.#jail.push(validatorInfo.address);
+    }
+    async #syncChain(lastBlock) {
+        if (this.#chainSyncing || !lastBlock || !lastBlock.hash || !lastBlock.hash)
+            return;
+        if (!this.lastBlock || Number(this.lastBlock.index) < Number(lastBlock.index)) {
+            this.#chainSyncing = true;
+            // 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;
+            debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`);
+            this.#blocks.length;
+            const start = (this.#blocks.length - blocksSynced) - 1;
+            await this.#loadBlocks(this.blocks.slice(start));
+            await this.#updateState(new BlockMessage(this.#blocks[this.#blocks.length - 1]));
+            this.#chainSyncing = false;
+        }
+    }
+    async #peerConnected(peer) {
+        let node = await new peernet.protos['peernet-request']({ request: 'lastBlock' });
+        node = await peernet.prepareMessage(node);
+        let response = await peer.request(node.encoded);
+        response = await new globalThis.peernet.protos['peernet-response'](response);
+        let lastBlock = response.decoded.response;
+        this.#syncChain(lastBlock);
+    }
+    #epochTimeout;
+    async #lastBlockHandler() {
+        return new peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
+    }
+    async resolveBlock(hash) {
+        if (!hash)
+            throw new Error(`expected hash, got: ${hash}`);
+        let block = await peernet.get(hash, 'block');
+        block = await new BlockMessage(block);
+        if (!await peernet.has(hash, 'block'))
+            await peernet.put(hash, block.encoded, 'block');
+        const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
+        this.#totalSize += size;
+        block = { ...block.decoded, hash };
+        if (this.#blocks[block.index] && this.#blocks[block.index].hash !== block.hash)
+            throw `invalid block ${hash} @${block.index}`;
+        this.#blocks[block.index] = block;
+        console.log(`resolved block: ${hash} @${block.index} ${formatBytes(size)}`);
+        if (block.previousHash !== '0x0') {
+            return this.resolveBlock(block.previousHash);
+        }
+    }
+    async resolveBlocks() {
+        try {
+            const localBlock = await 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 chainStore.put('lastBlock', new TextEncoder().encode('0x0'));
+            return this.resolveBlocks();
+            // console.log(e);
+        }
+    }
+    /**
+     *
+     * @param {Block[]} blocks
+     */
+    async #loadBlocks(blocks) {
+        for (const block of blocks) {
+            if (block && !block.loaded) {
+                for (const transaction of block.transactions) {
+                    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);
+                    }
+                }
+                this.#blocks[block.index].loaded = true;
+                debug(`loaded block: ${block.hash} @${block.index}`);
+            }
+        }
+    }
+    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
+            pubsub.publish(`transaction.completed.${hash}`, { status: 'fulfilled', hash });
+            return result || 'no state change';
+        }
+        catch (error) {
+            console.log(error);
+            pubsub.publish(`transaction.completed.${hash}`, { status: 'fail', hash, error: error });
+            throw error;
+        }
+    }
+    async #addBlock(block) {
+        // console.log(block);
+        const blockMessage = await new BlockMessage(block);
+        await Promise.all(blockMessage.decoded.transactions
+            .map(async (transaction) => transactionPoolStore.delete(transaction.hash)));
+        const hash = await blockMessage.hash();
+        await blockStore.put(hash, blockMessage.encoded);
+        if (this.lastBlock.index < blockMessage.decoded.index)
+            await this.#updateState(blockMessage);
+        debug(`added block: ${hash}`);
+        let promises = [];
+        let contracts = [];
+        for (let transaction of blockMessage.decoded.transactions) {
+            // await transactionStore.put(transaction.hash, transaction.encoded)
+            const index = contracts.indexOf(transaction.to);
+            if (index === -1)
+                contracts.push(transaction.to);
+            // Todo: go trough all accounts      
+            promises.push(this.#executeTransaction(transaction));
+        }
+        try {
+            promises = await Promise.allSettled(promises);
+            for (let transaction of blockMessage.decoded.transactions) {
+                pubsub.publish('transaction-processed', transaction);
+                if (transaction.to === peernet.selectedAccount)
+                    pubsub.publish('account-transaction-processed', transaction);
+                await 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);
+            // }
+            pubsub.publish('block-processed', blockMessage.decoded);
+        }
+        catch (error) {
+            console.log({ e: error });
+        }
+    }
+    async #updateState(message) {
+        const hash = await message.hash();
+        this.#lastBlock = { hash, ...message.decoded };
+        await this.state.updateState(message);
+        await chainStore.put('lastBlock', hash);
+    }
+    async participate(address) {
+        // TODO: validate participant
+        // hold min amount of 50k ART for 7 days
+        // lock the 50k
+        // introduce peer-reputation
+        // peerReputation(peerId)
+        // {bandwith: {up, down}, uptime}
+        this.#participating = true;
+        if (!await this.staticCall(addresses.validators, 'has', [address])) {
+            const rawTransaction = {
+                from: address,
+                to: addresses.validators,
+                method: 'addValidator',
+                params: [address],
+                nonce: (await this.getNonce(address)) + 1,
+                timestamp: Date.now()
+            };
+            const transaction = await signTransaction(rawTransaction, peernet.identity);
+            await this.sendTransaction(transaction);
+        }
+        if (await this.hasTransactionToHandle() && !this.#runningEpoch)
+            await this.#runEpoch();
+    }
+    // todo filter tx that need to wait on prev nonce
+    async #createBlock(limit = 1800) {
+        // vote for transactions
+        if (await transactionPoolStore.size() === 0)
+            return;
+        let transactions = await transactionPoolStore.values(this.transactionLimit);
+        if (Object.keys(transactions)?.length === 0)
+            return;
+        let block = {
+            transactions: [],
+            validators: [],
+            fees: BigNumber.from(0)
+        };
+        // exclude failing tx
+        transactions = await this.promiseTransactions(transactions);
+        transactions = transactions.sort((a, b) => a.nonce - b.nonce);
+        for (let transaction of transactions) {
+            const hash = await transaction.hash();
+            try {
+                await this.#executeTransaction({ ...transaction.decoded, hash });
+                block.transactions.push({ hash, ...transaction.decoded });
+                block.fees += Number(calculateFee(transaction.decoded));
+                await accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)));
+            }
+            catch (e) {
+                await transactionPoolStore.delete(hash);
+            }
+        }
+        // don't add empty block
+        if (block.transactions.length === 0)
+            return;
+        const validators = await this.staticCall(addresses.validators, 'validators');
+        console.log({ validators });
+        // block.validators = Object.keys(block.validators).reduce((set, key) => {
+        //   if (block.validators[key].active) {
+        //     push({
+        //       address: key
+        //     })
+        //   }
+        // }, [])
+        const peers = {};
+        for (const entry of peernet.peerEntries) {
+            peers[entry[0]] = entry[1];
+        }
+        for (const validator of Object.keys(validators)) {
+            if (validators[validator].active) {
+                const peer = peers[validator];
+                if (peer && peer.connected) {
+                    let data = await new BWRequestMessage();
+                    const node = await peernet.prepareMessage(validator, data.encoded);
+                    try {
+                        const bw = await peer.request(node.encoded);
+                        console.log({ bw });
+                        block.validators.push({
+                            address: validator,
+                            bw: bw.up + bw.down
+                        });
+                    }
+                    catch { }
+                }
+                else if (peernet.selectedAccount === validator) {
+                    block.validators.push({
+                        address: peernet.selectedAccount,
+                        bw: peernet.bw.up + peernet.bw.down
+                    });
+                }
+            }
+        }
+        console.log({ validators: block.validators });
+        block.reward = 150;
+        block.validators = block.validators.map(validator => {
+            validator.reward = String(Number(block.fees) + block.reward / block.validators.length);
+            delete validator.bw;
+            return validator;
+        });
+        // block.validators = calculateValidatorReward(block.validators, block.fees)
+        block.index = this.lastBlock?.index;
+        if (block.index === undefined)
+            block.index = 0;
+        else
+            block.index += 1;
+        block.previousHash = this.lastBlock?.hash || '0x0';
+        block.timestamp = Date.now();
+        const parts = String(block.fees).split('.');
+        let decimals = 0;
+        if (parts[1]) {
+            const potentional = parts[1].split('e');
+            if (potentional[0] === parts[1]) {
+                decimals = parts[1].length;
+            }
+            else {
+                parts[1] = potentional[0];
+                decimals = Number(potentional[1]?.replace(/[+-]/g, '')) + Number(potentional[0].length);
+            }
+        }
+        block.fees = Number.parseFloat(String(block.fees)).toFixed(decimals);
+        try {
+            await Promise.all(block.transactions
+                .map(async (transaction) => transactionPoolStore.delete(transaction.hash)));
+            let blockMessage = await new BlockMessage(block);
+            const hash = await blockMessage.hash();
+            await peernet.put(hash, blockMessage.encoded, 'block');
+            await this.#updateState(blockMessage);
+            debug(`created block: ${hash}`);
+            peernet.publish('add-block', blockMessage.encoded);
+            pubsub.publish('add-block', blockMessage.decoded);
+        }
+        catch (error) {
+            throw new Error(`invalid block ${block}`);
+        }
+        // data = await this.#machine.execute(to, method, params)
+        // transactionStore.put(message.hash, message.encoded)
+    }
+    async #addTransaction(transaction) {
+        try {
+            transaction = await new TransactionMessage(transaction);
+            const hash = await transaction.hash();
+            const has = await transactionPoolStore.has(hash);
+            if (!has)
+                await transactionPoolStore.put(hash, transaction.encoded);
+            if (this.#participating && !this.#runningEpoch)
+                this.#runEpoch();
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error('invalid transaction');
+        }
+    }
+    /**
+     * every tx done is trough contracts so no need for amount
+     * data is undefined when nothing is returned
+     * error is thrown on error so undefined data doesn't mean there is an error...
+     **/
+    async sendTransaction(transaction) {
+        const event = await super.sendTransaction(transaction);
+        this.#addTransaction(event.message.encoded);
+        return event;
+    }
+    async addContract(contractMessage) {
+        const hash = await contractMessage.hash();
+        await this.staticCall(hash, 'get');
+    }
+    /**
+     *
+     * @param {Address} sender
+     * @returns {globalMessage}
+     */
+    #createMessage(sender = globalThis.peernet.selectedAccount) {
+        return {
+            sender,
+            call: this.call,
+            staticCall: this.staticCall,
+            delegate: this.delegate,
+            staticDelegate: this.staticDelegate
+        };
+    }
+    /**
+     *
+     * @param {Address} sender
+     * @param {Address} contract
+     * @param {String} method
+     * @param {Array} parameters
+     * @returns
+     */
+    internalCall(sender, contract, method, parameters) {
+        globalThis.msg = this.#createMessage(sender);
+        return this.#machine.execute(contract, method, parameters);
+    }
+    /**
+     *
+     * @param {Address} contract
+     * @param {String} method
+     * @param {Array} parameters
+     * @returns
+     */
+    call(contract, method, parameters) {
+        globalThis.msg = this.#createMessage();
+        return this.#machine.execute(contract, method, parameters);
+    }
+    staticCall(contract, method, parameters) {
+        globalThis.msg = this.#createMessage();
+        return this.#machine.get(contract, method, parameters);
+    }
+    delegate(contract, method, parameters) {
+        globalThis.msg = this.#createMessage();
+        return this.#machine.execute(contract, method, parameters);
+    }
+    staticDelegate(contract, method, parameters) {
+        globalThis.msg = this.#createMessage();
+        return this.#machine.get(contract, method, parameters);
+    }
+    mint(to, amount) {
+        return this.call(addresses.nativeToken, 'mint', [to, amount]);
+    }
+    transfer(from, to, amount) {
+        return this.call(addresses.nativeToken, 'transfer', [from, to, amount]);
+    }
+    get balances() {
+        return this.staticCall(addresses.nativeToken, 'balances');
+    }
+    get contracts() {
+        return this.staticCall(addresses.contractFactory, 'contracts');
+    }
+    deleteAll() {
+        return this.#machine.deleteAll();
+    }
+    /**
+     * lookup an address for a registered name using the builtin nameService
+     * @check nameService
+     *
+     * @param {String} - contractName
+     * @returns {String} - address
+     *
+     * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
+     */
+    lookup(name) {
+        return this.call(addresses.nameService, 'lookup', [name]);
+    }
+}
+
+export { Chain as default };