@leofcoin/chain 1.4.20 → 1.4.21

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.4.20",
+  "version": "1.4.21",
   "description": "Official javascript implementation",
   "main": "./dist/node.js",
   "module": "./dist/chain.esm",
   "exports": {
-    "./node": "./src/node.js",
-    "./chain": "./src/chain.js"
+    "./node": "./exports/node.js",
+    "./chain": "./exports/chain.js"
   },
+  "types": "./exports/types/chain.d.ts",
   "type": "module",
   "scripts": {
     "np": "np",
@@ -16,7 +17,7 @@
     "w": "rollup -c -w",
     "docs": "sh ./node_modules/.bin/esdoc src/chain.js",
     "workers": "cp ./../workers/src/** ./workers",
-    "build": "npm run c && webpack && cp ./dist/*browser.js ./demo && cp -r ./dist/browser/workers/ ./demo",
+    "build": "npm run c",
     "demo": "jsproject --serve ./demo --port 5478 --open demo",
     "test": "node --openssl-legacy-provider test",
     "pack": "webpack"
@@ -30,6 +31,8 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
+    "@rollup/plugin-json": "^6.0.0",
+    "@rollup/plugin-typescript": "^11.0.0",
     "@types/bs58check": "^2.1.0",
     "@types/pako": "^2.0.0",
     "@types/randombytes": "^2.0.0",
@@ -38,6 +41,7 @@
     "eslint": "^8.28.0",
     "eslint-plugin-unicorn": "^45.0.0",
     "open": "^8.4.0",
+    "rollup": "^3.12.0",
     "tape": "^5.5.2",
     "tslib": "^2.4.1"
   },
@@ -48,7 +52,7 @@
     "@leofcoin/messages": "^1.2.0",
     "@leofcoin/multi-wallet": "^2.1.1",
     "@leofcoin/networks": "^1.0.0",
-    "@leofcoin/peernet": "^0.18.0",
+    "@leofcoin/peernet": "^1.0.0",
     "@leofcoin/storage": "^3.0.6",
     "@leofcoin/utils": "^1.1.4",
     "@leofcoin/workers": "^1.3.5",

package/rollup.config.js

@@ -0,0 +1,15 @@
+import json from '@rollup/plugin-json'
+import typescript from '@rollup/plugin-typescript'
+import tsConfig from './tsconfig.json' assert { type: 'json'}
+
+export default [{
+  input: ['./src/chain.ts', './src/node.ts'],
+  output: {
+    dir: './exports',
+    format: 'es'
+  },
+  plugins: [
+    json(),
+    typescript(tsConfig)
+  ]
+}]

package/src/{chain.js → chain.ts}

@@ -2,9 +2,11 @@ import { BigNumber, formatUnits, parseUnits, formatBytes } from '@leofcoin/utils
 import Machine from './machine.js'
 import { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } from '@leofcoin/messages'
 import addresses, { nativeToken } from '@leofcoin/addresses'
+import { signTransaction } from '@leofcoin/lib'
 import { contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, calculateFee } from '@leofcoin/lib'
 import State from './state.js'
 import Contract from './contract.js'
+import { BigNumberish } from '@ethersproject/bignumber'
 
 globalThis.BigNumber = BigNumber
 
@@ -122,7 +124,7 @@ export default class Chain  extends Contract {
     console.log('epoch');
     const validators = await this.staticCall(addresses.validators, 'validators')
     console.log({validators});
-    if (!validators[peernet.selectedAccount]?.active) return
+    if (!validators[globalThis.peernet.selectedAccount]?.active) return
     const start = Date.now()
     try {
       await this.#createBlock()
@@ -451,7 +453,19 @@ 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.validators, 'has', [address])) {
+      const rawTransaction = {
+        from: address,
+        to: addresses.validators,
+        method: 'addValidator',
+        params: [address],
+        nonce: (await this.getNonce(address)) + 1,
+        timestamp: Date.now()        
+      }      
+      
+      const transaction = await signTransaction(rawTransaction, peernet.identity)
+      await this.sendTransaction(transaction)
+    }
     if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
   }
 
@@ -591,33 +605,13 @@ async resolveBlock(hash) {
       throw new Error('invalid transaction')
     }
   }
-  /**
-   * 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)
-  } 
   /**
    * 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) {
-    const event = await super.createTransactionFrom(from, to, method, parameters, nonce)
+   **/
+   async sendTransaction(transaction) {
+    const event = await super.sendTransaction(transaction)
     this.#addTransaction(event.message.encoded)
     return event    
   }
