@leofcoin/chain 1.4.49 → 1.4.51

package/exports/chain.js

@@ -234,7 +234,7 @@ class State {
 
 class Protocol {
     limit = 1800;
-    transactionLimit = 1800;
+    transactionLimit = 10_000;
 }
 
 class Transaction extends Protocol {
@@ -396,7 +396,7 @@ class Transaction extends Protocol {
             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 };
+            return { hash, data, fee: await calculateFee(message.decoded), wait, message };
         }
         catch (error) {
             throw error;
@@ -661,8 +661,8 @@ class Chain extends Contract {
     async #init() {
         try {
             const version = await globalThis.chainStore.get('version');
-            this.version = version;
-            if (version !== '1.0.0') {
+            this.version = new TextDecoder().decode(version);
+            if (this.version !== '1.0.0') {
                 this.version = '1.0.0';
                 await globalThis.chainStore.clear();
                 await globalThis.blockStore.clear();
@@ -671,14 +671,14 @@ class Chain extends Contract {
             }
             // if (version)
         }
-        catch {
+        catch (e) {
+            console.log(e);
             this.version = '1.0.0';
             await globalThis.chainStore.clear();
             await globalThis.blockStore.clear();
             await globalThis.transactionPoolStore.clear();
-            await globalThis.chainStore.put('version', this.version);
+            await globalThis.chainStore.put('version', new TextEncoder().encode(this.version));
         }
-        await this.#clearPool();
         // this.node = await new Node()
         this.#participants = [];
         this.#participating = false;
@@ -700,7 +700,7 @@ class Chain extends Contract {
         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('add-transaction', this.#addTransaction.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
@@ -805,26 +805,33 @@ class Chain extends Contract {
         return response.decoded.response;
     }
     async #peerConnected(peer) {
+        console.log(peer);
         if (!peer.version || peer.version !== this.version)
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
-        this.#knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
-        let pool = await this.#makeRequest(peer, 'transactionPool');
-        pool = await Promise.all(pool.map(async (hash) => {
-            const has = await globalThis.peernet.has(hash);
-            return { has, hash };
-        }));
-        pool = pool.filter(item => !item.has);
-        await Promise.all(pool.map(async ({ hash }) => {
-            const result = await globalThis.peernet.get(hash);
-            const node = await new TransactionMessage(result);
-            await globalThis.transactionPoolStore.put(await node.hash(), node.encoded);
-        }));
-        if (pool.length > 0)
-            this.#runEpoch();
-        console.log(pool);
-        if (lastBlock)
-            this.#syncChain(lastBlock);
+        if (!this.#lastBlock || lastBlock && lastBlock.index > this.#lastBlock.index && lastBlock.hash === this.#lastBlock?.hash) {
+            this.#knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
+            let pool = await this.#makeRequest(peer, 'transactionPool');
+            pool = await Promise.all(pool.map(async (hash) => {
+                const has = await globalThis.peernet.has(hash);
+                return { has, hash };
+            }));
+            pool = pool.filter(item => !item.has);
+            await Promise.all(pool.map(async ({ hash }) => {
+                const result = await globalThis.peernet.get(hash);
+                // result could be undefined cause invalid/double transactions could be deleted already
+                if (!result)
+                    console.log(result);
+                if (result) {
+                    const node = await new TransactionMessage(result);
+                    await globalThis.transactionPoolStore.put(await node.hash(), node.encoded);
+                }
+            }));
+            if (lastBlock)
+                await this.#syncChain(lastBlock);
+            if (await this.hasTransactionToHandle())
+                this.#runEpoch();
+        }
     }
     #epochTimeout;
     async #transactionPoolHandler() {
@@ -1018,7 +1025,7 @@ class Chain extends Contract {
         let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
         if (Object.keys(transactions)?.length === 0)
             return;
-        const keys = await globalThis.transactionPoolStore.keys();
+        await globalThis.transactionPoolStore.keys();
         const timestamp = Date.now();
         let block = {
             transactions: [],
@@ -1042,35 +1049,30 @@ class Chain extends Contract {
                     }
                 }
             }
-            console.log();
             if (doubleTransactions.length > 0) {
                 await globalThis.transactionPoolStore.delete(hash);
                 await globalThis.peernet.publish('invalid-transaction', hash);
             }
             else {
-                if (timestamp + this.#slotTime > Date.now()) {
-                    try {
-                        const result = await this.#executeTransaction({ ...transaction.decoded, hash });
-                        console.log({ result });
-                        block.transactions.push({ hash, ...transaction.decoded });
-                        block.fees = block.fees.add(await calculateFee(transaction.decoded));
-                        await globalThis.accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)));
-                    }
-                    catch (e) {
-                        console.log(keys.includes(hash));
-                        console.log({ e });
-                        console.log(hash);
-                        await globalThis.transactionPoolStore.delete(hash);
-                    }
+                // if (timestamp + this.#slotTime > Date.now()) {
+                try {
+                    const result = await this.#executeTransaction({ ...transaction.decoded, hash });
+                    block.transactions.push(transaction);
+                    block.fees = block.fees.add(await calculateFee(transaction.decoded));
+                    await globalThis.accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)));
                 }
+                catch (e) {
+                    console.log({ e });
+                    console.log(hash);
+                    await globalThis.transactionPoolStore.delete(hash);
+                }
+                // }
             }
         }
-        console.log(block.transactions);
         // 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({
@@ -1090,7 +1092,6 @@ class Chain extends Contract {
                     const node = await globalThis.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
@@ -1106,16 +1107,13 @@ class Chain extends Contract {
                 }
             }
         }
