@leofcoin/chain 1.4.79 → 1.4.81

package/exports/browser/browser-store.js

@@ -1,64 +1,73 @@
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode$1 = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
+const encode = (string) => {
+    if (typeof string === 'string')
+        return new TextEncoder().encode(string);
+    throw Error(`expected typeof String instead got ${string}`);
 };
-
-const decode$1 = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
+const decode = (uint8Array) => {
+    if (uint8Array instanceof Uint8Array)
+        return new TextDecoder().decode(uint8Array);
+    throw Error(`expected typeof uint8Array instead got ${uint8Array}`);
 };
 
-class KeyValue {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode$1(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyValue) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue')
+const pathSepS = '/';
+class KeyPath {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(input);
+        }
+        else if (input instanceof Uint8Array) {
+            this.uint8Array = input;
+        }
+        else if (input instanceof KeyPath) {
+            this.uint8Array = input.uint8Array;
+        }
+        else {
+            throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath');
+        }
     }
-  }
-
-  isKeyValue() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'utf8') {
-    return decode$1(this.uint8Array)
-  }
+    isKeyPath() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
+    /**
+     * Returns the `list` representation of this path.
+     *
+     * @example
+     * ```js
+     * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+     * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+     * ```
+     */
+    list() {
+        return this.toString().split(pathSepS).slice(1);
+    }
+}
 
+class KeyValue {
+    uint8Array;
+    constructor(input) {
+        if (typeof input === 'string') {
+            this.uint8Array = encode(input);
+        }
+        else if (input instanceof Uint8Array) {
+            this.uint8Array = input;
+        }
+        else if (input instanceof KeyValue) {
+            this.uint8Array = input.uint8Array;
+        }
+        else {
+            throw new Error('Invalid KeyValue, should be a String, Uint8Array or KeyValue');
+        }
+    }
+    isKeyValue() {
+        return true;
+    }
+    toString() {
+        return decode(this.uint8Array);
+    }
 }
 
 const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
@@ -376,149 +385,66 @@ replaceTraps((oldTraps) => ({
     },
 }));
 
