@leofcoin/lib 0.4.12 → 1.0.1

package/src/block.js

@@ -1,70 +0,0 @@
-import Transaction from './transaction'
-import ipldLfc from 'ipld-lfc';
-
-const { LFCNode, util } = ipldLfc
-
-
-/**
- * @extends {Transaction}
- * @example
- * const block = new Block()
- */
-export default class Block extends Transaction {
-  constructor() {
-    super()
-  }
-
-  getDifficulty(hash) {
-	   return parseInt(hash.substring(0, 8), 16);
-  }
-
-  goodBlock(block, difficulty){
-    return new Promise(async (resolve, reject) => {
-      block.hash = await this.blockHash(block);
-      if (parseInt(block.hash.substring(0, 8), 16) >= difficulty) {
-        block.nonce++
-        block = await this.goodBlock(block, difficulty)
-      }
-      resolve(block)
-    })
-  }
-
-  async validateBlock(previousBlock, block, difficulty, unspent) {
-    const valid = await ipldLfc.util.isValid(block)
-  	if (!valid) return await ipldLfc.util.validate(block)
-  	// console.log(block, previousBlock);
-  	if (previousBlock.index + 1 !== block.index) return this.BlockError('index');
-    if (!previousBlock.hash) {
-      previousBlock = await new LFCNode(previousBlock)
-      previousBlock = previousBlock.toJSON()
-      previousBlock.hash = await util.cid(util.serialize(previousBlock))
-      previousBlock.hash = previousBlock.hash.toBaseEncodedString()
-    }
-    console.log(await this.blockHash(block), block.hash);
-  	if (previousBlock.hash !== block.prevHash) throw this.BlockError('prevhash');
-  	if (await this.blockHash(block) !== block.hash) return this.BlockError('hash');
-  	if (this.getDifficulty(block.hash) > difficulty) return this.BlockError('difficulty');
-
-
-  	return this.validateTransactions(block.transactions, unspent);
-  }
-
-  /**
-   * Create a new genesis block
-   */
-  async newGenesisDAGNode(difficulty = 1, address = Buffer.alloc(32).toString('hex')) {
-    let block = {
-      index: 0,
-      prevHash: Buffer.alloc(47).toString('hex'),
-      time: Math.floor(new Date().getTime() / 1000),
-      transactions: [
-        // ms.unspent(network, [], wallet.account()).create(index: 0, amount: consensusSubsidy(0), address)
-      ],
-      nonce: 0
-    }
-    block.hash = await blockHash(block);
-    block = await this.goodBlock(block, difficulty)
-    const node = new LFCNode(block)
-    return node;
-  }
-}

package/src/chain.js

