@leofcoin/chain 1.4.78 → 1.4.80

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, R as RawTransactionMessage, g as getDefaultExportFromCjs, c as BlockMessage, d as BWMessage, e as BWRequestMessage } from './index-fa2c6beb.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, g as getDefaultExportFromCjs, c as BlockMessage, d as BWMessage, e as BWRequestMessage } from './index-c3f4012c.js';
 
 const logger$1 = new Logger(version$1);
 const _constructorGuard = {};
@@ -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;
     }
@@ -1472,7 +1472,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);
                 }
@@ -1492,50 +1492,58 @@ 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));
@@ -1619,203 +1627,214 @@ 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;
-            }
-        }
-    }
-    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);
+  #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)
+  }
 }
 
 class Jobber {
@@ -1922,7 +1941,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));
@@ -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 {
@@ -2368,6 +2387,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
@@ -2385,6 +2405,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 +2422,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/browser/{index-502d190c-60cfcc02.js → index-5f6ba5a4-78b5c5ea.js}

@@ -1,5 +1,5 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-b35d8f46.js';
-import './index-fa2c6beb.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-5fe4a30f.js';
+import './index-c3f4012c.js';
 
 /**
  * @params {String} network

package/exports/browser/index-6311966e-b5f647d8.js

@@ -0,0 +1,37 @@
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-3cbee72b.js';
+import './index-c3f4012c.js';
+
+/**
+ * @params {String} network
+ * @return {object} { identity, accounts, config }
+ */
+var index = async (password, network) => {
+    if (!password)
+        throw new Error('wallets need to be password protected.');
+    let wallet = new MultiWallet(network);
+    /**
+     * @type {string}
+     */
+    let mnemonic = await wallet.generate(password);
+    wallet = new MultiWallet(network);
+    await wallet.recover(mnemonic, password, network);
+    mnemonic = new Uint8Array(await encrypt(password, mnemonic));
+    const multiWIF = new Uint8Array(await encrypt(password, await wallet.multiWIF));
+    /**
+     * @type {object}
+     */
+    const external = await wallet.account(1).external(1);
+    const externalAddress = await external.address;
+    const internal = await wallet.account(1).internal(1);
+    const internalAddress = await internal.address;
+    return {
+        identity: {
+            mnemonic: base58$1.encode(mnemonic),
+            multiWIF: base58$1.encode(multiWIF),
+            walletId: await external.id
+        },
+        accounts: [['main account', externalAddress, internalAddress]]
+    };
+};
+
+export { index as default };

package/exports/browser/{index-fa2c6beb.js → index-c3f4012c.js}

@@ -43,6 +43,8 @@ var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
 
 var require$$0 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
 
+bn.exports;
+
 (function (module) {
 	(function (module, exports) {