@leofcoin/chain 1.7.8 → 1.7.10

package/exports/browser/workers/machine-worker.js

@@ -150,10 +150,6 @@ const get = ({ contract, method, params }) => {
   return result
 };
 
-const resolveContract = (hash) => askFor('contract', hash);
-
-const resolveTransaction = (hash) => askFor('transaction', hash);
-
 const respond = (id, value) => {
   worker.postMessage({
     type: 'response',
@@ -255,6 +251,13 @@ const _executeTransaction = async (transaction) => {
   }
 };
 
+const addToWantList = (hash) => {
+  worker.postMessage({
+    type: 'addToWantList',
+    hash
+  });
+};
+
 _.init = async (message) => {
   let { peerid, fromState, state, info } = message;
   globalThis.peerid = peerid;
@@ -272,6 +275,10 @@ _.init = async (message) => {
     lastBlock = message.lastBlock;
     const setState = async (address, state) => {
       const contractBytes = await resolveContract(address);
+      if (contractBytes === address) {
+        addToWantList(address);
+        return
+      }
       const contract = await new ContractMessage(contractBytes);
 
       await _.runContract({ hash: address, decoded: contract.decoded, encoded: contract.encoded }, state);
@@ -341,30 +348,42 @@ _.init = async (message) => {
           latestTransactions.splice(-transactionCount, latestTransactions.length);
         }
         if (!block.loaded && !fromState) {
-          const transactions = await Promise.all(
-            block.transactions.map(async (transaction) =>
-              new TransactionMessage(await resolveTransaction(transaction)).decode()
-            )
-          );
-          const priority = transactions.filter((transaction) => transaction.priority)?.sort((a, b) => a.nonce - b.nonce);
-          if (priority.length > 0)
-            for (const transaction of priority) {
-              await _executeTransaction(transaction);
-            }
-
-          await Promise.all(
-            transactions
-              .filter((transaction) => !transaction.priority)
-              .map(async (transaction) => _executeTransaction(transaction))
-          );
+          try {
+            const transactions = await Promise.all(
+              block.transactions.map(async (transaction) => {
+                const message = new TransactionMessage(await resolveTransaction(transaction)).decode();
+                if (message === transaction) {
+                  throw new Error(`nothing found for ${transaction}`)
+                }
+              })
+            );
+            const priority = transactions
+              .filter((transaction) => transaction.priority)
+              ?.sort((a, b) => a.nonce - b.nonce);
+            if (priority.length > 0)
+              for (const transaction of priority) {
+                await _executeTransaction(transaction);
+              }
+
+            await Promise.all(
+              transactions
+                .filter((transaction) => !transaction.priority)
+                .map(async (transaction) => _executeTransaction(transaction))
+            );
+            block.loaded = true;
+            worker.postMessage({
+              type: 'debug',
+              message: `loaded transactions for block: ${block.hash} @${block.index}`
+            });
+          } catch (error) {
+            // just tell chain it's ready so we can get this node sync
+            // when a node connects this node will try to resolve the wantList
+            // this should result in the node beeing sync
+            if (error.message.includes('nothing found for')) worker.postMessage({ type: 'machine-ready', lastBlock });
+            else console.error(error);
+          }
         }
-        block.loaded = true;
-        worker.postMessage({
-          type: 'debug',
-          message: `loaded transactions for block: ${block.hash} @${block.index}`
-        });
       }
-
       if (blocks.length > 0) {
         lastBlock = blocks[blocks.length - 1];
       }
@@ -373,8 +392,6 @@ _.init = async (message) => {
   }
 
   worker.postMessage({ type: 'machine-ready', lastBlock });
-
-  // worker.postMessage({blocks});
 };
 
 _.addLoadedBlock = (block) => {
@@ -399,6 +416,10 @@ const askFor = (question, input) =>
     });
   });
 
+const resolveContract = (hash) => askFor('contract', hash);
+
+const resolveTransaction = (hash) => askFor('transaction', hash);
+
 const runTask = async (id, taskName, input) => {
   try {
     const result = await _[taskName](input);

package/exports/chain.js

@@ -292,6 +292,7 @@ class Machine {
                 totalBlocks: 0
             }
         };
+        this.wantList = [];
         // @ts-ignore
         return this.#init(blocks);
     }
@@ -345,10 +346,20 @@ class Machine {
                 pubsub.publish(data.id, data.value || false);
                 break;
             }
+            case 'addToWantList': {
+                this.wantList.push(data.hash);
+            }
             case 'ask': {
                 if (data.question === 'contract' || data.question === 'transaction') {
-                    const input = await peernet.get(data.input);
-                    this.worker.postMessage({ id: data.id, input });
+                    try {
+                        const input = await peernet.get(data.input);
+                        this.worker.postMessage({ id: data.id, input });
+                    }
+                    catch (error) {
+                        console.error(error);
+                        this.worker.postMessage({ id: data.id, input: data.input });
+                        this.wantList.push(data.input);
+                    }
                 }
             }
         }