@@ -1,350 +0,0 @@
-import { GENESISBLOCK, genesisCID, consensusSubsidyInterval, reward } from './params'
-import Block from './block'
-
-const invalidTransactions = {};
-
-globalThis.chain = globalThis.chain || [
-  GENESISBLOCK
-];
-
-globalThis.mempool = globalThis.mempool || [];
-globalThis.blockHashSet = globalThis.blockHashSet || [];
-
-const filterPeers = (peers, localPeer) => {
-  const set = []
-  return peers.reduce((p, c) => {
-    if (set.indexOf(c.peer) === -1 && c.peer !== localPeer) {
-      set.push(c.peer)
-      p.push(c)
-    }
-    return p
-  }, [])
-}
-
-/**
- * @extends {Block}
- * @example
- * const chain = new Chain()
- */
-export default class Chain extends Block {
-  constructor() {
-    super()
-  }
-
-  get chain() { return globalThis.chain }
-
-  get mempool() { return globalThis.mempool }
-
-  get blockHashSet() { return globalThis.blockHashSet }
-
-  // TODO: needs 3 nodes running
-  invalidTransaction(data) {
-    // console.log(data.data.toString());
-    data = JSON.parse(data.data.toString());
-    if (!invalidTransactions[data.tx]) invalidTransactions[data.tx] = 0;
-    ++invalidTransactions[data.tx]
-    const count = invalidTransactions[data.tx];
-    if (count === 3) {
-      const memIndex = mempool.indexOf(data)
-      mempool.splice(memIndex, 1)
-      delete invalidTransactions[data.tx];
-    }
-  }
-
-  /**
-   * @param {number} height
-   */
-  consensusSubsidy(height) {
-    // console.log(height);
-  	const quarterlings = height / consensusSubsidyInterval;
-  	if (quarterlings >= 256) {
-  		return 0;
-  	}
-  	//subsidy is lowered by 12.5 %, approx every year
-  	const minus = quarterlings >= 1 ? (quarterlings * (reward / 256)) : 0;
-  	return reward - minus;
-  }
-
-  async getTransactions(withMempool = true, index = 0) {
-    const _chain = [...chain];
-    if (index === chain.length - 1) return []
-    _chain.slice(index + 1, chain.length - 1)
-  	let transactions = _chain.reduce((transactions, block) => [ ...transactions, ...block.transactions], []);
-  	if (withMempool) transactions = transactions.concat(mempool);
-    let _transactions = []
-    // TODO: deprecated, get/put should be handled in core
-    for (const tx of transactions) {
-      const {multihash} = tx
-      if (multihash) {
-        let value;
-        if (leofcoin.api.transaction) value = await leofcoin.api.transaction.get(multihash)
-        _transactions.push(value)
-      } else {
-        _transactions.push(tx)
-      }
-
-    }
-    return _transactions
-  };
-
-  async getTransactionsForAddress(address, index = 0) {
-    const transactions = await this.getTransactions(false, index);
-  	return transactions.filter(tx => tx.inputs.find(i => i.address === address) ||
-    tx.outputs.find(o => o.address === address));
-  };
-
-  /**
-   *
-   * @param {string} withMempool - with or without mempool inclusion
-   * @param {number} index - block height to start from
-   */
-  async getUnspent(withMempool = false, index = 0) {
-  	const transactions = await this.getTransactions(withMempool, index);
-  	// Find all inputs with their tx ids
-  	const inputs = transactions.reduce((inputs, tx) => inputs.concat(tx.inputs), []);
-
-  	// Find all outputs with their tx ids
-  	const outputs = transactions.reduce((outputs, tx) =>
-  		outputs.concat(tx.outputs.map(output => Object.assign({}, output, {tx: tx.id}))), []);
-
-  	// Figure out which outputs are unspent
-  	const unspent = outputs.filter(output =>
-  		typeof inputs.find(input => input.tx === output.tx && input.index === output.index && input.amount === output.amount) === 'undefined');
-  	return unspent;
-  }
-
-  /**
-   * @param {String} address - wallet address
-   * @param {number} index - block height to start from
-   */
-  async getUnspentForAddress(address = null, index = 0) {
-    const unspent = await this.getUnspent(true, index)
-  	return unspent.filter(u => u.address === address);
-  }
-
-  /**
-   * @param {String} address - wallet address
-   * @param {Number} index - Block index to get balance after
-   */
-  async getBalanceForAddress(address = null, index) {
-    // debug(`Getting balance for ${address}`)
-    const unspent = await this.getUnspentForAddress(address, index)
-    const amount = unspent.reduce((acc, u) => acc + u.amount , 0);
-    // debug(`Got ${amount} for ${address}`)
-  	return amount
-  }
-
-  /**
-   * @deprecated Use getTransactionsForAddress(addr, index) instead
-   *
-   * @param {string} address - wallet address
-   * @param {number} index - block height to start from
-   *
-   * @return {number} balance
-   */
-  async getBalanceForAddressAfter(address = null, index = 0) {
-    // debug(`Getting balance for ${address} @${index}`)
-    const unspent = await this.getUnspentForAddress(address, index)
-    const amount = unspent.reduce((acc, u) => acc + u.amount , 0);
-    // debug(`Got ${amount} for ${address} @${index}`)
-    return amount
-  }
-
-  median(array) {
-    array.sort((a,b) => a - b)
-
-    var half = Math.floor(array.length / 2);
-
-    if(array.length % 2)
-      return array[half];
-    else
-      return (array[half - 1] + array[half]) / 2.0;
-  }
-
-  difficulty() {
-  	// TODO: lower difficulty when transactionpool contain more then 500 tx ?
-  	// TODO: raise difficulty when pool is empty
-
-    // or
-
-    // TODO: implement iTX (instant transaction)
-    // iTX is handled by multiple peers, itx is chained together by their hashes
-    // by handlng a tx as itx the block well be converted into a iRootBlock
-    // this results into smaller chains (tangles, tails) which should improve
-    // resolving transactions, wallet amounts etc ...
-  	const start = chain.length >= 128 ? (chain.length - 128) : 0;
-  	const blocks = chain.slice(start, (chain.length - 1)).reverse();
-  	const stamps = [];
-  	for (var i = 0; i < blocks.length; i++) {
-  		if (blocks[i + 1]) {
-  			stamps.push(blocks[i].time - blocks[i + 1].time);
-  		}
-  	}
-  	if (stamps.length === 0) {
-  		stamps.push(10);
-  	}
-  	let blocksMedian = this.median(stamps) || 10;
-    const offset = blocksMedian / 10
-     // offset for quick recovery
-  	if (blocksMedian < 10) {
-  		blocksMedian -= (offset / 2);
-  	} else if (blocksMedian > 10) {
-  		blocksMedian += (offset * 2);
-  	}
-    if (blocksMedian < 0) blocksMedian = -blocksMedian
-    console.log(`Average Block Time: ${blocksMedian}`);
-    console.log(`Difficulty: ${10 / blocksMedian}`);
-  	return (10000 / (10 / blocksMedian));
-  };//10000
-
-
-  /**
-   * Get the transactions for the next Block
-   *
-   * @return {object} transactions
-   */
-  async nextBlockTransactions() {
-
-  	try {
-      const unspent = await this.getUnspent(false);
-      return mempool.filter(async transaction => {
-        const multihash = transaction.multihash
-        const value = await leofcoin.api.transaction.get(multihash)
-    		try {
-    			await this.validateTransaction(multihash, value.toJSON(), unspent);
-          return transaction
-    		} catch (e) {
-          globalThis.pubsub.publish('invalid-transaction', Buffer.from(JSON.stringify(transaction)));
-    			console.error(e);
-    		}
-    	});
-    } catch (e) {
-      throw new Error(e)
-    }
-  }
-
-  longestChain() {
-    return new Promise(async (resolve, reject) => {
-      try {
-        // TODO: peernet.id => peer.id
-        let peers = await filterPeers([...peernet.peers], peernet.id)
-        let set = []
-        const request = new globalThis.peernet.protos['peernet-request']({
-          request: 'lastBlock'
-        })
-
-        for (const peer of peers) {
-          const to = peernet._getPeerId(peer.id)
-          if (to) {
-            const node = await peernet.prepareMessage(to, request.encoded)
-            let response = await peer.request(node.encoded)
-            const proto = new globalThis.peernet.protos['peernet-message'](Buffer.from(response.data))
-            response = new globalThis.peernet.protos['peernet-response'](Buffer.from(proto.decoded.data))
-            const block = JSON.parse(response.decoded.response)
-            set.push({peer, block})
-          }
-        }
-        let localIndex
-        let localHash
-        try {
-          const index = await chainStore.get('localIndex')
-          const hash = await chainStore.get('localBlock')
-          localIndex = Number(index.toString())
-          localHash = hash.toString()
-        } catch (e) {
-          localIndex = 0;
-          localHash = genesisCID;
-          await chainStore.put('localIndex', 0)
-          await chainStore.put('localBlock', genesisCID)
-        }
-
-        set = set.reduce((p, c) => {
-          if (Number(c.height) > Number(p.height)) {
-            c.seen = 1
-            return c
-          } else if (Number(c.height) === Number(p.height)) {
-            p.seen += 1
-          }
-          return p
-        }, { height: localIndex, hash: localHash, seen: 0})
-
-        // temp
-        // if (_blocks.seen < 2) {
-        //   _blocks = history[_blocks.block.index - 1]
-        //
-        // }
-        // const localIndex = await chainStore.get('localIndex')
-        // const localHash = await chainStore.get('localBlock')
-        return resolve({index: set.height, hash: set.hash})
-
-      } catch (e) {
-        console.warn(e);
-        // debug(e)
-        reject(e)
-      }
-    })
-  }
-
-  /**
-   * Resolve latest block from the longest chain.
-   * @return Promise(resolve(block))
-   */
-  lastBlock() {
-    return new Promise(async (resolve, reject) => {
-      const result = await this.longestChain();
-
-      resolve(result); // retrieve links
-    });
-  }
-
-  /**
-   * @param {String} address
-   * @return {Function} newBlock
-   */
-  async nextBlock(address) {
-    let transactions;
-    let previousBlock;
-    try {
-      previousBlock = await this.lastBlock()
-
-      if (previousBlock.index > chain.length - 1) {
-        await leofcoin.api.chain.sync()
-        previousBlock = await this.lastBlock()
-      }
-      if (!previousBlock.index) previousBlock = chain[chain.length - 1]
-      transactions = await this.nextBlockTransactions();
-    } catch (e) {
-      previousBlock = GENESISBLOCK
-      previousBlock.hash = genesisCID
-      transactions = await this.nextBlockTransactions();
-    } finally {
-      // console.log(transactions, previousBlock, address);
-      return await this.newBlock({transactions, previousBlock, address});
-    }
-  }
-
-  /**
-	 * Create new block
-	 *
-	 * @param {Array} transactions - transactions
-	 * @param {Object} previousBlock - previousBlock
-	 * @param {String} address - address
-	 * @return {Object} index, prevHash, time, transactions, nonce
-	 */
-  async newBlock({transactions = [], previousBlock, address}) {
-  	const index = previousBlock.index + 1
-  	const minedTx = await this.createRewardTransaction(address, this.consensusSubsidy(index))
-  	transactions.push(minedTx.toJSON());
-  	this.data = {
-  		index,
-  		prevHash: previousBlock.hash,
-  		time: Math.floor(new Date().getTime() / 1000),
-  		transactions,
-  		nonce: 0
-  	}
-
-  	this.data.hash = await this.blockHash({...this.data});
-
-  	return this.data;
-  }
-}

