@leofcoin/chain 1.4.21 → 1.4.22

package/src/state.js

@@ -1,31 +1,31 @@
-import pako from 'pako'
-
-export default 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 = true ? pako.inflate(value) : value
-  }
-
-  updateState(block) {
-    // block.decoded.index
-    // this.#isUpdateNeeded()
-  }
-}
+import pako from 'pako'
+
+export default 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 = true ? pako.inflate(value) : value
+  }
+
+  updateState(block) {
+    // block.decoded.index
+    // this.#isUpdateNeeded()
+  }
+}

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

@@ -1,182 +1,234 @@
-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
-    }
-    
-  }
+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/src/type.index.d.ts

@@ -1,21 +1,21 @@
-type Address = string
-
-interface Transaction {
-  to: Address,
-  from: Address,
-  method: String,
-  params: string[],
-  nonce: Number
-}
-
-interface RawTransaction extends Transaction {
-  timestamp: Number
-}
-
-interface globalMessage {
-  sender: Address,
-  call: Function,
-  staticCall: Function,
-  delegate: Function,
-  staticDelegate: Function
+type Address = string
+
+interface Transaction {
+  to: Address,
+  from: Address,
+  method: String,
+  params: string[],
+  nonce: Number
+}
+
+interface RawTransaction extends Transaction {
+  timestamp: Number
+}
+
+interface globalMessage {
+  sender: Address,
+  call: Function,
+  staticCall: Function,
+  delegate: Function,
+  staticDelegate: Function
 }

package/src/typer.js

@@ -1,19 +1,19 @@
-import {BigNumber} from '@leofcoin/utils'
-
-const codec = '0x'
-
-const isAddress = address => {
-  if (!address.startsWith(codec)) return false
-  if (address.length !== 64) return false
-}
-
-export default {
-  isType: (type, value) => {
-    type = type.toLowercase()
-    if (type === 'string') return typeof(value) === type
-    if (type === 'number') return !Number.isNaN(Number(value))
-    if (type === 'address') return isAddress(value)
-    if (type === 'BigNumber') return BigNumber.isBigNumber(value)
-  },
-  isAddress
-}
+import {BigNumber} from '@leofcoin/utils'
+
+const codec = '0x'
+
+const isAddress = address => {
+  if (!address.startsWith(codec)) return false
+  if (address.length !== 64) return false
+}
+
+export default {
+  isType: (type, value) => {
+    type = type.toLowercase()
+    if (type === 'string') return typeof(value) === type
+    if (type === 'number') return !Number.isNaN(Number(value))
+    if (type === 'address') return isAddress(value)
+    if (type === 'BigNumber') return BigNumber.isBigNumber(value)
+  },
+  isAddress
+}