@leofcoin/chain 1.3.10 → 1.3.12

package/dist/wrtc.browser.js

@@ -0,0 +1,28 @@
+(self["webpackChunk_leofcoin_chain"] = self["webpackChunk_leofcoin_chain"] || []).push([[228],{
+
+/***/ 9347:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+
+exports.MediaStream = window.MediaStream;
+exports.MediaStreamTrack = window.MediaStreamTrack;
+exports.RTCDataChannel = window.RTCDataChannel;
+exports.RTCDataChannelEvent = window.RTCDataChannelEvent;
+exports.RTCDtlsTransport = window.RTCDtlsTransport;
+exports.RTCIceCandidate = window.RTCIceCandidate;
+exports.RTCIceTransport = window.RTCIceTransport;
+exports.RTCPeerConnection = window.RTCPeerConnection;
+exports.RTCPeerConnectionIceEvent = window.RTCPeerConnectionIceEvent;
+exports.RTCRtpReceiver = window.RTCRtpReceiver;
+exports.RTCRtpSender = window.RTCRtpSender;
+exports.RTCRtpTransceiver = window.RTCRtpTransceiver;
+exports.RTCSctpTransport = window.RTCSctpTransport;
+exports.RTCSessionDescription = window.RTCSessionDescription;
+exports.getUserMedia = window.getUserMedia;
+exports.mediaDevices = navigator.mediaDevices;
+
+
+/***/ })
+
+}])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.3.10",
+  "version": "1.3.12",
   "description": "Official javascript implementation",
   "main": "./dist/node.js",
   "module": "./dist/chain.esm",
@@ -35,11 +35,13 @@
     "path-browserify": "^1.0.1",
     "rollup": "^2.70.1",
     "rollup-plugin-cleanup": "^3.2.1",
+    "rollup-plugin-modify": "^3.0.0",
     "rollup-plugin-terser": "^7.0.2",
     "stream-browserify": "^3.0.0",
     "tape": "^5.5.2",
     "terser": "^5.16.0",
     "vm-browserify": "^1.1.2",
