@leofcoin/chain 1.3.9 → 1.3.11

package/dist/module/chain.js

@@ -3,10 +3,11 @@ import _BN from 'bn.js';
 import '@ethersproject/bytes';
 import { Logger } from '@ethersproject/logger';
 import '@ethersproject/bignumber';
-import { randomBytes } from 'node:crypto';
-import { join } from 'node:path';
+import { randomBytes } from 'crypto';
+import { join } from 'path';
 import EasyWorker from '@vandeurenglenn/easy-worker';
 import { FormatInterface } from '@leofcoin/codec-format-interface';
+import pako from 'pako';
 import MultiWallet from '@leofcoin/multi-wallet';
 import { CodecHash } from '@leofcoin/codec-format-interface/dist/index';
 import bs32 from '@vandeurenglenn/base32';
@@ -15,17 +16,17 @@ var contractFactory$2 = "ihny2gqg6c6mwy5mhbrs5ulkkozsgwtk5vuz5krjidouy4mbwfdbjnb
 var nativeToken$2 = "ihny2gqhoockyg7yg4n5bpxuldahfavpqnmpoe2bn4ivnxmk7redc2ltwkb";
 var nameService$2 = "ihny2gqgztp3vj6qy7fgrfer7y5c5hxnp6imdz6v5spi4edkwtm5fkd5z2h";
 var validators$2 = "ihny2gqh4e2pr4pbtpkamhj3htsvuoydy3wotaudoeaktgcdwmoij66pecp";
