aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--packages/subproviders/CHANGELOG.json10
-rw-r--r--packages/subproviders/src/index.ts1
-rw-r--r--packages/subproviders/src/subproviders/base_wallet_subprovider.ts134
-rw-r--r--packages/subproviders/src/subproviders/ledger.ts158
-rw-r--r--packages/subproviders/src/subproviders/pk_wallet_subprovider.ts68
-rw-r--r--packages/subproviders/src/types.ts6
-rw-r--r--packages/subproviders/test/integration/ledger_subprovider_test.ts4
-rw-r--r--packages/subproviders/test/unit/ledger_subprovider_test.ts11
-rw-r--r--packages/subproviders/test/unit/pk_wallet_subprovider_test.ts188
9 files changed, 424 insertions, 156 deletions
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,5 +1,15 @@
[
{
+ "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",
"changes": [
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<string[]>;
+ public abstract async signTransactionAsync(txParams: PartialTxParams): Promise<string>;
+ public abstract async signPersonalMessageAsync(dataIfExists: string): Promise<string>;
+
+ /**
+ * 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<JSONRPCResponsePayload> {
+ const payload = {
+ method: 'eth_sendRawTransaction',
+ params: [signedTx],
+ };
+ const result = await this.emitPayloadAsync(payload);
+ return result;
+ }
+ private async _populateMissingTxParamsAsync(txParams: PartialTxParams): Promise<PartialTxParams> {
+ 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<string> {
+ 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<string> {
- 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<ResponseWithTxParams> {
- 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<PartialTxParams> {
- 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<string[]> {
+ 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<string> {
+ 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<string> {
+ 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);
+ });
+ });
+ });
+});
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 15:32:10 +0800