From 9d18f751c8822910391e55c29fc2b1912a1ee108 Mon Sep 17 00:00:00 2001 From: Jacob Evans Date: Thu, 5 Apr 2018 15:01:56 +1000 Subject: Create a private key subprovider --- packages/subproviders/CHANGELOG.json | 10 ++ packages/subproviders/src/index.ts | 1 + .../src/subproviders/base_wallet_subprovider.ts | 134 +++++++++++++++ packages/subproviders/src/subproviders/ledger.ts | 158 +---------------- .../src/subproviders/pk_wallet_subprovider.ts | 68 ++++++++ packages/subproviders/src/types.ts | 6 +- .../test/integration/ledger_subprovider_test.ts | 4 +- .../test/unit/ledger_subprovider_test.ts | 11 +- .../test/unit/pk_wallet_subprovider_test.ts | 188 +++++++++++++++++++++ 9 files changed, 424 insertions(+), 156 deletions(-) create mode 100644 packages/subproviders/src/subproviders/base_wallet_subprovider.ts create mode 100644 packages/subproviders/src/subproviders/pk_wallet_subprovider.ts create mode 100644 packages/subproviders/test/unit/pk_wallet_subprovider_test.ts diff --git a/packages/subproviders/CHANGELOG.json b/packages/subproviders/CHANGELOG.json index 54eb32378..0c299e90a 100644 --- a/packages/subproviders/CHANGELOG.json +++ b/packages/subproviders/CHANGELOG.json @@ -1,4 +1,14 @@ [ + { + "timestamp": 1522904386, + "version": "0.8.5", + "changes": [ + { + "note": "Add Prive Key Subprovider and refactor Provider Engine usage into Base Wallet Subprovider", + "pr": 506 + } + ] + }, { "timestamp": 1522673609, "version": "0.8.4", diff --git a/packages/subproviders/src/index.ts b/packages/subproviders/src/index.ts index 9786347e6..3541ac6f5 100644 --- a/packages/subproviders/src/index.ts +++ b/packages/subproviders/src/index.ts @@ -12,6 +12,7 @@ export { LedgerSubprovider } from './subproviders/ledger'; export { GanacheSubprovider } from './subproviders/ganache'; export { Subprovider } from './subproviders/subprovider'; export { NonceTrackerSubprovider } from './subproviders/nonce_tracker'; +export { PKWalletSubprovider } from './subproviders/pk_wallet_subprovider'; export { Callback, ErrorCallback, diff --git a/packages/subproviders/src/subproviders/base_wallet_subprovider.ts b/packages/subproviders/src/subproviders/base_wallet_subprovider.ts new file mode 100644 index 000000000..83b0da52f --- /dev/null +++ b/packages/subproviders/src/subproviders/base_wallet_subprovider.ts @@ -0,0 +1,134 @@ +import { JSONRPCRequestPayload, JSONRPCResponsePayload } from '@0xproject/types'; +import { addressUtils } from '@0xproject/utils'; +import * as _ from 'lodash'; + +import { Callback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types'; + +import { Subprovider } from './subprovider'; + +export abstract class BaseWalletSubprovider extends Subprovider { + protected static _validateSender(sender: string) { + if (_.isUndefined(sender) || !addressUtils.isAddress(sender)) { + throw new Error(WalletSubproviderErrors.SenderInvalidOrNotSupplied); + } + } + + public abstract async getAccountsAsync(): Promise; + public abstract async signTransactionAsync(txParams: PartialTxParams): Promise; + public abstract async signPersonalMessageAsync(dataIfExists: string): Promise; + + /** + * This method conforms to the web3-provider-engine interface. + * It is called internally by the ProviderEngine when it is this subproviders + * turn to handle a JSON RPC request. + * @param payload JSON RPC payload + * @param next Callback to call if this subprovider decides not to handle the request + * @param end Callback to call if subprovider handled the request and wants to pass back the request. + */ + // tslint:disable-next-line:async-suffix + public async handleRequest( + payload: JSONRPCRequestPayload, + next: Callback, + end: (err: Error | null, result?: any) => void, + ) { + let accounts; + let txParams; + switch (payload.method) { + case 'eth_coinbase': + try { + accounts = await this.getAccountsAsync(); + end(null, accounts[0]); + } catch (err) { + end(err); + } + return; + + case 'eth_accounts': + try { + accounts = await this.getAccountsAsync(); + end(null, accounts); + } catch (err) { + end(err); + } + return; + + case 'eth_sendTransaction': + txParams = payload.params[0]; + try { + BaseWalletSubprovider._validateSender(txParams.from); + const filledParams = await this._populateMissingTxParamsAsync(txParams); + const signedTx = await this.signTransactionAsync(filledParams); + const response = await this._emitSendTransactionAsync(signedTx); + end(null, response.result); + } catch (err) { + end(err); + } + return; + + case 'eth_signTransaction': + txParams = payload.params[0]; + try { + const filledParams = await this._populateMissingTxParamsAsync(txParams); + const signedTx = await this.signTransactionAsync(filledParams); + const result = { + raw: signedTx, + tx: txParams, + }; + end(null, result); + } catch (err) { + end(err); + } + return; + + case 'eth_sign': + case 'personal_sign': + const data = payload.method === 'eth_sign' ? payload.params[1] : payload.params[0]; + try { + const ecSignatureHex = await this.signPersonalMessageAsync(data); + end(null, ecSignatureHex); + } catch (err) { + end(err); + } + return; + + default: + next(); + return; + } + } + private async _emitSendTransactionAsync(signedTx: string): Promise { + const payload = { + method: 'eth_sendRawTransaction', + params: [signedTx], + }; + const result = await this.emitPayloadAsync(payload); + return result; + } + private async _populateMissingTxParamsAsync(txParams: PartialTxParams): Promise { + if (_.isUndefined(txParams.gasPrice)) { + const gasPriceResult = await this.emitPayloadAsync({ + method: 'eth_gasPrice', + params: [], + }); + const gasPrice = gasPriceResult.result.toString(); + txParams.gasPrice = gasPrice; + } + if (_.isUndefined(txParams.nonce)) { + const nonceResult = await this.emitPayloadAsync({ + method: 'eth_getTransactionCount', + params: [txParams.from, 'pending'], + }); + const nonce = nonceResult.result; + txParams.nonce = nonce; + } + if (_.isUndefined(txParams.gas)) { + const gasResult = await this.emitPayloadAsync({ + method: 'eth_estimateGas', + params: [txParams], + }); + const gas = gasResult.result.toString(); + txParams.gas = gas; + } + return txParams; + } +} diff --git a/packages/subproviders/src/subproviders/ledger.ts b/packages/subproviders/src/subproviders/ledger.ts index 95784a391..71864f19c 100644 --- a/packages/subproviders/src/subproviders/ledger.ts +++ b/packages/subproviders/src/subproviders/ledger.ts @@ -15,9 +15,10 @@ import { LedgerSubproviderErrors, PartialTxParams, ResponseWithTxParams, + WalletSubproviderErrors, } from '../types'; -import { Subprovider } from './subprovider'; +import { BaseWalletSubprovider } from './base_wallet_subprovider'; const DEFAULT_DERIVATION_PATH = `44'/60'/0'`; const DEFAULT_NUM_ADDRESSES_TO_FETCH = 10; @@ -29,7 +30,7 @@ const SHOULD_GET_CHAIN_CODE = true; * This subprovider intercepts all account related RPC requests (e.g message/transaction signing, etc...) and * re-routes them to a Ledger device plugged into the users computer. */ -export class LedgerSubprovider extends Subprovider { +export class LedgerSubprovider extends BaseWalletSubprovider { private _nonceLock = new Lock(); private _connectionLock = new Lock(); private _networkId: number; @@ -38,11 +39,6 @@ export class LedgerSubprovider extends Subprovider { private _ledgerEthereumClientFactoryAsync: LedgerEthereumClientFactoryAsync; private _ledgerClientIfExists?: LedgerEthereumClient; private _shouldAlwaysAskForConfirmation: boolean; - private static _validateSender(sender: string) { - if (_.isUndefined(sender) || !addressUtils.isAddress(sender)) { - throw new Error(LedgerSubproviderErrors.SenderInvalidOrNotSupplied); - } - } /** * Instantiates a LedgerSubprovider. Defaults to derivationPath set to `44'/60'/0'`. * TestRPC/Ganache defaults to `m/44'/60'/0'/0`, so set this in the configs if desired. @@ -168,7 +164,7 @@ export class LedgerSubprovider extends Subprovider { } } /** - * Sign a personal Ethereum signed message. The signing address will be to one + * Sign a personal Ethereum signed message. The signing address will be the one * retrieved given a derivationPath and pathIndex set on the subprovider. * The Ledger adds the Ethereum signed message prefix on-device. If you've added * the LedgerSubprovider to your app's provider, you can simply send an `eth_sign` @@ -178,6 +174,10 @@ export class LedgerSubprovider extends Subprovider { * @return Signature hex string (order: rsv) */ public async signPersonalMessageAsync(data: string): Promise { + if (_.isUndefined(data)) { + throw new Error(WalletSubproviderErrors.DataMissingForSignPersonalMessage); + } + assert.isHexString('data', data); this._ledgerClientIfExists = await this._createLedgerClientAsync(); try { const derivationPath = this._getDerivationPath(); @@ -198,82 +198,6 @@ export class LedgerSubprovider extends Subprovider { throw err; } } - /** - * This method conforms to the web3-provider-engine interface. - * It is called internally by the ProviderEngine when it is this subproviders - * turn to handle a JSON RPC request. - * @param payload JSON RPC payload - * @param next Callback to call if this subprovider decides not to handle the request - * @param end Callback to call if subprovider handled the request and wants to pass back the request. - */ - // tslint:disable-next-line:async-suffix - public async handleRequest( - payload: JSONRPCRequestPayload, - next: Callback, - end: (err: Error | null, result?: any) => void, - ) { - let accounts; - let txParams; - switch (payload.method) { - case 'eth_coinbase': - try { - accounts = await this.getAccountsAsync(); - end(null, accounts[0]); - } catch (err) { - end(err); - } - return; - - case 'eth_accounts': - try { - accounts = await this.getAccountsAsync(); - end(null, accounts); - } catch (err) { - end(err); - } - return; - - case 'eth_sendTransaction': - txParams = payload.params[0]; - try { - LedgerSubprovider._validateSender(txParams.from); - const result = await this._sendTransactionAsync(txParams); - end(null, result); - } catch (err) { - end(err); - } - return; - - case 'eth_signTransaction': - txParams = payload.params[0]; - try { - const result = await this._signTransactionWithoutSendingAsync(txParams); - end(null, result); - } catch (err) { - end(err); - } - return; - - case 'eth_sign': - case 'personal_sign': - const data = payload.method === 'eth_sign' ? payload.params[1] : payload.params[0]; - try { - if (_.isUndefined(data)) { - throw new Error(LedgerSubproviderErrors.DataMissingForSignPersonalMessage); - } - assert.isHexString('data', data); - const ecSignatureHex = await this.signPersonalMessageAsync(data); - end(null, ecSignatureHex); - } catch (err) { - end(err); - } - return; - - default: - next(); - return; - } - } private _getDerivationPath() { const derivationPath = `${this.getPath()}/${this._derivationPathIndex}`; return derivationPath; @@ -298,70 +222,4 @@ export class LedgerSubprovider extends Subprovider { this._ledgerClientIfExists = undefined; this._connectionLock.release(); } - private async _sendTransactionAsync(txParams: PartialTxParams): Promise { - await this._nonceLock.acquire(); - try { - // fill in the extras - const filledParams = await this._populateMissingTxParamsAsync(txParams); - // sign it - const signedTx = await this.signTransactionAsync(filledParams); - // emit a submit - const payload = { - method: 'eth_sendRawTransaction', - params: [signedTx], - }; - const result = await this.emitPayloadAsync(payload); - this._nonceLock.release(); - return result.result; - } catch (err) { - this._nonceLock.release(); - throw err; - } - } - private async _signTransactionWithoutSendingAsync(txParams: PartialTxParams): Promise { - await this._nonceLock.acquire(); - try { - // fill in the extras - const filledParams = await this._populateMissingTxParamsAsync(txParams); - // sign it - const signedTx = await this.signTransactionAsync(filledParams); - - this._nonceLock.release(); - const result = { - raw: signedTx, - tx: txParams, - }; - return result; - } catch (err) { - this._nonceLock.release(); - throw err; - } - } - private async _populateMissingTxParamsAsync(txParams: PartialTxParams): Promise { - if (_.isUndefined(txParams.gasPrice)) { - const gasPriceResult = await this.emitPayloadAsync({ - method: 'eth_gasPrice', - params: [], - }); - const gasPrice = gasPriceResult.result.toString(); - txParams.gasPrice = gasPrice; - } - if (_.isUndefined(txParams.nonce)) { - const nonceResult = await this.emitPayloadAsync({ - method: 'eth_getTransactionCount', - params: [txParams.from, 'pending'], - }); - const nonce = nonceResult.result; - txParams.nonce = nonce; - } - if (_.isUndefined(txParams.gas)) { - const gasResult = await this.emitPayloadAsync({ - method: 'eth_estimateGas', - params: [txParams], - }); - const gas = gasResult.result.toString(); - txParams.gas = gas; - } - return txParams; - } } diff --git a/packages/subproviders/src/subproviders/pk_wallet_subprovider.ts b/packages/subproviders/src/subproviders/pk_wallet_subprovider.ts new file mode 100644 index 000000000..06dc39237 --- /dev/null +++ b/packages/subproviders/src/subproviders/pk_wallet_subprovider.ts @@ -0,0 +1,68 @@ +import { assert } from '@0xproject/assert'; +import { JSONRPCRequestPayload } from '@0xproject/types'; +import EthereumTx = require('ethereumjs-tx'); +import * as ethUtil from 'ethereumjs-util'; +import * as _ from 'lodash'; + +import { Callback, ErrorCallback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types'; + +import { BaseWalletSubprovider } from './base_wallet_subprovider'; +import { Subprovider } from './subprovider'; + +/** + * This class implements the [web3-provider-engine](https://github.com/MetaMask/provider-engine) subprovider interface. + * This subprovider intercepts all account related RPC requests (e.g message/transaction signing, etc...) + */ +export class PKWalletSubprovider extends BaseWalletSubprovider { + private _address: string; + private _privateKeyBuffer: Buffer; + constructor(privateKey: string) { + super(); + this._privateKeyBuffer = new Buffer(privateKey, 'hex'); + this._address = `0x${ethUtil.privateToAddress(this._privateKeyBuffer).toString('hex')}`; + } + /** + * Retrieve the account calcuated from the private key. + * This method is automatically called when issuing a `eth_accounts` JSON RPC request + * via your providerEngine instance. + * @return An array of accounts + */ + public async getAccountsAsync(): Promise { + return [this._address]; + } + /** + * Sign a transaction with the private key. If you've added this Subprovider to your + * app's provider, you can simply send an `eth_sendTransaction` JSON RPC request, and + * this method will be called auto-magically. If you are not using this via a ProviderEngine + * instance, you can call it directly. + * @param txParams Parameters of the transaction to sign + * @return Signed transaction hex string + */ + public async signTransactionAsync(txParams: PartialTxParams): Promise { + const tx = new EthereumTx(txParams); + tx.sign(this._privateKeyBuffer); + const rawTx = `0x${tx.serialize().toString('hex')}`; + return rawTx; + } + /** + * Sign a personal Ethereum signed message. The signing address will be + * calculated from the private key. + * If you've added the PKWalletSubprovider to your app's provider, you can simply send an `eth_sign` + * or `personal_sign` JSON RPC request, and this method will be called auto-magically. + * If you are not using this via a ProviderEngine instance, you can call it directly. + * @param data Message to sign + * @return Signature hex string (order: rsv) + */ + public async signPersonalMessageAsync(dataIfExists: string): Promise { + if (_.isUndefined(dataIfExists)) { + throw new Error(WalletSubproviderErrors.DataMissingForSignPersonalMessage); + } + assert.isHexString('data', dataIfExists); + const dataBuff = ethUtil.toBuffer(dataIfExists); + const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff); + const sig = ethUtil.ecsign(msgHashBuff, this._privateKeyBuffer); + const rpcSig = ethUtil.toRpcSig(sig.v, sig.r, sig.s); + + return rpcSig; + } +} diff --git a/packages/subproviders/src/types.ts b/packages/subproviders/src/types.ts index a1fec1882..bacb7091b 100644 --- a/packages/subproviders/src/types.ts +++ b/packages/subproviders/src/types.ts @@ -95,11 +95,13 @@ export interface ResponseWithTxParams { tx: PartialTxParams; } +export enum WalletSubproviderErrors { + DataMissingForSignPersonalMessage = 'DATA_MISSING_FOR_SIGN_PERSONAL_MESSAGE', + SenderInvalidOrNotSupplied = 'SENDER_INVALID_OR_NOT_SUPPLIED', +} export enum LedgerSubproviderErrors { TooOldLedgerFirmware = 'TOO_OLD_LEDGER_FIRMWARE', FromAddressMissingOrInvalid = 'FROM_ADDRESS_MISSING_OR_INVALID', - DataMissingForSignPersonalMessage = 'DATA_MISSING_FOR_SIGN_PERSONAL_MESSAGE', - SenderInvalidOrNotSupplied = 'SENDER_INVALID_OR_NOT_SUPPLIED', MultipleOpenConnectionsDisallowed = 'MULTIPLE_OPEN_CONNECTIONS_DISALLOWED', } diff --git a/packages/subproviders/test/integration/ledger_subprovider_test.ts b/packages/subproviders/test/integration/ledger_subprovider_test.ts index bc60b4330..3039bd560 100644 --- a/packages/subproviders/test/integration/ledger_subprovider_test.ts +++ b/packages/subproviders/test/integration/ledger_subprovider_test.ts @@ -58,7 +58,9 @@ describe('LedgerSubprovider', () => { const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data); expect(ecSignatureHex.length).to.be.equal(132); - expect(ecSignatureHex.substr(0, 2)).to.be.equal('0x'); + expect(ecSignatureHex).to.be.equal( + '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', + ); }); it('signs a transaction', async () => { const tx = { diff --git a/packages/subproviders/test/unit/ledger_subprovider_test.ts b/packages/subproviders/test/unit/ledger_subprovider_test.ts index 3cb487f02..66cb39a48 100644 --- a/packages/subproviders/test/unit/ledger_subprovider_test.ts +++ b/packages/subproviders/test/unit/ledger_subprovider_test.ts @@ -7,7 +7,12 @@ import Web3ProviderEngine = require('web3-provider-engine'); import RpcSubprovider = require('web3-provider-engine/subproviders/rpc'); import { LedgerSubprovider } from '../../src'; -import { DoneCallback, LedgerCommunicationClient, LedgerSubproviderErrors } from '../../src/types'; +import { + DoneCallback, + LedgerCommunicationClient, + LedgerSubproviderErrors, + WalletSubproviderErrors, +} from '../../src/types'; import { chaiSetup } from '../chai_setup'; import { reportCallbackErrors } from '../utils/report_callback_errors'; @@ -222,7 +227,7 @@ describe('LedgerSubprovider', () => { }; const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { expect(err).to.not.be.a('null'); - expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied); + expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); done(); }); provider.sendAsync(payload, callback); @@ -241,7 +246,7 @@ describe('LedgerSubprovider', () => { }; const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { expect(err).to.not.be.a('null'); - expect(err.message).to.be.equal(LedgerSubproviderErrors.SenderInvalidOrNotSupplied); + expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); done(); }); provider.sendAsync(payload, callback); diff --git a/packages/subproviders/test/unit/pk_wallet_subprovider_test.ts b/packages/subproviders/test/unit/pk_wallet_subprovider_test.ts new file mode 100644 index 000000000..6dd96399a --- /dev/null +++ b/packages/subproviders/test/unit/pk_wallet_subprovider_test.ts @@ -0,0 +1,188 @@ +import { JSONRPCResponsePayload } from '@0xproject/types'; +import * as chai from 'chai'; +import * as ethUtils from 'ethereumjs-util'; +import * as _ from 'lodash'; +import Web3ProviderEngine = require('web3-provider-engine'); + +import { GanacheSubprovider, PKWalletSubprovider } from '../../src/'; +import { + DoneCallback, + LedgerCommunicationClient, + LedgerSubproviderErrors, + WalletSubproviderErrors, +} from '../../src/types'; +import { chaiSetup } from '../chai_setup'; +import { reportCallbackErrors } from '../utils/report_callback_errors'; + +chaiSetup.configure(); +const expect = chai.expect; +const TEST_RPC_ACCOUNT_0 = '0x5409ed021d9299bf6814279a6a1411a7e866a631'; +const TEST_ACCOUNT_PRIVATE_KEY = 'F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D'; + +describe('PKWalletSubprovider', () => { + let subprovider: PKWalletSubprovider; + before(async () => { + subprovider = new PKWalletSubprovider(TEST_ACCOUNT_PRIVATE_KEY); + }); + describe('direct method calls', () => { + describe('success cases', () => { + it('returns the account', async () => { + const accounts = await subprovider.getAccountsAsync(); + expect(accounts[0]).to.be.equal(TEST_RPC_ACCOUNT_0); + expect(accounts.length).to.be.equal(1); + }); + it('signs a personal message', async () => { + const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); + const ecSignatureHex = await subprovider.signPersonalMessageAsync(data); + expect(ecSignatureHex).to.be.equal( + '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', + ); + }); + it('signs a transaction', async () => { + const tx = { + nonce: '0x00', + gasPrice: '0x0', + gas: '0x2710', + to: '0x0000000000000000000000000000000000000000', + value: '0x00', + chainId: 3, + from: TEST_RPC_ACCOUNT_0, + }; + const txHex = await subprovider.signTransactionAsync(tx); + expect(txHex).to.be.equal( + '0xf85f808082271094000000000000000000000000000000000000000080802aa018894834d89899f71f6d8e74e6992fea34914c3b6d8090495f738086ca18f15da056e3333ec6c7465512a49558a84b56ec358718feaf0b162bda9aa6c40824ede4', + ); + }); + }); + }); + describe('calls through a provider', () => { + let provider: Web3ProviderEngine; + before(() => { + provider = new Web3ProviderEngine(); + provider.addProvider(subprovider); + const ganacheSubprovider = new GanacheSubprovider({}); + provider.addProvider(ganacheSubprovider); + provider.start(); + }); + describe('success cases', () => { + it('returns a list of accounts', (done: DoneCallback) => { + const payload = { + jsonrpc: '2.0', + method: 'eth_accounts', + params: [], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.be.a('null'); + expect(response.result[0]).to.be.equal(TEST_RPC_ACCOUNT_0); + expect(response.result.length).to.be.equal(1); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('signs a personal message with eth_sign', (done: DoneCallback) => { + const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); + const payload = { + jsonrpc: '2.0', + method: 'eth_sign', + params: ['0x0000000000000000000000000000000000000000', messageHex], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.be.a('null'); + expect(response.result).to.be.equal( + '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', + ); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('signs a personal message with personal_sign', (done: DoneCallback) => { + const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); + const payload = { + jsonrpc: '2.0', + method: 'personal_sign', + params: [messageHex, '0x0000000000000000000000000000000000000000'], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.be.a('null'); + expect(response.result).to.be.equal( + '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', + ); + done(); + }); + provider.sendAsync(payload, callback); + }); + }); + describe('failure cases', () => { + it('should throw if `data` param not hex when calling eth_sign', (done: DoneCallback) => { + const nonHexMessage = 'hello world'; + const payload = { + jsonrpc: '2.0', + method: 'eth_sign', + params: ['0x0000000000000000000000000000000000000000', nonHexMessage], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world'); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('should throw if `data` param not hex when calling personal_sign', (done: DoneCallback) => { + const nonHexMessage = 'hello world'; + const payload = { + jsonrpc: '2.0', + method: 'personal_sign', + params: [nonHexMessage, '0x0000000000000000000000000000000000000000'], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world'); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('should throw if `from` param missing when calling eth_sendTransaction', (done: DoneCallback) => { + const tx = { + to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', + value: '0xde0b6b3a7640000', + }; + const payload = { + jsonrpc: '2.0', + method: 'eth_sendTransaction', + params: [tx], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('should throw if `from` param invalid address when calling eth_sendTransaction', (done: DoneCallback) => { + const tx = { + to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', + from: '0xIncorrectEthereumAddress', + value: '0xde0b6b3a7640000', + }; + const payload = { + jsonrpc: '2.0', + method: 'eth_sendTransaction', + params: [tx], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); + done(); + }); + provider.sendAsync(payload, callback); + }); + }); + }); +}); -- cgit v1.2.3 From ea47613d901cb0e8d9543f37d7f591c91ef986c4 Mon Sep 17 00:00:00 2001 From: Jacob Evans Date: Thu, 5 Apr 2018 15:25:26 +1000 Subject: Use PKWalletSubprovider in testnet faucet --- packages/testnet-faucets/src/ts/handler.ts | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/packages/testnet-faucets/src/ts/handler.ts b/packages/testnet-faucets/src/ts/handler.ts index f9ac484de..9c8e59248 100644 --- a/packages/testnet-faucets/src/ts/handler.ts +++ b/packages/testnet-faucets/src/ts/handler.ts @@ -9,7 +9,7 @@ import * as Web3 from 'web3'; // we are not running in a browser env. // Filed issue: https://github.com/ethereum/web3.js/issues/844 (global as any).XMLHttpRequest = undefined; -import { NonceTrackerSubprovider } from '@0xproject/subproviders'; +import { NonceTrackerSubprovider, PKWalletSubprovider } from '@0xproject/subproviders'; import ProviderEngine = require('web3-provider-engine'); import HookedWalletSubprovider = require('web3-provider-engine/subproviders/hooked-wallet'); import RpcSubprovider = require('web3-provider-engine/subproviders/rpc'); @@ -41,9 +41,12 @@ const FIVE_DAYS_IN_MS = 4.32e8; // TODO: make this configurable export class Handler { private _networkConfigByNetworkId: ItemByNetworkId = {}; private static _createProviderEngine(rpcUrl: string) { + if (_.isUndefined(configs.DISPENSER_PRIVATE_KEY)) { + throw new Error('Dispenser Private key not found'); + } const engine = new ProviderEngine(); engine.addProvider(new NonceTrackerSubprovider()); - engine.addProvider(new HookedWalletSubprovider(idManagement)); + engine.addProvider(new PKWalletSubprovider(configs.DISPENSER_PRIVATE_KEY)); engine.addProvider( new RpcSubprovider({ rpcUrl, -- cgit v1.2.3 From 774ab8a8efa1ff5914896d9435c0362a4586c2ef Mon Sep 17 00:00:00 2001 From: Jacob Evans Date: Fri, 6 Apr 2018 14:55:03 +1000 Subject: Feedback remove id management from testnet faucet spread over txParams rather than modify in place --- packages/subproviders/CHANGELOG.json | 3 +- packages/subproviders/src/index.ts | 2 +- .../src/subproviders/base_wallet_subprovider.ts | 37 ++-- packages/subproviders/src/subproviders/ledger.ts | 1 + .../src/subproviders/pk_wallet_subprovider.ts | 68 -------- .../subproviders/private_key_wallet_subprovider.ts | 70 ++++++++ .../test/integration/ledger_subprovider_test.ts | 18 +- .../test/unit/pk_wallet_subprovider_test.ts | 188 --------------------- .../unit/private_key_wallet_subprovider_test.ts | 181 ++++++++++++++++++++ packages/subproviders/test/utils/fixture_data.ts | 8 + packages/testnet-faucets/src/ts/handler.ts | 6 +- packages/testnet-faucets/src/ts/id_management.ts | 35 ---- 12 files changed, 291 insertions(+), 326 deletions(-) delete mode 100644 packages/subproviders/src/subproviders/pk_wallet_subprovider.ts create mode 100644 packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts delete mode 100644 packages/subproviders/test/unit/pk_wallet_subprovider_test.ts create mode 100644 packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts create mode 100644 packages/subproviders/test/utils/fixture_data.ts delete mode 100644 packages/testnet-faucets/src/ts/id_management.ts diff --git a/packages/subproviders/CHANGELOG.json b/packages/subproviders/CHANGELOG.json index 0c299e90a..f0702cd5d 100644 --- a/packages/subproviders/CHANGELOG.json +++ b/packages/subproviders/CHANGELOG.json @@ -1,10 +1,9 @@ [ { - "timestamp": 1522904386, "version": "0.8.5", "changes": [ { - "note": "Add Prive Key Subprovider and refactor Provider Engine usage into Base Wallet Subprovider", + "note": "Add private key subprovider and refactor shared functionality into a base wallet subprovider", "pr": 506 } ] diff --git a/packages/subproviders/src/index.ts b/packages/subproviders/src/index.ts index 3541ac6f5..dd553fde4 100644 --- a/packages/subproviders/src/index.ts +++ b/packages/subproviders/src/index.ts @@ -12,7 +12,7 @@ export { LedgerSubprovider } from './subproviders/ledger'; export { GanacheSubprovider } from './subproviders/ganache'; export { Subprovider } from './subproviders/subprovider'; export { NonceTrackerSubprovider } from './subproviders/nonce_tracker'; -export { PKWalletSubprovider } from './subproviders/pk_wallet_subprovider'; +export { PrivateKeyWalletSubprovider } from './subproviders/private_key_wallet_subprovider'; export { Callback, ErrorCallback, diff --git a/packages/subproviders/src/subproviders/base_wallet_subprovider.ts b/packages/subproviders/src/subproviders/base_wallet_subprovider.ts index 83b0da52f..034f83e7f 100644 --- a/packages/subproviders/src/subproviders/base_wallet_subprovider.ts +++ b/packages/subproviders/src/subproviders/base_wallet_subprovider.ts @@ -1,13 +1,19 @@ +import { assert } from '@0xproject/assert'; import { JSONRPCRequestPayload, JSONRPCResponsePayload } from '@0xproject/types'; import { addressUtils } from '@0xproject/utils'; import * as _ from 'lodash'; -import { Callback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types'; +import { Callback, ErrorCallback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types'; import { Subprovider } from './subprovider'; export abstract class BaseWalletSubprovider extends Subprovider { - protected static _validateSender(sender: string) { + protected static _validateTxParams(txParams: PartialTxParams) { + assert.isETHAddressHex('to', txParams.to); + assert.isHexString('nonce', txParams.nonce); + assert.isHexString('gas', txParams.gas); + } + private static _validateSender(sender: string) { if (_.isUndefined(sender) || !addressUtils.isAddress(sender)) { throw new Error(WalletSubproviderErrors.SenderInvalidOrNotSupplied); } @@ -15,7 +21,7 @@ export abstract class BaseWalletSubprovider extends Subprovider { public abstract async getAccountsAsync(): Promise; public abstract async signTransactionAsync(txParams: PartialTxParams): Promise; - public abstract async signPersonalMessageAsync(dataIfExists: string): Promise; + public abstract async signPersonalMessageAsync(data: string): Promise; /** * This method conforms to the web3-provider-engine interface. @@ -26,11 +32,7 @@ export abstract class BaseWalletSubprovider extends Subprovider { * @param end Callback to call if subprovider handled the request and wants to pass back the request. */ // tslint:disable-next-line:async-suffix - public async handleRequest( - payload: JSONRPCRequestPayload, - next: Callback, - end: (err: Error | null, result?: any) => void, - ) { + public async handleRequest(payload: JSONRPCRequestPayload, next: Callback, end: ErrorCallback) { let accounts; let txParams; switch (payload.method) { @@ -104,30 +106,31 @@ export abstract class BaseWalletSubprovider extends Subprovider { const result = await this.emitPayloadAsync(payload); return result; } - private async _populateMissingTxParamsAsync(txParams: PartialTxParams): Promise { - if (_.isUndefined(txParams.gasPrice)) { + private async _populateMissingTxParamsAsync(partialTxParams: PartialTxParams): Promise { + let txParams = partialTxParams; + if (_.isUndefined(partialTxParams.gasPrice)) { const gasPriceResult = await this.emitPayloadAsync({ method: 'eth_gasPrice', params: [], }); const gasPrice = gasPriceResult.result.toString(); - txParams.gasPrice = gasPrice; + txParams = { ...txParams, gasPrice }; } - if (_.isUndefined(txParams.nonce)) { + if (_.isUndefined(partialTxParams.nonce)) { const nonceResult = await this.emitPayloadAsync({ method: 'eth_getTransactionCount', - params: [txParams.from, 'pending'], + params: [partialTxParams.from, 'pending'], }); const nonce = nonceResult.result; - txParams.nonce = nonce; + txParams = { ...txParams, nonce }; } - if (_.isUndefined(txParams.gas)) { + if (_.isUndefined(partialTxParams.gas)) { const gasResult = await this.emitPayloadAsync({ method: 'eth_estimateGas', - params: [txParams], + params: [partialTxParams], }); const gas = gasResult.result.toString(); - txParams.gas = gas; + txParams = { ...txParams, gas }; } return txParams; } diff --git a/packages/subproviders/src/subproviders/ledger.ts b/packages/subproviders/src/subproviders/ledger.ts index 71864f19c..aa86bf6c0 100644 --- a/packages/subproviders/src/subproviders/ledger.ts +++ b/packages/subproviders/src/subproviders/ledger.ts @@ -129,6 +129,7 @@ export class LedgerSubprovider extends BaseWalletSubprovider { * @return Signed transaction hex string */ public async signTransactionAsync(txParams: PartialTxParams): Promise { + LedgerSubprovider._validateTxParams(txParams); this._ledgerClientIfExists = await this._createLedgerClientAsync(); const tx = new EthereumTx(txParams); diff --git a/packages/subproviders/src/subproviders/pk_wallet_subprovider.ts b/packages/subproviders/src/subproviders/pk_wallet_subprovider.ts deleted file mode 100644 index 06dc39237..000000000 --- a/packages/subproviders/src/subproviders/pk_wallet_subprovider.ts +++ /dev/null @@ -1,68 +0,0 @@ -import { assert } from '@0xproject/assert'; -import { JSONRPCRequestPayload } from '@0xproject/types'; -import EthereumTx = require('ethereumjs-tx'); -import * as ethUtil from 'ethereumjs-util'; -import * as _ from 'lodash'; - -import { Callback, ErrorCallback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types'; - -import { BaseWalletSubprovider } from './base_wallet_subprovider'; -import { Subprovider } from './subprovider'; - -/** - * This class implements the [web3-provider-engine](https://github.com/MetaMask/provider-engine) subprovider interface. - * This subprovider intercepts all account related RPC requests (e.g message/transaction signing, etc...) - */ -export class PKWalletSubprovider extends BaseWalletSubprovider { - private _address: string; - private _privateKeyBuffer: Buffer; - constructor(privateKey: string) { - super(); - this._privateKeyBuffer = new Buffer(privateKey, 'hex'); - this._address = `0x${ethUtil.privateToAddress(this._privateKeyBuffer).toString('hex')}`; - } - /** - * Retrieve the account calcuated from the private key. - * This method is automatically called when issuing a `eth_accounts` JSON RPC request - * via your providerEngine instance. - * @return An array of accounts - */ - public async getAccountsAsync(): Promise { - return [this._address]; - } - /** - * Sign a transaction with the private key. If you've added this Subprovider to your - * app's provider, you can simply send an `eth_sendTransaction` JSON RPC request, and - * this method will be called auto-magically. If you are not using this via a ProviderEngine - * instance, you can call it directly. - * @param txParams Parameters of the transaction to sign - * @return Signed transaction hex string - */ - public async signTransactionAsync(txParams: PartialTxParams): Promise { - const tx = new EthereumTx(txParams); - tx.sign(this._privateKeyBuffer); - const rawTx = `0x${tx.serialize().toString('hex')}`; - return rawTx; - } - /** - * Sign a personal Ethereum signed message. The signing address will be - * calculated from the private key. - * If you've added the PKWalletSubprovider to your app's provider, you can simply send an `eth_sign` - * or `personal_sign` JSON RPC request, and this method will be called auto-magically. - * If you are not using this via a ProviderEngine instance, you can call it directly. - * @param data Message to sign - * @return Signature hex string (order: rsv) - */ - public async signPersonalMessageAsync(dataIfExists: string): Promise { - if (_.isUndefined(dataIfExists)) { - throw new Error(WalletSubproviderErrors.DataMissingForSignPersonalMessage); - } - assert.isHexString('data', dataIfExists); - const dataBuff = ethUtil.toBuffer(dataIfExists); - const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff); - const sig = ethUtil.ecsign(msgHashBuff, this._privateKeyBuffer); - const rpcSig = ethUtil.toRpcSig(sig.v, sig.r, sig.s); - - return rpcSig; - } -} diff --git a/packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts b/packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts new file mode 100644 index 000000000..c3a53773a --- /dev/null +++ b/packages/subproviders/src/subproviders/private_key_wallet_subprovider.ts @@ -0,0 +1,70 @@ +import { assert } from '@0xproject/assert'; +import { JSONRPCRequestPayload } from '@0xproject/types'; +import EthereumTx = require('ethereumjs-tx'); +import * as ethUtil from 'ethereumjs-util'; +import * as _ from 'lodash'; + +import { Callback, ErrorCallback, PartialTxParams, ResponseWithTxParams, WalletSubproviderErrors } from '../types'; + +import { BaseWalletSubprovider } from './base_wallet_subprovider'; +import { Subprovider } from './subprovider'; + +/** + * This class implements the [web3-provider-engine](https://github.com/MetaMask/provider-engine) subprovider interface. + * This subprovider intercepts all account related RPC requests (e.g message/transaction signing, etc...) and handles + * all requests with the supplied Ethereum private key. + */ +export class PrivateKeyWalletSubprovider extends BaseWalletSubprovider { + private _address: string; + private _privateKeyBuffer: Buffer; + constructor(privateKey: string) { + assert.isString('privateKey', privateKey); + super(); + this._privateKeyBuffer = new Buffer(privateKey, 'hex'); + this._address = `0x${ethUtil.privateToAddress(this._privateKeyBuffer).toString('hex')}`; + } + /** + * Retrieve the account associated with the supplied private key. + * This method is implicitly called when issuing a `eth_accounts` JSON RPC request + * via your providerEngine instance. + * @return An array of accounts + */ + public async getAccountsAsync(): Promise { + return [this._address]; + } + /** + * Sign a transaction with the private key. If you've added this Subprovider to your + * app's provider, you can simply send an `eth_sendTransaction` JSON RPC request, and + * this method will be called auto-magically. If you are not using this via a ProviderEngine + * instance, you can call it directly. + * @param txParams Parameters of the transaction to sign + * @return Signed transaction hex string + */ + public async signTransactionAsync(txParams: PartialTxParams): Promise { + PrivateKeyWalletSubprovider._validateTxParams(txParams); + const tx = new EthereumTx(txParams); + tx.sign(this._privateKeyBuffer); + const rawTx = `0x${tx.serialize().toString('hex')}`; + return rawTx; + } + /** + * Sign a personal Ethereum signed message. The signing address will be + * calculated from the private key. + * If you've added the PKWalletSubprovider to your app's provider, you can simply send an `eth_sign` + * or `personal_sign` JSON RPC request, and this method will be called auto-magically. + * If you are not using this via a ProviderEngine instance, you can call it directly. + * @param data Message to sign + * @return Signature hex string (order: rsv) + */ + public async signPersonalMessageAsync(dataIfExists: string): Promise { + if (_.isUndefined(dataIfExists)) { + throw new Error(WalletSubproviderErrors.DataMissingForSignPersonalMessage); + } + assert.isHexString('data', dataIfExists); + const dataBuff = ethUtil.toBuffer(dataIfExists); + const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff); + const sig = ethUtil.ecsign(msgHashBuff, this._privateKeyBuffer); + const rpcSig = ethUtil.toRpcSig(sig.v, sig.r, sig.s); + return rpcSig; + } +} diff --git a/packages/subproviders/test/integration/ledger_subprovider_test.ts b/packages/subproviders/test/integration/ledger_subprovider_test.ts index 3039bd560..da858b6b3 100644 --- a/packages/subproviders/test/integration/ledger_subprovider_test.ts +++ b/packages/subproviders/test/integration/ledger_subprovider_test.ts @@ -14,6 +14,7 @@ import RpcSubprovider = require('web3-provider-engine/subproviders/rpc'); import { LedgerSubprovider } from '../../src'; import { DoneCallback, LedgerEthereumClient } from '../../src/types'; import { chaiSetup } from '../chai_setup'; +import { fixtureData } from '../utils/fixture_data'; import { reportCallbackErrors } from '../utils/report_callback_errors'; chaiSetup.configure(); @@ -25,9 +26,6 @@ async function ledgerEthereumNodeJsClientFactoryAsync(): Promise { let ledgerSubprovider: LedgerSubprovider; const networkId: number = 42; @@ -35,7 +33,7 @@ describe('LedgerSubprovider', () => { ledgerSubprovider = new LedgerSubprovider({ networkId, ledgerEthereumClientFactoryAsync: ledgerEthereumNodeJsClientFactoryAsync, - derivationPath: TESTRPC_DERIVATION_PATH, + derivationPath: fixtureData.TESTRPC_DERIVATION_PATH, }); }); describe('direct method calls', () => { @@ -46,7 +44,7 @@ describe('LedgerSubprovider', () => { }); it('returns the expected first account from a ledger set up with the test mnemonic', async () => { const accounts = await ledgerSubprovider.getAccountsAsync(); - expect(accounts[0]).to.be.equal(TEST_RPC_ACCOUNT_0); + expect(accounts[0]).to.be.equal(fixtureData.TEST_RPC_ACCOUNT_0); }); it('returns requested number of accounts', async () => { const numberOfAccounts = 20; @@ -55,12 +53,10 @@ describe('LedgerSubprovider', () => { expect(accounts.length).to.be.equal(numberOfAccounts); }); it('signs a personal message', async () => { - const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); + const data = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING)); const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data); expect(ecSignatureHex.length).to.be.equal(132); - expect(ecSignatureHex).to.be.equal( - '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', - ); + expect(ecSignatureHex).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT); }); it('signs a transaction', async () => { const tx = { @@ -69,7 +65,7 @@ describe('LedgerSubprovider', () => { to: '0x0000000000000000000000000000000000000000', value: '0x00', chainId: 3, - from: TEST_RPC_ACCOUNT_0, + from: fixtureData.TEST_RPC_ACCOUNT_0, }; const txHex = await ledgerSubprovider.signTransactionAsync(tx); expect(txHex).to.be.equal( @@ -173,7 +169,7 @@ describe('LedgerSubprovider', () => { // Give first account on Ledger sufficient ETH to complete tx send let tx = { to: accounts[0], - from: TEST_RPC_ACCOUNT_0, + from: fixtureData.TEST_RPC_ACCOUNT_0, value: '0x8ac7230489e80000', // 10 ETH }; let payload = { diff --git a/packages/subproviders/test/unit/pk_wallet_subprovider_test.ts b/packages/subproviders/test/unit/pk_wallet_subprovider_test.ts deleted file mode 100644 index 6dd96399a..000000000 --- a/packages/subproviders/test/unit/pk_wallet_subprovider_test.ts +++ /dev/null @@ -1,188 +0,0 @@ -import { JSONRPCResponsePayload } from '@0xproject/types'; -import * as chai from 'chai'; -import * as ethUtils from 'ethereumjs-util'; -import * as _ from 'lodash'; -import Web3ProviderEngine = require('web3-provider-engine'); - -import { GanacheSubprovider, PKWalletSubprovider } from '../../src/'; -import { - DoneCallback, - LedgerCommunicationClient, - LedgerSubproviderErrors, - WalletSubproviderErrors, -} from '../../src/types'; -import { chaiSetup } from '../chai_setup'; -import { reportCallbackErrors } from '../utils/report_callback_errors'; - -chaiSetup.configure(); -const expect = chai.expect; -const TEST_RPC_ACCOUNT_0 = '0x5409ed021d9299bf6814279a6a1411a7e866a631'; -const TEST_ACCOUNT_PRIVATE_KEY = 'F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D'; - -describe('PKWalletSubprovider', () => { - let subprovider: PKWalletSubprovider; - before(async () => { - subprovider = new PKWalletSubprovider(TEST_ACCOUNT_PRIVATE_KEY); - }); - describe('direct method calls', () => { - describe('success cases', () => { - it('returns the account', async () => { - const accounts = await subprovider.getAccountsAsync(); - expect(accounts[0]).to.be.equal(TEST_RPC_ACCOUNT_0); - expect(accounts.length).to.be.equal(1); - }); - it('signs a personal message', async () => { - const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); - const ecSignatureHex = await subprovider.signPersonalMessageAsync(data); - expect(ecSignatureHex).to.be.equal( - '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', - ); - }); - it('signs a transaction', async () => { - const tx = { - nonce: '0x00', - gasPrice: '0x0', - gas: '0x2710', - to: '0x0000000000000000000000000000000000000000', - value: '0x00', - chainId: 3, - from: TEST_RPC_ACCOUNT_0, - }; - const txHex = await subprovider.signTransactionAsync(tx); - expect(txHex).to.be.equal( - '0xf85f808082271094000000000000000000000000000000000000000080802aa018894834d89899f71f6d8e74e6992fea34914c3b6d8090495f738086ca18f15da056e3333ec6c7465512a49558a84b56ec358718feaf0b162bda9aa6c40824ede4', - ); - }); - }); - }); - describe('calls through a provider', () => { - let provider: Web3ProviderEngine; - before(() => { - provider = new Web3ProviderEngine(); - provider.addProvider(subprovider); - const ganacheSubprovider = new GanacheSubprovider({}); - provider.addProvider(ganacheSubprovider); - provider.start(); - }); - describe('success cases', () => { - it('returns a list of accounts', (done: DoneCallback) => { - const payload = { - jsonrpc: '2.0', - method: 'eth_accounts', - params: [], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.be.a('null'); - expect(response.result[0]).to.be.equal(TEST_RPC_ACCOUNT_0); - expect(response.result.length).to.be.equal(1); - done(); - }); - provider.sendAsync(payload, callback); - }); - it('signs a personal message with eth_sign', (done: DoneCallback) => { - const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); - const payload = { - jsonrpc: '2.0', - method: 'eth_sign', - params: ['0x0000000000000000000000000000000000000000', messageHex], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.be.a('null'); - expect(response.result).to.be.equal( - '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', - ); - done(); - }); - provider.sendAsync(payload, callback); - }); - it('signs a personal message with personal_sign', (done: DoneCallback) => { - const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); - const payload = { - jsonrpc: '2.0', - method: 'personal_sign', - params: [messageHex, '0x0000000000000000000000000000000000000000'], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.be.a('null'); - expect(response.result).to.be.equal( - '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', - ); - done(); - }); - provider.sendAsync(payload, callback); - }); - }); - describe('failure cases', () => { - it('should throw if `data` param not hex when calling eth_sign', (done: DoneCallback) => { - const nonHexMessage = 'hello world'; - const payload = { - jsonrpc: '2.0', - method: 'eth_sign', - params: ['0x0000000000000000000000000000000000000000', nonHexMessage], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.not.be.a('null'); - expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world'); - done(); - }); - provider.sendAsync(payload, callback); - }); - it('should throw if `data` param not hex when calling personal_sign', (done: DoneCallback) => { - const nonHexMessage = 'hello world'; - const payload = { - jsonrpc: '2.0', - method: 'personal_sign', - params: [nonHexMessage, '0x0000000000000000000000000000000000000000'], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.not.be.a('null'); - expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world'); - done(); - }); - provider.sendAsync(payload, callback); - }); - it('should throw if `from` param missing when calling eth_sendTransaction', (done: DoneCallback) => { - const tx = { - to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', - value: '0xde0b6b3a7640000', - }; - const payload = { - jsonrpc: '2.0', - method: 'eth_sendTransaction', - params: [tx], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.not.be.a('null'); - expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); - done(); - }); - provider.sendAsync(payload, callback); - }); - it('should throw if `from` param invalid address when calling eth_sendTransaction', (done: DoneCallback) => { - const tx = { - to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', - from: '0xIncorrectEthereumAddress', - value: '0xde0b6b3a7640000', - }; - const payload = { - jsonrpc: '2.0', - method: 'eth_sendTransaction', - params: [tx], - id: 1, - }; - const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { - expect(err).to.not.be.a('null'); - expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); - done(); - }); - provider.sendAsync(payload, callback); - }); - }); - }); -}); diff --git a/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts b/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts new file mode 100644 index 000000000..32650b3a0 --- /dev/null +++ b/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts @@ -0,0 +1,181 @@ +import { JSONRPCResponsePayload } from '@0xproject/types'; +import * as chai from 'chai'; +import * as ethUtils from 'ethereumjs-util'; +import * as _ from 'lodash'; +import Web3ProviderEngine = require('web3-provider-engine'); + +import { GanacheSubprovider, PrivateKeyWalletSubprovider } from '../../src/'; +import { + DoneCallback, + LedgerCommunicationClient, + LedgerSubproviderErrors, + WalletSubproviderErrors, +} from '../../src/types'; +import { chaiSetup } from '../chai_setup'; +import { fixtureData } from '../utils/fixture_data'; +import { reportCallbackErrors } from '../utils/report_callback_errors'; + +chaiSetup.configure(); +const expect = chai.expect; + +describe('PrivateKeyWalletSubprovider', () => { + let subprovider: PrivateKeyWalletSubprovider; + before(async () => { + subprovider = new PrivateKeyWalletSubprovider(fixtureData.TEST_ACCOUNT_PRIVATE_KEY); + }); + describe('direct method calls', () => { + describe('success cases', () => { + it('returns the account', async () => { + const accounts = await subprovider.getAccountsAsync(); + expect(accounts[0]).to.be.equal(fixtureData.TEST_RPC_ACCOUNT_0); + expect(accounts.length).to.be.equal(1); + }); + it('signs a personal message', async () => { + const data = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING)); + const ecSignatureHex = await subprovider.signPersonalMessageAsync(data); + expect(ecSignatureHex).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT); + }); + it('signs a transaction', async () => { + const tx = { + nonce: '0x00', + gasPrice: '0x0', + gas: '0x2710', + to: '0x0000000000000000000000000000000000000000', + value: '0x00', + chainId: 3, + from: fixtureData.TEST_RPC_ACCOUNT_0, + }; + const txHex = await subprovider.signTransactionAsync(tx); + expect(txHex).to.be.equal( + '0xf85f808082271094000000000000000000000000000000000000000080802aa018894834d89899f71f6d8e74e6992fea34914c3b6d8090495f738086ca18f15da056e3333ec6c7465512a49558a84b56ec358718feaf0b162bda9aa6c40824ede4', + ); + }); + }); + }); + describe('calls through a provider', () => { + let provider: Web3ProviderEngine; + before(() => { + provider = new Web3ProviderEngine(); + provider.addProvider(subprovider); + const ganacheSubprovider = new GanacheSubprovider({}); + provider.addProvider(ganacheSubprovider); + provider.start(); + }); + describe('success cases', () => { + it('returns a list of accounts', (done: DoneCallback) => { + const payload = { + jsonrpc: '2.0', + method: 'eth_accounts', + params: [], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.be.a('null'); + expect(response.result[0]).to.be.equal(fixtureData.TEST_RPC_ACCOUNT_0); + expect(response.result.length).to.be.equal(1); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('signs a personal message with eth_sign', (done: DoneCallback) => { + const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING)); + const payload = { + jsonrpc: '2.0', + method: 'eth_sign', + params: ['0x0000000000000000000000000000000000000000', messageHex], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.be.a('null'); + expect(response.result).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('signs a personal message with personal_sign', (done: DoneCallback) => { + const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING)); + const payload = { + jsonrpc: '2.0', + method: 'personal_sign', + params: [messageHex, '0x0000000000000000000000000000000000000000'], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.be.a('null'); + expect(response.result).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT); + done(); + }); + provider.sendAsync(payload, callback); + }); + }); + describe('failure cases', () => { + it('should throw if `data` param not hex when calling eth_sign', (done: DoneCallback) => { + const nonHexMessage = 'hello world'; + const payload = { + jsonrpc: '2.0', + method: 'eth_sign', + params: ['0x0000000000000000000000000000000000000000', nonHexMessage], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world'); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('should throw if `data` param not hex when calling personal_sign', (done: DoneCallback) => { + const nonHexMessage = 'hello world'; + const payload = { + jsonrpc: '2.0', + method: 'personal_sign', + params: [nonHexMessage, '0x0000000000000000000000000000000000000000'], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal('Expected data to be of type HexString, encountered: hello world'); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('should throw if `from` param missing when calling eth_sendTransaction', (done: DoneCallback) => { + const tx = { + to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', + value: '0xde0b6b3a7640000', + }; + const payload = { + jsonrpc: '2.0', + method: 'eth_sendTransaction', + params: [tx], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); + done(); + }); + provider.sendAsync(payload, callback); + }); + it('should throw if `from` param invalid address when calling eth_sendTransaction', (done: DoneCallback) => { + const tx = { + to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', + from: '0xIncorrectEthereumAddress', + value: '0xde0b6b3a7640000', + }; + const payload = { + jsonrpc: '2.0', + method: 'eth_sendTransaction', + params: [tx], + id: 1, + }; + const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { + expect(err).to.not.be.a('null'); + expect(err.message).to.be.equal(WalletSubproviderErrors.SenderInvalidOrNotSupplied); + done(); + }); + provider.sendAsync(payload, callback); + }); + }); + }); +}); diff --git a/packages/subproviders/test/utils/fixture_data.ts b/packages/subproviders/test/utils/fixture_data.ts new file mode 100644 index 000000000..3b6ab123e --- /dev/null +++ b/packages/subproviders/test/utils/fixture_data.ts @@ -0,0 +1,8 @@ +export const fixtureData = { + TEST_RPC_ACCOUNT_0: '0x5409ed021d9299bf6814279a6a1411a7e866a631', + TEST_ACCOUNT_PRIVATE_KEY: 'F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D', + PERSONAL_MESSAGE_STRING: 'hello world', + PERSONAL_MESSAGE_SIGNED_RESULT: + '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', + TESTRPC_DERIVATION_PATH: `m/44'/60'/0'/0`, +}; diff --git a/packages/testnet-faucets/src/ts/handler.ts b/packages/testnet-faucets/src/ts/handler.ts index 9c8e59248..a6e786552 100644 --- a/packages/testnet-faucets/src/ts/handler.ts +++ b/packages/testnet-faucets/src/ts/handler.ts @@ -9,15 +9,13 @@ import * as Web3 from 'web3'; // we are not running in a browser env. // Filed issue: https://github.com/ethereum/web3.js/issues/844 (global as any).XMLHttpRequest = undefined; -import { NonceTrackerSubprovider, PKWalletSubprovider } from '@0xproject/subproviders'; +import { NonceTrackerSubprovider, PrivateKeyWalletSubprovider } from '@0xproject/subproviders'; import ProviderEngine = require('web3-provider-engine'); -import HookedWalletSubprovider = require('web3-provider-engine/subproviders/hooked-wallet'); import RpcSubprovider = require('web3-provider-engine/subproviders/rpc'); import { configs } from './configs'; import { DispatchQueue } from './dispatch_queue'; import { dispenseAssetTasks } from './dispense_asset_tasks'; -import { idManagement } from './id_management'; import { rpcUrls } from './rpc_urls'; interface NetworkConfig { @@ -46,7 +44,7 @@ export class Handler { } const engine = new ProviderEngine(); engine.addProvider(new NonceTrackerSubprovider()); - engine.addProvider(new PKWalletSubprovider(configs.DISPENSER_PRIVATE_KEY)); + engine.addProvider(new PrivateKeyWalletSubprovider(configs.DISPENSER_PRIVATE_KEY)); engine.addProvider( new RpcSubprovider({ rpcUrl, diff --git a/packages/testnet-faucets/src/ts/id_management.ts b/packages/testnet-faucets/src/ts/id_management.ts deleted file mode 100644 index 7c598f91c..000000000 --- a/packages/testnet-faucets/src/ts/id_management.ts +++ /dev/null @@ -1,35 +0,0 @@ -import EthereumTx = require('ethereumjs-tx'); -import * as ethUtil from 'ethereumjs-util'; -import * as _ from 'lodash'; - -import { configs } from './configs'; - -type Callback = (err: Error | null, result: any) => void; - -export const idManagement = { - getAccounts(callback: Callback) { - callback(null, [configs.DISPENSER_ADDRESS]); - }, - approveTransaction(txData: object, callback: Callback) { - callback(null, true); - }, - signTransaction(txData: object, callback: Callback) { - const tx = new EthereumTx(txData); - const privateKeyBuffer = new Buffer(configs.DISPENSER_PRIVATE_KEY as string, 'hex'); - tx.sign(privateKeyBuffer); - const rawTx = `0x${tx.serialize().toString('hex')}`; - callback(null, rawTx); - }, - signMessage(message: object, callback: Callback) { - const dataIfExists = _.get(message, 'data'); - if (_.isUndefined(dataIfExists)) { - callback(new Error('NO_DATA_TO_SIGN'), null); - } - const privateKeyBuffer = new Buffer(configs.DISPENSER_PRIVATE_KEY as string, 'hex'); - const dataBuff = ethUtil.toBuffer(dataIfExists); - const msgHashBuff = ethUtil.hashPersonalMessage(dataBuff); - const sig = ethUtil.ecsign(msgHashBuff, privateKeyBuffer); - const rpcSig = ethUtil.toRpcSig(sig.v, sig.r, sig.s); - callback(null, rpcSig); - }, -}; -- cgit v1.2.3 From a0fac663f72feafbac98c2949578ec48b8d2ec0a Mon Sep 17 00:00:00 2001 From: Jacob Evans Date: Fri, 6 Apr 2018 16:07:00 +1000 Subject: Update shared fixture data for network 42 --- .../test/integration/ledger_subprovider_test.ts | 25 +++++----------------- .../test/unit/ledger_subprovider_test.ts | 5 +++-- .../unit/private_key_wallet_subprovider_test.ts | 17 +++------------ packages/subproviders/test/utils/fixture_data.ts | 19 ++++++++++++++-- 4 files changed, 28 insertions(+), 38 deletions(-) diff --git a/packages/subproviders/test/integration/ledger_subprovider_test.ts b/packages/subproviders/test/integration/ledger_subprovider_test.ts index da858b6b3..503618089 100644 --- a/packages/subproviders/test/integration/ledger_subprovider_test.ts +++ b/packages/subproviders/test/integration/ledger_subprovider_test.ts @@ -28,7 +28,7 @@ async function ledgerEthereumNodeJsClientFactoryAsync(): Promise { let ledgerSubprovider: LedgerSubprovider; - const networkId: number = 42; + const networkId: number = fixtureData.NETWORK_ID; before(async () => { ledgerSubprovider = new LedgerSubprovider({ networkId, @@ -59,18 +59,8 @@ describe('LedgerSubprovider', () => { expect(ecSignatureHex).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT); }); it('signs a transaction', async () => { - const tx = { - nonce: '0x00', - gas: '0x2710', - to: '0x0000000000000000000000000000000000000000', - value: '0x00', - chainId: 3, - from: fixtureData.TEST_RPC_ACCOUNT_0, - }; - const txHex = await ledgerSubprovider.signTransactionAsync(tx); - expect(txHex).to.be.equal( - '0xf85f8080822710940000000000000000000000000000000000000000808078a0712854c73c69445cc1b22a7c3d7312ff9a97fe4ffba35fd636e8236b211b6e7ca0647cee031615e52d916c7c707025bc64ad525d8f1b9876c3435a863b42743178', - ); + const txHex = await ledgerSubprovider.signTransactionAsync(fixtureData.TX_DATA); + expect(txHex).to.be.equal(fixtureData.TX_DATA_SIGNED_RESULT); }); }); describe('calls through a provider', () => { @@ -144,20 +134,15 @@ describe('LedgerSubprovider', () => { })().catch(done); }); it('signs a transaction', (done: DoneCallback) => { - const tx = { - to: '0xafa3f8684e54059998bc3a7b0d2b0da075154d66', - value: '0x00', - }; const payload = { jsonrpc: '2.0', method: 'eth_signTransaction', - params: [tx], + params: [fixtureData.TX_DATA], id: 1, }; const callback = reportCallbackErrors(done)((err: Error, response: JSONRPCResponsePayload) => { expect(err).to.be.a('null'); - expect(response.result.raw.length).to.be.equal(206); - expect(response.result.raw.substr(0, 2)).to.be.equal('0x'); + expect(response.result.raw).to.be.equal(fixtureData.TX_DATA_SIGNED_RESULT); done(); }); ledgerProvider.sendAsync(payload, callback); diff --git a/packages/subproviders/test/unit/ledger_subprovider_test.ts b/packages/subproviders/test/unit/ledger_subprovider_test.ts index 66cb39a48..c18506681 100644 --- a/packages/subproviders/test/unit/ledger_subprovider_test.ts +++ b/packages/subproviders/test/unit/ledger_subprovider_test.ts @@ -14,6 +14,7 @@ import { WalletSubproviderErrors, } from '../../src/types'; import { chaiSetup } from '../chai_setup'; +import { fixtureData } from '../utils/fixture_data'; import { reportCallbackErrors } from '../utils/report_callback_errors'; chaiSetup.configure(); @@ -80,7 +81,7 @@ describe('LedgerSubprovider', () => { expect(accounts.length).to.be.equal(numberOfAccounts); }); it('signs a personal message', async () => { - const data = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); + const data = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING)); const ecSignatureHex = await ledgerSubprovider.signPersonalMessageAsync(data); expect(ecSignatureHex).to.be.equal( '0xa6cc284bff14b42bdf5e9286730c152be91719d478605ec46b3bebcd0ae491480652a1a7b742ceb0213d1e744316e285f41f878d8af0b8e632cbca4c279132d001', @@ -144,7 +145,7 @@ describe('LedgerSubprovider', () => { provider.sendAsync(payload, callback); }); it('signs a personal message with personal_sign', (done: DoneCallback) => { - const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer('hello world')); + const messageHex = ethUtils.bufferToHex(ethUtils.toBuffer(fixtureData.PERSONAL_MESSAGE_STRING)); const payload = { jsonrpc: '2.0', method: 'personal_sign', diff --git a/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts b/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts index 32650b3a0..ca0665871 100644 --- a/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts +++ b/packages/subproviders/test/unit/private_key_wallet_subprovider_test.ts @@ -21,7 +21,7 @@ const expect = chai.expect; describe('PrivateKeyWalletSubprovider', () => { let subprovider: PrivateKeyWalletSubprovider; before(async () => { - subprovider = new PrivateKeyWalletSubprovider(fixtureData.TEST_ACCOUNT_PRIVATE_KEY); + subprovider = new PrivateKeyWalletSubprovider(fixtureData.TEST_RPC_ACCOUNT_0_ACCOUNT_PRIVATE_KEY); }); describe('direct method calls', () => { describe('success cases', () => { @@ -36,19 +36,8 @@ describe('PrivateKeyWalletSubprovider', () => { expect(ecSignatureHex).to.be.equal(fixtureData.PERSONAL_MESSAGE_SIGNED_RESULT); }); it('signs a transaction', async () => { - const tx = { - nonce: '0x00', - gasPrice: '0x0', - gas: '0x2710', - to: '0x0000000000000000000000000000000000000000', - value: '0x00', - chainId: 3, - from: fixtureData.TEST_RPC_ACCOUNT_0, - }; - const txHex = await subprovider.signTransactionAsync(tx); - expect(txHex).to.be.equal( - '0xf85f808082271094000000000000000000000000000000000000000080802aa018894834d89899f71f6d8e74e6992fea34914c3b6d8090495f738086ca18f15da056e3333ec6c7465512a49558a84b56ec358718feaf0b162bda9aa6c40824ede4', - ); + const txHex = await subprovider.signTransactionAsync(fixtureData.TX_DATA); + expect(txHex).to.be.equal(fixtureData.TX_DATA_SIGNED_RESULT); }); }); }); diff --git a/packages/subproviders/test/utils/fixture_data.ts b/packages/subproviders/test/utils/fixture_data.ts index 3b6ab123e..890573d0d 100644 --- a/packages/subproviders/test/utils/fixture_data.ts +++ b/packages/subproviders/test/utils/fixture_data.ts @@ -1,8 +1,23 @@ +const TEST_RPC_ACCOUNT_0 = '0x5409ed021d9299bf6814279a6a1411a7e866a631'; +const networkId = 42; export const fixtureData = { - TEST_RPC_ACCOUNT_0: '0x5409ed021d9299bf6814279a6a1411a7e866a631', - TEST_ACCOUNT_PRIVATE_KEY: 'F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D', + TEST_RPC_ACCOUNT_0, + TEST_RPC_ACCOUNT_0_ACCOUNT_PRIVATE_KEY: 'F2F48EE19680706196E2E339E5DA3491186E0C4C5030670656B0E0164837257D', PERSONAL_MESSAGE_STRING: 'hello world', PERSONAL_MESSAGE_SIGNED_RESULT: '0x1b0ec5e2908e993d0c8ab6b46da46be2688fdf03c7ea6686075de37392e50a7d7fcc531446699132fbda915bd989882e0064d417018773a315fb8d43ed063c9b00', TESTRPC_DERIVATION_PATH: `m/44'/60'/0'/0`, + NETWORK_ID: networkId, + TX_DATA: { + nonce: '0x00', + gasPrice: '0x0', + gas: '0x2710', + to: '0x0000000000000000000000000000000000000000', + value: '0x00', + chainId: networkId, + from: TEST_RPC_ACCOUNT_0, + }, + // This is the signed result of the abouve Transaction Data + TX_DATA_SIGNED_RESULT: + '0xf85f8080822710940000000000000000000000000000000000000000808078a0712854c73c69445cc1b22a7c3d7312ff9a97fe4ffba35fd636e8236b211b6e7ca0647cee031615e52d916c7c707025bc64ad525d8f1b9876c3435a863b42743178', }; -- cgit v1.2.3