-var addresses = {
+var addresses$1 = {
 	contractFactory: contractFactory$2,
 	nativeToken: nativeToken$2,
 	nameService: nameService$2,
 	validators: validators$2
 };
 
-const contractFactory$1 = addresses.contractFactory;
-const nameService$1 = addresses.nameService;
-const nativeToken$1 = addresses.nativeToken;
-const validators$1 = addresses.validators;
+const contractFactory$1 = addresses$1.contractFactory;
+const nameService$1 = addresses$1.nameService;
+const nativeToken$1 = addresses$1.nativeToken;
+const validators$1 = addresses$1.validators;
 
 const version$1 = "bignumber/5.6.2";
 
@@ -125,7 +126,7 @@ message BlockMessage {
 }
 `;
 
-class BlockMessage extends FormatInterface {
+class BlockMessage$1 extends FormatInterface {
   get keys() {
     return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
   }
@@ -289,22 +290,27 @@ class Machine {
     
   }
 
+  /**
+   * 
+   * @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 (this.#contracts[parameters[0]]) throw new Error(`duplicate contract @${parameters[0]}`)
         let message;
-        if (!contractStore.has(parameters[0])) {
+        if (!await contractStore.has(parameters[0])) {
           message = await peernet.get(parameters[0], 'contract');
-          message = new ContractMessage(message);
+          message = await new ContractMessage(message);
           await contractStore.put(await message.hash, message.encoded);
         }
         if (!message) {
           message = await contractStore.get(parameters[0]);
-          message = new ContractMessage(message);
+          message = await new ContractMessage(message);
         }
-        
         if (!this.#contracts[await message.hash]) await this.#runContract(message);
       }
     } catch (error) {
@@ -418,24 +424,397 @@ const calculateFee = async transaction => {
   return Number.parseFloat(fee.toString()).toFixed(decimals)
 };
 
+class State {
+  constructor() {
+    // return this.#init()
+  }
+
+  // async #init() {
+  //   const state = await stateStore.get()
+  //   for (const [key, value] of Object.entries(state)) {
+  //
+  //   }
+  //
+  //   return this
+  // }
+
+  async put(key, value, isCompressed = true) {
+    value = isCompressed ? value : await pako.deflate(value);
+    await stateStore.put(key, value);
+  }
+
+  async get(key, isCompressed = true) {
+    const value = await stateStore.get(key);
+    return isCompressed = pako.inflate(value) 
+  }
+
+  updateState(block) {
+    // block.decoded.index
+    // this.#isUpdateNeeded()
+  }
+}
+
+class Protocol {
+  limit = 1800
+}
+
+class Transaction extends Protocol {
+  constructor() {
+    super();
+  }
+
+  /**
+   * 
+   * @param {Address[]} transactions 
+   * @returns transactions to include
+   */
+  async getTransactions (transactions) {
+    return new Promise(async (resolve, reject) => {
+      let size = 0;
+      const _transactions = [];
+      
+      
+      await Promise.all(transactions
+        .map(async tx => {
+          tx = await new TransactionMessage(tx);
+          size += tx.encoded.length;
+          if (!formatBytes(size).includes('MB') || formatBytes(size).includes('MB') && Number(formatBytes(size).split(' MB')[0]) <= 0.75) _transactions.push({...tx.decoded, hash: await tx.hash});
+          else resolve(_transactions);
+        }));
+
+      return resolve(_transactions)
+    })
+    
+  }
+
+  /**
+   * 
+   * @param {Transaction[]} transactions An array containing Transactions
+   * @returns {TransactionMessage}
+   */
+  async promiseTransactions(transactions) {
+    transactions = await Promise.all(transactions.map(tx => new TransactionMessage(tx)));
+    return transactions
+  }
+
+  /**
+   * 
+   * @param {Transaction[]} transactions An array containing Transactions
+   * @returns {Object} {transaction.decoded, transaction.hash}
+   */
+  async promiseTransactionsContent(transactions) {
+    transactions = await Promise.all(transactions.map(tx => new Promise(async (resolve, reject) => {
+      resolve({ ...tx.decoded, hash: await tx.hash });
+    })));
+
+    return transactions
+  }
+
+  /**
+   * When a nonce isn't found for an address fallback to just checking the transactionnPoolStore
+   * @param {Address} address 
+   * @returns {Number} nonce
+   */
+  async #getNonceFallback(address) {
+    let transactions = await transactionPoolStore.values();
+    transactions = await this.promiseTransactions(transactions);
+    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);
+      block = await new BlockMessage(block);
+
+      // for (let tx of block.decoded?.transactions) {
+      //   tx = await peernet.get(tx, 'transaction')
+      //   transactions.push(new TransactionMessage(tx))
+      // }
+      transactions = transactions.filter(tx => tx.from === address);
+      while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== '0x0') {
+        block = await blockStore.get(block.decoded.previousHash);
+        block = await new BlockMessage(block);
+        transactions = block.decoded.transactions.filter(tx => tx.from === address);
+      }
+
+    }
+    if (transactions.length === 0) return 0
+
+    transactions = transactions.sort((a, b) => a.timestamp - b.timestamp);
+    return transactions[transactions.length - 1].nonce
+  }
+
+  /**
+   * Get amount of transactions by address
+   * @param {Address} address The address to get the nonce for
+   * @returns {Number} nonce
+   */
+  async getNonce(address) {
+    if (!await accountsStore.has(address)) {
+      const nonce = await this.#getNonceFallback(address);
+      await accountsStore.put(address, new TextEncoder().encode(String(nonce)));
+    }
+    // todo: are those in the pool in cluded also ? they need to be included!!!
+    let nonce = await accountsStore.get(address);
+    nonce = new TextDecoder().decode(nonce);
+    return Number(nonce)
+  }
+
+  /**
+   * whenever method = createContract params should hold the contract hash
+   *
+   * example: [hash]
+   * createTransaction('0x0', 'createContract', [hash])
+   *
+   * @param {String} to - the contract address for the contract to interact with
+   * @param {String} method - the method/function to run
+   * @param {Array} params - array of paramters to apply to the contract method
+   * @param {Number} nonce - total transaction count [optional]
+   */
+  async createTransaction(to, method, parameters, nonce, signature) {
+    return this.createTransactionFrom(peernet.selectedAccount, to, method, parameters, nonce)
+  } 
+
+  /**
+   * 
+   * @param {Transaction} transaction
+   * @param {String} transaction.from address
+   * @param {String} transaction.to address
+   * @param {Object} transaction.params {}
+   * @param {String} transaction.params.method get, call
+   * @param {Buffer} transaction.params.data 
+   * @returns 
+   */
+  async createTransactionHash(transaction) {
+    // todo: validate  
+    const peernetHash = await new CodecHash(transaction, {name: 'transaction-message'});
+    return peernetHash.digest
+  }
+
+  /**
+   * @param {Transaction} transaction
+   * @param {object} wallet any wallet/signer that supports sign(RAWtransaction)
+   */
+  async #signTransaction (transaction, wallet) {
+    return wallet.sign(await this.createTransactionHash(transaction))
+  }
+
+  /**
+   * 
+   * @param {RawTransaction} transaction 
+   * @param {Signer} signer 
+   * @returns {Transaction} a signed transaction
+   */
+  async signTransaction(transaction, signer) {
+    let identity = await walletStore.get('identity');
+    identity = JSON.parse(new TextDecoder().decode(identity));
+    const wallet = new MultiWallet(peernet.network);
+    wallet.recover(identity.mnemonic);
+    const account = wallet.account(0).external(0);
+    transaction.signature = await this.#signTransaction(transaction, account);
+    transaction.signature = bs32.encode(transaction.signature);
+    return transaction
+  }
+
+  /**
+   * 
+   * @param {Transaction} transaction
+   * @param {Address} transaction.from
+   * @param {Address} transaction.to
+   * @param {String} transaction.method
+   * @param {Array} transaction.params
+   * @param {Number} transaction.nonce
+   * 
+   * @returns {RawTransaction} transaction
+   */
+  async ensureNonce(transaction) {
+    if (!transaction.from) transaction.from = peernet.selectedAccount;
+    transaction.timestamp = Date.now();
+
+    if (transaction.nonce === undefined) {
+      transaction.nonce = await this.getNonce(transaction.from);
+    } else {
+      let nonce = await accountsStore.get(transaction.from);
+      nonce = new TextDecoder().decode(nonce);
+      if (transaction.nonce < nonce) throw new Error(`a transaction with a higher nonce already exists`)
+      if (transaction.nonce === nonce) throw new Error(`a transaction with the same nonce already exists`)
+    }
+    return transaction
+  }
+
+  /**
+   * every tx done is trough contracts so no need for amount
+   * data is undefined when nothing is returned
+   * error is thrown on error so undefined data doesn't mean there is an error...
+   *
+   * @param {Address} from - the sender address
+   * @param {Address} to - the contract address for the contract to interact with
+   * @param {String} method - the method/function to run
+   * @param {Array} params - array of paramters to apply to the contract method
+   * @param {Number} nonce - total transaction count [optional]
+   */
+  async createTransactionFrom(from, to, method, parameters, nonce) {
+    try {
+      const rawTransaction = await this.ensureNonce({from, to, nonce, method, params: parameters});    
+      const transaction = await this.signTransaction(rawTransaction, from);
+      const message = await new TransactionMessage(transaction);
+
+      let data;
+      const wait = () => new Promise(async (resolve, reject) => {
+        if (pubsub.subscribers[`transaction.completed.${await message.hash}`]) {
+          const result = pubsub.subscribers[`transaction.completed.${await message.hash}`].value;
+          result.status === 'fulfilled' ? resolve(await result.hash) : reject({hash: await result.hash, error: result.error});
+        } else {
+          const completed = async result => {
+            result.status === 'fulfilled' ? resolve(await result.hash) : reject({hash: await result.hash, error: result.error});
+    
+            setTimeout(async () => {
+              pubsub.unsubscribe(`transaction.completed.${await message.hash}`, completed);
+            }, 10_000);
+          };
+          pubsub.subscribe(`transaction.completed.${await message.hash}`, completed);
+        }
+      });
+      await transactionPoolStore.put(await message.hash, message.encoded);
+      peernet.publish('add-transaction', message.encoded);
+      return {hash: await message.hash, data, fee: await calculateFee(message.decoded), wait, message}
+    } catch (error) {
+      console.log(error);
+      throw error
+    }
+  }
+}
+
+/**
+ * @extends {Transaction}
+ */
+class Contract extends Transaction {
+  constructor() {
+    super();
+  }
+
+  /**
+   * 
+   * @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])    
+  }
+  
+}
+
 globalThis.BigNumber = BigNumber;
 
 // check if browser or local
-class Chain {
+class Chain  extends Contract {
+  /** {Address[]} */
   #validators = []
+  /** {Block[]} */
   #blocks = []
+
   #machine
+  /** {Boolean} */
   #runningEpoch = false
+
+  /** {Boolean} */
   #chainSyncing = false
+
+  /** {Number} */
+  #totalSize = 0
+
+  /** 
+   * {Block} {index, hash, previousHash}
+   */
   #lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
+
+  /** 
+   * amount the native token has been iteracted with
+   */
+  #nativeCalls = 0
+
+  /** 
+   * amount the native token has been iteracted with
+   */
+   #nativeTransfers = 0
+
+  /** 
+   * amount of native token burned
+   * {Number}
+   */
+  #nativeBurns = 0
+
+  /** 
+   * amount of native tokens minted
+   * {Number}
+   */
+  #nativeMints = 0
+
+  /** 
+   * total amount of transactions
+   * {Number}
+   */
+   #totalTransactions = 0
+
   #participants = []
   #participating = false
   #jail = []
 
   constructor() {
+    super();
     return this.#init()
   }
 
+  get nativeMints() {
+    return this.#nativeMints
+  }
+
+  get nativeBurns() {
+    return this.#nativeBurns
+  }
+  
+  get nativeTransfers() {
+    return this.#nativeTransfers
+  }
+
+  get totalTransactions() {
+    return this.#totalTransactions
+  }
+
+  get totalSize() {
+    return this.#totalSize
+  }
+
   get lib() {
     return lib
   }
@@ -445,7 +824,7 @@ class Chain {
   }
 
   get nativeToken() {
-    return addresses.nativeToken
+    return addresses$1.nativeToken
   }
 
   get validators() {
@@ -465,10 +844,9 @@ class Chain {
   async #runEpoch() {
     this.#runningEpoch = true;
     console.log('epoch');
-    const validators = await this.staticCall(addresses.validators, 'validators');
+    const validators = await this.staticCall(addresses$1.validators, 'validators');
     console.log(validators);
     if (!validators[peernet.selectedAccount]?.active) return
-
     const start = Date.now();
     try {
       await this.#createBlock();
@@ -487,16 +865,16 @@ class Chain {
   async #setup() {
 
     const contracts = [{
-      address: addresses.contractFactory,
+      address: addresses$1.contractFactory,
       message: contractFactoryMessage
     }, {
-      address: addresses.nativeToken,
+      address: addresses$1.nativeToken,
       message: nativeTokenMessage
     }, {
-      address: addresses.validators,
+      address: addresses$1.validators,
       message: validatorsMessage
     }, {
-      address: addresses.nameService,
+      address: addresses$1.nameService,
       message: nameServiceMessage
     }];
 
@@ -554,7 +932,7 @@ class Chain {
     
     if (latest.hash && latest.hash !== '0x0') {
       latest = await peernet.get(latest.hash, block);
-      latest = await new BlockMessage(latest);
+      latest = await new BlockMessage$1(latest);
     }
 
     return latest
@@ -564,11 +942,13 @@ class Chain {
     // this.node = await new Node()
     this.#participants = [];
     this.#participating = false;
-    const initialized = await contractStore.has(addresses.contractFactory);
+    const initialized = await contractStore.has(addresses$1.contractFactory);
     if (!initialized) await this.#setup();
 
    
     this.utils = { BigNumber, formatUnits, parseUnits };
+
+    this.state = new State();
     
     try {
       let localBlock;
@@ -581,7 +961,7 @@ class Chain {
       localBlock = new TextDecoder().decode(localBlock);
       if (localBlock && localBlock !== '0x0') {
         localBlock = await peernet.get(localBlock, 'block');
-        localBlock = await new BlockMessage(localBlock);
+        localBlock = await new BlockMessage$1(localBlock);
         this.#lastBlock = {...localBlock.decoded, hash: await localBlock.hash};
       } else {
         const latestBlock = await this.#getLatestBlock();
@@ -652,16 +1032,6 @@ class Chain {
 
  #epochTimeout
 
- async #addTransaction(transaction) {
-  try {
-    transaction = await new TransactionMessage(transaction);
-    const has = await transactionPoolStore.has(await transaction.hash);
-    if (!has) await transactionPoolStore.put(await transaction.hash, transaction.encoded);
-    if (this.#participating && !this.#runningEpoch) this.#runEpoch();
-  } catch {
-    throw new Error('invalid transaction')
-  }
-}
 
 async #lastBlockHandler() {
   return new peernet.protos['peernet-response']({response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index }})
@@ -670,9 +1040,10 @@ async #lastBlockHandler() {
 async resolveBlock(hash) {
   if (!hash)  throw new Error(`expected hash, got: ${hash}`)
   let block = await peernet.get(hash, 'block');
-  block = await new BlockMessage(block);
+  block = await new BlockMessage$1(block);
   if (!await peernet.has(hash, 'block')) await peernet.put(hash, block.encoded, 'block');
   const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
+  this.#totalSize += size;
   block = {...block.decoded, hash};
   if (this.#blocks[block.index] && this.#blocks[block.index].hash !== block.hash) throw `invalid block ${hash} @${block.index}`
   this.#blocks[block.index] = block;
@@ -698,37 +1069,29 @@ async resolveBlock(hash) {
     }
   }
 
+  /**
+   * 
+   * @param {Block[]} blocks 
+   */
   async #loadBlocks(blocks) {
     for (const block of blocks) {
       if (block && !block.loaded) {
         for (const transaction of block.transactions) {
           try {
             await this.#machine.execute(transaction.to, transaction.method, transaction.params);
-
+            if (transaction.to === nativeToken$1) {
+              this.#nativeCalls += 1;
+              if (transaction.method === 'burn') this.#nativeBurns += 1;
+              if (transaction.method === 'mint') this.#nativeMints += 1;
+              if (transaction.method === 'transfer') this.#nativeTransfers += 1;
+            }
+            this.#totalTransactions += 1;
           } catch (error) {
   console.log(error);
           }
         }
         this.#blocks[block.index].loaded = true;
-        console.log(`loaded block: ${block.hash} @${block.index}`);
-        // let message = await peernet.get(block.hash, 'block')
-
-        // const compressed = pako.deflate(message);
-        // const result = pako.inflate(compressed);
-        // console.log(result.length, compressed.length);
-        //
-        // console.log(result.length - compressed.length);
-
-        // message = new BlockMessage(message)
-  //       for (const transaction of message.decoded.transactions) {
-  //         try {
-  //           await this.#machine.execute(transaction.to, transaction.method, transaction.params)
-  //
-  //         } catch (e) {
-  // // console.log(e);
-  //         }
-  //       }
-        // block.loaded = true
+        debug(`loaded block: ${block.hash} @${block.index}`);
       }
     }
   }
@@ -747,26 +1110,10 @@ async resolveBlock(hash) {
 
   async #addBlock(block) {
     // console.log(block);
-    const blockMessage = await new BlockMessage(new Uint8Array(Object.values(block)));
-    // if (!Buffer.isBuffer(block)) block = Buffer.from(block, 'hex')
-    // const transactionJob = async transaction => {
-    //   try {
-    //     transaction = await transactionPoolStore.get(transaction)
-    //   } catch (e) {
-    //     try {
-    //       transaction = await peernet.get(transaction, 'transaction')
-    //     } catch (e) {
-    //       console.warn(`couldn't resolve ${transaction}`);
-    //     }
-    //   }
-    //   transaction = new TransactionMessage(transaction)
-    //   return transaction
-    // }
+    const blockMessage = await new BlockMessage$1(new Uint8Array(Object.values(block)));
     await Promise.all(blockMessage.decoded.transactions
       .map(async transaction => transactionPoolStore.delete(await transaction.hash)));
     const hash = await blockMessage.hash;
-    // let transactions = blockMessage.decoded.transactions.map(tx => transactionJob(tx))
-    // transactions = await Promise.all(transactions)
     
     await blockStore.put(hash, blockMessage.encoded);
     
@@ -809,6 +1156,7 @@ async resolveBlock(hash) {
   async #updateState(message) {
     const hash = await message.hash;
     this.#lastBlock = { hash, ...message.decoded };
+    await this.state.updateState(message);
     await chainStore.put('lastBlock', hash);
   }
 
@@ -822,14 +1170,8 @@ async resolveBlock(hash) {
     // peerReputation(peerId)
     // {bandwith: {up, down}, uptime}
     this.#participating = true;
-    if (!await this.staticCall(addresses.validators, 'has', [address])) await this.createTransactionFrom(address, addresses.validators, 'addValidator', [address]);
+    if (!await this.staticCall(addresses$1.validators, 'has', [address])) await this.createTransactionFrom(address, addresses$1.validators, 'addValidator', [address]);
     if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch();
-    
-    // const runEpoch = () => setTimeout(async () => {
-    //   if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
-    //   runEpoch()
-    // }, 5000)
-    // runEpoch()
   }
 
   calculateFee(transaction) {
@@ -839,25 +1181,6 @@ async resolveBlock(hash) {
     return (transaction.encoded.length / 1024) / 1e-6
   }
 
-  async getTransactions (transactions) {
-    return new Promise(async (resolve, reject) => {
-      let size = 0;
-      const _transactions = [];
-      
-      
-      await Promise.all(transactions
-        .map(async tx => {
-          tx = await new TransactionMessage(tx);
-          size += tx.encoded.length;
-          if (!formatBytes(size).includes('MB') || formatBytes(size).includes('MB') && Number(formatBytes(size).split(' MB')[0]) <= 0.75) _transactions.push({...tx.decoded, hash: await tx.hash});
-          else resolve(_transactions);
-        }));
-
-      return resolve(_transactions)
-    })
-    
-  }
-
   // todo filter tx that need to wait on prev nonce
   async #createBlock(limit = 1800) {
     // vote for transactions
@@ -890,7 +1213,7 @@ async resolveBlock(hash) {
     }
     // don't add empty block
     if (block.transactions.length === 0) return
-    const validators = await this.staticCall(addresses.validators, 'validators');
+    const validators = await this.staticCall(addresses$1.validators, 'validators');
     console.log({validators});
     // block.validators = Object.keys(block.validators).reduce((set, key) => {
     //   if (block.validators[key].active) {
@@ -965,7 +1288,7 @@ async resolveBlock(hash) {
         .map(async transaction => transactionPoolStore.delete(await transaction.hash)));
 
 
-      let blockMessage = await new BlockMessage(block);
+      let blockMessage = await new BlockMessage$1(block);
       const hash = await blockMessage.hash;
       
       
@@ -983,58 +1306,18 @@ async resolveBlock(hash) {
     // transactionStore.put(message.hash, message.encoded)
   }
 
-  async promiseTransactions(transactions) {
-    transactions = await Promise.all(transactions.map(tx => new TransactionMessage(tx)));
-    return transactions
-  }
-
-  async promiseTransactionsContent(transactions) {
-    transactions = await Promise.all(transactions.map(tx => new Promise(async (resolve, reject) => {
-      resolve({ ...tx.decoded, hash: await tx.hash });
-    })));
-
-    return transactions
-  }
-
-  async #getNonceFallback(address) {
-    let transactions = await transactionPoolStore.values();
-    transactions = await this.promiseTransactions(transactions);
-    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);
-      block = await new BlockMessage(block);
-
-      // for (let tx of block.decoded?.transactions) {
-      //   tx = await peernet.get(tx, 'transaction')
-      //   transactions.push(new TransactionMessage(tx))
-      // }
-      transactions = transactions.filter(tx => tx.from === address);
-      while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== '0x0') {
-        block = await blockStore.get(block.decoded.previousHash);
-        block = await new BlockMessage(block);
-        transactions = block.decoded.transactions.filter(tx => tx.from === address);
-      }
-
-    }
-    if (transactions.length === 0) return 0
-
-    transactions = transactions.sort((a, b) => a.timestamp - b.timestamp);
-    return transactions[transactions.length - 1].nonce
-  }
+  
 