@@ -709,6 +720,12 @@ class State extends Contract {
     #totalSize;
     #machine;
     #loaded;
+    /**
+     * contains transactions we need before we can successfully load
+     */
+    get wantList() {
+        return this.#machine.wantList;
+    }
     get state() {
         return {
             sync: this.#syncState,

package/exports/machine.d.ts

@@ -18,6 +18,7 @@ export default class Machine {
             totalBlocks: number;
         };
     };
+    wantList: string[];
     constructor(blocks: any);
     updateState(): Promise<void>;
     /**

package/exports/state.d.ts

@@ -12,7 +12,7 @@ export default class State extends Contract {
     /**
      * contains transactions we need before we can successfully load
      */
-    wantList: string[];
+    get wantList(): string[];
     get state(): {
         sync: SyncState;
         chain: ChainState;

package/exports/workers/machine-worker.js

@@ -150,10 +150,6 @@ const get = ({ contract, method, params }) => {
   return result
 };
 
-const resolveContract = (hash) => askFor('contract', hash);
-
-const resolveTransaction = (hash) => askFor('transaction', hash);
-
 const respond = (id, value) => {
   worker.postMessage({
     type: 'response',
@@ -255,6 +251,13 @@ const _executeTransaction = async (transaction) => {
   }
 };
 
+const addToWantList = (hash) => {
+  worker.postMessage({
+    type: 'addToWantList',
+    hash
+  });
+};
+
 _.init = async (message) => {
   let { peerid, fromState, state, info } = message;
   globalThis.peerid = peerid;
@@ -272,6 +275,10 @@ _.init = async (message) => {
     lastBlock = message.lastBlock;
     const setState = async (address, state) => {
       const contractBytes = await resolveContract(address);
+      if (contractBytes === address) {
+        addToWantList(address);
+        return
+      }
       const contract = await new ContractMessage(contractBytes);
 
       await _.runContract({ hash: address, decoded: contract.decoded, encoded: contract.encoded }, state);
@@ -341,30 +348,42 @@ _.init = async (message) => {
           latestTransactions.splice(-transactionCount, latestTransactions.length);
         }
         if (!block.loaded && !fromState) {
-          const transactions = await Promise.all(
-            block.transactions.map(async (transaction) =>
-              new TransactionMessage(await resolveTransaction(transaction)).decode()
-            )
-          );
-          const priority = transactions.filter((transaction) => transaction.priority)?.sort((a, b) => a.nonce - b.nonce);
-          if (priority.length > 0)
-            for (const transaction of priority) {
-              await _executeTransaction(transaction);
-            }
-
-          await Promise.all(
-            transactions
-              .filter((transaction) => !transaction.priority)
-              .map(async (transaction) => _executeTransaction(transaction))
-          );
+          try {
+            const transactions = await Promise.all(
+              block.transactions.map(async (transaction) => {
+                const message = new TransactionMessage(await resolveTransaction(transaction)).decode();
+                if (message === transaction) {
+                  throw new Error(`nothing found for ${transaction}`)
+                }
+              })
+            );
+            const priority = transactions
+              .filter((transaction) => transaction.priority)
+              ?.sort((a, b) => a.nonce - b.nonce);
+            if (priority.length > 0)
+              for (const transaction of priority) {
+                await _executeTransaction(transaction);
+              }
+
+            await Promise.all(
+              transactions
+                .filter((transaction) => !transaction.priority)
+                .map(async (transaction) => _executeTransaction(transaction))
+            );
+            block.loaded = true;
+            worker.postMessage({
+              type: 'debug',
+              message: `loaded transactions for block: ${block.hash} @${block.index}`
+            });
+          } catch (error) {
+            // just tell chain it's ready so we can get this node sync
+            // when a node connects this node will try to resolve the wantList
+            // this should result in the node beeing sync
+            if (error.message.includes('nothing found for')) worker.postMessage({ type: 'machine-ready', lastBlock });
+            else console.error(error);
+          }
         }
-        block.loaded = true;
-        worker.postMessage({
-          type: 'debug',
-          message: `loaded transactions for block: ${block.hash} @${block.index}`
-        });
       }
-
       if (blocks.length > 0) {
         lastBlock = blocks[blocks.length - 1];
       }
@@ -373,8 +392,6 @@ _.init = async (message) => {
   }
 
   worker.postMessage({ type: 'machine-ready', lastBlock });
-
-  // worker.postMessage({blocks});
 };
 
 _.addLoadedBlock = (block) => {
@@ -399,6 +416,10 @@ const askFor = (question, input) =>
     });
   });
 
+const resolveContract = (hash) => askFor('contract', hash);
+
+const resolveTransaction = (hash) => askFor('transaction', hash);
+
 const runTask = async (id, taskName, input) => {
   try {
     const result = await _[taskName](input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.7.8",
+  "version": "1.7.10",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {