How to use ethereumjs-wallet - 10 common examples

it('create eth.account, and compare to ethereumjs-wallet', function() {
                var ethAccounts = new Accounts();

                // create account
                var acc = ethAccounts.create();

                // create ethereumjs-wallet account
                var ethWall = ethereumWallet.fromPrivateKey(Buffer.from(acc.privateKey.replace('0x', ''), 'hex'));

                // compare addresses
                assert.equal(acc.address, ethWall.getChecksumAddressString());
            });
        });

const ledger = process.env['LEDGER'];
const networkId = process.env['NETWORK_ID'];

var address;
var walletProvider;

function die(s) {
	console.error(s);
	process.exit();
}

if (key != undefined) {
	if (api == undefined) die('API not set')
	if (url == undefined) die('URL not set')
  address = `0xb912740f1389fa0c99965fcda9039b9e5638e5f7`;
  const wallet = Wallet.fromPrivateKey(Buffer.from(key, 'hex'));
  const walletAddress = wallet.getAddressString();
  if (walletAddress != address) die(`Key address ${walletAddress} does not match ${address}`);
  walletProvider = () => new WalletProvider(key, `${url}/v3/${api}`, 0);
} else if (mnemonic != undefined) {
	if (api == undefined) die('API not set')
	if (url == undefined) die('URL not set')
	// address = `0x808b6dB94ce973Bab908450E764Db7405A533FAa`;
	address = `0xe90319CBACc28aA19c12A7225322Ce64e5701D56`;

	if (!bip39.validateMnemonic(mnemonic)) die(`${mnemonic} not valid`);
	const seed = bip39.mnemonicToSeed(mnemonic);
	var wallet = HDKey.fromMasterSeed(seed).derivePath("m/44'/60'/0'/0/0").getWallet();
  const walletAddress = wallet.getAddress().toString('hex');
  if (`0x${walletAddress}` != address.toLowerCase()) die(`HDKey address 0x${walletAddress} does not match ${address}`);
  walletProvider = () => new WalletProvider(mnemonic, `${url}/v3/${api}`, 0);
} else if (testkey != undefined) {

} else if(window && window.web3) {
      // BUG: This never finds window.web3, and thus always falls back to localStorage keys
      this.web3 = new Web3(window.web3.currentProvider);
    } else {
      var privateKey = options.privateKey || localStorage.getItem("localPrivateKey");
      if(!privateKey) {
        privateKey = Wallet.generate().getPrivateKeyString().slice(2);
        if(localStorage) {
        localStorage.setItem("localPrivateKey", privateKey)}
      }
      // This uses web3-provider-engine and ethereumjs-wallet to construct a
      // wallet in-browser, without needing Metamask, Toshi, etc.
      //
      // Note that the current version of ethereumjs-wallet on npm has a bug,
      // but the latest on Github works just fine.
      var wallet = Wallet.fromPrivateKey(new Buffer(privateKey, "hex"));
      this.engine = new ProviderEngine();
      this.web3 = new Web3(this.engine);
      console.log(this.web3)
      // static results
      this.engine.addProvider(new FixtureSubprovider({
        web3_clientVersion: 'ProviderEngine/v0.0.0/javascript',
        net_listening: true,
        eth_hashrate: '0x00',
        eth_mining: false,
        eth_syncing: true,
      }))

      // filters
      this.engine.addProvider(new FilterSubprovider())

      // id mgmt

)
  console.log('private key', u.buf2hex(secretStore.getASk()))
  console.log('public key', u.buf2hex(secretStore.getAPk()))
  initEventHandlers(platformState, secretStore, k0Eth)

  const k0 = await makeK0(serverPorts[who])

  const artefacts = await compileContracts()
  const dollarCoin = new web3.eth.Contract(
    artefacts.DollarCoin.abi,
    addresses.DollarCoin
  )

  const mnemonic = mnemonics[who]
  const seed = bip39.mnemonicToSeed(mnemonic)
  const root = hdkey.fromMasterSeed(seed)
  const path = "m/44'/60'/0'/0/0" // eslint-disable-line
  const wallet = root.derivePath(path).getWallet()

  const values = _.times(3, () => new BN(_.random(50).toString() + '000'))

  const total = values.reduce((acc, el) => acc.add(el), new BN('0'))

  await demoUtil.prompt()

  const platformRoot = await k0Eth.merkleTreeRoot()
  console.log(`Platform Merkle tree root: ${u.buf2hex(platformRoot)}`)
  const localRoot = await platformState.merkleTreeRoot()
  console.log(`Local Merkle tree root: ${u.buf2hex(localRoot)}`)
  assert(localRoot.equals(platformRoot))

  // approve

generateKeyRand() {
    if (!this.encryptionKey) {
      // KeyContainer not unlocked
      console.error('Error: KeyContainer not unlocked');
      return undefined;
    }
    const w = ethWallet.generate();
    const privK = w._privKey;
    const address = ethUtil.privateToAddress(privK);
    const addressHex = utils.bytesToHex(address);
    const privKHex = utils.bytesToHex(privK);
    const privKHexEncrypted = kcUtils.encrypt(this.encryptionKey, privKHex);

    this.db.insert(this.prefix + addressHex, privKHexEncrypted);
    return addressHex;
  }

