@leofcoin/chain 1.4.80 → 1.4.81

package/exports/browser/chain.js

@@ -1377,7 +1377,7 @@ class Transaction extends Protocol {
         transactions = transactions.filter(tx => tx.decoded.from === address);
         transactions = await this.promiseTransactionsContent(transactions);
         if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
-            let block = await peernet.get(this.lastBlock.hash);
+            let block = await peernet.get(this.lastBlock.hash, 'block');
             block = await new BlockMessage(block);
             // for (let tx of block.decoded?.transactions) {
             //   tx = await peernet.get(tx, 'transaction')
@@ -1457,18 +1457,24 @@ class Transaction extends Protocol {
             throw new Error(`transaction not signed`);
         if (message.decoded.nonce === undefined)
             throw new Error(`nonce required`);
+        await this.validateNonce(message.decoded.from, message.decoded.nonce);
+        // todo check if signature is valid
+        const hash = await message.hash();
         try {
-            await this.validateNonce(message.decoded.from, message.decoded.nonce);
-            // todo check if signature is valid
-            const hash = await message.hash();
             let data;
             const wait = new Promise(async (resolve, reject) => {
                 if (pubsub.subscribers[`transaction.completed.${hash}`]) {
                     const result = pubsub.subscribers[`transaction.completed.${hash}`].value;
+                    if (result.status !== 'fulfilled') {
+                        await transactionPoolStore.delete(hash);
+                    }
                     result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
                 }
                 else {
                     const completed = async (result) => {
+                        if (result.status !== 'fulfilled') {
+                            await transactionPoolStore.delete(hash);
+                        }
                         result.status === 'fulfilled' ? resolve(result.hash) : reject({ hash: result.hash, error: result.error });
                         setTimeout(async () => {
                             pubsub.unsubscribe(`transaction.completed.${hash}`, completed);
@@ -1483,6 +1489,8 @@ class Transaction extends Protocol {
             return { hash, data, fee: await calculateFee(message.decoded), wait, message };
         }
         catch (error) {
+            console.log('remo');
+            await transactionPoolStore.delete(hash);
             throw error;
         }
     }
@@ -1492,58 +1500,50 @@ 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) {
+    }
 }
 
 const randombytes = strength => crypto.getRandomValues(new Uint8Array(strength));
@@ -1627,214 +1627,203 @@ class EasyWorker {
 }
 
 // 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)
-    }
-  }
-
-  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
-      }
+    #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 #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('./exports/browser/workers/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$1),
+                contractStore.get(nativeToken$1),
+                contractStore.get(validators$1),
+                contractStore.get(nameService$1)
+            ]);
+            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$1 && 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);
+            }
+        }
+        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);
     }