@@ -664,7 +658,7 @@ async resolveBlock(hash) {
     return this.#machine.execute(contract, method, parameters)
   }
 
-  staticCall(contract, method, parameters) {
+  staticCall(contract, method, parameters?) {
     globalThis.msg = this.#createMessage()
     return this.#machine.get(contract, method, parameters)
   }
@@ -675,21 +669,21 @@ async resolveBlock(hash) {
     return this.#machine.execute(contract, method, parameters)
   }
 
-  staticDelegate(contract, method, parameters) {
+  staticDelegate(contract: Address, method: string, parameters: []): any {
     globalThis.msg = this.#createMessage()
 
     return this.#machine.get(contract, method, parameters)
   }
 
-  mint(to, amount) {
+  mint(to: string, amount: BigNumberish) {
     return this.call(addresses.nativeToken, 'mint', [to, amount])
   }
 
-  transfer(from, to, amount) {
+  transfer(from: string, to: string, amount: BigNumberish) {
     return this.call(addresses.nativeToken, 'transfer', [from, to, amount])
   }
 
-  get balances() {
+  get balances(): {address: BigNumberish} {
     return this.staticCall(addresses.nativeToken, 'balances')
   }
 
@@ -710,7 +704,7 @@ async resolveBlock(hash) {
    *
    * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
    */
-  lookup(name) {
+  lookup(name): {owner: string, address: string} {
     return this.call(addresses.nameService, 'lookup', [name])
   }
 }

package/src/{node.js → node.ts}

@@ -13,7 +13,7 @@ export default class Node {
     networkName: 'leofcoin:peach',
     networkVersion: 'peach',
     stars: networks.leofcoin.peach.stars
-  }) {
+  }): Promise<this> {
     globalThis.Peernet ? await new globalThis.Peernet(config) : await new Peernet(config)
     await nodeConfig(config)
 

package/src/transaction.ts

@@ -0,0 +1,182 @@
+import Protocol from "./protocol.js"
+import { TransactionMessage, BlockMessage } from "@leofcoin/messages"
+import { calculateFee } from '@leofcoin/lib'
+import { formatBytes } from '@leofcoin/utils'
+
+export default 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 = []
+      
+      
+      const promises = 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): Promise<TransactionMessage[]> {
+    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 globalThis.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 globalThis.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 globalThis.accountsStore.has(address)) {
+      const nonce = await this.#getNonceFallback(address)
+      await globalThis.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 globalThis.accountsStore.get(address)
+    nonce = new TextDecoder().decode(nonce)
+    
+    let transactions = await globalThis.transactionPoolStore.values()
+    transactions = await this.promiseTransactions(transactions)
+    transactions = transactions.filter(tx => tx.decoded.from === address)
+    transactions = await this.promiseTransactionsContent(transactions)
+    for (const transaction of transactions) {
+      if (transaction.nonce > nonce) nonce = transaction.nonce
+    }
+    return Number(nonce)
+  }
+
+  async validateNonce(address, nonce) {    
+    let previousNonce = await globalThis.accountsStore.get(address)
+    previousNonce = Number(new TextDecoder().decode(previousNonce))
+    if (previousNonce > nonce) throw new Error(`a transaction with a higher nonce already exists`)
+    if (previousNonce === nonce) throw new Error(`a transaction with the same nonce already exists`)
+    
+    let transactions = await globalThis.transactionPoolStore.values()
+    transactions = await this.promiseTransactions(transactions)
+    transactions = transactions.filter(tx => tx.decoded.from === address)
+    
+    for (const transaction of transactions) {
+      if (transaction.decoded.nonce > nonce) throw new Error(`a transaction with a higher nonce already exists`)
+      if (transaction.decoded.nonce === nonce) throw new Error(`a transaction with the same nonce already exists`)
+    }
+  }
+
+  isTransactionMessage(message) {
+    if (message instanceof TransactionMessage) return true
+    return false
+  }
+
+  async createTransaction(transaction) {
+    return {
+      from: transaction.from, 
+      to: transaction.to, 
+      method: transaction.method,
+      params: transaction.params,
+      timestamp: transaction.timestamp || Date.now(),
+      nonce: transaction.nonce || (await this.getNonce(transaction.from)) + 1
+    }
+  }
+
+  async sendTransaction(message) {
+    if (!this.isTransactionMessage(message)) message = new TransactionMessage(message)
+    if (!message.decoded.signature) throw new Error(`transaction not signed`)
+    if (message.decoded.nonce === undefined) throw new Error(`nonce required`)    
+    
+    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
+          result.status === 'fulfilled' ? resolve(result.hash) : reject({hash: result.hash, error: result.error})
+        } else {
+          const completed = async result => {
+            result.status === 'fulfilled' ? resolve(result.hash) : reject({hash: result.hash, error: result.error})
+    
+            setTimeout(async () => {
+              pubsub.unsubscribe(`transaction.completed.${hash}`, completed)
+            }, 10_000)
+          }
+          pubsub.subscribe(`transaction.completed.${hash}`, completed)
+        }
+      })
+      await globalThis.transactionPoolStore.put(hash, message.encoded)
+      debug(`Added ${hash} to the transaction pool`)
+      peernet.publish('add-transaction', message.encoded)
+      return {hash: hash, data, fee: await calculateFee(message.decoded), wait, message}
+    } catch (error) {
+      throw error
+    }
+    
+  }
+}

