@leofcoin/chain 1.4.49 → 1.4.51

package/exports/browser/chain.js

@@ -1,4 +1,4 @@
-import { B as BigNumber, L as Logger, v as version$1, h as hexZeroPad, i as isBigNumberish, a as arrayify, b as isBytes, C as ContractMessage, T as TransactionMessage, c as CodecHash, d as BlockMessage, e as BWMessage, f as BWRequestMessage } from './contract-f76383c3.js';
+import { B as BigNumber, L as Logger, v as version$1, h as hexZeroPad, i as isBigNumberish, a as arrayify, b as isBytes, C as ContractMessage, T as TransactionMessage, R as RawTransactionMessage, c as BlockMessage, d as BWMessage, e as BWRequestMessage } from './index-640d9f36.js';
 
 const logger$1 = new Logger(version$1);
 const _constructorGuard = {};
@@ -729,7 +729,16 @@ const calculateFee = async (transaction, format = false) => {
     // fee = fee.div(1000000)
     return format ? formatUnits(fee.toString()) : fee;
 };
-const createTransactionHash = async (transaction) => (await new CodecHash(transaction, { name: 'transaction-message' })).digest;
+const createTransactionHash = async (transaction) => {
+    const isRawTransactionMessage = transaction instanceof RawTransactionMessage;
+    if (!isRawTransactionMessage) {
+        if (transaction.decoded && transaction instanceof TransactionMessage)
+            transaction = await new RawTransactionMessage(transaction.decoded);
+        else
+            transaction = await new RawTransactionMessage(transaction);
+    }
+    return (await transaction.peernetHash).digest;
+};
 const signTransaction = async (transaction, wallet) => {
     const signature = await wallet.sign(await createTransactionHash(transaction));
     const signedTransaction = { ...transaction, signature };
@@ -7639,7 +7648,7 @@ class State {
 
 class Protocol {
     limit = 1800;
-    transactionLimit = 1800;
+    transactionLimit = 10_000;
 }
 
 class Transaction extends Protocol {
@@ -7801,7 +7810,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;
@@ -8066,8 +8075,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();
@@ -8076,14 +8085,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;
@@ -8105,7 +8114,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
@@ -8210,26 +8219,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() {
@@ -8423,7 +8439,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: [],
@@ -8447,35 +8463,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({
@@ -8495,7 +8506,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
@@ -8511,16 +8521,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)
@@ -8528,12 +8535,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');
@@ -8543,23 +8553,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);
@@ -8574,7 +8583,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/exports/browser/{client-345f1d43-a7ba559a.js → client-345f1d43-54202b18.js}

@@ -1,5 +1,5 @@
-import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './node-browser-8791470c.js';
-import './contract-f76383c3.js';
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './node-browser-63d44d8e.js';
+import './index-640d9f36.js';
 
 function commonjsRequire(path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');

package/exports/browser/{index-5ed49438-539fe0fa.js → index-5ed49438-165d8320.js}

@@ -1,5 +1,5 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-8791470c.js';
-import './contract-f76383c3.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-63d44d8e.js';
+import './index-640d9f36.js';
 
 /**
  * @params {String} network