-    
-  }
-
-  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('./exports/browser/workers/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$1),
-        contractStore.get(nativeToken$1),
-        contractStore.get(validators$1),
-        contractStore.get(nameService$1)
-      ]);
-      
-      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$1 && 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);
-      }
-    } 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 {
@@ -1970,9 +1959,17 @@ class State extends Contract {
         }
         catch (error) {
             console.log({ e: error });
+            console.log({ e: error });
         }
         globalThis.pubsub.publish('lastBlock', this.lastBlock);
         // load local blocks
+        try {
+            this.knownBlocks = await blockStore.keys();
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
         await this.resolveBlocks();
         this.#machine = await new Machine(this.#blocks);
         await this.#loadBlocks(this.#blocks);
@@ -2218,6 +2215,8 @@ class State extends Contract {
                         this.#totalTransactions += 1;
                     }
                     catch (error) {
+                        await globalThis.transactionPoolStore.delete(transaction.hash);
+                        console.log('removing invalid transaction');
                         console.log(error);
                         return false;
                     }
@@ -2271,6 +2270,7 @@ class State extends Contract {
 }
 
 globalThis.BigNumber = BigNumber;
+const ignorelist = ['BA5XUACBBBAT653LT3GHP2Z5SUHVCA42BP6IBFBJACHOZIHHR4DUPG2XMB'];
 // check if browser or local
 class Chain extends State {
     #state;
@@ -2313,6 +2313,7 @@ class Chain extends State {
         }
         catch (error) {
             console.error(error);
+            console.log('ttttt');
         }
         const end = Date.now();
         console.log(((end - start) / 1000) + ' s');
@@ -2343,7 +2344,7 @@ class Chain extends State {
         console.log('handle native contracts');
         // handle native contracts
     }
-    async #clearPool() {
+    async clearPool() {
         await globalThis.transactionPoolStore.clear();
     }
     async #init() {
@@ -2392,7 +2393,7 @@ class Chain extends State {
         globalThis.pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
         // todo some functions rely on state
         await super.init();
-        globalThis.globalThis.pubsub.publish('chain:ready', true);
+        globalThis.pubsub.publish('chain:ready', true);
         return this;
     }
     async #invalidTransaction(hash) {
@@ -2428,8 +2429,9 @@ class Chain extends State {
         const transactionsToGet = [];
         for (const key of transactionsInPool) {
             if (!transactions.includes(key))
-                transactionsToGet.push(transactionPoolStore.put(key, (await peernet.get(key))));
+                transactionsToGet.push(transactionPoolStore.put(key, (await peernet.get(key, 'transaction'))));
         }
+        console.log(await transactionPoolStore.keys());
         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) {
@@ -2459,7 +2461,7 @@ class Chain extends State {
             return result || 'no state change';
         }
         catch (error) {
-            console.log({ error });
+            await transactionPoolStore.delete(hash);
             globalThis.peernet.publish('invalid-transaction', hash);
             globalThis.pubsub.publish(`transaction.completed.${hash}`, { status: 'fail', hash, error: error });
             throw { error, hash, from, to, params, nonce };
@@ -2501,6 +2503,9 @@ class Chain extends State {
             globalThis.pubsub.publish('block-processed', blockMessage.decoded);
         }
         catch (error) {
+            console.log(error.hash);
+            console.log('errrrr');
+            await transactionPoolStore.delete(error.hash);
             console.log({ e: error });
         }
     }
@@ -2533,6 +2538,10 @@ class Chain extends State {
         if (await globalThis.transactionPoolStore.size() === 0)
             return;
         let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
+        for (const hash of await globalThis.transactionPoolStore.keys()) {
+            if (ignorelist.includes(hash))
+                await globalThis.transactionPoolStore.delete(hash);
+        }
         if (Object.keys(transactions)?.length === 0)
             return;
         const timestamp = Date.now();
@@ -2548,6 +2557,7 @@ class Chain extends State {
         // exclude failing tx
         transactions = await this.promiseTransactions(transactions);
         transactions = transactions.sort((a, b) => a.nonce - b.nonce);
+        console.log({ transactions });
         for (let transaction of transactions) {
             const hash = await transaction.hash();
             const doubleTransactions = [];
@@ -2561,21 +2571,25 @@ class Chain extends State {
             if (doubleTransactions.length > 0) {
                 await globalThis.transactionPoolStore.delete(hash);
                 await globalThis.peernet.publish('invalid-transaction', hash);
+                return;
             }
-            else {
-                // 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);
-                }
-                // }
+            // if (timestamp + this.#slotTime > Date.now()) {
+            try {
+                const result = await this.#executeTransaction({ ...transaction.decoded, hash });
+                console.log({ result });
+                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('vvvvvv');
+                console.log({ e });
+                console.log(hash);
+                peernet.publish('invalid-transaction', hash);
+                console.log(await globalThis.transactionPoolStore.keys());
+                console.log(await globalThis.transactionPoolStore.has(e.hash));
+                await globalThis.transactionPoolStore.delete(e.hash);
+                console.log(await globalThis.transactionPoolStore.has(e.hash));
             }
         }
         // don't add empty block
@@ -2649,6 +2663,7 @@ class Chain extends State {
         }
         catch (error) {
             console.log(error);
+            console.log('eeeee');
             throw new Error(`invalid block ${block}`);
         }
         // data = await this.machine.execute(to, method, params)
@@ -2667,6 +2682,7 @@ class Chain extends State {
         }
         catch (e) {
             console.log(e);
+            console.log('rrrrr');
             globalThis.peernet.publish('invalid-transaction', hash);
             throw new Error('invalid transaction');
         }
@@ -2696,7 +2712,7 @@ class Chain extends State {
      * @param {Address} sender
      * @returns {globalMessage}
      */
-    #createMessage(sender = globalThis.globalThis.peernet.selectedAccount) {
+    #createMessage(sender = globalThis.peernet.selectedAccount) {
         return {
             sender,
             call: this.call,