@leofcoin/lib 0.4.12 → 1.0.1

package/src/transaction.js

@@ -1,205 +0,0 @@
-import Errors from './errors.js'
-import Hash from './hash.js'
-import { randomBytes } from 'crypto'
-import MultiWallet from '@leofcoin/multi-wallet'
-import { network, reward } from './params.js';
-import * as ipldLfcTx from 'ipld-lfc-tx';
-
-const { LFCTx, util } = ipldLfcTx
-
-/**
- * @extends {Hash}
- * @example
- * const transaction = new Transaction()
- */
-export default 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: 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(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.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(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 = {
-  		tx: 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);
-  }
-}

package/test/index.js

@@ -1,106 +0,0 @@
-const test = require('tape');
-const Peernet = require('@leofcoin/peernet');
-const Chain = require('./../index');
-
-const address = '8HFTVVfRMeL1sASrsdp6mvqDW9pvSD4AKySPEq3So16Wo1mpgY';
-
-
-(async () => {
-  await new Peernet()
-
-  const chain = new Chain()
-
-  chain.chain.push({
-    hash: 'zsNS6waLSmzg9BFR5CwJxJWpmT1ygXpXHuJ8Y4hTeqq8HRAVEcDfUnsMxEeFb7DLmaF3kPiUyEAfdX3dgPdTNLPHqCfvY6',
-    index: 1,
-    nonce: 263991677,
-    prevHash: 'zsNS6wZiHSc2QPHmjV8TMNn798b4Kp9jpjsBNeUkPhaJTza3GosWUgE72Jy3X9jKMrFCcDni7Pq4yXogQN4TcAfrPmTXFt',
-    time: 1590242832,
-    transactions: [{
-      id: 'f83349fbde4098c9be72be87468265d7ae43de8137fec514e3b81adbd8ff1c9d',
-      inputs: [],
-      outputs: [{
-        address: '8HFTVVfRMeL1sASrsdp6mvqDW9pvSD4AKySPEq3So16Wo1mpgY',
-        amount: 150,
-        index: 0
-      }],
-      reward: 'mined',
-      script: 'mined',
-      time: 1590242832
-    }]
-  })
-
-  // test('block', tape => {
-  //   tape.plan(1)
-  //
-  //   tape.equals('block')
-  // })
-  const testChain = () => new Promise((resolve, reject) => {
-    test('chain', async tape => {
-      tape.plan(15)
-
-      let value = await chain.getTransactions()
-      tape.equals(value.length, 1, 'getTransactions')
-
-      value = await chain.getTransactions(false, 1)
-      tape.equals(value.length, 0, 'getTransactions after block 1')
-
-      value = await chain.getTransactionsForAddress(address)
-      tape.equals(value.length, 1, 'getTransactionsForAddress')
-
-      value = await chain.getTransactionsForAddress(address, 1)
-      tape.equals(value.length, 0, 'getTransactionsForAddress after block 1')
-
-      value = await chain.getUnspent(address)
-      tape.equals(value.length, 1, 'getUnspent')
-
-      value = await chain.getUnspentForAddress(address)
-      tape.equals(value.length, 1, 'getUnspentForAddress')
-
-      value = await chain.getBalanceForAddress(address)
-      tape.equals(value, 150, 'getBalanceForAddress')
-
-      value = await chain.getBalanceForAddress(address, 1)
-      tape.equals(value, 0, 'getBalanceForAddress after block 1')
-
-      value = await chain.nextBlockTransactions()
-      tape.equals(value.length, 0, 'nextBlockTransactions')
-
-      value = await chain.longestChain()
-      tape.equals(value.index, 0, 'longestChain')
-
-      value = await chain.lastBlock()
-      tape.equals(value.index, 0, 'lastBlock')
-
-      value = await chain.nextBlock('8HFTVVfRMeL1sASrsdp6mvqDW9pvSD4AKySPEq3So16Wo1mpgY')
-      tape.equals(value.transactions[0].reward, 'mined', 'nextBlock')
-
-      const hash = value.hash
-
-      value = await chain.blockHash(value)
-      tape.equals(value, hash, 'blockHash')
-
-      value = await chain.transactionHash(chain.chain[1].transactions[0])
-      tape.equals(value, 'z3vzxp8k4VbTshwYpcaQQwrD9h9AZLzQjo3Dvx8sLRUdziUfmnB', 'transactionHash')
-
-
-      try {
-        value = await chain.validateBlock(chain.chain[0], chain.chain[1], await chain.difficulty(), await chain.getUnspentForAddress('8HFTVVfRMeL1sASrsdp6mvqDW9pvSD4AKySPEq3So16Wo1mpgY'))
-        tape.equals(value, true, 'validateBlock')
-
-      } catch (e) {
-        console.warn({e});
-      } finally {
-
-      }
-
-      setTimeout(function () {
-        resolve()
-      }, 200);
-    })
-  });
-  await testChain()
-  process.exit(0)
-
-
-})()