@leofcoin/chain 1.4.21 → 1.4.23

package/src/config/config.js

@@ -1,14 +0,0 @@
-import main from './main'
-import protocol from './protocol'
-
-// export default async () => {
-//   let config = { ...main, protocol }
-//   try {
-//     let data = await read(main.configPath)
-//     data = JSON.parse(data.toString())
-//     config = { ...config, ...data }
-//   } catch (e) {
-//     await write(main.configPath, JSON.stringify(config, null, '\t'))
-//   }
-//   return config
-// }

package/src/config/main.js

@@ -1,4 +0,0 @@
-export default {
-  datadir: '',
-  configPath: ''
-}

package/src/config/protocol.js

@@ -1,5 +0,0 @@
-export default {
-  block: {
-    size: 1024
-  }
-}

package/src/contract.js

@@ -1,52 +0,0 @@
-import Transaction from "./transaction.js";
-import { createContractMessage } from '@leofcoin/lib'
-import addresses from "@leofcoin/addresses"
-
-/**
- * @extends {Transaction}
- */
-export default 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()])    
-  }
-  
-}

package/src/fee/config.js

@@ -1,3 +0,0 @@
-export default {
-  deployment: 0.000_001
-}

package/src/machine.js

@@ -1,215 +0,0 @@
-import { contractFactory, nativeToken, validators, nameService } from '@leofcoin/addresses'
-import { randombytes } from '@leofcoin/crypto'
-import EasyWorker from '@vandeurenglenn/easy-worker'
-import { ContractMessage } from '@leofcoin/messages'
-// import State from './state'
-
-export default class Machine {
-  #contracts = {}
-  #nonces = {}
-  lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
-
-  constructor(blocks) {
-    return this.#init(blocks)
-  }
-
-  #createMessage(sender = peernet.selectedAccount) {
-    return {
-      sender,
-      call: this.execute,
-      staticCall: this.get.bind(this)
-    }
-  }
-
-  async #onmessage(data) {
-    switch (data.type) {
-      case 'contractError': {
-        console.warn(`removing contract ${await data.hash()}`);
-        await contractStore.delete(await data.hash())  
-        break
-      }
-
-      case 'initError': {
-        console.error(`init error: ${data.message}`);       
-        break
-      }
-
-      case 'executionError': {
-        // console.warn(`error executing transaction ${data.message}`);
-        pubsub.publish(data.id, {error: data.message})
-      break
-      }
-
-      case 'debug': {
-        for (const message of data.messages) debug(message)
-      break
-      }
-      case 'machine-ready': {
-        this.lastBlock = data.lastBlock
-        pubsub.publish('machine.ready', true)
-      break
-      }
-      case 'response': {
-        pubsub.publish(data.id, data.value || false)
-      break
-      }
-    }
-    
-  }
-
-  async #init(blocks) {
-    return new Promise(async (resolve) => {
-      const machineReady = () => {
-        pubsub.unsubscribe('machine.ready', machineReady)
-        resolve(this)
-      }
-      pubsub.subscribe('machine.ready', machineReady)
-
-      this.worker = await new EasyWorker('node_modules/@leofcoin/workers/src/machine-worker.js', {serialization: 'advanced', type:'module'})
-      this.worker.onmessage(this.#onmessage.bind(this))
-
-      // const blocks = await blockStore.values()
-      const contracts = await Promise.all([
-        contractStore.get(contractFactory),
-        contractStore.get(nativeToken),
-        contractStore.get(validators),
-        contractStore.get(nameService)
-      ])
-      
-      const message = {
-        type: 'init',
-        input: {
-          contracts,
-          blocks,
-          peerid: peernet.peerId
-        }
-      }
-      this.worker.postMessage(message)
-    })
-    
-  }
-
-  async #runContract(contractMessage) {
-    const hash = await contractMessage.hash()
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString('hex')
-      const onmessage = message => {        
-        pubsub.unsubscribe(id, onmessage)
-        if (message?.error) reject(message.error)
-        else resolve(message)
-      }
-      pubsub.subscribe(id, onmessage)
-      this.worker.postMessage({
-        type: 'run',
-        id,
-        input: {
-          decoded: contractMessage.decoded,
-          encoded: contractMessage.encoded,
-          hash 
-        }
-      })
-    })
-    
-  }
-
-  /**
-   * 
-   * @param {Address} contract 
-   * @param {String} method 
-   * @param {Array} parameters 
-   * @returns Promise<message>
-   */
-  async execute(contract, method, parameters) {
-    try {
-      if (contract === contractFactory && method === 'registerContract') {
-        if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`)
-        let message;
-        if (!await contractStore.has(parameters[0])) {
-          message = await peernet.get(parameters[0], 'contract')
-          message = await new ContractMessage(message)
-          await contractStore.put(await message.hash(), message.encoded)
-        }
-        if (!message) {
-          message = await contractStore.get(parameters[0])
-          message = await new ContractMessage(message)
-        }
-        if (!await this.has(await message.hash())) await this.#runContract(message)
-      }
-    } catch (error) {
-      throw new Error(`contract deployment failed for ${parameters[0]}\n${error.message}`)
-    }
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString('hex')
-      const onmessage = message => {
-        pubsub.unsubscribe(id, onmessage)
-        if (message?.error) reject(message.error)
-        else resolve(message)
-      }
-      pubsub.subscribe(id, onmessage)
-      this.worker.postMessage({
-        type: 'execute',
-        id,
-        input: {
-          contract,
-          method,
-          params: parameters
-        }
-      })
-    })
-    
-  }
-
-  get(contract, method, parameters) {
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString()
-      const onmessage = message => {
-        pubsub.unsubscribe(id, onmessage)
-        resolve(message)
-      }
-      pubsub.subscribe(id, onmessage)
-      this.worker.postMessage({
-        type: 'get',
-        id,
-        input: {
-          contract,
-          method,
-          params: parameters
-        }
-      })
-    })
-  }
-
-
-  async has(address) {
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString('hex')
-      const onmessage = message => {        
-        pubsub.unsubscribe(id, onmessage)
-        if (message?.error) reject(message.error)
-        else resolve(message)
-      }
-      pubsub.subscribe(id, onmessage)
-      this.worker.postMessage({
-        type: 'has',
-        id,
-        input: {
-          address 
-        }
-      })
-    })
-  }
-
-  async delete(hash) {
-    return contractStore.delete(hash)
-  }
-
-  /**
-   * 
-   * @returns Promise
-   */
-  async deleteAll() {
-    let hashes = await contractStore.get()
-    hashes = Object.keys(hashes).map(hash => this.delete(hash))
-    return Promise.all(hashes)
-  }
-}

package/src/node.ts

@@ -1,24 +0,0 @@
-// import config from './config/config'
-import Peernet from '@leofcoin/peernet'
-import nodeConfig from '@leofcoin/lib/node-config';
-import networks from '@leofcoin/networks';
-
-export default class Node {
-  constructor() {
-    return this._init()
-  }
-
-  async _init(config = {
-    network: 'leofcoin:peach',
-    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)
-
-    return this
-    // this.config = await config()
-  }
-
-}

package/src/protocol.js

@@ -1,4 +0,0 @@
-export default class Protocol {
-  limit = 1800
-  transactionLimit = 1800
-}

package/src/state.js

@@ -1,31 +0,0 @@
-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

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

@@ -1,21 +0,0 @@
-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 +0,0 @@
-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
-}