package/src/errors.js

@@ -1,19 +0,0 @@
-const invalid = (name, text) => new Error(`Invalid ${name}: ${text}`);
-// TODO: show notification
-/**
- * @example
- * const errors = new Errors()
- */
-export default class Errors {
-  BlockError(text) {
-    return invalid('block', text)
-  }
-  
-  TransactionError(text) {
-    return invalid('transaction', text)
-  }
-  
-  MinerWarning(text) {
-    new Error(`warning @Miner: ${text}`)
-  }
-}

package/src/hash.js

@@ -1,60 +0,0 @@
-import IPLDLFCTx from 'ipld-lfc-tx'
-import ipldLfc from 'ipld-lfc'
-import CID from 'cids'
-import Errors from './errors'
-import cryptoJs from 'crypto-js';
-
-const { LFCNode, util } = ipldLfc
-const {SHA256} = cryptoJs
-
-const _SHA256 = (object) => {
-  return SHA256(JSON.stringify(object)).toString();
-}
-
-/**
- * @extends {Validator}
- * @example
- * const hash = new Hash()
- */
-export default class Hash extends Errors {
-	constructor() {
-		super()
-	}
-
-	hashFromMultihash(multihash) {
-	  const cid = new CID(multihash.replace('/ipfs/', ''))
-	  return cid.multihash.slice(cid.prefix.length / 2).toString('hex')
-	}
-
-	multihashFromHash(hash) {
-	  const cid = new CID(1, 'leofcoin-block', Buffer.from(`1d40${hash}`, 'hex'), 'base58btc');
-	  return cid.toBaseEncodedString();
-	}
-
-	async blockHash(block) {
-	  const cid = await util.cid(await util.serialize(await new LFCNode({...block})))
-	  return cid.toBaseEncodedString();
-	}
-
-	/**
-	 * Generate transaction hash
-	 *
-	 * @param {object} transaction {id, type, inputs, outputs}
-	 */
-	async transactionHash(transaction) {
-		const tx = await new IPLDLFCTx.LFCTx(transaction)
-		const cid = await IPLDLFCTx.util.cid(await tx.serialize())
-		return cid.toBaseEncodedString()
-	}
-
-	/**
-	 * Generate transaction input hash
-	 *
-	 * @param {object} transactionInput {transaction, index, amount, address}
-	 */
-	transactionInputHash(transactionInput) {
-		const {tx, index, amount, address} = transactionInput;
-		return _SHA256({tx, index, amount, address});
-	}
-
-}

