@leofcoin/chain 1.4.79 → 1.4.80

package/exports/browser/node-browser.js

@@ -1,2 +1,2 @@
-export { N as default } from './node-browser-44a01a16.js';
+export { N as default } from './node-browser-3cbee72b.js';
 import './index-c3f4012c.js';

package/exports/chain.js

@@ -8,11 +8,11 @@ import EasyWorker from '@vandeurenglenn/easy-worker';
 
 const limit = 1800;
 const transactionLimit = 1800;
-const requestTimeout = 30_000;
-const syncTimeout = 30_000;
+const requestTimeout = 30000;
+const syncTimeout = 30000;
 class Protocol {
     version;
-    resolveTimeout = 30_000;
+    resolveTimeout = 30000;
     get limit() {
         return limit;
     }
@@ -178,7 +178,7 @@ class Transaction extends Protocol {
                         result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
                         setTimeout(async () => {
                             pubsub.unsubscribe(`transaction.completed.${hash}`, completed);
-                        }, 10_000);
+                        }, 10000);
                     };
                     pubsub.subscribe(`transaction.completed.${hash}`, completed);
                 }
@@ -198,250 +198,269 @@ class Transaction extends Protocol {
  * @extends {Transaction}
  */
 class Contract extends Transaction {
-    constructor() {
-        super();
-    }
-    async init() {
-    }
-    /**
-     *
-     * @param {Address} creator
-     * @param {String} contract
-     * @param {Array} constructorParameters
-     * @returns lib.createContractMessage
-     */
-    async createContractMessage(creator, contract, constructorParameters = []) {
-        return createContractMessage(creator, contract, constructorParameters);
-    }
-    /**
-     *
-     * @param {Address} creator
-     * @param {String} contract
-     * @param {Array} constructorParameters
-     * @returns {Address}
-     */
-    async createContractAddress(creator, contract, constructorParameters = []) {
-        contract = await this.createContractMessage(creator, contract, constructorParameters);
-        return contract.hash();
-    }
-    /**
-     *
-     * @param {String} contract
-     * @param {Array} parameters
-     * @returns
-     */
-    async deployContract(contract, constructorParameters = []) {
-        const message = await createContractMessage(peernet.selectedAccount, contract, constructorParameters);
-        try {
-            await contractStore.put(await message.hash(), message.encoded);
-        }
-        catch (error) {
-            throw error;
-        }
-        return this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'registerContract', [await message.hash()]);
-    }
-    async deployContractMessage(message) {
-    }
+  constructor() {
+    super();
+  }
+
+  async init() {
+
+  }
+
+  /**
+   * 
+   * @param {Address} creator 
+   * @param {String} contract 
+   * @param {Array} constructorParameters 
+   * @returns lib.createContractMessage
+   */
+  async createContractMessage(creator, contract, constructorParameters = []) {
+    return createContractMessage(creator, contract, constructorParameters)
+  }
+
+  /**
+   * 
+   * @param {Address} creator 
+   * @param {String} contract 
+   * @param {Array} constructorParameters 
+   * @returns {Address}
+   */
+  async createContractAddress(creator, contract, constructorParameters = []) {
+    contract = await this.createContractMessage(creator, contract, constructorParameters);
+    return contract.hash()
+  }
+
+  /**
+   * 
+   * @param {String} contract 
+   * @param {Array} parameters 
+   * @returns 
+   */
+  async deployContract(contract, constructorParameters = []) {
+    const message = await createContractMessage(peernet.selectedAccount, contract, constructorParameters);
+    try {
+      await contractStore.put(await message.hash(), message.encoded);
+    } catch (error) {
+      throw error
+    }
+    return this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'registerContract', [await message.hash()])    
+  }
+  
+  async deployContractMessage(message) {
+
+  }
+
+ 
 }
 
 // import State from './state'
