How to use ethereumjs-util - 10 common examples

it('should give proper information about the TX input', async () => {
        const tx = createTransaction(TxTypeSplit, 0, 
            [{
                blockNumber: 1,
                txNumberInBlock: 200,
                outputNumberInTransaction: 0,
                amount: 10
            }],
            [{
                amount: 10,
                to: alice
            }],
                aliceKey
        )
        const reencodedTX = tx.serialize();
        const info = await txTester.getInputInfo(ethUtil.bufferToHex(reencodedTX), 0);
        const blockNumber = info[0].toNumber();
        const txNumberInBlock = info[1].toNumber();
        const outputNumber = info[2].toNumber();
        const amount = info[3].toString(10);
        assert(blockNumber === 1);
        // assert(txNumberInBlock === 200);
        assert(outputNumber === 0);
        assert(amount === ""+10);
    });

p2pClient.on('status-changed', (s) => {
  // console.log('STATUS', s)
  if (s === 'connected') {
    start = Date.now();
    for (var i = 0; i < 1000; i++) {
      transferredAmount = transferredAmount.add(new util.BN(1));
      engine.sendDirectTransfer(util.toBuffer(acct4), transferredAmount);
      //var msg = sendQueue[sendQueue.length -1];
    }
    end = Date.now();
    cl("Direct Transfers Sent Per SECOND per USER " + 1000 / ((end - start) / 1000));
  }
}
)

RootChain,
  ERC20Validator
} from '../helpers/contracts'

let ChildChain = artifacts.require('../child/ChildChain.sol')
let ChildToken = artifacts.require('../child/ChildERC20.sol')

const web3Child = new web3.constructor(
  new web3.providers.HttpProvider('http://localhost:8546')
)

ChildChain.web3 = web3Child
ChildToken.web3 = web3Child

const BN = utils.BN
const rlp = utils.rlp

// const printReceiptEvents = receipt => {
//   receipt.logs.forEach(l => {
//     console.log(l.event, JSON.stringify(l.args))
//   })
// }