-// import base32 from '@vandeurenglenn/base32'
-// import base58 from '@vandeurenglenn/base58'
-
-// export const encodings = {
-//   base58,
-//   base32
-// }
-
-const encode = (string, encoding = 'utf-8') => {
-  if (typeof string === 'string') {
-    let encoded;
-    
-    // if (encodings[encoding]) encoded = encodings[encoding].encode(encoded)    
-    encoded = new TextEncoder().encode(string);
-    return encoded
-  }
-  throw Error(`expected typeof String instead got ${string}`)
-};
-
-const decode = (uint8Array, encoding) => {
-  if (uint8Array instanceof Uint8Array) {
-    let decoded;
-    // if (encodings[encoding]) decoded = encodings[encoding].decode(decoded)
-    decoded = new TextDecoder().decode(uint8Array);
-    
-    return decoded
-  }
-  throw Error(`expected typeof uint8Array instead got ${uint8Array}`)
-};
-
-const pathSepS = '/';
-class KeyPath {
-
-  /**
-   * @param {string | Uint8Array} input
-   */
-  constructor(input) {
-    if (typeof input === 'string') {
-      this.uint8Array = encode(input);
-    } else if (input instanceof Uint8Array) {
-      this.uint8Array = input;
-    } else if (input instanceof KeyPath) {
-      this.uint8Array = input.uint8Array;
-    } else {
-      throw new Error('Invalid keyPath, should be a String, Uint8Array or KeyPath')
-    }
-  }
-  
-  isKeyPath() {
-    return true
-  }
-
-  /**
-   * Convert to the string representation
-   *
-   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding='utf8'] - The encoding to use.
-   * @returns {string}
-   */
-  toString(encoding = 'hex') {
-    return decode(this.uint8Array)
-  }
-
-  /**
-   * Returns the `list` representation of this path.
-   *
-   * @returns string[]
-   *
-   * @example
-   * ```js
-   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
-   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
-   * ```
-   */
-  list() {
-    return this.toString().split(pathSepS).slice(1)
-  }
-
-}
-
 class BrowerStore {
-  constructor(name = 'storage', root = '.leofcoin', version = 1) {
-    this.version = version;
-    this.name = name;
-    this.root = root;
-    this.db = openDB(`${root}/${name}`, version, {
-      upgrade(db) {
-        db.createObjectStore(name);
-      }
-    });
-  }
-
-  toKeyPath(key) {
-    if (!key.isKeyPath()) key = new KeyPath(key);
-    return key.toString('base32')
-  }
-  
-  toKeyValue(value) {
-    if (!value.isKeyValue()) value = new KeyValue(value);
-    return value.uint8Array
-  }
-
-  async get(key) {
-    return (await this.db).get(this.name, this.toKeyPath(key))
-  }
-
-  async put(key, value) {
-    return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key))
-  }
-
-  async delete(key) {
-    return (await this.db).delete(this.name, this.toKeyPath(key))
-  }
-
-  async clear() {
-    return (await this.db).clear(this.name)
-  }
-
-  async values(limit = -1) {
-    const values = [];
-    const tx = (await this.db).transaction(this.name);
-    
-    for await (const cursor of tx.store) {
-      values.push(cursor.value);
-      if (limit && values.length === limit) return values      
+    db;
+    name;
+    root;
+    version;
+    constructor(name = 'storage', root = '.leofcoin', version = '1') {
+        this.version = version;
+        this.name = name;
+        this.root = root;
+        this.db = openDB(`${root}/${name}`, Number(version), {
+            upgrade(db) {
+                db.createObjectStore(name);
+            }
+        });
     }
-    return values
-  }
-
-  async keys(limit = -1) {
-    const keys = [];
-    const tx = (await this.db).transaction(this.name);
-
-    for await (const cursor of tx.store) {
-      keys.push(cursor.key);
-      if (limit && keys.length === limit) return keys      
+    toKeyPath(key) {
+        if (!key.isKeyPath())
+            key = new KeyPath(key);
+        return key.toString('base32');
+    }
+    toKeyValue(value) {
+        if (!value.isKeyValue())
+            value = new KeyValue(value);
+        return value.uint8Array;
+    }
+    async get(key) {
+        return (await this.db).get(this.name, this.toKeyPath(key));
+    }
+    async put(key, value) {
+        return (await this.db).put(this.name, this.toKeyValue(value), this.toKeyPath(key));
+    }
+    async delete(key) {
+        return (await this.db).delete(this.name, this.toKeyPath(key));
+    }
+    async clear() {
+        return (await this.db).clear(this.name);
+    }
+    async values(limit = -1) {
+        const values = [];
+        const tx = (await this.db).transaction(this.name);
+        for await (const cursor of tx.store) {
+            values.push(cursor.value);
+            if (limit && values.length === limit)
+                return values;
+        }
+        return values;
+    }
+    async keys(limit = -1) {
+        const keys = [];
+        const tx = (await this.db).transaction(this.name);
+        for await (const cursor of tx.store) {
+            keys.push(cursor.key);
+            if (limit && keys.length === limit)
+                return keys;
+        }
+        return keys;
+    }
+    async iterate() {
+        return (await this.db).transaction(this.name).store;
     }
-    return keys
-  }
-
-  async iterate() {
-    return (await this.db).transaction(this.name).store
-  }
-
 }
 
 export { BrowerStore as default };

package/exports/browser/chain.js

@@ -1302,11 +1302,11 @@ _PQueue_carryoverConcurrencyCount = new WeakMap(), _PQueue_isIntervalIgnored = n
 
 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;
     }
@@ -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,22 +1457,28 @@ 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);
-                        }, 10_000);
+                        }, 10000);
                     };
                     pubsub.subscribe(`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;
         }
     }
@@ -1922,7 +1930,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));
@@ -1951,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);
@@ -2199,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;
                     }
@@ -2252,6 +2270,7 @@ class State extends Contract {
 }
 
 globalThis.BigNumber = BigNumber;
+const ignorelist = ['BA5XUACBBBAT653LT3GHP2Z5SUHVCA42BP6IBFBJACHOZIHHR4DUPG2XMB'];
 // check if browser or local
 class Chain extends State {
     #state;
@@ -2286,7 +2305,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 {
@@ -2294,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');
@@ -2324,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() {
@@ -2368,11 +2388,12 @@ 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
         await super.init();
-        globalThis.globalThis.pubsub.publish('chain:ready', true);
+        globalThis.pubsub.publish('chain:ready', true);
         return this;
     }
     async #invalidTransaction(hash) {
@@ -2385,6 +2406,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);
@@ -2399,13 +2423,27 @@ 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, '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) {
                 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() {
@@ -2423,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 };
@@ -2465,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 });
         }
     }
@@ -2497,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();
@@ -2512,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 = [];
@@ -2525,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
@@ -2613,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)
@@ -2631,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');
         }
@@ -2660,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,

package/exports/browser/{index-b203939f-54b1df28.js → index-6311966e-b5f647d8.js}

@@ -1,4 +1,4 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-44a01a16.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-3cbee72b.js';
 import './index-c3f4012c.js';
 
 /**