@leofcoin/lib 0.4.12 → 1.0.1

package/index.js

@@ -1,739 +0,0 @@
-'use strict';
-
-var ipldLfcTx = require('ipld-lfc-tx');
-var ipldLfc = require('ipld-lfc');
-var CID = require('cids');
-var crypto = require('crypto');
-var MultiWallet = require('@leofcoin/multi-wallet');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () {
-            return e[k];
-          }
-        });
-      }
-    });
-  }
-  n['default'] = e;
-  return Object.freeze(n);
-}
-
-var ipldLfcTx__default = /*#__PURE__*/_interopDefaultLegacy(ipldLfcTx);
-var ipldLfcTx__namespace = /*#__PURE__*/_interopNamespace(ipldLfcTx);
-var ipldLfc__default = /*#__PURE__*/_interopDefaultLegacy(ipldLfc);
-var CID__default = /*#__PURE__*/_interopDefaultLegacy(CID);
-var MultiWallet__default = /*#__PURE__*/_interopDefaultLegacy(MultiWallet);
-
-const reward = 150;
-const consensusSubsidyInterval = 52500;
-const genesisCID = 'zsNS6wZiHSc2QPHmjV8TMNn798b4Kp9jpjsBNeUkPhaJTza3GosWUgE72Jy3X9jKMrFCcDni7Pq4yXogQN4TcAfrPmTXFt';
-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
- */
-const network = 'leofcoin';
-
-const invalid = (name, text) => new Error(`Invalid ${name}: ${text}`);
-// TODO: show notification
-/**
- * @example
- * const errors = new Errors()
- */
-class Errors {
-  BlockError(text) {
-    return invalid('block', text)
-  }
-  
-  TransactionError(text) {
-    return invalid('transaction', text)
-  }
-  
-  MinerWarning(text) {
-  }
-}
-
-const { LFCNode, util } = ipldLfc__default['default'];
-
-/**
- * @extends {Validator}
- * @example
- * const hash = new Hash()
- */
-class Hash extends Errors {
-	constructor() {
-		super();
-	}
-
-	hashFromMultihash(multihash) {
-	  const cid = new CID__default['default'](multihash.replace('/ipfs/', ''));
-	  return cid.multihash.slice(cid.prefix.length / 2).toString('hex')
-	}
-
-	multihashFromHash(hash) {
-	  const cid = new CID__default['default'](1, 'leofcoin-block', Buffer.from(`1d40${hash}`, 'hex'), 'base58btc');
-	  return cid.toBaseEncodedString();
-	}
-
-	async blockHash(block) {
-	  block = await new LFCNode({...block});
-	  const cid = await util.cid(await util.serialize(block));
-	  return cid.toBaseEncodedString();
-	}
-
-	/**
-	 * Generate transaction hash
-	 *
-	 * @param {object} transaction {id, type, inputs, outputs}
-	 */
-	async transactionHash(transaction) {
-		const tx = await new ipldLfcTx__default['default'].LFCTx(transaction);
-		const cid = await ipldLfcTx__default['default'].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});
-	}
-
-}
-
-const { LFCTx, util: util$1 } = ipldLfcTx__namespace;
-
-/**
- * @extends {Hash}
- * @example
- * const transaction = new Transaction()
- */
-class Transaction extends Hash {
-  constructor() {
-    super();
-  }
-
-
-  /**
-   * Create transaction
-   *
-   * @param inputs
-   * @param outputs
-   * @param reward
-   * @return {{id: string, reward: boolean, inputs: *, outputs: *, hash: string}}
-   */
-  async newTransaction(inputs, outputs, reward = null) {
-    try {
-      const tx = new LFCTx({
-        id: crypto.randomBytes(32).toString('hex'),
-        time: Math.floor(new Date().getTime() / 1000),
-        reward,
-        outputs,
-        inputs
-      });
-      // const cid = await util.cid(tx.serialize())
-      // await global.ipfs.dag.put(tx, {format: util.codec, hashAlg: util.defaultHashAlg, version: 1, baseFormat: 'base58btc'})
-      return tx
-    } catch (e) {
-      throw e
-    }
-  }
-
-  /**
-   * Create reward transaction for block mining
-   *
-   * @param {string} address
-   * @param {number} height
-   * @return {id: string, reward: boolean, inputs: *, outputs: *, hash: string}
-   */
-  async createRewardTransaction(address, amount) {
-    return this.newTransaction([], [{index: 0, amount, address}], 'mined');
-  }
-
-  /**
-   * validate transaction
-   *
-   * @param multihash
-   * @param transaction
-   * @param unspent
-   */
-  async validateTransaction(multihash, transaction, unspent) {
-  	if (!transaction.reward) delete transaction.reward;
-  	const outputs = transaction.outputs.map(o => {
-  		// TODO: fix script
-  		if (!o.script) delete o.script;
-  		return o
-  	});
-    console.log(transaction);
-  	transaction.outputs = outputs;
-  	if (!transaction.script) delete transaction.script;
-  	if (!ipldLfcTx.util.isValid(transaction)) return await ipldLfcTx.util.validate(transaction)
-  	if (multihash !== await this.transactionHash(transaction)) throw this.TransactionError('Invalid transaction hash');
-  	// TODO: versions should be handled here...
-  	// Verify each input signature
-
-  	if (transaction.inputs) {
-  		transaction.inputs.forEach(input => {
-  	  	const { signature, address } = input;
-  			const hash = this.transactionInputHash(input);
-
-  	  	let wallet = new MultiWallet__default['default'](network);
-  	    wallet.fromAddress(address, null, network);
-
-  			if (!wallet.verify(Buffer.from(signature, 'hex'), Buffer.from(hash, 'hex')))
-  				throw this.TransactionError('Invalid input signature');
-  		});
-
-  		// Check if inputs are in unspent list
-  		transaction.inputs.forEach((input) => {
-  			if (!unspent.find(out => out.tx === input.tx && out.index === input.index)) { throw this.TransactionError('Input has been already spent: ' + input.tx); }
-  		});
-  	}
-
-  	if (transaction.reward === 'mined') {
-  		// For reward transaction: check if reward output is correct
-  		if (transaction.outputs.length !== 1) throw this.TransactionError('Reward transaction must have exactly one output');
-  		if (transaction.outputs[0].amount !== reward) throw this.TransactionError(`Mining reward must be exactly: ${reward}`);
-  	} else if (transaction.inputs) {
-  		// For normal transaction: check if total output amount equals input amount
-  		if (transaction.inputs.reduce((acc, input) => acc + input.amount, 0) !==
-        transaction.outputs.reduce((acc, output) => acc + output.amount, 0)) { throw this.TransactionError('Input and output amounts do not match'); }
-  	}
-
-  	return true;
-  }
-
-  /**
-   * validate transactions list for current block
-   *
-   * @param {array} transactions
-   * @param unspent
-   */
-  async validateTransactions(transactions, unspent) {
-  	const _transactions = [];
-  	for (let tx of transactions) {
-      let multihash = tx.multihash;
-
-      if (multihash) tx = await leofcoin.api.transaction.get(multihash);
-      else {
-        tx = await new LFCTx({...tx});
-        multihash = await util$1.cid(await tx.serialize());
-        multihash = multihash.toBaseEncodedString();
-      }
-
-      _transactions.push({multihash, value: tx.toJSON()});
-  	}
-
-  	try {
-      for (const {value, multihash} of _transactions) {
-    		// TODO: fix value.scrip
-    		await this.validateTransaction(multihash, value, unspent);
-    	}
-    } catch (e) {
-      throw e
-    }
-
-  	if (_transactions.filter(({value}) => value.reward === 'mined').length !== 1)
-  		throw this.TransactionError('Transactions cannot have more than one reward');
-
-    return true
-  }
-
-  /**
-   * Verify signature
-   *
-   * @param {string} address - signer address
-   * @param {string} signature - signature to verify
-   * @param {string} hash - transaction hash
-   */
-  verifySignature(address, signature, hash) {
-  	const wallet = new MultiWallet__default['default'](network);
-  	return wallet.verify(signature, hash, address);
-  }
-
-  /**
-   * Create and sign input
-   *
-   * @param transaction Based on transaction id
-   * @param index Based on transaction output index
-   * @param amount
-   * @param wallet
-   * @return {Object} {transaction, index, amount, address}
-   */
-  createInput(transaction, index, amount, wallet) {
-  	const input = {
-  		transaction,
-  		index,
-  		amount,
-  		address: wallet.address,
-  	};
-  	input.signature = wallet.sign(Buffer.from(this.transactionInputHash(input), 'hex')).toString('hex');
-  	return input;
-  }
-
-  /**
-   * Create a transaction
-   *
-   * @param wallet
-   * @param toAddress
-   * @param amount
-   * @return {Object} {id, reward, inputs, outputs, hash,}
-   */
-  async buildTransaction(wallet, toAddress, amount, unspent) {
-  	let inputsAmount = 0;
-  	// const unspent = await this.getUnspentForAddress(wallet.address);
-  	const inputsRaw = unspent.filter(i => {
-  		const more = inputsAmount < amount;
-  		if (more) inputsAmount += i.amount;
-  		return more;
-  	});
-  	if (inputsAmount < amount) throw this.TransactionError('Not enough funds');
-  	// TODO: Add multiSigning
-  	const inputs = inputsRaw.map(i => this.createInput(i.tx, i.index, i.amount, wallet));
-  	// Send amount to destination address
-  	const outputs = [{index: 0, amount, address: toAddress}];
-  	// Send back change to my wallet
-  	if (inputsAmount - amount > 0) {
-  		outputs.push({index: 1, amount: inputsAmount - amount, address: wallet.address});
-  	}
-  	return this.newTransaction(inputs, outputs);
-  }
-}
-
-const { LFCNode: LFCNode$1, util: util$2 } = ipldLfc__default['default'];
-
-
-/**
- * @extends {Transaction}
- * @example
- * const block = new Block()
- */
-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__default['default'].util.isValid(block);
-  	if (!valid) return await ipldLfc__default['default'].util.validate(block)
-  	// console.log(block, previousBlock);
-  	if (previousBlock.index + 1 !== block.index) return this.BlockError('index');
-    if (!previousBlock.hash) {
-      previousBlock = await new LFCNode$1(previousBlock);
-      previousBlock = previousBlock.toJSON();
-      previousBlock.hash = await util$2.cid(util$2.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$1(block);
-    return node;
-  }
-}
-
-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()
- */
-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 (1000 / (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;
-  }
-}
-
-module.exports = Chain;