+    "webpack": "^5.75.0",
     "webpack-cli": "^4.9.2"
   },
   "dependencies": {
@@ -59,8 +61,7 @@
     "@vandeurenglenn/easy-worker": "^1.0.1",
     "@vandeurenglenn/queue": "^1.0.0",
     "chalk": "^4.0.0",
-    "pako": "^2.0.4",
-    "webpack": "^5.74.0"
+    "pako": "^2.0.4"
   },
   "eslintConfig": {
     "env": {

package/rollup.config.js

@@ -1,6 +1,7 @@
 import json from '@rollup/plugin-json'
 import strip from '@rollup/plugin-strip';
 import { terser } from "rollup-plugin-terser";
+import modify from 'rollup-plugin-modify'
 
 import { execSync } from 'node:child_process'
 
@@ -12,49 +13,38 @@ try {
 }
 export default [{
   input: ['./src/chain.js'],
-  output: {
+  output: [{
     dir: './dist',
     format: 'cjs'
-  },
-  plugins: [
-    json(),
-    // terser({
-    //   keep_classnames: true
-    // }),
-  ]
-}, {
-  input: ['./src/node.js'],
-  output: {
-    dir: 'dist',
-    format: 'cjs'
-  },
-  plugins: [
-    json(),
-    // terser({
-    //   keep_classnames: true
-    // }),
-    // cjs()
-  ]
-}, {
-  input: ['./src/chain.js'],
-  output: {
+  }, {
     dir: './dist/module',
     format: 'es'
-  },
+  }],
   plugins: [
     json(),
+    modify({
+      'node:path': 'path',
+      'node:crypto': 'crypto'
+    })
     // terser({
     //   keep_classnames: true
     // }),
   ]
 }, {
   input: ['./src/node.js'],
-  output: {
+  output: [{
+    dir: 'dist',
+    format: 'cjs'
+  }, {
     dir: 'dist/module',
     format: 'es'
-  },
+  }],
   plugins: [
     json(),
+    modify({
+      'node:path': 'path',
+      'node:crypto': 'crypto'
+    })
     // terser({
     //   keep_classnames: true
     // }),

package/src/chain.js

@@ -1,31 +1,97 @@
 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 { createContractMessage, 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 addresses, { nativeToken } from './../../addresses/src/addresses'
+import { contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, calculateFee } from './../../lib/src/lib'
 import { formatBytes } from '../../utils/src/utils.js'
+import State from './state.js'
+import Contract from './contract.js'
 
 globalThis.BigNumber = BigNumber
 
 // check if browser or local
-export default class Chain {
+export default class Chain  extends Contract {
+  /** {Address[]} */
   #validators = []
+  /** {Block[]} */
   #blocks = []
+
   #machine
+  /** {Boolean} */
   #runningEpoch = false
+
+  /** {Boolean} */
   #chainSyncing = false
+
+  /** {Number} */
+  #totalSize = 0
+
+  /** 
+   * {Block} {index, hash, previousHash}
+   */
   #lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
+
+  /** 
+   * amount the native token has been iteracted with
+   */
+  #nativeCalls = 0
+
+  /** 
+   * amount the native token has been iteracted with
+   */
+   #nativeTransfers = 0
+
+  /** 
+   * amount of native token burned
+   * {Number}
+   */
+  #nativeBurns = 0
+
+  /** 
+   * amount of native tokens minted
+   * {Number}
+   */
+  #nativeMints = 0
+
+  /** 
+   * total amount of transactions
+   * {Number}
+   */
+   #totalTransactions = 0
+
   #participants = []
   #participating = false
   #jail = []
 
   constructor() {
+    super()
     return this.#init()
   }
 
+  get nativeMints() {
+    return this.#nativeMints
+  }
+
+  get nativeBurns() {
+    return this.#nativeBurns
+  }
+  
+  get nativeTransfers() {
+    return this.#nativeTransfers
+  }
+
+  get totalTransactions() {
+    return this.#totalTransactions
+  }
+
+  get nativeCalls() {
+    return this.#nativeCalls
+  }
+
+  get totalSize() {
+    return this.#totalSize
+  }
+
   get lib() {
     return lib
   }
@@ -161,6 +227,8 @@ export default class Chain {
 
    
     this.utils = { BigNumber, formatUnits, parseUnits }
+
+    this.state = new State()
     
     try {
       let localBlock
@@ -244,16 +312,6 @@ export default class Chain {
 
  #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 && !this.#runningEpoch) this.#runEpoch()
-  } catch {
-    throw new Error('invalid transaction')
-  }
-}
 
 async #lastBlockHandler() {
   return new peernet.protos['peernet-response']({response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index }})
@@ -265,6 +323,7 @@ async resolveBlock(hash) {
   block = await new BlockMessage(block)
   if (!await peernet.has(hash, 'block')) await peernet.put(hash, block.encoded, 'block')
   const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength
+  this.#totalSize += size
   block = {...block.decoded, hash}
   if (this.#blocks[block.index] && this.#blocks[block.index].hash !== block.hash) throw `invalid block ${hash} @${block.index}`
   this.#blocks[block.index] = block
@@ -290,37 +349,29 @@ async resolveBlock(hash) {
     }
   }
 
+  /**
+   * 
+   * @param {Block[]} blocks 
+   */
   async #loadBlocks(blocks) {
     for (const block of blocks) {
       if (block && !block.loaded) {
         for (const transaction of block.transactions) {
           try {
             await this.#machine.execute(transaction.to, transaction.method, transaction.params)
-
+            if (transaction.to === nativeToken) {
+              this.#nativeCalls += 1
+              if (transaction.method === 'burn') this.#nativeBurns += 1
+              if (transaction.method === 'mint') this.#nativeMints += 1
+              if (transaction.method === 'transfer') this.#nativeTransfers += 1
+            }
+            this.#totalTransactions += 1
           } catch (error) {
   console.log(error);
           }
         }
         this.#blocks[block.index].loaded = true
-        console.log(`loaded block: ${block.hash} @${block.index}`);
-        // 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
+        debug(`loaded block: ${block.hash} @${block.index}`);
       }
     }
   }
@@ -340,25 +391,9 @@ async resolveBlock(hash) {
   async #addBlock(block) {
     // console.log(block);
     const blockMessage = await new BlockMessage(new Uint8Array(Object.values(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
+    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)
     
     await blockStore.put(hash, blockMessage.encoded)
     
@@ -401,6 +436,7 @@ async resolveBlock(hash) {
   async #updateState(message) {
     const hash = await message.hash
     this.#lastBlock = { hash, ...message.decoded }
+    await this.state.updateState(message)
     await chainStore.put('lastBlock', hash)
   }
 
@@ -416,12 +452,6 @@ async resolveBlock(hash) {
     this.#participating = true
     if (!await this.staticCall(addresses.validators, 'has', [address])) await this.createTransactionFrom(address, addresses.validators, 'addValidator', [address])
     if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
-    
-    // const runEpoch = () => setTimeout(async () => {
-    //   if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
-    //   runEpoch()
-    // }, 5000)
-    // runEpoch()
   }
 
   calculateFee(transaction) {
@@ -431,25 +461,6 @@ async resolveBlock(hash) {
     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(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)
-    })
-    
-  }
-
   // todo filter tx that need to wait on prev nonce
   async #createBlock(limit = 1800) {
     // vote for transactions
@@ -575,58 +586,18 @@ async resolveBlock(hash) {
     // 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.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 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)))
+  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 && !this.#runningEpoch) this.#runEpoch()
+    } catch {
+      throw new Error('invalid transaction')
     }
-    let nonce = await accountsStore.get(address)
-    nonce = new TextDecoder().decode(nonce)
-    return Number(nonce)
   }
-
   /**
    * whenever method = createContract params should hold the contract hash
    *
@@ -638,72 +609,9 @@ async resolveBlock(hash) {
    * @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) {
+   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))
-}
-
-  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, account)
-    transaction.signature = bs32.encode(transaction.signature)
-    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 createRawTransaction(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
@@ -715,83 +623,10 @@ async #signTransaction (transaction, wallet) {
    * @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.createRawTransaction({from, to, nonce, method, params: parameters})    
-      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)
-            }, 10_000)
-          }
-          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)
-      debug('creating tx')
-      return {hash: await message.hash, data, fee: await calculateFee(message.decoded), wait}
-    } catch (error) {
-      console.log(error)
-      throw error
-    }
-    
-  }
-
-  /**
-   * 
-   * @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])    
+   async createTransactionFrom(from, to, method, parameters, nonce) {
+    const event = await super.createTransactionFrom(from, to, method, parameters, nonce)
+    this.#addTransaction(event.message.encoded)
+    return event    
   }
 
   /**

package/src/contract.js

@@ -0,0 +1,51 @@
+import Transaction from "./transaction";
+import { createContractMessage } from './../../lib/src/lib'
+
+/**
+ * @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/protocol.js

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

package/src/state.js

@@ -15,7 +15,7 @@ export default class State {
   // }
 
   async put(key, value, isCompressed = true) {
-    value = isCompressed ? isCompressed : await pako.deflate(value)
+    value = isCompressed ? value : await pako.deflate(value)
     await stateStore.put(key, value)
   }
 
@@ -26,6 +26,6 @@ export default class State {
 
   updateState(block) {
     // block.decoded.index
-    this.#isUpdateNeeded()
+    // this.#isUpdateNeeded()
   }
 }