function ensureAccounts(personas) {
    // Generate missing accounts
    for (let persona of personas) {
        let wallet
        if (accounts[persona] === undefined) {
            console.log(persona, 'unknown, generating account...')
            wallet = ethwallet.generate()
            // keyfileName = wallet.getV3Filename(new Date().getTime())
        } else {
            wallet = ethwallet.fromV3(JSON.stringify(accounts[persona].keyfile), password)
            console.log(persona, `wallet valid (address: ${wallet.getAddressString()})`)
            // keyfileName = accounts[persona].keyfileName
        }
        accounts[persona] = {
            address: wallet.getAddressString(),
            privkey: wallet.getPrivateKeyString(),
            keyfile: JSON.parse(wallet.toV3String(password)),
            // keyfileName: persona,
        }
    }
    fs.writeFileSync(path.join(accountDirPath(), 'accounts.json'), JSON.stringify(accounts, null, 4))

    // Write keyfiles

this.engine = new ProviderEngine();
      this.web3 = new Web3(this.engine);
      // static results
      this.engine.addProvider(new FixtureSubprovider({
        web3_clientVersion: 'ProviderEngine/v0.0.0/javascript',
        net_listening: true,
        eth_hashrate: '0x00',
        eth_mining: false,
        eth_syncing: true
      }));

      // filters
      this.engine.addProvider(new FilterSubprovider());

      // id mgmt
      this.engine.addProvider(new WalletSubprovider(wallet, {}));

      this.engine.addProvider(new Web3Subprovider(new Web3.providers.HttpProvider(rpcURL)));

      this.engine.on('block', function (block) {
        console.log('BLOCK CHANGED:', '#' + block.number.toString('hex'), '0x' + block.hash.toString('hex'));
      });

      // network connectivity error
      this.engine.on('error', function (err) {
        // report connectivity errors
        console.error(err.stack);
      });

      // start polling for blocks
      this.engine.start();
    }

this.web3 = new Web3(this.engine);
      console.log(this.web3)
      // static results
      this.engine.addProvider(new FixtureSubprovider({
        web3_clientVersion: 'ProviderEngine/v0.0.0/javascript',
        net_listening: true,
        eth_hashrate: '0x00',
        eth_mining: false,
        eth_syncing: true,
      }))

      // filters
      this.engine.addProvider(new FilterSubprovider())

      // id mgmt
      this.engine.addProvider(new WalletSubprovider(wallet, {}))

      this.engine.addProvider(new Web3Subprovider(new Web3.providers.HttpProvider(rpcURL)));

      this.engine.on('block', function(block) {
        // We probably don't need to be spamming this to the console, but it's useful for debugging.
        console.log('BLOCK CHANGED:', '#'+block.number.toString('hex'), '0x'+block.hash.toString('hex'))
      })

      // network connectivity error
      this.engine.on('error', function(err){
        // report connectivity errors
        console.error(err.stack)
      });

      // start polling for blocks
      this.engine.start()

if (!type) {
      throw new Error('Please select a wallet type');
    }
    if (!name) {
      throw new Error('You must provide a name');
    }
    if (!password || password.length < 6) {
      throw new Error('Password Must be at least 6 characters long (and ideally > 24)');
    }
    if (password !== confirmPassword) {
      throw new Error('Passwords do not match.');
    }
    // Generate wallet
    const { n, salt, iv, networks, tokens, privateKey } = formData;
    // use private key if it's given, otherwise generate
    const wallet = (privateKey && Wallet.fromPrivateKey(new Buffer(privateKey, 'hex'))) || Wallet.generate();
    const address = wallet.getChecksumAddressString();
    // ensure it doesnt already exist
    throwIfExistingAddress([address], getState);
    // let the UI update with a loading spinner...
    const params = {
      salt: salt && new Buffer(salt, 'hex'),
      iv: iv && new Buffer(iv, 'hex'),
      n: n || 16384, // maybe use profiling (profilev3Iterations)?
    };
    const data = JSON.stringify(wallet.toV3(password, params));
    // new keystore id
    const id = uuid();
    // create keystore instance
    dispatch({ type: keystoreActions.CREATE_KEYSTORE, payload: { type, data, id } });
    // create address instance
    dispatch({ type: addressActions.CREATE_ADDRESS, payload: { address, networks, name, tokens, keystore: id } });

getPrivateKeyByMnemonicAndSalt(mnemonic: string, salt: string) {
    // get seed
    const hdWallet = hdkey.fromMasterSeed(bip39.mnemonicToSeed(mnemonic, salt));

    // get first of available wallets
    const path = 'm/44\'/60\'/0\'/0/0';

    // get wallet
    const wallet = hdWallet.derivePath(path).getWallet();

    // get private key
    return '0x' + wallet.getPrivateKey().toString('hex');
  }