@leofcoin/chain 1.0.21 → 1.0.24

package/src/chain.js

@@ -1,10 +1,16 @@
 import { BigNumber, formatUnits, parseUnits } from '@leofcoin/utils'
-import Machine from './machine'
-import lib from '@leofcoin/lib'
+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
 
-const { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } = lib
 // check if browser or local
 export default class Chain {
   #validators = []
@@ -26,7 +32,7 @@ export default class Chain {
   }
 
   get nativeToken() {
-    return lib.nativeToken
+    return addresses.nativeToken
   }
 
   get validators() {
@@ -39,28 +45,39 @@ export default class Chain {
 
   async hasTransactionToHandle() {
     const size = await transactionPoolStore.size()
+    console.log({size});
     if (size > 0) return true
     return false
   }
 
   async #runEpoch() {
-    const validators = await this.staticCall(lib.validators, 'validators')
+    this.#runningEpoch = true
+    console.log('epoch');
+    const validators = await this.staticCall(addresses.validators, 'validators')
     if (!validators[peernet.id]?.active) return
+    console.log('active');
 
-    this.#runningEpoch = true
+    
     const start = new Date().getTime()
-    await this.#createBlock()
+    try {
+      await this.#createBlock()
+    } catch (e) {
+      console.error(e);
+    }
+    
     const end = new Date().getTime()
-    console.log((end - start) / 1000 + ' s');
+    console.log(((end - start) / 1000) + ' s');
+    
     if (await this.hasTransactionToHandle()) return this.#runEpoch()
     this.#runningEpoch = false
+    // if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
   }
 
   async #setup() {
-    await contractStore.put(lib.contractFactory, lib.contractFactoryMessage)
-    await contractStore.put(lib.nativeToken, lib.nativeTokenMessage)
-    await contractStore.put(lib.validators, lib.validatorsMessage)
-    await contractStore.put(lib.nameService, lib.nameServiceMessage)
+    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
   }
@@ -79,7 +96,6 @@ export default class Chain {
 
     promises = await Promise.allSettled(promises)
     promises = promises.reduce((set, c) => {
-      console.log({c});
       if (c.index > set.index) {
         set.index = c.index
         set.hash = c.hash
@@ -92,7 +108,8 @@ export default class Chain {
   async #init() {
     // this.node = await new Node()
     this.participants = []
-    const initialized = await contractStore.has(lib.contractFactory)
+    this.participating = false
+    const initialized = await contractStore.has(addresses.contractFactory)
     if (!initialized) await this.#setup()
 
     this.#machine = await new Machine()
@@ -101,8 +118,8 @@ export default class Chain {
     try {
       let localBlock = await chainStore.get('lastBlock')
       localBlock = await peernet.get(new TextDecoder().decode(localBlock))
-      localBlock = new BlockMessage(localBlock)
-      this.#lastBlock = {...localBlock.decoded, hash: localBlock.hash}
+      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()
@@ -118,15 +135,7 @@ export default class Chain {
 
     peernet.subscribe('add-block', this.#addBlock.bind(this))
 
-    peernet.subscribe('add-transaction', async transaction => {
-      try {
-        transaction = new TransactionMessage(transaction)
-        await transactionPoolStore.put(transaction.hash, transaction.encoded)
-        if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
-      } catch (e) {
-        throw Error('invalid transaction')
-      }
-    })
+    peernet.subscribe('add-transaction', this.#addTransaction.bind(this))
 
     pubsub.subscribe('peer:connected', this.#peerConnected.bind(this))
 
@@ -159,28 +168,41 @@ export default class Chain {
       const end = this.#blocks.length
       const start = (this.#blocks.length) - blocksSynced
       await this.#loadBlocks(this.#blocks)
-      const message = new BlockMessage(this.lastBlock)
-      await blockStore.put(message.hash, message.encoded)
+      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))
     }
  }
 
-  async #lastBlockHandler() {
-    return new peernet.protos['peernet-response']({response: new TextEncoder().encode(JSON.stringify({ hash: this.lastBlock?.hash, index: this.lastBlock?.index }))})
+ #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 (e) {
+    throw Error('invalid transaction')
   }
+}
 
-  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} ${Math.round((size / 1024 / 1024) * 100) / 100} mb`);
-    if (block.index !== 0) {
-      return this.resolveBlock(block.previousHash)
-    }
+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 {
@@ -245,7 +267,7 @@ export default class Chain {
   }
 
   async #addBlock(block) {
-    const blockMessage = new BlockMessage(block)
+    const blockMessage = await new BlockMessage(block)
     // if (!Buffer.isBuffer(block)) block = Buffer.from(block, 'hex')
     // const transactionJob = async transaction => {
     //   try {
@@ -260,15 +282,15 @@ export default class Chain {
     //   transaction = new TransactionMessage(transaction)
     //   return transaction
     // }
-    await Promise.all(blockMessage.decoded.transactions
-      .map(transaction => transactionPoolStore.delete(transaction.hash)))
-
+    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.hash, ...blockMessage.decoded}
-    await blockStore.put(blockMessage.hash, blockMessage.encoded)
-    await chainStore.put('lastBlock', new TextEncoder().encode(blockMessage.hash))
-    debug(`added block: ${blockMessage.hash}`)
+    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) {
@@ -279,7 +301,10 @@ export default class Chain {
     }
     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')
@@ -293,6 +318,10 @@ export default class Chain {
 
   }
 
+  async #updateState() {
+    
+  }
+
 
 
   async participate() {
@@ -302,56 +331,72 @@ export default class Chain {
     // introduce peer-reputation
     // peerReputation(peerId)
     // {bandwith: {up, down}, uptime}
-    if (!await this.staticCall(lib.validators, 'has', [peernet.id])) await this.createTransactionFrom(peernet.id, lib.validators, 'addValidator', [peernet.id])
-    if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
+    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() && !this.#runningEpoch) await this.#runEpoch()
+    
+    // const runEpoch = () => setTimeout(async () => {
+    //   if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
+    //   runEpoch()
+    // }, 5000)
+    // runEpoch()
   }
 
   calculateFee(transaction) {
     // excluded from fees
-    if (transaction.decoded.to === lib.validators) return 0
+    // 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 <= 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
     }
 
-    let _transactions = []
-
     // exclude failing tx
-    for (let transaction of Object.values(transactions)) {
-      transaction = new TransactionMessage(new Uint8Array(transaction, transaction.byteOffset, transaction.byteLength))
-
-      block.fees += Number(lib.calculateFee(transaction))
-      _transactions.push({...transaction.decoded, hash: transaction.hash })
-    }
+    transactions = await this.getTransactions(transactions)
 
-    transactions = _transactions.sort((a, b) => a.nonce - b.nonce)
-    _transactions = []
-    for (let transaction of transactions) {
+    transactions = transactions.sort((a, b) => a.nonce - b.nonce)
+    for (let transaction of transactions) { 
       try {
         await this.#executeTransaction(transaction)
-        _transactions.push(transaction)
+        block.transactions.push(transaction)
+        block.fees += Number(calculateFee(transaction))
+        await accountsStore.put(transaction.from, new TextEncoder().encode(String(transaction.nonce)))
       } catch (e) {
-        transaction = new TransactionMessage(transaction)
-        block.fees -= Number(lib.calculateFee(transaction))
-        await transactionPoolStore.delete(transaction.hash)
-
+        console.error(e)
+        transaction = await new TransactionMessage(transaction)
+        await transactionPoolStore.delete(await transaction.hash)
+console.log(e);
       }
     }
-    transactions = _transactions
     // don't add empty block
-    if (transactions.length === 0) return
-
-    block.transactions = transactions
-    const validators = await this.staticCall(lib.validators, 'validators')
+    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) {
@@ -368,7 +413,7 @@ export default class Chain {
       if (validators[validator].active) {
         const peer = peers[validator]
         if (peer && peer.connected) {
-          let data = new BWRequestMessage()
+          let data = await new BWRequestMessage()
           const node = await peernet.prepareMessage(validator, data.encoded)
           try {
             const bw = await peer.request(node.encoded)
@@ -392,7 +437,7 @@ export default class Chain {
 
     }
 
-    console.log(block.validators);
+    console.log({validators: block.validators});
 
     block.reward = 150
     block.validators = block.validators.map(validator => {
@@ -400,7 +445,7 @@ export default class Chain {
       delete validator.bw
       return validator
     })
-    // block.validators = lib.calculateValidatorReward(block.validators, block.fees)
+    // block.validators = calculateValidatorReward(block.validators, block.fees)
 
     block.index = this.lastBlock?.index
     if (block.index === undefined) block.index = 0
@@ -424,25 +469,48 @@ export default class Chain {
     block.fees = Number.parseFloat(String(block.fees)).toFixed(decimals)
 
     try {
-      let blockMessage = new BlockMessage(block)
-      this.#lastBlock = {...block, hash: blockMessage.hash}
+      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.#addBlock(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 getNonce(address) {
+  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 = Object.keys(transactions).map(tx => new TransactionMessage(transactions[tx]))
+    transactions = await this.promiseTransactions(Object.values(transactions))
     transactions = transactions.filter(tx => tx.decoded.from === address)
-    transactions = transactions.map(tx => { return {...tx.decoded, hash: tx.hash} })
+    transactions = await this.promiseTransactionsContent(transactions)
+
     if (this.lastBlock && transactions.length === 0) {
       let block = await peernet.get(this.lastBlock.hash)
-      block = new BlockMessage(block)
+      block = await new BlockMessage(block)
 
       // for (let tx of block.decoded?.transactions) {
       //   tx = await peernet.get(tx, 'transaction')
@@ -451,7 +519,7 @@ export default class Chain {
       transactions = transactions.filter(tx => tx.from === address)
       while (transactions.length === 0 && block.decoded.index !== 0) {
         block = await blockStore.get(block.decoded.previousHash)
-        block = new BlockMessage(block)
+        block = await new BlockMessage(block)
         transactions = block.decoded.transactions.filter(tx => tx.from === address)
       }
 
@@ -462,6 +530,16 @@ export default class Chain {
     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
    *
@@ -473,9 +551,74 @@ export default class Chain {
    * @param {Array} params - array of paramters to apply to the contract method
    * @param {Number} nonce - total transaction count [optional]
    */
-  createTransaction(to, method, params, nonce) {
+  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 < 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
@@ -488,31 +631,41 @@ export default class Chain {
    * @param {Number} nonce - total transaction count [optional]
    */
   async createTransactionFrom(from, to, method, params, nonce) {
-    if (nonce === undefined) {
-      nonce = await this.getNonce(from)
-      nonce += 1
-    }
-
-    let data
-    let message = new TransactionMessage({timestamp: new Date().getTime(), from, to, nonce, method, params})
     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})))
-      await transactionPoolStore.put(message.hash, 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
     }
-    const wait = () => new Promise((resolve, reject) => {
-      const completed = result => {
-        result.status === 'fulfilled' ? resolve(result.hash) : reject({hash: result.hash, error: result.error})
-
-        pubsub.unsubscribe(`transaction.completed.${message.hash}`, completed)
-      }
-      pubsub.subscribe(`transaction.completed.${message.hash}`, completed)
-    })
-
-    if (await this.hasTransactionToHandle() && !this.#runningEpoch) this.#runEpoch()
-    return {hash: message.hash, data, fee: lib.calculateFee(message), wait}
+    
   }
 
   async createContractMessage(creator, contract, constructorParameters = []) {
@@ -524,8 +677,8 @@ export default class Chain {
   }
 
   async createContractAddress(creator, contract, constructorParameters = []) {
-    return this.createContractMessage(creator, contract, constructorParameters)
-      .hash
+    contract = await this.createContractMessage(creator, contract, constructorParameters)
+    return contract.hash
   }
 
   /**
@@ -538,7 +691,7 @@ export default class Chain {
     const hash = await this.createContractAddress(creator, contract, params)
 
     try {
-      const tx = await this.createTransactionFrom(peernet.id, lib.contractFactory, 'deployContract', [hash, creator, contract, constructorParameters])
+      const tx = await this.createTransactionFrom(peernet.id, addresses.contractFactory, 'deployContract', [hash, creator, contract, constructorParameters])
     } catch (e) {
       throw e
     }
@@ -585,15 +738,15 @@ export default class Chain {
   }
 
   mint(to, amount) {
-    return this.call(lib.nativeToken, 'mint', [to, amount])
+    return this.call(addresses.nativeToken, 'mint', [to, amount])
   }
 
   transfer(from, to, amount) {
-    return this.call(lib.nativeToken, 'transfer', [from, to, amount])
+    return this.call(addresses.nativeToken, 'transfer', [from, to, amount])
   }
 
   get balances() {
-    return this.staticCall(lib.nativeToken, 'balances')
+    return this.staticCall(addresses.nativeToken, 'balances')
   }
 
   deleteAll() {
@@ -610,6 +763,6 @@ export default class Chain {
    * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
    */
   lookup(name) {
-    return this.call(lib.nameService, 'lookup', [name])
+    return this.call(addresses.nameService, 'lookup', [name])
   }
 }

package/src/config/config.js

@@ -1,9 +1,13 @@
 import main from './main'
 import protocol from './protocol'
-import { read, write } from './../utils/utils'
+import { promisify } from 'util'
+import { readFile, writeFile } from 'fs'
+
+const read = promisify(readFile)
+const write = promisify(writeFile)
 
 export default async () => {
-  let config = { ...main, ...protocol }
+  let config = { ...main, protocol }
   try {
     let data = await read(main.configPath)
     data = JSON.parse(data.toString())