-  async getNonce(address) {
-    if (!await accountsStore.has(address)) {
-      const nonce = await this.#getNonceFallback(address);
-      await accountsStore.put(address, new TextEncoder().encode(String(nonce)));
+  async #addTransaction(transaction) {
+    try {
+      transaction = await new TransactionMessage(transaction);
+      const has = await transactionPoolStore.has(await transaction.hash);
+      if (!has) await transactionPoolStore.put(await transaction.hash, transaction.encoded);
+      if (this.#participating && !this.#runningEpoch) this.#runEpoch();
+    } catch {
+      throw new Error('invalid transaction')
     }
-    let nonce = await accountsStore.get(address);
-    nonce = new TextDecoder().decode(nonce);
-    return Number(nonce)
   }
-
   /**
    * whenever method = createContract params should hold the contract hash
    *
@@ -1046,146 +1329,31 @@ async resolveBlock(hash) {
    * @param {Array} params - array of paramters to apply to the contract method
    * @param {Number} nonce - total transaction count [optional]
    */
-  async createTransaction(to, method, parameters, nonce, signature) {
+   async createTransaction(to, method, parameters, nonce, signature) {
     return this.createTransactionFrom(peernet.selectedAccount, to, method, parameters, nonce)
-  }
-
-  
-
-/**
- * 
- * @param {Object} transaction {}
- * @param {String} transaction.from address
- * @param {String} transaction.to address
- * @param {Object} transaction.params {}
- * @param {String} transaction.params.method get, call
- * @param {Buffer} transaction.params.data 
- * @returns 
- */
-async createTransactionHash(transaction) {
-  // todo: validate  
-  const peernetHash = await new CodecHash(transaction, {name: 'transaction-message'});
-  return peernetHash.digest
-}
-
-/**
- * @params {object} transaction -
- * @params {object} wallet - any wallet/signer that supports sign(RAWtransaction)
- */
-async #signTransaction (transaction, wallet) {
-  return wallet.sign(await this.createTransactionHash(transaction))
-}
-
-  async signTransaction(transaction, signer) {
-    let identity = await walletStore.get('identity');
-    identity = JSON.parse(new TextDecoder().decode(identity));
-    const wallet = new MultiWallet(peernet.network);
-    wallet.recover(identity.mnemonic);
-    const account = wallet.account(0).external(0);
-    transaction.signature = await this.#signTransaction(transaction, account);
-    transaction.signature = bs32.encode(transaction.signature);
-    return transaction
-  }
-
-  /**
-   * 
-   * @param {Object} transaction
-   * @param {Address} transaction.from
-   * @param {Address} transaction.to
-   * @param {String} transaction.method
-   * @param {Array} transaction.params
-   * @param {Number} transaction.nonce
-   * 
-   * @returns {Object} transaction
-   */
-  async createRawTransaction(transaction) {
-    if (!transaction.from) transaction.from = peernet.selectedAccount;
-    transaction.timestamp = Date.now();
-
-    if (transaction.nonce === undefined) {
-      transaction.nonce = await this.getNonce(transaction.from);
-    } else {
-      let nonce = await accountsStore.get(transaction.from);
-      nonce = new TextDecoder().decode(nonce);
-      if (transaction.nonce < nonce) throw new Error(`a transaction with a higher nonce already exists`)
-      if (transaction.nonce === nonce) throw new Error(`a transaction with the same nonce already exists`)
-    }
-    return transaction
-  }
+  } 
   /**
    * every tx done is trough contracts so no need for amount
    * data is undefined when nothing is returned
    * error is thrown on error so undefined data doesn't mean there is an error...
    *
-   * @param {String} from - the sender address
-   * @param {String} to - the contract address for the contract to interact with
+   * @param {Address} from - the sender address
+   * @param {Address} to - the contract address for the contract to interact with
    * @param {String} method - the method/function to run
    * @param {Array} params - array of paramters to apply to the contract method
    * @param {Number} nonce - total transaction count [optional]
    */
-  async createTransactionFrom(from, to, method, parameters, nonce) {
-    try {
-      
-      const rawTransaction = await this.createRawTransaction({from, to, nonce, method, params: parameters});    
-      const transaction = await this.signTransaction(rawTransaction, from);
-      const message = await new TransactionMessage(transaction);
-
-      let data;
-      // await transactionPoolStore.put(message.hash, new TextEncoder().encode(JSON.stringify({signature, message: message.encoded})))
-      const wait = () => new Promise(async (resolve, reject) => {
-        if (pubsub.subscribers[`transaction.completed.${await message.hash}`]) {
-          const result = pubsub.subscribers[`transaction.completed.${await message.hash}`].value;
-          result.status === 'fulfilled' ? resolve(await result.hash) : reject({hash: await result.hash, error: result.error});
-        } else {
-          const completed = async result => {
-            result.status === 'fulfilled' ? resolve(await result.hash) : reject({hash: await result.hash, error: result.error});
-    
-            setTimeout(async () => {
-              pubsub.unsubscribe(`transaction.completed.${await message.hash}`, completed);
-            }, 10_000);
-          };
-          pubsub.subscribe(`transaction.completed.${await message.hash}`, completed);
-        }
-        
-        
-      });
-      
-      await transactionPoolStore.put(await message.hash, message.encoded);
-      peernet.publish('add-transaction', message.encoded);
-      this.#addTransaction(message.encoded);
-      return {hash: await message.hash, data, fee: await calculateFee(message.decoded), wait}
-    } catch (error) {
-      console.log(error);
-      throw error
-    }
-    
-  }
-
-  async createContractMessage(creator, contract, constructorParameters = []) {
-    return createContractMessage(creator, contract, constructorParameters)
-  }
-
-  async createContractAddress(creator, contract, constructorParameters = []) {
-    contract = await this.createContractMessage(creator, contract, constructorParameters);
-    return contract.hash
+   async createTransactionFrom(from, to, method, parameters, nonce) {
+    const event = await super.createTransactionFrom(from, to, method, parameters, nonce);
+    this.#addTransaction(event.message.encoded);
+    return event    
   }
 
   /**
    * 
-   * @param {String} contract 
-   * @param {Array} parameters 
-   * @returns 
+   * @param {Address} sender 
+   * @returns {globalMessage}
    */
-  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])    
-  }
-
   #createMessage(sender = peernet.selectedAccount) {
     return {
       sender,
@@ -1196,12 +1364,27 @@ async #signTransaction (transaction, wallet) {
     }
   }
 
