m/metamask-extension
1
0
Fork 0
mirror of https://github.com/kremalicious/metamask-extension.git synced 2024-11-27 12:56:01 +01:00
Code
a49a4a066c
metamask-extension/test/unit/app/controllers/transactions/tx-controller-test.js
Brad Decker a49a4a066c
expand transaction constants coverage (#9790) 
* expand transaction constants coverage

* touchups

* dont import inside of e2e

* Update app/scripts/controllers/transactions/tx-state-manager.js

Co-authored-by: Mark Stacey <markjstacey@gmail.com>

* Update test/unit/app/controllers/transactions/tx-controller-test.js

Co-authored-by: Mark Stacey <markjstacey@gmail.com>

Co-authored-by: Mark Stacey <markjstacey@gmail.com>
2020-11-07 01:38:12 -06:00

988 lines
30 KiB
JavaScript
Raw Blame History

import { strict as assert } from 'assert'
import EventEmitter from 'events'
import ethUtil from 'ethereumjs-util'
import EthTx from 'ethereumjs-tx'
import ObservableStore from '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'
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'
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,
})
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 })
.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 = ['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',
)
})
})
})
View Git Blame Copy Permalink