package/test/chain.js

@@ -1,8 +1,8 @@
-
+import { signTransaction } from '@leofcoin/lib'
 
   globalThis.DEBUG = true
-  const Chain = await import('./../src/chain.js');
-  const Node = await import('./../src/node.js');
+  const Chain = await import('./../exports/chain.js');
+  const Node = await import('./../exports/node.js');
   let imp = await import('../../networks/networks.js')
   const networks = imp.default
   console.log(networks.leofcoin.peach);
@@ -14,6 +14,7 @@
   })
   const chain = await new Chain.default()
   let start
+  // console.log(peernet.identity.sign());
       await chain.participate(peernet.selectedAccount)
       console.log(peernet.selectedAccount);
 const job = async () => {
@@ -22,7 +23,14 @@ const job = async () => {
   // // setTimeout(async () => {
     let tx
     // try {
-    //   tx = await chain.createTransaction(chain.nativeToken, 'grantRole', [peernet.selectedAccount, 'MINT'])
+    //   const rawTransaction = await chain.createTransaction({
+    //     from: peernet.selectedAccount, 
+    //     to: chain.nativeToken, 
+    //     method: 'grantRole',
+    //     params: [peernet.selectedAccount, 'MINT']
+    //   })
+    //   const transaction = await signTransaction(rawTransaction, peernet.identity)
+    //   tx = await chain.sendTransaction(transaction)
     //   console.log({tx});
     //   await tx.wait
 
@@ -30,14 +38,21 @@ const job = async () => {
     //   console.log({e});
     // }
 
-    // try {
-    //   tx = await chain.createTransaction(chain.nativeToken, 'mint', [peernet.selectedAccount, chain.utils.parseUnits('100000000000000').toString()])
-
+    // try {      
+    //   const rawTransaction = await chain.createTransaction({
+    //     from: peernet.selectedAccount, 
+    //     to: chain.nativeToken, 
+    //     method: 'mint',
+    //     params: [peernet.selectedAccount, chain.utils.parseUnits('100000000000000').toString()]
+    //   })
+    //   const transaction = await signTransaction(rawTransaction, peernet.identity)
+    //   tx = await chain.sendTransaction(transaction)
+    //   console.log({tx});
     //   await tx.wait
     // } catch (e) {
     //   console.log({e});
     // }
-    return
+    // return
     console.log({nonce});
     let balances = await chain.balances
     console.log({balances});
@@ -46,11 +61,20 @@ const job = async () => {
     // console.log(`balance for ${Object.keys(balances)[1]}:${chain.utils.formatUnits(balances[Object.keys(balances)[1]]).toString()}`);
     // return
     let promises = []
-    // nonce += 1
+    // nonce += 
+    nonce = await chain.getNonce(peernet.selectedAccount)
     for (let i = 0; i < 10; i++) {
       // contract , method, from, to, amount, (optional) nonce
       nonce += 1
-      promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()], nonce))
+      const rawTransaction = await chain.createTransaction({
+        from: peernet.selectedAccount, 
+        to: chain.nativeToken, 
+        method: 'transfer',
+        nonce,
+        params: [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()]
+      })
+      const transaction = await signTransaction(rawTransaction, peernet.identity)
+      promises.push(chain.sendTransaction(transaction))
     }
     promises = await Promise.allSettled(promises)
     promises = await Promise.allSettled(promises.map(({value}) => value.wait))
@@ -63,13 +87,20 @@ const job = async () => {
 // return
 //     // setTimeout(async () => {
     promises = []
-
+    nonce = await chain.getNonce(peernet.selectedAccount)
     // nonce += 1
-    for (let i = 0; i < 100; i++) {
+    for (let i = 0; i < 10; i++) {
       // contract , method, from, to, amount, (optional) nonce
-      
       nonce += 1
-      promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()], nonce))
+      const rawTransaction = await chain.createTransaction({
+        from: peernet.selectedAccount, 
+        to: chain.nativeToken, 
+        method: 'transfer',
+        nonce,
+        params: [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()]
+      })
+      const transaction = await signTransaction(rawTransaction, peernet.identity)
+      promises.push(chain.sendTransaction(transaction))
     }
     promises = await Promise.allSettled(promises)
     promises = await Promise.allSettled(promises.map(({value}) => value.wait))