package/src/index.js

@@ -1,3 +0,0 @@
-import Chain from './chain'
-
-export default Chain

package/src/params.js

@@ -1,18 +0,0 @@
-export const reward = 150;
-export const consensusSubsidyInterval = 52500;
-export const consensusSubsidyPercentage = 12.5; // quarterlings
-export const genesisCID = 'zsNS6wZiHSc2QPHmjV8TMNn798b4Kp9jpjsBNeUkPhaJTza3GosWUgE72Jy3X9jKMrFCcDni7Pq4yXogQN4TcAfrPmTXFt';
-export const GENESISBS58 = 'EKBqhKsFG14thpzEKUbbb94WG9a1p9sm82YQ2YwK6wkme4C1df2dMwggnDgh74zZsBx2UbWi1qDQLysrrU3YKJ6V73sLtASepYieNpx8Fwjxyjh6xWNYToTNbNkp1geiSWq6fne7Npf37HCZVmi';
-export const GENESISBLOCK = {
-	index: 0,
-  prevHash: Buffer.alloc(47).toString('hex'),
-  time: 1590240964,
-  transactions: [],
-  nonce: 1077701
-}
-
-/**
- * network (hardcoded for now)
- * @dev change to 'leofcoin:olivia' for testnet
- */
-export const network = 'leofcoin'