-        console.log({ validators: block.validators });
         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);
-            validator.reward = validator.reward.toString();
             delete validator.bw;
             return validator;
         });
-        console.log({ validators: block.validators });
         // block.validators = calculateValidatorReward(block.validators, block.fees)
         block.index = this.lastBlock?.index;
         if (block.index === undefined)
@@ -1123,12 +1121,15 @@ class Chain extends Contract {
         else
             block.index += 1;
         block.previousHash = this.lastBlock?.hash || '0x0';
-        block.timestamp = Date.now();
-        block.reward = block.reward.toString();
-        block.fees = block.fees.toString();
+        // block.timestamp = Date.now()
+        // block.reward = block.reward.toString()
+        // block.fees = block.fees.toString()
         try {
-            await Promise.all(block.transactions
-                .map(async (transaction) => globalThis.transactionPoolStore.delete(transaction.hash)));
+            block.transactions = await Promise.all(block.transactions
+                .map(async (transaction) => {
+                await globalThis.transactionPoolStore.delete(await transaction.hash());
+                return transaction.decoded;
+            }));
             let blockMessage = await new BlockMessage(block);
             const hash = await blockMessage.hash();
             await globalThis.peernet.put(hash, blockMessage.encoded, 'block');
@@ -1138,23 +1139,22 @@ class Chain extends Contract {
             globalThis.pubsub.publish('add-block', blockMessage.decoded);
         }
         catch (error) {
+            console.log(error);
             throw new Error(`invalid block ${block}`);
         }
         // data = await this.#machine.execute(to, method, params)
         // transactionStore.put(message.hash, message.encoded)
     }
-    async #addTransaction(transaction) {
-        transaction = await new TransactionMessage(transaction);
+    async #sendTransaction(transaction) {
+        transaction = await new TransactionMessage(transaction.encoded);
         const hash = await transaction.hash();
         try {
             const has = await globalThis.transactionPoolStore.has(hash);
             if (!has) {
                 await globalThis.transactionPoolStore.put(hash, transaction.encoded);
-                if (this.#participating && !this.#runningEpoch)
-                    this.#runEpoch();
             }
-            else
-                globalThis.peernet.publish('invalid-transaction', hash);
+            if (this.#participating && !this.#runningEpoch)
+                this.#runEpoch();
         }
         catch (e) {
             console.log(e);
@@ -1169,7 +1169,8 @@ class Chain extends Contract {
      **/
     async sendTransaction(transaction) {
         const event = await super.sendTransaction(transaction);
-        this.#addTransaction(event.message.encoded);
+        this.#sendTransaction(await new TransactionMessage(event.message.encoded));
+        globalThis.peernet.publish('send-transaction', event.message.encoded);
         return event;
     }
     async addContract(transaction, contractMessage) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.4.49",
+  "version": "1.4.51",
   "description": "Official javascript implementation",
   "exports": {
     "./node": "./exports/node.js",
@@ -53,9 +53,9 @@
   },
   "dependencies": {
     "@leofcoin/addresses": "^1.0.4",
-    "@leofcoin/codec-format-interface": "^1.6.4",
+    "@leofcoin/codec-format-interface": "^1.6.14",
     "@leofcoin/lib": "^1.0.11",
-    "@leofcoin/messages": "^1.2.0",
+    "@leofcoin/messages": "^1.3.7",
     "@leofcoin/multi-wallet": "^2.1.1",
     "@leofcoin/networks": "^1.0.0",
     "@leofcoin/peernet": "^1.1.12",