@leofcoin/chain 1.4.50 → 1.4.52

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 };
@@ -7637,9 +7646,23 @@ class State {
     }
 }
 
+const limit = 1800;
+const transactionLimit = 1800;
+const requestTimeout = 30_000;
+const syncTimeout = 30_000;
 class Protocol {
-    limit = 1800;
-    transactionLimit = 1800;
+    get limit() {
+        return limit;
+    }
+    get transactionLimit() {
+        return transactionLimit;
+    }
+    get requestTimeout() {
+        return requestTimeout;
+    }
+    get syncTimeout() {
+        return syncTimeout;
+    }
 }
 
 class Transaction extends Protocol {
@@ -7801,7 +7824,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;
@@ -8000,7 +8023,7 @@ class Chain extends Contract {
             const timeout = setTimeout(() => {
                 resolve([{ index: 0, hash: '0x0' }]);
                 globalThis.debug('sync timed out');
-            }, 10_000);
+            }, this.requestTimeout);
             promises = await Promise.allSettled(promises);
             promises = promises.filter(({ status }) => status === 'fulfilled');
             clearTimeout(timeout);
@@ -8048,11 +8071,11 @@ class Chain extends Contract {
             const hash = await message.hash();
             if (hash !== latest.hash)
                 throw new Error('invalid block @getLatestBlock');
-            let data = await new globalThis.peernet.protos['peernet-request']({ request: 'knownBlocks' });
-            let node = await globalThis.peernet.prepareMessage(data);
-            const peer = promises[0].peer;
             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 node = await globalThis.peernet.prepareMessage(data);
                 let message = await peer.request(node);
                 message = await new globalThis.peernet.protos['peernet-response'](message);
                 this.#knownBlocks = message.decoded.response;
@@ -8067,7 +8090,7 @@ class Chain extends Contract {
         try {
             const version = await globalThis.chainStore.get('version');
             this.version = new TextDecoder().decode(version);
-            if (version !== '1.0.0') {
+            if (this.version !== '1.0.0') {
                 this.version = '1.0.0';
                 await globalThis.chainStore.clear();
                 await globalThis.blockStore.clear();
@@ -8076,14 +8099,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 +8128,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
@@ -8162,7 +8185,7 @@ class Chain extends Contract {
         let current;
         const timeout = () => current = setTimeout(() => {
             if (this.#chainSyncing) {
-                if (this.#lastResolved + 10000 > Date.now())
+                if (this.#lastResolved + this.syncTimeout > Date.now())
                     timeout();
                 else {
                     this.#chainSyncing = false;
@@ -8170,7 +8193,7 @@ class Chain extends Contract {
                     this.#syncChain(lastBlock);
                 }
             }
-        }, 10000);
+        }, this.syncTimeout);
         timeout();
         if (this.#chainSyncing || !lastBlock || !lastBlock.hash || !lastBlock.hash)
             return;
@@ -8213,23 +8236,38 @@ class Chain extends Contract {
         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 (lastBlock.index > this.#lastBlock?.index) {
+            // this.#knownBlocks = await this.#makeRequest(peer, 'knownBlocks')
+            try {
+                console.log('getting pool');
+                let pool = await this.#makeRequest(peer, 'transactionPool');
+                console.log('got pool');
+                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);
+                    }
+                }));
+            }
+            catch (error) {
+                console.log(error);
+                console.log('error fetching transactionPool');
+            }
+            console.log(lastBlock);
+            if (lastBlock)
+                await this.#syncChain(lastBlock);
+            if (await this.hasTransactionToHandle())
+                this.#runEpoch();
+        }
     }
     #epochTimeout;
     async #transactionPoolHandler() {
@@ -8246,13 +8284,16 @@ class Chain extends Contract {
         return new globalThis.peernet.protos['peernet-response']({ response: { blocks: this.#blocks.map((block) => block.hash) } });
     }
     async getAndPutBlock(hash) {
+        // todo peernet resolves undefined blocks....
         let block = await globalThis.peernet.get(hash, 'block');
-        block = await new BlockMessage(block);
-        const { index } = block.decoded;
-        if (this.#blocks[index] && this.#blocks[index].hash !== block.hash)
-            throw `invalid block ${hash} @${index}`;
-        if (!await globalThis.peernet.has(hash, 'block'))
-            await globalThis.peernet.put(hash, block.encoded, 'block');
+        if (block !== undefined) {
+            block = await new BlockMessage(block);
+            const { index } = block.decoded;
+            if (this.#blocks[index] && this.#blocks[index].hash !== block.hash)
+                throw `invalid block ${hash} @${index}`;
+            if (!await globalThis.peernet.has(hash, 'block'))
+                await globalThis.peernet.put(hash, block.encoded, 'block');
+        }
         return block;
     }
     async resolveBlock(hash) {
@@ -8326,12 +8367,14 @@ class Chain extends Contract {
                     }
                     catch (error) {
                         console.log(error);
+                        return false;
                     }
                 }
                 this.#blocks[block.index].loaded = true;
                 globalThis.debug(`loaded block: ${block.hash} @${block.index}`);
             }
         }
+        return true;
     }
     async #executeTransaction({ hash, from, to, method, params, nonce }) {
         try {
@@ -8423,7 +8466,6 @@ 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();
         const timestamp = Date.now();
         let block = {
             transactions: [],
@@ -8447,35 +8489,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 +8532,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 +8547,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 +8561,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 +8579,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 +8609,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