@leofcoin/chain 1.4.24 → 1.4.26

package/exports/chain.js

@@ -494,6 +494,7 @@ class Chain extends Contract {
     #participants = [];
     #participating = false;
     #jail = [];
+    #knownBlocks = [];
     constructor() {
         super();
         return this.#init();
@@ -589,9 +590,11 @@ class Chain extends Contract {
             promises = await Promise.allSettled(promises);
             promises = promises.filter(({ status }) => status === 'fulfilled');
             clearTimeout(timeout);
-            promises = promises.map(({ value }) => new peernet.protos['peernet-response'](value));
+            promises = promises.map(async ({ value }) => {
+                const node = await new peernet.protos['peernet-response'](value.result);
+                return { value: node.decoded.response, peer: value.peer };
+            });
             promises = await Promise.all(promises);
-            promises = promises.map(node => node.decoded.response);
             resolve(promises);
         });
     }
@@ -601,24 +604,40 @@ class Chain extends Contract {
     async #getLatestBlock() {
         let promises = [];
         let data = await new peernet.protos['peernet-request']({ request: 'lastBlock' });
-        const node = await peernet.prepareMessage(data);
+        let 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));
+                promises.push(async () => {
+                    try {
+                        const result = await peer.request(node.encoded);
+                        return { result, peer };
+                    }
+                    catch (error) {
+                        throw error;
+                    }
+                });
             }
             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();
-            }
-        }
+        let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
+        promises = promises.sort((a, b) => b.index - a.index);
+        latest = promises[0].value;
         if (latest.hash && latest.hash !== '0x0') {
-            latest = await peernet.get(latest.hash, block);
-            latest = await new BlockMessage(latest);
+            let message = await 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');
+            let data = await new peernet.protos['peernet-request']({ request: 'knownBlocks' });
+            let node = await peernet.prepareMessage(data);
+            const peer = promises[0].peer;
+            if (peer.connected && peer.readyState === 'open' && peer.peerId !== this.id) {
+                let message = await peer.request(node);
+                message = await new peernet.protos['peernet-response'](message);
+                this.#knownBlocks = message.decoded.response;
+            }
+            latest = { ...message.decoded, hash };
         }
         return latest;
     }
@@ -658,6 +677,7 @@ class Chain extends Contract {
             return new BWMessage(peernet.client.bw) || { up: 0, down: 0 };
         });
         await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+        await peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.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));
@@ -677,6 +697,15 @@ class Chain extends Contract {
     async #syncChain(lastBlock) {
         if (this.#chainSyncing || !lastBlock || !lastBlock.hash || !lastBlock.hash)
             return;
+        if (this.#knownBlocks?.length === Number(lastBlock.index) + 1) {
+            let promises = [];
+            promises = await Promise.allSettled(this.#knownBlocks.map(async (address) => {
+                const has = await peernet.has(address, 'block');
+                return { has, address };
+            }));
+            promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has);
+            await Promise.allSettled(promises.map(({ value }) => peernet.get(value.address, 'block')));
+        }
         if (!this.lastBlock || Number(this.lastBlock.index) < Number(lastBlock.index)) {
             this.#chainSyncing = true;
             // TODO: check if valid
@@ -704,6 +733,9 @@ class Chain extends Contract {
     async #lastBlockHandler() {
         return new peernet.protos['peernet-response']({ response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index } });
     }
+    async #knownBlocksHandler() {
+        return new peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
+    }
     async resolveBlock(hash) {
         if (!hash)
             throw new Error(`expected hash, got: ${hash}`);
@@ -986,9 +1018,14 @@ class Chain extends Contract {
         this.#addTransaction(event.message.encoded);
         return event;
     }
-    async addContract(contractMessage) {
+    async addContract(transaction, contractMessage) {
         const hash = await contractMessage.hash();
-        await this.staticCall(hash, 'get');
+        const has = await this.staticCall(addresses.contractFactory, 'isRegistered', [hash]);
+        if (has)
+            throw new Error('contract exists');
+        const tx = await this.sendTransaction(transaction);
+        await tx.wait;
+        return tx;
     }
     /**
      *

package/exports/typings/chain.d.ts

@@ -23,6 +23,7 @@ export default class Chain extends Contract {
     getLatestBlock(): Promise<{
         index: number;
         hash: string;
+        previousHash: string;
     }>;
     resolveBlock(hash: any): any;
     resolveBlocks(): any;
@@ -39,7 +40,13 @@ export default class Chain extends Contract {
         wait: Promise<unknown>;
         message: any;
     }>;
-    addContract(contractMessage: any): Promise<void>;
+    addContract(transaction: any, contractMessage: any): Promise<{
+        hash: any;
+        data: any;
+        fee: string | 0;
+        wait: Promise<unknown>;
+        message: any;
+    }>;
     /**
      *
      * @param {Address} sender

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.4.24",
+  "version": "1.4.26",
   "description": "Official javascript implementation",
   "exports": {
     "./node": "./exports/node.js",