npm - @leofcoin/chain - Versions diffs - 1.0.23 → 1.0.24 - Mend

@leofcoin/chain 1.0.23 → 1.0.24

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (49) hide show

package/docs/@leofcoin/chain/1.0.24/chain.js.html ADDED Viewed

@@ -0,0 +1,891 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>
+      chain.js - Documentation
+  </title>
+  <link href="https://www.braintreepayments.com/images/favicon-ccda0b14.png" rel="icon" type="image/png">
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.7.0/highlight.min.js"></script>
+  <script>hljs.initHighlightingOnLoad();</script>
+  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.1.0/jquery.min.js"></script>
+  <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
+  <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
+  <link type="text/css" rel="stylesheet" href="styles/collapse.css">
+  <!-- start Mixpanel -->
+  <script type="text/javascript">(function(e,a){if(!a.__SV){var b=window;try{var c,l,i,j=b.location,g=j.hash;c=function(a,b){return(l=a.match(RegExp(b+"=([^&]*)")))?l[1]:null};g&&c(g,"state")&&(i=JSON.parse(decodeURIComponent(c(g,"state"))),"mpeditor"===i.action&&(b.sessionStorage.setItem("_mpcehash",g),history.replaceState(i.desiredHash||"",e.title,j.pathname+j.search)))}catch(m){}var k,h;window.mixpanel=a;a._i=[];a.init=function(b,c,f){function e(b,a){var c=a.split(".");2==c.length&&(b=b[c[0]],a=c[1]);b[a]=function(){b.push([a].concat(Array.prototype.slice.call(arguments,
+  0)))}}var d=a;"undefined"!==typeof f?d=a[f]=[]:f="mixpanel";d.people=d.people||[];d.toString=function(b){var a="mixpanel";"mixpanel"!==f&&(a+="."+f);b||(a+=" (stub)");return a};d.people.toString=function(){return d.toString(1)+".people (stub)"};k="disable time_event track track_pageview track_links track_forms register register_once alias unregister identify name_tag set_config reset people.set people.set_once people.increment people.append people.union people.track_charge people.clear_charges people.delete_user".split(" ");
+  for(h=0;h<k.length;h++)e(d,k[h]);a._i.push([b,c,f])};a.__SV=1.2;b=e.createElement("script");b.type="text/javascript";b.async=!0;b.src="undefined"!==typeof MIXPANEL_CUSTOM_LIB_URL?MIXPANEL_CUSTOM_LIB_URL:"file:"===e.location.protocol&&"//cdn.mxpnl.com/libs/mixpanel-2-latest.min.js".match(/^\/\//)?"https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js":"//cdn.mxpnl.com/libs/mixpanel-2-latest.min.js";c=e.getElementsByTagName("script")[0];c.parentNode.insertBefore(b,c)}})(document,window.mixpanel||[]);
+  mixpanel.init("1919205b2da72e4da3b9b6639b444d59");</script>
+  <!-- end Mixpanel -->
+</head>
+<body>
+  <svg style="display: none;">
+    <defs>
+      <symbol id="linkIcon" fill="#706d77" height="24" viewBox="0 0 24 24" width="24" xmlns="http://www.w3.org/2000/svg">
+          <path d="M0 0h24v24H0z" fill="none"/>
+          <path d="M3.9 12c0-1.71 1.39-3.1 3.1-3.1h4V7H7c-2.76 0-5 2.24-5 5s2.24 5 5 5h4v-1.9H7c-1.71 0-3.1-1.39-3.1-3.1zM8 13h8v-2H8v2zm9-6h-4v1.9h4c1.71 0 3.1 1.39 3.1 3.1s-1.39 3.1-3.1 3.1h-4V17h4c2.76 0 5-2.24 5-5s-2.24-5-5-5z"/>
+      </symbol>
+    </defs>
+  </svg>
+  <input type="checkbox" id="nav-trigger" class="nav-trigger" />
+  <label for="nav-trigger" class="navicon-button x">
+    <div class="navicon"></div>
+  </label>
+  <label for="nav-trigger" class="overlay"></label>
+  <div class="top-nav-wrapper">
+    <ul>
+      <li >
+        <a href="index.html">
+            <svg fill="#6D6D6D" height="24" viewBox="0 0 24 24" width="24" xmlns="http://www.w3.org/2000/svg">
+              <path d="M10 20v-6h4v6h5v-8h3L12 3 2 12h3v8z"/>
+              <path d="M0 0h24v24H0z" fill="none"/>
+            </svg>
+        </a>
+      </li>
+    </ul>
+  </div>
+  <nav>
+    <h3 class="reference-title">
+      @leofcoin/chain
+    </h3>
+      <h3>
+        Resources
+      </h3>
+        <a href="https://github.com/arteontoken/monorepo/tree/main/chain">github</a>
+    <h3 id="global-nav">Global</h3><ul><li><a href="global.html#addContract">addContract</a></li><li><a href="global.html#createRawTransaction">createRawTransaction</a></li><li><a href="global.html#createTransaction">createTransaction</a></li><li><a href="global.html#createTransactionFrom">createTransactionFrom</a></li><li><a href="global.html#createTransactionHash">createTransactionHash</a></li><li><a href="global.html#deployContract">deployContract</a></li><li><a href="global.html#lookup">lookup</a></li><li><a href="global.html#state">state</a></li></ul>
+  </nav>
+  <div id="main">
+      <h1 class="page-title">
+        chain.js
+      </h1>
+<section>
+  <article>
+    <pre class="prettyprint source linenums"><code>import { BigNumber, formatUnits, parseUnits } from '@leofcoin/utils'
+import Machine from './machine.js'
+import { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } from './../../messages/src/messages'
+import { addresses } from './../../addresses/src/addresses'
+import { contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, calculateFee } from './../../lib/src/lib'
+import MultiWallet from '@leofcoin/multi-wallet'
+import {CodecHash} from '@leofcoin/codec-format-interface/dist/index'
+import bs32 from '@vandeurenglenn/base32'
+import config from './config/config'
+import { formatBytes } from '../../utils/src/utils.js'
+globalThis.BigNumber = BigNumber
+// check if browser or local
+export default class Chain {
+  #validators = []
+  #blocks = []
+  #machine
+  #runningEpoch = false
+  #lastBlock = {index: 0, previousHash: '0x0'}
+  constructor() {
+    return this.#init()
+  }
+  get lib() {
+    return lib
+  }
+  get lastBlock() {
+    return this.#lastBlock
+  }
+  get nativeToken() {
+    return addresses.nativeToken
+  }
+  get validators() {
+    return [...this.#validators]
+  }
+  get blocks() {
+    return [...this.#blocks]
+  }
+  async hasTransactionToHandle() {
+    const size = await transactionPoolStore.size()
+    console.log({size});
+    if (size > 0) return true
+    return false
+  }
+  async #runEpoch() {
+    this.#runningEpoch = true
+    console.log('epoch');
+    const validators = await this.staticCall(addresses.validators, 'validators')
+    if (!validators[peernet.id]?.active) return
+    console.log('active');
+    const start = new Date().getTime()
+    try {
+      await this.#createBlock()
+    } catch (e) {
+      console.error(e);
+    }
+    const end = new Date().getTime()
+    console.log(((end - start) / 1000) + ' s');
+    if (await this.hasTransactionToHandle()) return this.#runEpoch()
+    this.#runningEpoch = false
+    // if (await this.hasTransactionToHandle() &amp;&amp; !this.#runningEpoch) return this.#runEpoch()
+  }
+  async #setup() {
+    await contractStore.put(addresses.contractFactory, contractFactoryMessage)
+    await contractStore.put(addresses.nativeToken, nativeTokenMessage)
+    await contractStore.put(addresses.validators, validatorsMessage)
+    await contractStore.put(addresses.nameService, nameServiceMessage)
+    console.log('handle native contracts');
+    // handle native contracts
+  }
+  async #sync() {
+    let promises = []
+    for (const peer of peernet.connections) {
+      if (peer.peerId !== this.id) {
+        let data = new peernet.protos['peernet-request']({request: 'lastBlock'})
+        const node = await peernet.prepareMessage(id, data.encoded)
+        promises.push(peer.request(node.encoded))
+      }
+    }
+    // if (this.)
+    promises = await Promise.allSettled(promises)
+    promises = promises.reduce((set, c) => {
+      if (c.index > set.index) {
+        set.index = c.index
+        set.hash = c.hash
+      }
+      return set
+    }, {index: 0, hash: '0x0'})
+    // get lastblock
+  }
+  async #init() {
+    // this.node = await new Node()
+    this.participants = []
+    this.participating = false
+    const initialized = await contractStore.has(addresses.contractFactory)
+    if (!initialized) await this.#setup()
+    this.#machine = await new Machine()
+    this.utils = { BigNumber, formatUnits, parseUnits }
+    try {
+      let localBlock = await chainStore.get('lastBlock')
+      localBlock = await peernet.get(new TextDecoder().decode(localBlock))
+      localBlock = await await new BlockMessage(localBlock)
+      this.#lastBlock = {...localBlock.decoded, hash: await localBlock.hash}
+      // console.log(this.lastBlock.decoded.transactions);
+    } catch (e) {
+      await this.#sync()
+      // this.#setup()
+    }
+    await peernet.addRequestHandler('bw-request-message', () => {
+      return new BWMessage(peernet.client.bw) || { up: 0, down: 0 }
+    })
+    await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this))
+    peernet.subscribe('add-block', this.#addBlock.bind(this))
+    peernet.subscribe('add-transaction', this.#addTransaction.bind(this))
+    pubsub.subscribe('peer:connected', this.#peerConnected.bind(this))
+    // load local blocks
+    await this.resolveBlocks()
+    return this
+  }
+  async #peerConnected(peer) {
+    let node = new peernet.protos['peernet-request']({request: 'lastBlock'})
+    node = await peernet.prepareMessage(peer.id, node.encoded)
+    let response = await peer.request(node.encoded)
+    response = new Uint8Array(Object.values(response))
+    const proto = new globalThis.peernet.protos['peernet-message'](response)
+    response = new globalThis.peernet.protos['peernet-response'](proto.decoded.data)
+    let lastBlock = JSON.parse(new TextDecoder().decode(response.decoded.response))
+    if (!this.lastBlock || this.lastBlock.index &lt; lastBlock.index) {
+         // TODO: check if valid
+      const localIndex = this.lastBlock ? this.lastBlock.index : 0
+      const index = lastBlock.index
+      await this.resolveBlock(lastBlock.hash)
+      this.#lastBlock = this.#blocks[this.#blocks.length - 1]
+      console.log({lastBlock: this.#lastBlock});
+      console.log(this.#blocks);
+      let blocksSynced = localIndex > 0 ? localIndex - index : index
+      blocksSynced += 1
+      debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`)
+      const end = this.#blocks.length
+      const start = (this.#blocks.length) - blocksSynced
+      await this.#loadBlocks(this.#blocks)
+      const message = await new BlockMessage(this.lastBlock)
+      await blockStore.put(await message.hash, message.encoded)
+      await chainStore.put('lastBlock', new TextEncoder().encode(this.lastBlock.hash))
+    }
+ }
+ #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 &amp;&amp; !this.#runningEpoch) this.#runEpoch()
+  } catch (e) {
+    throw Error('invalid transaction')
+  }
+}
+async #lastBlockHandler() {
+  return new peernet.protos['peernet-response']({response: new TextEncoder().encode(JSON.stringify({ hash: this.lastBlock?.hash, index: this.lastBlock?.index }))})
+}
+async resolveBlock(hash) {
+  let block = await peernet.get(hash, 'block')
+  if (!await peernet.has(hash, 'block')) await peernet.put(hash, block, 'block')
+  block = await new BlockMessage(block)
+  const size = block.encoded.length || block.encoded.byteLength
+  block = {...block.decoded, hash}
+  this.#blocks[block.index] = block
+  console.log(`loaded block: ${hash} @${block.index} ${formatBytes(size)}`);
+  if (block.index !== 0) {
+    return this.resolveBlock(block.previousHash)
+  }
+}
+  async resolveBlocks() {
+    try {
+      const localBlock = await chainStore.get('lastBlock')
+      const hash = new TextDecoder().decode(localBlock)
+      if (hash !== '0x0')
+        await this.resolveBlock(new TextDecoder().decode(localBlock))
+        this.#lastBlock = this.#blocks[this.#blocks.length - 1]
+        await this.#loadBlocks(this.#blocks)
+    } catch (e) {
+      await chainStore.put('lastBlock', new TextEncoder().encode('0x0'))
+      return this.resolveBlocks()
+// console.log(e);
+    }
+  }
+  async #loadBlocks(blocks) {
+    for (const block of blocks) {
+      if (!block.loaded) {
+        for (const transaction of block.transactions) {
+          try {
+            await this.#machine.execute(transaction.to, transaction.method, transaction.params)
+          } catch (e) {
+  console.log(e);
+          }
+        }
+        block.loaded = true
+        // 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
+      }
+    }
+  }
+  async #executeTransaction({hash, from, to, method, params, nonce}) {
+    try {
+      let result = await this.#machine.execute(to, method, params, from, nonce)
+      // if (!result) result = this.#machine.state
+      pubsub.publish(`transaction.completed.${hash}`, {status: 'fulfilled', hash})
+      return result ? result : 'no state change'
+    } catch (e) {
+      pubsub.publish(`transaction.completed.${hash}`, {status: 'fail', hash, error: e})
+      throw e
+    }
+  }
+  async #addBlock(block) {
+    const blockMessage = await new BlockMessage(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 deletions = 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)
+    this.#lastBlock = { hash, ...blockMessage.decoded }
+    await blockStore.put(hash, blockMessage.encoded)
+    await chainStore.put('lastBlock', new TextEncoder().encode(hash))
+    debug(`added block: ${hash}`)
+    let promises = []
+    let contracts = []
+    for (let transaction of blockMessage.decoded.transactions) {
+      // await transactionStore.put(transaction.hash, transaction.encoded)
+      const index = contracts.indexOf(transaction.to)
+      if (index === -1) contracts.push(transaction.to)
+      promises.push(this.#executeTransaction(transaction))
+    }
+    try {
+      promises = await Promise.allSettled(promises)
+      for (let transaction of blockMessage.decoded.transactions) {
+        await accountsStore.put(transaction.from, new TextEncoder().encode(String(transaction.nonce)))
+      }
+      // todo finish state
+      // for (const contract of contracts) {
+      //   const state = await this.#machine.get(contract, 'state')
+      //   // await stateStore.put(contract, state)
+      //   console.log(state);
+      // }
+      pubsub.publish('block-processed', blockMessage.decoded)
+    } catch (e) {
+      console.log(e);
+    }
+  }
+  async #updateState() {
+  }
+  async participate() {
+    // TODO: validate participant
+    // hold min amount of 50k ART for 7 days
+    // lock the 50k
+    // introduce peer-reputation
+    // peerReputation(peerId)
+    // {bandwith: {up, down}, uptime}
+    this.participating = true
+    if (!await this.staticCall(addresses.validators, 'has', [peernet.id])) await this.createTransactionFrom(peernet.id, addresses.validators, 'addValidator', [peernet.id])
+    if (await this.hasTransactionToHandle() &amp;&amp; !this.#runningEpoch) await this.#runEpoch()
+    // const runEpoch = () => setTimeout(async () => {
+    //   if (await this.hasTransactionToHandle() &amp;&amp; !this.#runningEpoch) await this.#runEpoch()
+    //   runEpoch()
+    // }, 5000)
+    // runEpoch()
+  }
+  calculateFee(transaction) {
+    // excluded from fees
+    // if (transaction.decoded.to === addresses.validators) return 0
+    // fee per gb
+    return (transaction.encoded.length / 1024) / 1e-6
+  }
+  async getTransactions (transactions) {
+    return new Promise(async (resolve, reject) => {
+      let size = 0
+      const _transactions = []
+      const promises = await Promise.all(Object.values(transactions)
+        .map(tx => new TransactionMessage(new Uint8Array(tx, tx.byteOffset, tx.byteLength))))
+      for (let transaction of promises) {
+        size += transaction.encoded.length
+        if ((size / 1024) / 1024 &lt;= 1.15 ) _transactions.push({...transaction.decoded, hash: await transaction.hash })
+        else return resolve(_transactions)
+      }
+      return resolve(_transactions)
+    })
+  }
+  async #createBlock() {
+    let transactions = await transactionPoolStore.get()
+    if (Object.keys(transactions)?.length === 0 ) return
+    let block = {
+      transactions: [],
+      validators: [],
+      fees: 0
+    }
+    // exclude failing tx
+    transactions = await this.getTransactions(transactions)
+    transactions = transactions.sort((a, b) => a.nonce - b.nonce)
+    for (let transaction of transactions) {
+      try {
+        await this.#executeTransaction(transaction)
+        block.transactions.push(transaction)
+        block.fees += Number(calculateFee(transaction))
+        await accountsStore.put(transaction.from, new TextEncoder().encode(String(transaction.nonce)))
+      } catch (e) {
+        console.error(e)
+        transaction = await new TransactionMessage(transaction)
+        await transactionPoolStore.delete(await transaction.hash)
+console.log(e);
+      }
+    }
+    // don't add empty block
+    if (block.transactions.length === 0) return
+    const validators = await this.staticCall(addresses.validators, 'validators')
+    console.log({validators});
+    // block.validators = Object.keys(block.validators).reduce((set, key) => {
+    //   if (block.validators[key].active) {
+    //     push({
+    //       address: key
+    //     })
+    //   }
+    // }, [])
+    const peers = {}
+    for (const entry of peernet.peerEntries) {
+      peers[entry[0]] = entry[1]
+    }
+    for (const validator of Object.keys(validators)) {
+      if (validators[validator].active) {
+        const peer = peers[validator]
+        if (peer &amp;&amp; peer.connected) {
+          let data = await new BWRequestMessage()
+          const node = await peernet.prepareMessage(validator, data.encoded)
+          try {
+            const bw = await peer.request(node.encoded)
+            console.log(bw);
+            block.validators.push({
+              address: validator,
+              bw: bw.up + bw.down
+            })
+          } catch(e) {
+          }
+        } else if (peernet.id === validator) {
+          block.validators.push({
+            address: peernet.id,
+            bw: peernet.bw.up + peernet.bw.down
+          })
+          }
+        }
+    }
+    console.log({validators: block.validators});
+    block.reward = 150
+    block.validators = block.validators.map(validator => {
+      validator.reward = String(Number(block.fees) + block.reward / block.validators.length)
+      delete validator.bw
+      return validator
+    })
+    // block.validators = calculateValidatorReward(block.validators, block.fees)
+    block.index = this.lastBlock?.index
+    if (block.index === undefined) block.index = 0
+    else block.index += 1
+    block.previousHash = this.lastBlock?.hash || '0x0'
+    block.timestamp = new Date().getTime()
+    const parts = String(block.fees).split('.')
+    let decimals = 0
+    if (parts[1]) {
+      const potentional = parts[1].split('e')
+      if (potentional[0] !== parts[1]) {
+        parts[1] = potentional[0]
+        decimals = Number(potentional[1]?.replace(/\-|\+/g, '')) + Number(potentional[0].length)
+      } else {
+        decimals = parts[1].length
+      }
+    }
+    block.fees = Number.parseFloat(String(block.fees)).toFixed(decimals)
+    try {
+      let blockMessage = await new BlockMessage(block)
+      const hash = await blockMessage.hash
+      await Promise.all(blockMessage.decoded.transactions
+        .map(async transaction => transactionPoolStore.delete(await transaction.hash)))
+      this.#lastBlock = { hash, ...blockMessage.decoded }
+      await blockStore.put(hash, blockMessage.encoded)
+      await chainStore.put('lastBlock', new TextEncoder().encode(hash))
+      debug(`created block: ${hash}`)
+      peernet.publish('add-block', blockMessage.encoded)
+      this.#updateState(blockMessage)
+    } catch (e) {
+      console.log(e);
+      throw Error(`invalid block ${block}`)
+    }
+    // data = await this.#machine.execute(to, method, params)
+    // 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.get()
+    transactions = await this.promiseTransactions(Object.values(transactions))
+    transactions = transactions.filter(tx => tx.decoded.from === address)
+    transactions = await this.promiseTransactionsContent(transactions)
+    if (this.lastBlock &amp;&amp; transactions.length === 0) {
+      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 &amp;&amp; block.decoded.index !== 0) {
+        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)))
+    }
+    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, params, nonce, signature) {
+    return this.createTransactionFrom(peernet.id, to, method, params, 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, wallet)
+    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.id
+    transaction.timestamp = Date.now()
+    if (transaction.nonce === undefined) {
+      transaction.nonce = await this.getNonce(transaction.from)
+      transaction.nonce += 1
+      await accountsStore.put(transaction.from, new TextEncoder().encode(String(transaction.nonce)))
+    } else {
+      let nonce = await accountsStore.get(transaction.from)
+      nonce = new TextDecoder().decode(nonce)
+      if (transaction.nonce &lt; nonce) throw Error(`a transaction with a higher nonce already exists`)
+      if (transaction.nonce === nonce) throw 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 {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, params, nonce) {
+    try {
+      const rawTransaction = await this.createRawTransaction({from, to, nonce, method, params})
+      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)
+            }, 10000)
+          }
+          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 (e) {
+      console.log(e);
+      throw e
+    }
+  }
+  async createContractMessage(creator, contract, constructorParameters = []) {
+    return new ContractMessage({
+      creator,
+      contract,
+      constructorParameters
+    })
+  }
+  async createContractAddress(creator, contract, constructorParameters = []) {
+    contract = await this.createContractMessage(creator, contract, constructorParameters)
+    return contract.hash
+  }
+  /**
+   *
+   * @param {String} contract - a contract string (see plugins/deployContract)
+   */
+  async deployContract(contract, params = []) {
+    globalThis.msg = {sender: peernet.id, call: this.call}
+    const hash = await this.createContractAddress(creator, contract, params)
+    try {
+      const tx = await this.createTransactionFrom(peernet.id, addresses.contractFactory, 'deployContract', [hash, creator, contract, constructorParameters])
+    } catch (e) {
+      throw e
+    }
+    return this.#machine.addContract(message)
+  }
+  #createMessage(sender = peernet.id) {
+    return {
+      sender: peernet.id,
+      call: this.call,
+      staticCall: this.staticCall,
+      delegate: this.delegate,
+      staticDelegate: this.staticDelegate
+    }
+  }
+  internalCall(sender, contract, method, params) {
+    globalThis.msg = this.#createMessage(sender)
+    return this.#machine.execute(contract, method, params)
+  }
+  call(contract, method, params) {
+    globalThis.msg = this.#createMessage()
+    return this.#machine.execute(contract, method, params)
+  }
+  staticCall(contract, method, params) {
+    globalThis.msg = this.#createMessage()
+    return this.#machine.get(contract, method, params)
+  }
+  delegate(contract, method, params) {
+    globalThis.msg = this.#createMessage()
+    return this.#machine.execute(contract, method, params)
+  }
+  staticDelegate(contract, method, params) {
+    globalThis.msg = this.#createMessage()
+    return this.#machine.get(contract, method, params)
+  }
+  mint(to, amount) {
+    return this.call(addresses.nativeToken, 'mint', [to, amount])
+  }
+  transfer(from, to, amount) {
+    return this.call(addresses.nativeToken, 'transfer', [from, to, amount])
+  }
+  get balances() {
+    return this.staticCall(addresses.nativeToken, 'balances')
+  }
+  deleteAll() {
+    return this.#machine.deleteAll()
+  }
+  /**
+   * lookup an address for a registered name using the builtin nameService
+   * @check nameService
+   *
+   * @param {String} - contractName
+   * @returns {String} - address
+   *
+   * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
+   */
+  lookup(name) {
+    return this.call(addresses.nameService, 'lookup', [name])
+  }
+}
+</code></pre>
+  </article>
+</section>
+  </div>
+  <br class="clear">
+  <footer>
+    Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.6.11</a>
+  </footer>
+  <script src="scripts/linenumber.js"></script>
+  <script src="scripts/pagelocation.js"></script>
+</body>
+</html>