@leofcoin/chain 1.4.20 → 1.4.22

package/src/config/config.js

@@ -1,14 +1,14 @@
-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
-// }
+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 +1,4 @@
-export default {
-  datadir: '',
-  configPath: ''
-}
+export default {
+  datadir: '',
+  configPath: ''
+}

package/src/config/protocol.js

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

package/src/contract.js

@@ -1,52 +1,52 @@
-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()])    
-  }
-  
+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 +1,3 @@
-export default {
-  deployment: 0.000_001
-}
+export default {
+  deployment: 0.000_001
+}

package/src/machine.js

@@ -1,215 +1,215 @@
-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)
-  }
-}
+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.js

@@ -1,24 +1,24 @@
-// 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
-  }) {
-    globalThis.Peernet ? await new globalThis.Peernet(config) : await new Peernet(config)
-    await nodeConfig(config)
-
-    return this
-    // this.config = await config()
-  }
-
-}
+// 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
+  }) {
+    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 +1,4 @@
-export default class Protocol {
-  limit = 1800
-  transactionLimit = 1800
+export default class Protocol {
+  limit = 1800
+  transactionLimit = 1800
 }