import { strict as assert } from 'assert' ;
import EventEmitter from 'events' ;
import ethUtil from 'ethereumjs-util' ;
import EthTx from 'ethereumjs-tx' ;
import { ObservableStore } from '@metamask/obs-store' ;
import sinon from 'sinon' ;
import TransactionController from '../../../../../app/scripts/controllers/transactions' ;
import {
createTestProviderTools ,
getTestAccounts ,
} from '../../../../stub/provider' ;
import {
TRANSACTION _CATEGORIES ,
TRANSACTION _STATUSES ,
TRANSACTION _TYPES ,
} from '../../../../../shared/constants/transaction' ;
import { METAMASK _CONTROLLER _EVENTS } from '../../../../../app/scripts/metamask-controller' ;
const noop = ( ) => true ;
const currentNetworkId = '42' ;
const currentChainId = '0x2a' ;
describe ( 'Transaction Controller' , function ( ) {
let txController , provider , providerResultStub , fromAccount ;
beforeEach ( function ( ) {
providerResultStub = {
// 1 gwei
eth _gasPrice : '0x0de0b6b3a7640000' ,
// by default, all accounts are external accounts (not contracts)
eth _getCode : '0x' ,
} ;
provider = createTestProviderTools ( { scaffold : providerResultStub } )
. provider ;
fromAccount = getTestAccounts ( ) [ 0 ] ;
const blockTrackerStub = new EventEmitter ( ) ;
blockTrackerStub . getCurrentBlock = noop ;
blockTrackerStub . getLatestBlock = noop ;
txController = new TransactionController ( {
provider ,
getGasPrice ( ) {
return '0xee6b2800' ;
} ,
networkStore : new ObservableStore ( currentNetworkId ) ,
txHistoryLimit : 10 ,
blockTracker : blockTrackerStub ,
signTransaction : ( ethTx ) =>
new Promise ( ( resolve ) => {
ethTx . sign ( fromAccount . key ) ;
resolve ( ) ;
} ) ,
getPermittedAccounts : ( ) => undefined ,
getCurrentChainId : ( ) => currentChainId ,
getParticipateInMetrics : ( ) => false ,
} ) ;
txController . nonceTracker . getNonceLock = ( ) =>
Promise . resolve ( { nextNonce : 0 , releaseLock : noop } ) ;
} ) ;
describe ( '#getState' , function ( ) {
it ( 'should return a state object with the right keys and data types' , function ( ) {
const exposedState = txController . getState ( ) ;
assert . ok (
'unapprovedTxs' in exposedState ,
'state should have the key unapprovedTxs' ,
) ;
assert . ok (
'currentNetworkTxList' in exposedState ,
'state should have the key currentNetworkTxList' ,
) ;
assert . ok (
typeof exposedState ? . unapprovedTxs === 'object' ,
'should be an object' ,
) ;
assert . ok (
Array . isArray ( exposedState . currentNetworkTxList ) ,
'should be an array' ,
) ;
} ) ;
} ) ;
describe ( '#getUnapprovedTxCount' , function ( ) {
it ( 'should return the number of unapproved txs' , function ( ) {
txController . txStateManager . _saveTxList ( [
{
id : 1 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 2 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 3 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
] ) ;
const unapprovedTxCount = txController . getUnapprovedTxCount ( ) ;
assert . equal ( unapprovedTxCount , 3 , 'should be 3' ) ;
} ) ;
} ) ;
describe ( '#getPendingTxCount' , function ( ) {
it ( 'should return the number of pending txs' , function ( ) {
txController . txStateManager . _saveTxList ( [
{
id : 1 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 2 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 3 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
] ) ;
const pendingTxCount = txController . getPendingTxCount ( ) ;
assert . equal ( pendingTxCount , 3 , 'should be 3' ) ;
} ) ;
} ) ;
describe ( '#getConfirmedTransactions' , function ( ) {
it ( 'should return the number of confirmed txs' , function ( ) {
const address = '0xc684832530fcbddae4b4230a47e991ddcec2831d' ;
const txParams = {
from : address ,
to : '0xc684832530fcbddae4b4230a47e991ddcec2831d' ,
} ;
txController . txStateManager . _saveTxList ( [
{
id : 0 ,
status : TRANSACTION _STATUSES . CONFIRMED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 1 ,
status : TRANSACTION _STATUSES . CONFIRMED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 2 ,
status : TRANSACTION _STATUSES . CONFIRMED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 3 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 4 ,
status : TRANSACTION _STATUSES . REJECTED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 5 ,
status : TRANSACTION _STATUSES . APPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 6 ,
status : TRANSACTION _STATUSES . SIGNED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 7 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
{
id : 8 ,
status : TRANSACTION _STATUSES . FAILED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
] ) ;
assert . equal (
txController . nonceTracker . getConfirmedTransactions ( address ) . length ,
3 ,
) ;
} ) ;
} ) ;
describe ( '#newUnapprovedTransaction' , function ( ) {
let stub , txMeta , txParams ;
beforeEach ( function ( ) {
txParams = {
from : '0xc684832530fcbddae4b4230a47e991ddcec2831d' ,
to : '0xc684832530fcbddae4b4230a47e991ddcec2831d' ,
} ;
txMeta = {
status : TRANSACTION _STATUSES . UNAPPROVED ,
id : 1 ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ;
txController . txStateManager . _saveTxList ( [ txMeta ] ) ;
stub = sinon
. stub ( txController , 'addUnapprovedTransaction' )
. callsFake ( ( ) => {
txController . emit ( 'newUnapprovedTx' , txMeta ) ;
return Promise . resolve ( txController . txStateManager . addTx ( txMeta ) ) ;
} ) ;
} ) ;
afterEach ( function ( ) {
txController . txStateManager . _saveTxList ( [ ] ) ;
stub . restore ( ) ;
} ) ;
it ( 'should resolve when finished and status is submitted and resolve with the hash' , async function ( ) {
txController . once ( 'newUnapprovedTx' , ( txMetaFromEmit ) => {
setTimeout ( ( ) => {
txController . setTxHash ( txMetaFromEmit . id , '0x0' ) ;
txController . txStateManager . setTxStatusSubmitted ( txMetaFromEmit . id ) ;
} ) ;
} ) ;
const hash = await txController . newUnapprovedTransaction ( txParams ) ;
assert . ok ( hash , 'newUnapprovedTransaction needs to return the hash' ) ;
} ) ;
it ( 'should reject when finished and status is rejected' , async function ( ) {
txController . once ( 'newUnapprovedTx' , ( txMetaFromEmit ) => {
setTimeout ( ( ) => {
txController . txStateManager . setTxStatusRejected ( txMetaFromEmit . id ) ;
} ) ;
} ) ;
await assert . rejects (
( ) => txController . newUnapprovedTransaction ( txParams ) ,
{
message : 'MetaMask Tx Signature: User denied transaction signature.' ,
} ,
) ;
} ) ;
} ) ;
describe ( '#addUnapprovedTransaction' , function ( ) {
const selectedAddress = '0x1678a085c290ebd122dc42cba69373b5953b831d' ;
const recipientAddress = '0xc42edfcc21ed14dda456aa0756c153f7985d8813' ;
let getSelectedAddress , getPermittedAccounts ;
beforeEach ( function ( ) {
getSelectedAddress = sinon
. stub ( txController , 'getSelectedAddress' )
. returns ( selectedAddress ) ;
getPermittedAccounts = sinon
. stub ( txController , 'getPermittedAccounts' )
. returns ( [ selectedAddress ] ) ;
} ) ;
afterEach ( function ( ) {
getSelectedAddress . restore ( ) ;
getPermittedAccounts . restore ( ) ;
} ) ;
it ( 'should add an unapproved transaction and return a valid txMeta' , async function ( ) {
const txMeta = await txController . addUnapprovedTransaction ( {
from : selectedAddress ,
to : recipientAddress ,
} ) ;
assert . ok ( 'id' in txMeta , 'should have a id' ) ;
assert . ok ( 'time' in txMeta , 'should have a time stamp' ) ;
assert . ok (
'metamaskNetworkId' in txMeta ,
'should have a metamaskNetworkId' ,
) ;
assert . ok ( 'txParams' in txMeta , 'should have a txParams' ) ;
assert . ok ( 'history' in txMeta , 'should have a history' ) ;
assert . equal (
txMeta . txParams . value ,
'0x0' ,
'should have added 0x0 as the value' ,
) ;
const memTxMeta = txController . txStateManager . getTx ( txMeta . id ) ;
assert . deepEqual ( txMeta , memTxMeta ) ;
} ) ;
it ( 'should emit newUnapprovedTx event and pass txMeta as the first argument' , function ( done ) {
providerResultStub . eth _gasPrice = '4a817c800' ;
txController . once ( 'newUnapprovedTx' , ( txMetaFromEmit ) => {
assert . ok ( txMetaFromEmit , 'txMeta is falsy' ) ;
done ( ) ;
} ) ;
txController
. addUnapprovedTransaction ( {
from : selectedAddress ,
to : recipientAddress ,
} )
. catch ( done ) ;
} ) ;
it ( "should fail if the from address isn't the selected address" , async function ( ) {
await assert . rejects ( ( ) =>
txController . addUnapprovedTransaction ( {
from : '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2' ,
} ) ,
) ;
} ) ;
it ( 'should fail if netId is loading' , async function ( ) {
txController . networkStore = new ObservableStore ( 'loading' ) ;
await assert . rejects (
( ) =>
txController . addUnapprovedTransaction ( {
from : selectedAddress ,
to : '0x0d1d4e623D10F9FBA5Db95830F7d3839406C6AF2' ,
} ) ,
{ message : 'MetaMask is having trouble connecting to the network' } ,
) ;
} ) ;
} ) ;
describe ( '#addTxGasDefaults' , function ( ) {
it ( 'should add the tx defaults if their are none' , async function ( ) {
txController . txStateManager . _saveTxList ( [
{
id : 1 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
] ) ;
const txMeta = {
id : 1 ,
txParams : {
from : '0xc684832530fcbddae4b4230a47e991ddcec2831d' ,
to : '0xc684832530fcbddae4b4230a47e991ddcec2831d' ,
} ,
history : [ { } ] ,
} ;
providerResultStub . eth _gasPrice = '4a817c800' ;
providerResultStub . eth _getBlockByNumber = { gasLimit : '47b784' } ;
providerResultStub . eth _estimateGas = '5209' ;
const txMetaWithDefaults = await txController . addTxGasDefaults ( txMeta ) ;
assert . ok (
txMetaWithDefaults . txParams . gasPrice ,
'should have added the gas price' ,
) ;
assert . ok (
txMetaWithDefaults . txParams . gas ,
'should have added the gas field' ,
) ;
} ) ;
} ) ;
describe ( '#addTx' , function ( ) {
it ( 'should emit updates' , function ( done ) {
const txMeta = {
id : '1' ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
} ;
const eventNames = [
METAMASK _CONTROLLER _EVENTS . UPDATE _BADGE ,
'1:unapproved' ,
] ;
const listeners = [ ] ;
eventNames . forEach ( ( eventName ) => {
listeners . push (
new Promise ( ( resolve ) => {
txController . once ( eventName , ( arg ) => {
resolve ( arg ) ;
} ) ;
} ) ,
) ;
} ) ;
Promise . all ( listeners )
. then ( ( returnValues ) => {
assert . deepEqual (
returnValues . pop ( ) ,
txMeta ,
'last event 1:unapproved should return txMeta' ,
) ;
done ( ) ;
} )
. catch ( done ) ;
txController . addTx ( txMeta ) ;
} ) ;
} ) ;
describe ( '#approveTransaction' , function ( ) {
it ( 'does not overwrite set values' , async function ( ) {
const originalValue = '0x01' ;
const txMeta = {
id : '1' ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : {
nonce : originalValue ,
gas : originalValue ,
gasPrice : originalValue ,
} ,
} ;
this . timeout ( 15000 ) ;
const wrongValue = '0x05' ;
txController . addTx ( txMeta ) ;
providerResultStub . eth _gasPrice = wrongValue ;
providerResultStub . eth _estimateGas = '0x5209' ;
const signStub = sinon
. stub ( txController , 'signTransaction' )
. callsFake ( ( ) => Promise . resolve ( ) ) ;
const pubStub = sinon
. stub ( txController , 'publishTransaction' )
. callsFake ( ( ) => {
txController . setTxHash ( '1' , originalValue ) ;
txController . txStateManager . setTxStatusSubmitted ( '1' ) ;
} ) ;
await txController . approveTransaction ( txMeta . id ) ;
const result = txController . txStateManager . getTx ( txMeta . id ) ;
const params = result . txParams ;
assert . equal ( params . gas , originalValue , 'gas unmodified' ) ;
assert . equal ( params . gasPrice , originalValue , 'gas price unmodified' ) ;
assert . equal ( result . hash , originalValue ) ;
assert . equal (
result . status ,
TRANSACTION _STATUSES . SUBMITTED ,
'should have reached the submitted status.' ,
) ;
signStub . restore ( ) ;
pubStub . restore ( ) ;
} ) ;
} ) ;
describe ( '#sign replay-protected tx' , function ( ) {
it ( 'prepares a tx with the chainId set' , async function ( ) {
txController . addTx (
{
id : '1' ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
} ,
noop ,
) ;
const rawTx = await txController . signTransaction ( '1' ) ;
const ethTx = new EthTx ( ethUtil . toBuffer ( rawTx ) ) ;
assert . equal ( ethTx . getChainId ( ) , 42 ) ;
} ) ;
} ) ;
describe ( '#updateAndApproveTransaction' , function ( ) {
it ( 'should update and approve transactions' , async function ( ) {
const txMeta = {
id : 1 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
txParams : {
from : fromAccount . address ,
to : '0x1678a085c290ebd122dc42cba69373b5953b831d' ,
gasPrice : '0x77359400' ,
gas : '0x7b0d' ,
nonce : '0x4b' ,
} ,
metamaskNetworkId : currentNetworkId ,
} ;
txController . txStateManager . addTx ( txMeta ) ;
const approvalPromise = txController . updateAndApproveTransaction ( txMeta ) ;
const tx = txController . txStateManager . getTx ( 1 ) ;
assert . equal ( tx . status , TRANSACTION _STATUSES . APPROVED ) ;
await approvalPromise ;
} ) ;
} ) ;
describe ( '#getChainId' , function ( ) {
it ( 'returns 0 when the chainId is NaN' , function ( ) {
txController . networkStore = new ObservableStore ( 'loading' ) ;
assert . equal ( txController . getChainId ( ) , 0 ) ;
} ) ;
} ) ;
describe ( '#cancelTransaction' , function ( ) {
it ( 'should emit a status change to rejected' , function ( done ) {
txController . txStateManager . _saveTxList ( [
{
id : 0 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
{
id : 1 ,
status : TRANSACTION _STATUSES . REJECTED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
{
id : 2 ,
status : TRANSACTION _STATUSES . APPROVED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
{
id : 3 ,
status : TRANSACTION _STATUSES . SIGNED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
{
id : 4 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
{
id : 5 ,
status : TRANSACTION _STATUSES . CONFIRMED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
{
id : 6 ,
status : TRANSACTION _STATUSES . FAILED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
} ,
] ) ;
txController . once ( 'tx:status-update' , ( txId , status ) => {
try {
assert . equal (
status ,
TRANSACTION _STATUSES . REJECTED ,
'status should be rejected' ,
) ;
assert . equal ( txId , 0 , 'id should e 0' ) ;
done ( ) ;
} catch ( e ) {
done ( e ) ;
}
} ) ;
txController . cancelTransaction ( 0 ) ;
} ) ;
} ) ;
describe ( '#createSpeedUpTransaction' , function ( ) {
let addTxSpy ;
let approveTransactionSpy ;
let txParams ;
let expectedTxParams ;
beforeEach ( function ( ) {
addTxSpy = sinon . spy ( txController , 'addTx' ) ;
approveTransactionSpy = sinon . spy ( txController , 'approveTransaction' ) ;
txParams = {
nonce : '0x00' ,
from : '0xB09d8505E1F4EF1CeA089D47094f5DD3464083d4' ,
to : '0xB09d8505E1F4EF1CeA089D47094f5DD3464083d4' ,
gas : '0x5209' ,
gasPrice : '0xa' ,
} ;
txController . txStateManager . _saveTxList ( [
{
id : 1 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
txParams ,
history : [ { } ] ,
} ,
] ) ;
expectedTxParams = { ... txParams , gasPrice : '0xb' } ;
} ) ;
afterEach ( function ( ) {
addTxSpy . restore ( ) ;
approveTransactionSpy . restore ( ) ;
} ) ;
it ( 'should call this.addTx and this.approveTransaction with the expected args' , async function ( ) {
await txController . createSpeedUpTransaction ( 1 ) ;
assert . equal ( addTxSpy . callCount , 1 ) ;
const addTxArgs = addTxSpy . getCall ( 0 ) . args [ 0 ] ;
assert . deepEqual ( addTxArgs . txParams , expectedTxParams ) ;
const { lastGasPrice , type } = addTxArgs ;
assert . deepEqual (
{ lastGasPrice , type } ,
{
lastGasPrice : '0xa' ,
type : TRANSACTION _TYPES . RETRY ,
} ,
) ;
} ) ;
it ( 'should call this.approveTransaction with the id of the returned tx' , async function ( ) {
const result = await txController . createSpeedUpTransaction ( 1 ) ;
assert . equal ( approveTransactionSpy . callCount , 1 ) ;
const approveTransactionArg = approveTransactionSpy . getCall ( 0 ) . args [ 0 ] ;
assert . equal ( result . id , approveTransactionArg ) ;
} ) ;
it ( 'should return the expected txMeta' , async function ( ) {
const result = await txController . createSpeedUpTransaction ( 1 ) ;
assert . deepEqual ( result . txParams , expectedTxParams ) ;
const { lastGasPrice , type } = result ;
assert . deepEqual (
{ lastGasPrice , type } ,
{
lastGasPrice : '0xa' ,
type : TRANSACTION _TYPES . RETRY ,
} ,
) ;
} ) ;
} ) ;
describe ( '#publishTransaction' , function ( ) {
let hash , txMeta ;
beforeEach ( function ( ) {
hash =
'0x2a5523c6fa98b47b7d9b6c8320179785150b42a16bcff36b398c5062b65657e8' ;
txMeta = {
id : 1 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
txParams : { } ,
metamaskNetworkId : currentNetworkId ,
} ;
providerResultStub . eth _sendRawTransaction = hash ;
} ) ;
it ( 'should publish a tx, updates the rawTx when provided a one' , async function ( ) {
const rawTx =
'0x477b2e6553c917af0db0388ae3da62965ff1a184558f61b749d1266b2e6d024c' ;
txController . txStateManager . addTx ( txMeta ) ;
await txController . publishTransaction ( txMeta . id , rawTx ) ;
const publishedTx = txController . txStateManager . getTx ( 1 ) ;
assert . equal ( publishedTx . hash , hash ) ;
assert . equal ( publishedTx . status , TRANSACTION _STATUSES . SUBMITTED ) ;
} ) ;
it ( 'should ignore the error "Transaction Failed: known transaction" and be as usual' , async function ( ) {
providerResultStub . eth _sendRawTransaction = async ( _ , _ _ , _ _ _ , end ) => {
end ( 'Transaction Failed: known transaction' ) ;
} ;
const rawTx =
'0xf86204831e848082520894f231d46dd78806e1dd93442cf33c7671f853874880802ca05f973e540f2d3c2f06d3725a626b75247593cb36477187ae07ecfe0a4db3cf57a00259b52ee8c58baaa385fb05c3f96116e58de89bcc165cb3bfdfc708672fed8a' ;
txController . txStateManager . addTx ( txMeta ) ;
await txController . publishTransaction ( txMeta . id , rawTx ) ;
const publishedTx = txController . txStateManager . getTx ( 1 ) ;
assert . equal (
publishedTx . hash ,
'0x2cc5a25744486f7383edebbf32003e5a66e18135799593d6b5cdd2bb43674f09' ,
) ;
assert . equal ( publishedTx . status , TRANSACTION _STATUSES . SUBMITTED ) ;
} ) ;
} ) ;
describe ( '#_markNonceDuplicatesDropped' , function ( ) {
it ( 'should mark all nonce duplicates as dropped without marking the confirmed transaction as dropped' , function ( ) {
txController . txStateManager . _saveTxList ( [
{
id : 1 ,
status : TRANSACTION _STATUSES . CONFIRMED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
{
id : 2 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
{
id : 3 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
{
id : 4 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
{
id : 5 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
{
id : 6 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
{
id : 7 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
history : [ { } ] ,
txParams : { nonce : '0x01' } ,
} ,
] ) ;
txController . _markNonceDuplicatesDropped ( 1 ) ;
const confirmedTx = txController . txStateManager . getTx ( 1 ) ;
const droppedTxs = txController . txStateManager . getFilteredTxList ( {
nonce : '0x01' ,
status : TRANSACTION _STATUSES . DROPPED ,
} ) ;
assert . equal (
confirmedTx . status ,
TRANSACTION _STATUSES . CONFIRMED ,
'the confirmedTx should remain confirmed' ,
) ;
assert . equal ( droppedTxs . length , 6 , 'their should be 6 dropped txs' ) ;
} ) ;
} ) ;
describe ( '#_determineTransactionCategory' , function ( ) {
it ( 'should return a simple send transactionCategory when to is truthy but data is falsy' , async function ( ) {
const result = await txController . _determineTransactionCategory ( {
to : '0xabc' ,
data : '' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . SENT _ETHER ,
getCodeResponse : null ,
} ) ;
} ) ;
it ( 'should return a token transfer transactionCategory when data is for the respective method call' , async function ( ) {
const result = await txController . _determineTransactionCategory ( {
to : '0xabc' ,
data :
'0xa9059cbb0000000000000000000000002f318C334780961FB129D2a6c30D0763d9a5C970000000000000000000000000000000000000000000000000000000000000000a' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . TOKEN _METHOD _TRANSFER ,
getCodeResponse : undefined ,
} ) ;
} ) ;
it ( 'should return a token approve transactionCategory when data is for the respective method call' , async function ( ) {
const result = await txController . _determineTransactionCategory ( {
to : '0xabc' ,
data :
'0x095ea7b30000000000000000000000002f318C334780961FB129D2a6c30D0763d9a5C9700000000000000000000000000000000000000000000000000000000000000005' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . TOKEN _METHOD _APPROVE ,
getCodeResponse : undefined ,
} ) ;
} ) ;
it ( 'should return a contract deployment transactionCategory when to is falsy and there is data' , async function ( ) {
const result = await txController . _determineTransactionCategory ( {
to : '' ,
data : '0xabd' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . DEPLOY _CONTRACT ,
getCodeResponse : undefined ,
} ) ;
} ) ;
it ( 'should return a simple send transactionCategory with a 0x getCodeResponse when there is data and but the to address is not a contract address' , async function ( ) {
const result = await txController . _determineTransactionCategory ( {
to : '0x9e673399f795D01116e9A8B2dD2F156705131ee9' ,
data : '0xabd' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . SENT _ETHER ,
getCodeResponse : '0x' ,
} ) ;
} ) ;
it ( 'should return a simple send transactionCategory with a null getCodeResponse when to is truthy and there is data and but getCode returns an error' , async function ( ) {
const result = await txController . _determineTransactionCategory ( {
to : '0xabc' ,
data : '0xabd' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . SENT _ETHER ,
getCodeResponse : null ,
} ) ;
} ) ;
it ( 'should return a contract interaction transactionCategory with the correct getCodeResponse when to is truthy and there is data and it is not a token transaction' , async function ( ) {
const _providerResultStub = {
// 1 gwei
eth _gasPrice : '0x0de0b6b3a7640000' ,
// by default, all accounts are external accounts (not contracts)
eth _getCode : '0xa' ,
} ;
const _provider = createTestProviderTools ( {
scaffold : _providerResultStub ,
} ) . provider ;
const _fromAccount = getTestAccounts ( ) [ 0 ] ;
const _blockTrackerStub = new EventEmitter ( ) ;
_blockTrackerStub . getCurrentBlock = noop ;
_blockTrackerStub . getLatestBlock = noop ;
const _txController = new TransactionController ( {
provider : _provider ,
getGasPrice ( ) {
return '0xee6b2800' ;
} ,
networkStore : new ObservableStore ( currentNetworkId ) ,
txHistoryLimit : 10 ,
blockTracker : _blockTrackerStub ,
signTransaction : ( ethTx ) =>
new Promise ( ( resolve ) => {
ethTx . sign ( _fromAccount . key ) ;
resolve ( ) ;
} ) ,
getParticipateInMetrics : ( ) => false ,
} ) ;
const result = await _txController . _determineTransactionCategory ( {
to : '0x9e673399f795D01116e9A8B2dD2F156705131ee9' ,
data : 'abd' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . CONTRACT _INTERACTION ,
getCodeResponse : '0x0a' ,
} ) ;
} ) ;
it ( 'should return a contract interaction transactionCategory with the correct getCodeResponse when to is a contract address and data is falsy' , async function ( ) {
const _providerResultStub = {
// 1 gwei
eth _gasPrice : '0x0de0b6b3a7640000' ,
// by default, all accounts are external accounts (not contracts)
eth _getCode : '0xa' ,
} ;
const _provider = createTestProviderTools ( {
scaffold : _providerResultStub ,
} ) . provider ;
const _fromAccount = getTestAccounts ( ) [ 0 ] ;
const _blockTrackerStub = new EventEmitter ( ) ;
_blockTrackerStub . getCurrentBlock = noop ;
_blockTrackerStub . getLatestBlock = noop ;
const _txController = new TransactionController ( {
provider : _provider ,
getGasPrice ( ) {
return '0xee6b2800' ;
} ,
networkStore : new ObservableStore ( currentNetworkId ) ,
txHistoryLimit : 10 ,
blockTracker : _blockTrackerStub ,
signTransaction : ( ethTx ) =>
new Promise ( ( resolve ) => {
ethTx . sign ( _fromAccount . key ) ;
resolve ( ) ;
} ) ,
getParticipateInMetrics : ( ) => false ,
} ) ;
const result = await _txController . _determineTransactionCategory ( {
to : '0x9e673399f795D01116e9A8B2dD2F156705131ee9' ,
data : '' ,
} ) ;
assert . deepEqual ( result , {
transactionCategory : TRANSACTION _CATEGORIES . CONTRACT _INTERACTION ,
getCodeResponse : '0x0a' ,
} ) ;
} ) ;
} ) ;
describe ( '#getPendingTransactions' , function ( ) {
it ( 'should show only submitted and approved transactions as pending transaction' , function ( ) {
txController . txStateManager . _saveTxList ( [
{
id : 1 ,
status : TRANSACTION _STATUSES . UNAPPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
} ,
{
id : 2 ,
status : TRANSACTION _STATUSES . REJECTED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 3 ,
status : TRANSACTION _STATUSES . APPROVED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 4 ,
status : TRANSACTION _STATUSES . SIGNED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 5 ,
status : TRANSACTION _STATUSES . SUBMITTED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 6 ,
status : TRANSACTION _STATUSES . CONFIRMED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
{
id : 7 ,
status : TRANSACTION _STATUSES . FAILED ,
metamaskNetworkId : currentNetworkId ,
txParams : { } ,
history : [ { } ] ,
} ,
] ) ;
assert . equal (
txController . pendingTxTracker . getPendingTransactions ( ) . length ,
2 ,
) ;
const states = txController . pendingTxTracker
. getPendingTransactions ( )
. map ( ( tx ) => tx . status ) ;
assert . ok (
states . includes ( TRANSACTION _STATUSES . APPROVED ) ,
'includes approved' ,
) ;
assert . ok (
states . includes ( TRANSACTION _STATUSES . SUBMITTED ) ,
'includes submitted' ,
) ;
} ) ;
} ) ;
} ) ;