+
 class Machine {
-    #contracts = {};
-    #nonces = {};
-    lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
-    constructor(blocks) {
-        return this.#init(blocks);
-    }
-    #createMessage(sender = peernet.selectedAccount) {
-        return {
-            sender,
-            call: this.execute,
-            staticCall: this.get.bind(this)
-        };
+  #contracts = {}
+  #nonces = {}
+  lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
+
+  constructor(blocks) {
+    return this.#init(blocks)
+  }
+
+  #createMessage(sender = peernet.selectedAccount) {
+    return {
+      sender,
+      call: this.execute,
+      staticCall: this.get.bind(this)
     }
-    async #onmessage(data) {
-        switch (data.type) {
-            case 'contractError': {
-                console.warn(`removing contract ${await data.hash()}`);
-                await contractStore.delete(await data.hash());
-                break;
-            }
-            case 'initError': {
-                console.error(`init error: ${data.message}`);
-                break;
-            }
-            case 'executionError': {
-                // console.warn(`error executing transaction ${data.message}`);
-                pubsub.publish(data.id, { error: data.message });
-                break;
-            }
-            case 'debug': {
-                for (const message of data.messages)
-                    debug(message);
-                break;
-            }
-            case 'machine-ready': {
-                this.lastBlock = data.lastBlock;
-                pubsub.publish('machine.ready', true);
-                break;
-            }
-            case 'response': {
-                pubsub.publish(data.id, data.value || false);
-                break;
-            }
+  }
+
+  async #onmessage(data) {
+    switch (data.type) {
+      case 'contractError': {
+        console.warn(`removing contract ${await data.hash()}`);
+        await contractStore.delete(await data.hash());  
+        break
+      }
+
+      case 'initError': {
+        console.error(`init error: ${data.message}`);       
+        break
+      }
+
+      case 'executionError': {
+        // console.warn(`error executing transaction ${data.message}`);
+        pubsub.publish(data.id, {error: data.message});
+      break
+      }
+
+      case 'debug': {
+        for (const message of data.messages) debug(message);
+      break
+      }
+      case 'machine-ready': {
+        this.lastBlock = data.lastBlock;
+        pubsub.publish('machine.ready', true);
+      break
+      }
+      case 'response': {
+        pubsub.publish(data.id, data.value || false);
+      break
+      }
+    }
+    
+  }
+
+  async #init(blocks) {
+    return new Promise(async (resolve) => {
+      const machineReady = () => {
+        pubsub.unsubscribe('machine.ready', machineReady);
+        resolve(this);
+      };
+      pubsub.subscribe('machine.ready', machineReady);
+
+      this.worker = await new EasyWorker('node_modules/@leofcoin/workers/src/machine-worker.js', {serialization: 'advanced', type:'module'});
+      this.worker.onmessage(this.#onmessage.bind(this));
+      // const blocks = await blockStore.values()
+      const contracts = await Promise.all([
+        contractStore.get(contractFactory),
+        contractStore.get(nativeToken),
+        contractStore.get(validators),
+        contractStore.get(nameService)
+      ]);
+      
+      const message = {
+        type: 'init',
+        input: {
+          contracts,
+          blocks,
+          peerid: peernet.peerId
         }
-    }
-    async #init(blocks) {
-        return new Promise(async (resolve) => {
-            const machineReady = () => {
-                pubsub.unsubscribe('machine.ready', machineReady);
-                resolve(this);
-            };
-            pubsub.subscribe('machine.ready', machineReady);
-            this.worker = await new EasyWorker('node_modules/@leofcoin/workers/src/machine-worker.js', { serialization: 'advanced', type: 'module' });
-            this.worker.onmessage(this.#onmessage.bind(this));
-            // const blocks = await blockStore.values()
-            const contracts = await Promise.all([
-                contractStore.get(contractFactory),
-                contractStore.get(nativeToken),
-                contractStore.get(validators),
-                contractStore.get(nameService)
-            ]);
-            const message = {
-                type: 'init',
-                input: {
-                    contracts,
-                    blocks,
-                    peerid: peernet.peerId
-                }
-            };
-            this.worker.postMessage(message);
-        });
-    }
-    async #runContract(contractMessage) {
-        const hash = await contractMessage.hash();
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString('hex');
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                if (message?.error)
-                    reject(message.error);
-                else
-                    resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'run',
-                id,
-                input: {
-                    decoded: contractMessage.decoded,
-                    encoded: contractMessage.encoded,
-                    hash
-                }
-            });
-        });
-    }
-    /**
-     *
-     * @param {Address} contract
-     * @param {String} method
-     * @param {Array} parameters
-     * @returns Promise<message>
-     */
-    async execute(contract, method, parameters) {
-        try {
-            if (contract === contractFactory && method === 'registerContract') {
-                if (await this.has(parameters[0]))
-                    throw new Error(`duplicate contract @${parameters[0]}`);
-                let message;
-                if (!await contractStore.has(parameters[0])) {
-                    message = await peernet.get(parameters[0], 'contract');
-                    message = await new ContractMessage(message);
-                    await contractStore.put(await message.hash(), message.encoded);
-                }
-                if (!message) {
-                    message = await contractStore.get(parameters[0]);
-                    message = await new ContractMessage(message);
-                }
-                if (!await this.has(await message.hash()))
-                    await this.#runContract(message);
-            }
+      };
+      this.worker.postMessage(message);
+    })
+    
+  }
+
+  async #runContract(contractMessage) {
+    const hash = await contractMessage.hash();
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString('hex');
+      const onmessage = message => {        
+        pubsub.unsubscribe(id, onmessage);
+        if (message?.error) reject(message.error);
+        else resolve(message);
+      };
+      pubsub.subscribe(id, onmessage);
+      this.worker.postMessage({
+        type: 'run',
+        id,
+        input: {
+          decoded: contractMessage.decoded,
+          encoded: contractMessage.encoded,
+          hash 
         }
-        catch (error) {
-            throw new Error(`contract deployment failed for ${parameters[0]}\n${error.message}`);
+      });
+    })
+    
+  }
+
+  /**
+   * 
+   * @param {Address} contract 
+   * @param {String} method 
+   * @param {Array} parameters 
+   * @returns Promise<message>
+   */
+  async execute(contract, method, parameters) {
+    try {
+      if (contract === contractFactory && method === 'registerContract') {
+        if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`)
+        let message;
+        if (!await contractStore.has(parameters[0])) {
+          message = await peernet.get(parameters[0], 'contract');
+          message = await new ContractMessage(message);
+          await contractStore.put(await message.hash(), message.encoded);
         }
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString('hex');
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                if (message?.error)
-                    reject(message.error);
-                else
-                    resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'execute',
-                id,
-                input: {
-                    contract,
-                    method,
-                    params: parameters
-                }
-            });
-        });
-    }
-    get(contract, method, parameters) {
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString();
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'get',
-                id,
-                input: {
-                    contract,
-                    method,
-                    params: parameters
-                }
-            });
-        });
-    }
-    async has(address) {
-        return new Promise((resolve, reject) => {
-            const id = randombytes(20).toString('hex');
-            const onmessage = message => {
-                pubsub.unsubscribe(id, onmessage);
-                if (message?.error)
-                    reject(message.error);
-                else
-                    resolve(message);
-            };
-            pubsub.subscribe(id, onmessage);
-            this.worker.postMessage({
-                type: 'has',
-                id,
-                input: {
-                    address
-                }
-            });
-        });
-    }
-    async delete(hash) {
-        return contractStore.delete(hash);
-    }
-    /**
-     *
-     * @returns Promise
-     */
-    async deleteAll() {
-        let hashes = await contractStore.get();
-        hashes = Object.keys(hashes).map(hash => this.delete(hash));
-        return Promise.all(hashes);
-    }
+        if (!message) {
+          message = await contractStore.get(parameters[0]);
+          message = await new ContractMessage(message);
+        }
+        if (!await this.has(await message.hash())) await this.#runContract(message);
+      }
+    } catch (error) {
+      throw new Error(`contract deployment failed for ${parameters[0]}\n${error.message}`)
+    }
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString('hex');
+      const onmessage = message => {
+        pubsub.unsubscribe(id, onmessage);
+        if (message?.error) reject(message.error);
+        else resolve(message);
+      };
+      pubsub.subscribe(id, onmessage);
+      this.worker.postMessage({
+        type: 'execute',
+        id,
+        input: {
+          contract,
+          method,
+          params: parameters
+        }
+      });
+    })
+    
+  }
+
+  get(contract, method, parameters) {
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString();
+      const onmessage = message => {
+        pubsub.unsubscribe(id, onmessage);
+        resolve(message);
+      };
+      pubsub.subscribe(id, onmessage);
+      this.worker.postMessage({
+        type: 'get',
+        id,
+        input: {
+          contract,
+          method,
+          params: parameters
+        }
+      });
+    })
+  }
+
+
+  async has(address) {
+    return new Promise((resolve, reject) => {
+      const id = randombytes(20).toString('hex');
+      const onmessage = message => {        
+        pubsub.unsubscribe(id, onmessage);
+        if (message?.error) reject(message.error);
+        else resolve(message);
+      };
+      pubsub.subscribe(id, onmessage);
+      this.worker.postMessage({
+        type: 'has',
+        id,
+        input: {
+          address 
+        }
+      });
+    })
+  }
+
+  async delete(hash) {
+    return contractStore.delete(hash)
+  }
+
+  /**
+   * 
+   * @returns Promise
+   */
+  async deleteAll() {
+    let hashes = await contractStore.get();
+    hashes = Object.keys(hashes).map(hash => this.delete(hash));
+    return Promise.all(hashes)
+  }
 }
 
 class Jobber {
@@ -548,7 +567,7 @@ class State extends Contract {
         super();
     }
     async init() {
-        this.jobber = new Jobber(30_000);
+        this.jobber = new Jobber(30000);
         if (super.init)
             await super.init();
         await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
@@ -912,7 +931,7 @@ class Chain extends State {
         console.log('epoch');
         const validators = await this.staticCall(addresses.validators, 'validators');
         console.log({ validators });
-        if (!validators[globalThis.globalThis.peernet.selectedAccount]?.active)
+        if (!validators[peernet.selectedAccount]?.active)
             return;
         const start = Date.now();
         try {
@@ -994,6 +1013,7 @@ class Chain extends State {
         globalThis.peernet.subscribe('add-block', this.#addBlock.bind(this));
         globalThis.peernet.subscribe('invalid-transaction', this.#invalidTransaction.bind(this));
         globalThis.peernet.subscribe('send-transaction', this.#sendTransaction.bind(this));
+        globalThis.peernet.subscribe('add-transaction', this.#addTransaction.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
@@ -1011,6 +1031,9 @@ class Chain extends State {
         }, validatorInfo.timeout);
         this.#jail.push(validatorInfo.address);
     }
+    #addTransaction(message) {
+        console.log(message);
+    }
     async #prepareRequest(request) {
         let node = await new globalThis.peernet.protos['peernet-request']({ request });
         return globalThis.peernet.prepareMessage(node);
@@ -1025,13 +1048,26 @@ class Chain extends State {
         if (!peer.version || peer.version !== this.version)
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
+        let transactionsInPool = await this.#makeRequest(peer, 'transactionPool');
+        const transactions = await globalThis.transactionPoolStore.keys();
+        console.log({ transactionsInPool });
+        const transactionsToGet = [];
+        for (const key of transactionsInPool) {
+            if (!transactions.includes(key))
+                transactionsToGet.push(transactionPoolStore.put(key, (await peernet.get(key))));
+        }
+        await Promise.all(transactionsToGet);
         if (Object.keys(lastBlock).length > 0) {
             if (!this.lastBlock || !this.blocks[this.blocks.length - 1]?.loaded || lastBlock && lastBlock.index > this.lastBlock?.index || !this.loaded && !this.resolving) {
                 this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
                 await this.syncChain(lastBlock);
                 // if (await this.hasTransactionToHandle() && this.#participating) this.#runEpoch()
             }
+            else if (!this.knownBlocks)
+                this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
         }
+        if (this.#participating)
+            this.#runEpoch();
     }
     #epochTimeout;
     async #transactionPoolHandler() {

package/exports/typings/sync-controller.d.ts

@@ -0,0 +1,13 @@
+export default class SyncController {
+    #private;
+    get busy(): boolean;
+    get loading(): boolean;
+    get resolving(): boolean;
+    get fullyResolved(): boolean;
+    get fullyLoaded(): boolean;
+    constructor();
+    /**
+     * Resolves/rejects a promise or rejects on timeout
+     */
+    resolve(): void;
+}

package/exports/typings/types.d.ts

@@ -0,0 +1 @@
+export type Address = string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.4.79",
+  "version": "1.4.80",
   "description": "Official javascript implementation",
   "exports": {
     "./node": "./exports/node.js",
@@ -14,6 +14,7 @@
   ],
   "scripts": {
     "np": "np",
+    "watch": "rollup -c -w",
     "lint": "eslint src --fix",
     "c": "rollup -c",
     "w": "rollup -c -w",