@@ -78,13 +109,23 @@ const job = async () => {
     console.log(`balance for ${Object.keys(balances)[1]}:${chain.utils.formatUnits(balances[Object.keys(balances)[1]]).toString()}`);
 
     promises = []
+    nonce = await chain.getNonce(peernet.selectedAccount)
 
+    const createSignSendTransaction = async (nonce) => {
+      const rawTransaction = await chain.createTransaction({
+        from: peernet.selectedAccount, 
+        to: chain.nativeToken, 
+        method: 'transfer',
+        nonce,
+        params: [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()]
+      })
+      const transaction = await signTransaction(rawTransaction, peernet.identity)
+      return chain.sendTransaction(transaction)
+    }
     // nonce += 1
     for (let i = 0; i < 1000; i++) {
-      // contract , method, from, to, amount, (optional) nonce
-      
       nonce += 1
-      promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()], nonce))
+      promises.push(createSignSendTransaction(nonce))
     }
     promises = await Promise.allSettled(promises)
     promises = await Promise.allSettled(promises.map(({value}) => value.wait))

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "module": "es2022",
+    "target": "es2022",
+    "outDir": "./exports",
+    "moduleResolution":"NodeNext",
+    "declaration": true,
+    "declarationDir": "./exports/typings",
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,    
+    "resolveJsonModule": true
+  },
+  "include": [
+    "./src/**/*"
+  ],
+  "exclude": ["./node_modules"]
+}

package/src/transaction.js

@@ -1,234 +0,0 @@
-import Protocol from "./protocol.js"
-import MultiWallet from '@leofcoin/multi-wallet'
-import {CodecHash} from '@leofcoin/codec-format-interface'
-import bs32 from '@vandeurenglenn/base32'
-import { TransactionMessage, BlockMessage } from "@leofcoin/messages"
-import { calculateFee } from '@leofcoin/lib'
-import { formatBytes } from '@leofcoin/utils'
-
-export default 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 = []
-      
-      
-      const promises = 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(this.transactionLimit)
-    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)
-    await wallet.recover(identity.mnemonic)
-    const account = await wallet.account(0).external(0)
-    transaction.signature = await this.#signTransaction(transaction, account)
-    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)
-      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
-          result.status === 'fulfilled' ? resolve(result.hash) : reject({hash: result.hash, error: result.error})
-        } else {
-          const completed = async result => {
-            result.status === 'fulfilled' ? resolve(result.hash) : reject({hash: result.hash, error: result.error})
-    
-            setTimeout(async () => {
-              pubsub.unsubscribe(`transaction.completed.${hash}`, completed)
-            }, 10_000)
-          }
-          pubsub.subscribe(`transaction.completed.${hash}`, completed)
-        }
-      })
-      await transactionPoolStore.put(hash, message.encoded)
-      debug(`Added ${hash} to the transaction pool`)
-      peernet.publish('add-transaction', message.encoded)
-      return {hash: hash, data, fee: await calculateFee(message.decoded), wait, message}
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/tsconfig.js

@@ -1,15 +0,0 @@
-export default {
-  
-  "esModuleInterop": true,
-  'allowSyntheticDefaultImports': true,
-  "compilerOptions": {
-      "outDir": "./dist",
-      "esModuleInterop": true,
-      'allowSyntheticDefaultImports': true,
-      "allowJs": true,
-      "target": "es11"
-  },
-      "include": [
-      "./src/**/*"
-  ]
-}