contract('ERC20Validator', async function(accounts) {
  describe('initialization', async function() {
    let stakeToken
    let rootToken
    let childToken
    let rootChain
    let stakeManager
    let wallets
    let childChain

assert(exitRecord[6].toNumber() === 0)
        assert(exitRecord[7] === true)
        assert(exitRecord[8] === false)

        //now lets offer a buyoyt for half of the amount
        // function publishPreacceptedBuyout(
        //     bytes22 _index,
        //     uint256 _amount,
        //     address _beneficiary,
        //     uint8 v,
        //     bytes32 r, 
        //     bytes32 s
        // )

        const valueBuffer = (new BN(50)).toBuffer("be", 32)
        const dataToSign = Buffer.concat([ethUtil.toBuffer(exitRecordHash), valueBuffer, ethUtil.toBuffer(bob)])
        const hashToSign = ethUtil.hashPersonalMessage(dataToSign)
        const signature = ethUtil.ecsign(hashToSign, aliceKey)
        const {v, r, s} = signature
        let oldBalanceAlice = await web3.eth.getBalance(alice);
        submissionReceipt = await plasma.publishPreacceptedBuyout(
            exitRecordHash,
            50,
            bob,
            v,
            ethUtil.bufferToHex(r),
            ethUtil.bufferToHex(s),
            {from: bob, value: 50})
        assert(submissionReceipt.logs.length == 1);
        let offer = await plasma.exitBuyoutOffers(exitRecordHash);
        assert(offer[1] === bob);
        assert(offer[0].toString(10) === "50");

async function signV2Order(order) {
  const signature = await promisify(web3Instance.eth.sign)(
    getV2OrderHash(order), order.makerAddress
  );

  const { v, r, s } = ethUtil.fromRpcSig(signature);

  // 0x00 Illegal
  // 0x01 Invalid
  // 0x02 EIP712 (no prepended string)
  // 0x03 EthSign (prepended "\x19Ethereum Signed Message:\n32")
  // 0x04 Wallet
  // 0x05 Validator
  // 0x06 PreSigned
  // 0x07 NSignatureTypes
  const sigType = 3;

  return ethUtil.bufferToHex(
    Buffer.concat([
      ethUtil.toBuffer(v),
      r,
      s,

// check storage
  if (testData.post) {
    const expectedAccount = testData.post[testData.exec.address]
    // TODO: check all accounts
    if (expectedAccount) {
      const expectedStorage = expectedAccount.storage
      if (expectedStorage) {
        for (let key in expectedStorage) {
          const keyHex = (new U256(key)).toString(16)
          // pad values to get consistent hex strings for comparison
          let expectedValue = ethUtil.setLengthLeft(ethUtil.toBuffer(expectedStorage[key]), 32)
          expectedValue = '0x' + expectedValue.toString('hex')
          let actualValue = environment.state[testData.exec.address]['storage'][keyHex]
          if (actualValue) {
            actualValue = '0x' + ethUtil.setLengthLeft(ethUtil.toBuffer(actualValue), 32).toString('hex')
          } else {
            actualValue = '0x' + ethUtil.setLengthLeft(ethUtil.toBuffer(0), 32).toString('hex')
          }
          t.equals(actualValue, expectedValue, `should have correct storage value at key ${key}`)
        }
      }
    }
  }
}

import Trie from 'merkle-patricia-tree'
import utils from 'ethereumjs-util'
import EthereumTx from 'ethereumjs-tx'
import EthereumBlock from 'ethereumjs-block/from-rpc'
import MerkleTree from '../helpers/merkle-tree.js'

const rlp = utils.rlp

// raw header
function getRawHeader(_block) {
  if (typeof _block.difficulty !== 'string') {
    _block.difficulty = '0x' + _block.difficulty.toString(16)
  }

  const block = new EthereumBlock(_block)
  return block.header
}

// squanch transaction
export function squanchTx(tx) {
  tx.gasPrice = '0x' + parseInt(tx.gasPrice).toString(16)
  tx.value = '0x' + parseInt(tx.value).toString(16) || '0'
  tx.gas = '0x' + parseInt(tx.gas).toString(16)

if (self.opts.debug) {
    vm.on('step', function (data) {
      console.log(data.opcode.name)
    })
  }

  // create tx
  var txParams = payload.params[0]
  // console.log('params:', payload.params)

  const normalizedTxParams = {
    to: txParams.to ? ethUtil.addHexPrefix(txParams.to) : undefined,
    from: txParams.from ? ethUtil.addHexPrefix(txParams.from) : undefined,
    value: txParams.value ? ethUtil.addHexPrefix(txParams.value) : undefined,
    data: txParams.data ? ethUtil.addHexPrefix(txParams.data) : undefined,
    gasLimit: txParams.gas ? ethUtil.addHexPrefix(txParams.gas) : block.header.gasLimit,
    gasPrice: txParams.gasPrice ? ethUtil.addHexPrefix(txParams.gasPrice) : undefined,
    nonce: txParams.nonce ? ethUtil.addHexPrefix(txParams.nonce) : undefined,
  }
  var tx = new FakeTransaction(normalizedTxParams)
  tx._from = normalizedTxParams.from || '0x0000000000000000000000000000000000000000'

  vm.runTx({
    tx: tx,
    block: block,
    skipNonce: true,
    skipBalance: true
  }, function(err, results) {
    if (err) return cb(err)
    if (results.error != null) {
      return cb(new Error("VM error: " + results.error))
    }

enableHomestead: true
  })

  if (self.opts.debug) {
    vm.on('step', function (data) {
      console.log(data.opcode.name)
    })
  }

  // create tx
  var txParams = payload.params[0]
  // console.log('params:', payload.params)

  const normalizedTxParams = {
    to: txParams.to ? ethUtil.addHexPrefix(txParams.to) : undefined,
    from: txParams.from ? ethUtil.addHexPrefix(txParams.from) : undefined,
    value: txParams.value ? ethUtil.addHexPrefix(txParams.value) : undefined,
    data: txParams.data ? ethUtil.addHexPrefix(txParams.data) : undefined,
    gasLimit: txParams.gas ? ethUtil.addHexPrefix(txParams.gas) : block.header.gasLimit,
    gasPrice: txParams.gasPrice ? ethUtil.addHexPrefix(txParams.gasPrice) : undefined,
    nonce: txParams.nonce ? ethUtil.addHexPrefix(txParams.nonce) : undefined,
  }
  var tx = new FakeTransaction(normalizedTxParams)
  tx._from = normalizedTxParams.from || '0x0000000000000000000000000000000000000000'

  vm.runTx({
    tx: tx,
    block: block,
    skipNonce: true,
    skipBalance: true
  }, function(err, results) {
    if (err) return cb(err)

function normalizeDecodedValue(type, value) {
	if (_.isArray(value))
		return _.map(value, v => normalizeDecodedValue(type, v));
	const elementType = /^[a-z0-9]+/i.exec(type)[0];
	assert(elementType);
	// Convert addresses to checksummed addresses.
	if (elementType == 'address')
		return ethjs.toChecksumAddress(value);
	// Convert integers to strings.
	if (/^u?int/.test(elementType) && _.isObject(value))
		return value.toString(10);
	// Resize bytes values.
	const m = /^bytes(\d+)?$/.exec(elementType);
	if (m && m[1]) {
		const size = parseInt(m[1]);
		return ethjs.bufferToHex(ethjs.setLengthRight(value, size));
	}
	return value;
}