@leofcoin/chain 1.5.24 → 1.5.26

package/exports/chain.js

@@ -12,7 +12,7 @@ const requestTimeout = 30000;
 const syncTimeout = 30000;
 class Protocol {
     constructor() {
-        this.resolveTimeout = 30000;
+        this.resolveTimeout = 10000;
     }
     get limit() {
         return limit;
@@ -41,11 +41,11 @@ class Transaction extends Protocol {
         return new Promise(async (resolve, reject) => {
             let size = 0;
             const _transactions = [];
-            await Promise.all(transactions
-                .map(async (tx) => {
+            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)
+                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);
@@ -59,7 +59,7 @@ class Transaction extends Protocol {
      * @returns {TransactionMessage}
      */
     async promiseTransactions(transactions) {
-        transactions = await Promise.all(transactions.map(tx => new TransactionMessage(tx.encoded || tx)));
+        transactions = await Promise.all(transactions.map((tx) => new TransactionMessage(tx.encoded || tx)));
         return transactions;
     }
     /**
@@ -68,7 +68,7 @@ class Transaction extends Protocol {
      * @returns {Object} {transaction.decoded, transaction.hash}
      */
     async promiseTransactionsContent(transactions) {
-        transactions = await Promise.all(transactions.map(tx => new Promise(async (resolve, reject) => {
+        transactions = await Promise.all(transactions.map((tx) => new Promise(async (resolve, reject) => {
             resolve({ ...tx.decoded, hash: await tx.hash() });
         })));
         return transactions;
@@ -81,7 +81,7 @@ class Transaction extends Protocol {
     async #getNonceFallback(address) {
         let transactions = await globalThis.transactionPoolStore.values();
         transactions = await this.promiseTransactions(transactions);
-        transactions = transactions.filter(tx => tx.decoded.from === address);
+        transactions = transactions.filter((tx) => tx.decoded.from === address);
         transactions = await this.promiseTransactionsContent(transactions);
         // @ts-ignore
         if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
@@ -92,11 +92,11 @@ class Transaction extends Protocol {
             //   tx = await peernet.get(tx, 'transaction')
             //   transactions.push(new TransactionMessage(tx))
             // }
-            transactions = transactions.filter(tx => tx.from === address);
+            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);
+                transactions = block.decoded.transactions.filter((tx) => tx.from === address);
             }
         }
         if (transactions.length === 0)
@@ -110,7 +110,7 @@ class Transaction extends Protocol {
      * @returns {Number} nonce
      */
     async getNonce(address) {
-        if (!await globalThis.accountsStore.has(address)) {
+        if (!(await globalThis.accountsStore.has(address))) {
             const nonce = await this.#getNonceFallback(address);
             await globalThis.accountsStore.put(address, new TextEncoder().encode(String(nonce)));
         }
@@ -119,7 +119,7 @@ class Transaction extends Protocol {
         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 = transactions.filter((tx) => tx.decoded.from === address);
         transactions = await this.promiseTransactionsContent(transactions);
         for (const transaction of transactions) {
             if (transaction.nonce > nonce)
@@ -136,7 +136,7 @@ class Transaction extends Protocol {
             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);
+        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`);
@@ -215,8 +215,7 @@ class Contract extends Transaction {
     constructor() {
         super();
     }
-    async init() {
-    }
+    async init() { }
     /**
      *
      * @param {Address} creator
@@ -335,7 +334,10 @@ class Machine {
                 // browser env
                 pre = './';
             }
-            this.worker = await new EasyWorker(pre + 'workers/machine-worker.js', { serialization: 'advanced', type: 'module' });
+            this.worker = await new EasyWorker(pre + 'workers/machine-worker.js', {
+                serialization: 'advanced',
+                type: 'module'
+            });
             this.worker.onmessage(this.#onmessage.bind(this));
             // const blocks = await blockStore.values()
             const contracts = await Promise.all([
@@ -361,7 +363,7 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(message.error);
@@ -393,7 +395,7 @@ class Machine {
                 if (await this.has(parameters[0]))
                     throw new Error(`duplicate contract @${parameters[0]}`);
                 let message;
-                if (!await globalThis.contractStore.has(parameters[0])) {
+                if (!(await globalThis.contractStore.has(parameters[0]))) {
                     message = await peernet.get(parameters[0], 'contract');
                     message = await new ContractMessage(message);
                     await globalThis.contractStore.put(await message.hash(), message.encoded);
@@ -402,7 +404,7 @@ class Machine {
                     message = await globalThis.contractStore.get(parameters[0]);
                     message = await new ContractMessage(message);
                 }
-                if (!await this.has(await message.hash()))
+                if (!(await this.has(await message.hash())))
                     await this.#runContract(message);
             }
         }
@@ -412,7 +414,7 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(new ExecutionError(message.error));
@@ -434,7 +436,7 @@ class Machine {
     get(contract, method, parameters) {
         return new Promise((resolve, reject) => {
             const id = randombytes(20).toString();
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 resolve(message);
             };
@@ -454,7 +456,7 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
-            const onmessage = message => {
+            const onmessage = (message) => {
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(message.error);
@@ -480,7 +482,7 @@ class Machine {
      */
     async deleteAll() {
         let hashes = await globalThis.contractStore.keys();
-        hashes = Object.keys(hashes).map(hash => this.delete(hash));
+        hashes = Object.keys(hashes).map((hash) => this.delete(hash));
         return Promise.all(hashes);
     }
 }
@@ -496,7 +498,7 @@ class Jobber {
             const timeout = setTimeout(() => {
                 reject('timeout');
             }, this.timeout);
-            this.stop = () => {
+            this.destroy = () => {
                 clearTimeout(timeout);
                 this.busy = false;
                 resolve('stopped');
@@ -508,6 +510,7 @@ class Jobber {
                 resolve(result);
             }
             catch (error) {
+                clearTimeout(timeout);
                 reject(error);
             }
         });
@@ -521,6 +524,7 @@ class State extends Contract {
     #resolving;
     #resolveErrorCount;
     #syncState;
+    #chainState;
     #lastBlockInQue;
     #syncErrorCount;
     #blockHashMap;
@@ -530,6 +534,12 @@ class State extends Contract {
     #totalSize;
     #machine;
     #loaded;
+    get state() {
+        return {
+            sync: this.#syncState,
+            chain: this.#chainState
+        };
+    }
     get blockHashMap() {
         return this.#blockHashMap.entries();
     }
@@ -591,8 +601,10 @@ class State extends Contract {
     }
     constructor() {
         super();
+        this.#lastResolvedTime = 0;
         this.#resolving = false;
         this.#resolveErrorCount = 0;
+        this.#chainState = 'loading';
         this.#syncErrorCount = 0;
         this.#blockHashMap = new Map();
         this.#chainSyncing = false;
@@ -624,12 +636,28 @@ class State extends Contract {
          * {Number}
          */
         this.#totalTransactions = 0;
+        this.#chainStateHandler = () => {
+            return new globalThis.peernet.protos['peernet-response']({
+                response: this.#chainState
+            });
+        };
+        this.#lastBlockHandler = async () => {
+            return new globalThis.peernet.protos['peernet-response']({
+                response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index }
+            });
+        };
+        this.#knownBlocksHandler = async () => {
+            return new globalThis.peernet.protos['peernet-response']({
+                response: { blocks: this.#blocks.map((block) => block.hash) }
+            });
+        };
         this.#loadBlockTransactions = (transactions) => Promise.all(transactions.map((transaction) => new TransactionMessage(transaction)));
         this.#getLastTransactions = async () => {
-            let lastTransactions = (await Promise.all(this.#blocks.filter(block => block.loaded).slice(-128)
-                .map(block => this.#loadBlockTransactions(block.transactions))))
-                .reduce((all, transactions) => [...all, ...transactions], []);
-            return Promise.all(lastTransactions.map(transaction => transaction.hash()));
+            let lastTransactions = (await Promise.all(this.#blocks
+                .filter((block) => block.loaded)
+                .slice(-128)
+                .map((block) => this.#loadBlockTransactions(block.transactions)))).reduce((all, transactions) => [...all, ...transactions], []);
+            return Promise.all(lastTransactions.map((transaction) => transaction.hash()));
         };
     }
     async clearPool() {
@@ -644,12 +672,16 @@ class State extends Contract {
         await globalThis.blockStore.clear();
         await globalThis.transactionPoolStore.clear();
     }
+    #chainStateHandler;
+    #lastBlockHandler;
+    #knownBlocksHandler;
     async init() {
-        this.jobber = new Jobber(30000);
+        this.jobber = new Jobber(this.resolveTimeout);
         if (super.init)
             await super.init();
-        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
-        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler);
+        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler);
+        await globalThis.peernet.addRequestHandler('chainState', this.#chainStateHandler);
         try {
             let localBlock;
             try {
@@ -663,7 +695,10 @@ class State extends Contract {
             if (localBlock && localBlock !== '0x0') {
                 localBlock = await globalThis.peernet.get(localBlock, 'block');
                 localBlock = await new BlockMessage(localBlock);
-                this.#lastBlock = { ...localBlock.decoded, hash: await localBlock.hash() };
+                this.#lastBlock = {
+                    ...localBlock.decoded,
+                    hash: await localBlock.hash()
+                };
             }
             else {
                 if (globalThis.peernet?.connections.length > 0) {
@@ -704,12 +739,6 @@ class State extends Contract {
         await globalThis.chainStore.put('lastBlock', hash);
         globalThis.pubsub.publish('lastBlock', this.#lastBlock);
     }
-    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() {
         // @ts-ignore
         return this.#getLatestBlock();
@@ -722,7 +751,7 @@ class State extends Contract {
             const { index } = block.decoded;
             if (this.#blocks[index - 1] && this.#blocks[index - 1].hash !== block.hash)
                 throw `invalid block ${hash} @${index}`;
-            if (!await globalThis.peernet.has(hash))
+            if (!(await globalThis.peernet.has(hash)))
                 await globalThis.peernet.put(hash, block.encoded, 'block');
         }
         return block;
@@ -750,8 +779,6 @@ class State extends Contract {
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
-            this.#resolving = false;
-            this.#chainSyncing = false;
             throw new ResolveError(`block: ${hash}@${index}`);
         }
         return;
@@ -764,6 +791,8 @@ class State extends Contract {
         if (this.#resolving)
             return 'already resolving';
         this.#resolving = true;
+        if (this.jobber.busy && this.jobber.destroy)
+            await this.jobber.destroy();
         try {
             await this.jobber.add(() => this.#resolveBlock(hash));
             this.#resolving = false;
@@ -773,6 +802,7 @@ class State extends Contract {
         catch (error) {
             console.log({ error });
             this.#resolveErrorCount += 1;
+            this.#resolving = false;
             if (this.#resolveErrorCount < 3)
                 return this.resolveBlock(hash);
             this.#resolveErrorCount = 0;
@@ -781,8 +811,8 @@ class State extends Contract {
     }
     async resolveBlocks() {
         try {
-            if (this.jobber.busy && this.jobber.stop) {
-                await this.jobber.stop();
+            if (this.jobber.busy && this.jobber.destroy) {
+                await this.jobber.destroy();
             }
         }
         catch (error) {
@@ -798,10 +828,10 @@ class State extends Contract {
         }
         catch (error) {
             console.log(error);
+            this.#chainSyncing = false;
+            this.#syncState = 'errored';
             this.#resolveErrored = true;
-            this.#resolveErrorCount += 1;
-            this.#resolving = false;
-            this.restoreChain();
+            return this.restoreChain();
             // console.log(e);
         }
     }
@@ -819,23 +849,24 @@ class State extends Contract {
             this.#resolveErrored = true;
             this.#resolveErrorCount += 1;
             this.#resolving = false;
-            this.restoreChain();
+            return this.restoreChain();
             // console.log(e);
         }
     }
+    destroyResolveJob() { }
     async syncChain(lastBlock) {
-        if (!this.shouldSync) {
+        if (!this.shouldSync)
             return;
-        }
+        this.#syncState;
+        this.#chainSyncing = true;
         try {
-            if (this.jobber.busy && this.jobber.stop) {
-                await this.jobber.stop();
+            if (this.jobber.busy && this.jobber.destroy) {
+                await this.jobber.destroy();
             }
         }
         catch (error) {
             console.error(error);
         }
-        this.#chainSyncing = true;
         if (!lastBlock)
             lastBlock = await this.#getLatestBlock();
         console.log('starting sync');
@@ -850,7 +881,8 @@ class State extends Contract {
                 return this.syncChain(lastBlock);
             this.#syncErrorCount = 0;
             this.#chainSyncing = false;
-            return 'errored';
+            this.#syncState = 'errored';
+            return this.#syncState;
         }
         if (lastBlock.index === this.#lastBlockInQue?.index)
             this.#lastBlockInQue = undefined;
@@ -858,7 +890,8 @@ class State extends Contract {
         this.#chainSyncing = false;
         if (this.#lastBlockInQue)
             return this.syncChain(this.#lastBlockInQue);
-        return 'synced';
+        this.#syncState = 'synced';
+        return this.#syncState;
     }
     async #syncChain(lastBlock) {
         try {
@@ -879,7 +912,7 @@ class State extends Contract {
                 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);
+                const start = this.#blocks.length - blocksSynced;
                 if (this.#machine)
                     await this.#loadBlocks(this.blocks.slice(start));
                 await this.updateState(new BlockMessage(this.#blocks[this.#blocks.length - 1]));
@@ -892,7 +925,9 @@ class State extends Contract {
     }
     async #getLatestBlock() {
         let promises = [];
-        let data = await new globalThis.peernet.protos['peernet-request']({ request: 'lastBlock' });
+        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) {
             // @ts-ignore
@@ -924,7 +959,9 @@ class State extends Contract {
             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 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);
@@ -940,6 +977,7 @@ class State extends Contract {
      * @param {Block[]} blocks
      */
     async #loadBlocks(blocks) {
+        this.#chainState = 'loading';
         let poolTransactionKeys = await globalThis.transactionPoolStore.keys();
         for (const block of blocks) {
             if (block && !block.loaded) {
@@ -992,6 +1030,7 @@ class State extends Contract {
                 globalThis.pubsub.publish('block-loaded', { ...block });
             }
         }
+        this.#chainState = 'loaded';
         return true;
     }
     promiseRequests(promises) {
@@ -1022,9 +1061,12 @@ class State extends Contract {
         return true;
     }
     get shouldSync() {
-        if (this.canSync ||
-            this.#resolveErrored ||
-            !this.canSync && this.#lastResolvedTime + this.resolveTimeout > new Date().getTime())
+        if (this.#chainSyncing)
+            return false;
+        if (this.#resolveErrored ||
+            this.#syncState === 'errored' ||
+            this.#syncState === 'connectionless' ||
+            (!this.canSync && this.#lastResolvedTime + this.resolveTimeout > Date.now()))
             return true;
         return false;
     }
@@ -1044,7 +1086,7 @@ class VersionControl extends State {
         super();
     }
     async init() {
-        super.init && await super.init();
+        super.init && (await super.init());
         console.log('init');
         try {
             const version = await globalThis.chainStore.get('version');
@@ -1126,29 +1168,34 @@ class Chain extends VersionControl {
             console.error(error);
         }
         const end = Date.now();
-        console.log(((end - start) / 1000) + ' s');
+        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 = [{
+        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 }) => {
             // @ts-ignore
-            message = await new ContractMessage(Uint8Array.from(message.split(',').map(string => Number(string))));
+            message = await new ContractMessage(Uint8Array.from(message.split(',').map((string) => Number(string))));
             // @ts-ignore
             await globalThis.contractStore.put(address, message.encoded);
         }));
@@ -1170,7 +1217,7 @@ class Chain extends VersionControl {
             return new BWMessage(globalThis.peernet.client.bw) || { up: 0, down: 0 };
         });
         // await globalThis.peernet.addRequestHandler('peerId', () => {
-        //   let node = 
+        //   let node =
         //   globalThis.peernet.protos['peernet-response']({response: node.encoded})
         // })
         await globalThis.peernet.addRequestHandler('transactionPool', this.#transactionPoolHandler.bind(this));
@@ -1207,31 +1254,36 @@ class Chain extends VersionControl {
         response = await new globalThis.peernet.protos['peernet-response'](new Uint8Array(Object.values(response)));
         return response.decoded.response;
     }
+    async getPeerTransactionPool(peer) {
+        const transactionsInPool = await this.#makeRequest(peer, 'transactionPool');
+        // todo iterate vs getting all keys?
+        const transactions = await globalThis.transactionPoolStore.keys();
+        const transactionsToGet = [];
+        for (const key of transactionsInPool) {
+            !transactions.includes(key) &&
+                !ignorelist.includes(key) &&
+                transactionsToGet.push(transactionPoolStore.put(key, await peernet.get(key, 'transaction')));
+        }
+        return Promise.all(transactionsToGet);
+    }
     async #peerConnected(peer) {
         // todo handle version changes
         // for now just do nothing if version doesn't match
         if (!peer.version || peer.version !== this.version)
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
-        let transactionsInPool = await this.#makeRequest(peer, 'transactionPool');
-        const transactions = await globalThis.transactionPoolStore.keys();
-        const transactionsToGet = [];
-        for (const key of transactionsInPool) {
-            if (!transactions.includes(key) && !ignorelist.includes(key))
-                transactionsToGet.push(transactionPoolStore.put(key, (await peernet.get(key, 'transaction'))));
-        }
-        await Promise.all(transactionsToGet);
+        const higherThenCurrentLocal = lastBlock.index > this.lastBlock?.index;
+        const peerTransactionPool = (higherThenCurrentLocal && (await this.getPeerTransactionPool(peer))) || [];
         if (Object.keys(lastBlock).length > 0) {
-            if (!this.lastBlock || !this.blocks[this.blocks.length - 1]?.loaded || lastBlock && lastBlock.index > this.lastBlock?.index || !this.loaded && !this.resolving) {
+            if (!this.lastBlock || higherThenCurrentLocal) {
                 this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
                 await this.syncChain(lastBlock);
-                // if (await this.hasTransactionToHandle() && this.#participating) this.#runEpoch()
             }
             else if (!this.knownBlocks)
                 this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
         }
-        if (this.#participating)
-            this.#runEpoch();
+        if (this.#participating && peerTransactionPool.length > 0)
+            return this.#runEpoch();
     }
     #epochTimeout;
     async #transactionPoolHandler() {
@@ -1310,7 +1362,7 @@ class Chain extends VersionControl {
         // peerReputation(peerId)
         // {bandwith: {up, down}, uptime}
         this.#participating = true;
-        if (!await this.staticCall(addresses.validators, 'has', [address])) {
+        if (!(await this.staticCall(addresses.validators, 'has', [address]))) {
             const rawTransaction = {
                 from: address,
                 to: addresses.validators,
@@ -1322,13 +1374,13 @@ class Chain extends VersionControl {
             const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
             await this.sendTransaction(transaction);
         }
-        if (await this.hasTransactionToHandle() && !this.#runningEpoch && this.#participating)
+        if ((await this.hasTransactionToHandle()) && !this.#runningEpoch && this.#participating)
             await this.#runEpoch();
     }
     // todo filter tx that need to wait on prev nonce
     async #createBlock(limit = this.transactionLimit) {
         // vote for transactions
-        if (await globalThis.transactionPoolStore.size() === 0)
+        if ((await globalThis.transactionPoolStore.size()) === 0)
             return;
         let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
         for (const hash of await globalThis.transactionPoolStore.keys()) {
@@ -1421,7 +1473,7 @@ class Chain extends VersionControl {
                 }
             }
         }
-        block.validators = block.validators.map(validator => {
+        block.validators = block.validators.map((validator) => {
             validator.reward = block.fees;
             validator.reward = validator.reward.add(block.reward);
             validator.reward = validator.reward.div(block.validators.length);
@@ -1439,8 +1491,7 @@ class Chain extends VersionControl {
         // block.reward = block.reward.toString()
         // block.fees = block.fees.toString()
         try {
-            block.transactions = await Promise.all(block.transactions
-                .map(async (transaction) => {
+            block.transactions = await Promise.all(block.transactions.map(async (transaction) => {
                 await globalThis.transactionPoolStore.delete(await transaction.hash());
                 return transaction.decoded;
             }));

package/exports/contract.d.ts

@@ -1,4 +1,4 @@
-import Transaction from "./transaction.js";
+import Transaction from './transaction.js';
 import type MultiWallet from '@leofcoin/multi-wallet';
 /**
  * @extends {Transaction}

package/exports/jobs/jobber.d.ts

@@ -1,7 +1,7 @@
 export default class Jobber {
     timeout: EpochTimeStamp;
     busy: boolean;
-    stop: Function;
+    destroy: Function;
     constructor(timeout: any);
     add(fn: any): Promise<unknown>;
 }

package/exports/node.js

@@ -16,7 +16,9 @@ class Node {
         stars: networks.leofcoin.peach.stars,
         autoStart: false
     }, password) {
-        this.#node = globalThis.Peernet ? await new globalThis.Peernet(config, password) : await new Peernet(config, password);
+        this.#node = globalThis.Peernet
+            ? await new globalThis.Peernet(config, password)
+            : await new Peernet(config, password);
         await nodeConfig(config);
         globalThis.pubsub.subscribe('chain:ready', async () => {
             // when autostart is false the node will only be started after the chain is ready (this is here so we can just use node for communication)

package/exports/state.d.ts

@@ -4,10 +4,15 @@ import Machine from './machine.js';
 import Jobber from './jobs/jobber.js';
 import { BlockHash } from './types.js';
 declare type SyncState = 'syncing' | 'synced' | 'errored' | 'connectionless';
+declare type ChainState = 'loading' | 'loaded';
 export default class State extends Contract {
     #private;
     knownBlocks: BlockHash[];
     jobber: Jobber;
+    get state(): {
+        sync: SyncState;
+        chain: ChainState;
+    };
     get blockHashMap(): IterableIterator<[any, any]>;
     get loaded(): boolean;
     get resolving(): boolean;
@@ -35,8 +40,9 @@ export default class State extends Contract {
     getLatestBlock(): Promise<BlockMessage['decoded']>;
     getAndPutBlock(hash: string): Promise<BlockMessage>;
     resolveBlock(hash: any): any;
-    resolveBlocks(): Promise<void>;
-    restoreChain(): Promise<void>;
+    resolveBlocks(): Promise<any>;
+    restoreChain(): any;
+    destroyResolveJob(): void;
     syncChain(lastBlock?: any): Promise<SyncState>;
     promiseRequests(promises: any): Promise<unknown>;
     get canSync(): boolean;