+  /**
+   * 
+   * @param {Address} sender 
+   * @param {Address} contract 
+   * @param {String} method 
+   * @param {Array} parameters 
+   * @returns 
+   */
   internalCall(sender, contract, method, parameters) {
     globalThis.msg = this.#createMessage(sender);
 
     return this.#machine.execute(contract, method, parameters)
   }
 
+  /**
+   * 
+   * @param {Address} contract 
+   * @param {String} method 
+   * @param {Array} parameters 
+   * @returns 
+   */
   call(contract, method, parameters) {
     globalThis.msg = this.#createMessage();
 
@@ -1226,19 +1409,19 @@ async #signTransaction (transaction, wallet) {
   }
 
   mint(to, amount) {
-    return this.call(addresses.nativeToken, 'mint', [to, amount])
+    return this.call(addresses$1.nativeToken, 'mint', [to, amount])
   }
 
   transfer(from, to, amount) {
-    return this.call(addresses.nativeToken, 'transfer', [from, to, amount])
+    return this.call(addresses$1.nativeToken, 'transfer', [from, to, amount])
   }
 
   get balances() {
-    return this.staticCall(addresses.nativeToken, 'balances')
+    return this.staticCall(addresses$1.nativeToken, 'balances')
   }
 
   get contracts() {
-    return this.staticCall(addresses.contractFactory, 'contracts')
+    return this.staticCall(addresses$1.contractFactory, 'contracts')
   }
 
   deleteAll() {
@@ -1255,7 +1438,7 @@ async #signTransaction (transaction, wallet) {
    * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
    */
   lookup(name) {
-    return this.call(addresses.nameService, 'lookup', [name])
+    return this.call(addresses$1.nameService, 'lookup', [name])
   }
 }