import { pino } from '@0x/api-utils';
import { OtcOrder, SignatureType } from '@0x/protocol-utils';
import { BigNumber } from '@0x/utils';
import { expect } from 'chai';
import { BigNumber as EthersBigNumber, providers } from 'ethersv5';
import * as _ from 'lodash';
import { Producer } from 'sqs-producer';
import { anything, capture, deepEqual, instance, mock, spy, verify, when } from 'ts-mockito';

import { ETH_DECIMALS, GWEI_DECIMALS, ONE_SECOND_MS } from '../../src/core/constants';
import {
    MetaTransactionJobEntity,
    RfqmJobEntity,
    RfqmTransactionSubmissionEntity,
    RfqmV2JobEntity,
    RfqmV2QuoteEntity,
    RfqmV2TransactionSubmissionEntity,
} from '../../src/entities';
import { MetaTransactionJobConstructorOpts } from '../../src/entities/MetaTransactionJobEntity';
import {
    MetaTransactionSubmissionEntity,
    MetaTransactionSubmissionEntityConstructorOpts,
} from '../../src/entities/MetaTransactionSubmissionEntity';
import {
    MetaTransactionV2JobConstructorOpts,
    MetaTransactionV2JobEntity,
} from '../../src/entities/MetaTransactionV2JobEntity';
import {
    MetaTransactionV2SubmissionEntity,
    MetaTransactionV2SubmissionEntityConstructorOpts,
} from '../../src/entities/MetaTransactionV2SubmissionEntity';
import {
    RfqmJobStatus,
    RfqmOrderTypes,
    RfqmTransactionSubmissionStatus,
    RfqmTransactionSubmissionType,
    SubmissionContextStatus,
} from '../../src/entities/types';
import { logger } from '../../src/logger';
import { RfqMakerBalanceCacheService } from '../../src/services/rfq_maker_balance_cache_service';
import { WorkerService } from '../../src/services/WorkerService';
import { CacheClient } from '../../src/utils/cache_client';
import { GasStationAttendant } from '../../src/utils/GasStationAttendant';
import { GasStationAttendantEthereum } from '../../src/utils/GasStationAttendantEthereum';
import { QuoteServerClient } from '../../src/utils/quote_server_client';
import { RfqmDbUtils } from '../../src/utils/rfqm_db_utils';
import { RfqBlockchainUtils } from '../../src/utils/rfq_blockchain_utils';
import { RfqMakerManager } from '../../src/utils/rfq_maker_manager';
import { padSignature } from '../../src/utils/signature_utils';
import { SubmissionContext } from '../../src/utils/SubmissionContext';
import {
    MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
    MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
    MOCK_META_TRANSACTION,
    MOCK_META_TRANSACTION_V2,
    MOCK_PERMIT_APPROVAL,
} from '../constants';

// $eslint-fix-me https://github.com/rhinodavid/eslint-fix-me
// eslint-disable-next-line @typescript-eslint/no-loss-of-precision
const MOCK_WORKER_REGISTRY_ADDRESS = '0x1023331a469c6391730ff1E2749422CE8873EC38';
const MOCK_GAS_PRICE = new BigNumber(100);
const TEST_RFQM_TRANSACTION_WATCHER_SLEEP_TIME_MS = 50;
const WORKER_FULL_BALANCE_WEI = new BigNumber(1).shiftedBy(ETH_DECIMALS);
let loggerSpy: pino.Logger;

const buildWorkerServiceForUnitTest = (
    overrides: {
        cacheClient?: CacheClient;
        dbUtils?: RfqmDbUtils;
        rfqMakerBalanceCacheService?: RfqMakerBalanceCacheService;
        rfqMakerManager?: RfqMakerManager;
        gasStationAttendant?: GasStationAttendant;
        quoteServerClient?: QuoteServerClient;
        rfqBlockchainUtils?: RfqBlockchainUtils;
        initialMaxPriorityFeePerGasGwei?: number;
        maxFeePerGasGwei?: number;
        enableAccessList?: boolean;
    } = {},
): WorkerService => {
    const gasStationAttendantMock = mock(GasStationAttendantEthereum);
    when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(MOCK_GAS_PRICE);
    const gasStationAttendantInstance = instance(gasStationAttendantMock);

    const rfqBlockchainUtilsMock = mock(RfqBlockchainUtils);
    when(rfqBlockchainUtilsMock.getAccountBalanceAsync(MOCK_WORKER_REGISTRY_ADDRESS)).thenResolve(
        WORKER_FULL_BALANCE_WEI,
    );
    const sqsMock = mock(Producer);
    when(sqsMock.queueSize()).thenResolve(0);
    const quoteServerClientMock = mock(QuoteServerClient);

    const cacheClientMock = mock(CacheClient);
    const defaultDbUtilsMock = mock(RfqmDbUtils);
    const rfqMakerBalanceCacheServiceMock = mock(RfqMakerBalanceCacheService);
    const rfqMakerManagerMock = mock(RfqMakerManager);

    return new WorkerService(
        1,
        overrides.gasStationAttendant || gasStationAttendantInstance,
        MOCK_WORKER_REGISTRY_ADDRESS,
        overrides.rfqBlockchainUtils || instance(rfqBlockchainUtilsMock),
        overrides.dbUtils || instance(defaultDbUtilsMock),
        overrides.quoteServerClient || quoteServerClientMock,
        TEST_RFQM_TRANSACTION_WATCHER_SLEEP_TIME_MS,
        overrides.cacheClient || cacheClientMock,
        overrides.rfqMakerBalanceCacheService || instance(rfqMakerBalanceCacheServiceMock),
        overrides.rfqMakerManager || rfqMakerManagerMock,
        overrides.initialMaxPriorityFeePerGasGwei || 2,
        overrides.maxFeePerGasGwei || 128,
        overrides.enableAccessList,
    );
};

const createMetaTransactionJobEntity = (
    opts: MetaTransactionJobConstructorOpts,
    id: string,
): MetaTransactionJobEntity => {
    const job = new MetaTransactionJobEntity(opts);
    job.id = id;
    return job;
};

const createMetaTransactionV2JobEntity = (
    opts: MetaTransactionV2JobConstructorOpts,
    id: string,
): MetaTransactionV2JobEntity => {
    const job = new MetaTransactionV2JobEntity(opts);
    job.id = id;
    return job;
};

const createMetaTransactionSubmissionEntity = (
    opts: MetaTransactionSubmissionEntityConstructorOpts,
    id: string,
): MetaTransactionSubmissionEntity => {
    const submission = new MetaTransactionSubmissionEntity(opts);
    submission.id = id;
    return submission;
};

const createMetaTransactionV2SubmissionEntity = (
    opts: MetaTransactionV2SubmissionEntityConstructorOpts,
    id: string,
): MetaTransactionV2SubmissionEntity => {
    const submission = new MetaTransactionV2SubmissionEntity(opts);
    submission.id = id;
    return submission;
};

const fakeClockMs = 1637722898000;
const fakeOneMinuteAgoS = fakeClockMs / ONE_SECOND_MS - 60;
const fakeFiveMinutesLater = fakeClockMs / ONE_SECOND_MS + 300;

const maker = '0xbb004090d26845b672f17c6da4b7d162df3bfc5e';
const orderHash = '0x112160fb0933ecde720f63b50b303ce64e52ded702bef78b9c20361f3652a462';

// This sig actually belongs to the maker above
const validEIP712Sig = {
    signatureType: SignatureType.EIP712,
    v: 28,
    r: '0xdc158f7b53b940863bc7b001552a90282e51033f29b73d44a2701bd16faa19d2',
    s: '0x55f6c5470e41b39a5ddeb63c22f8ba1d34748f93265715b9dc4a0f10138985a6',
};

// This is a real signature that had a missing byte
const missingByteSig = {
    r: '0x568b31076e1c65954adb1bccc723718b3460f1b699ce1252f8a83bda0d521005',
    s: '0x0307cc7f4161df812f7e5a651b23dbd33981c0410df0dd820a52f61be7a5ab',
    v: 28,
    signatureType: SignatureType.EthSign,
};

jest.setTimeout(ONE_SECOND_MS * 120);

describe('WorkerService', () => {
    beforeEach(() => {
        loggerSpy = spy(logger);
    });

    describe('workerBeforeLogicAsync', () => {
        it('calls `processJobAsync` with the correct arguments', async () => {
            const workerIndex = 0;
            const workerAddress = MOCK_WORKER_REGISTRY_ADDRESS;
            const jobId = 'jobId';
            const metaTransactionJob = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const metaTransactionV2Job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const rfqmV2Job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress,
                workflow: 'rfqm',
            });

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const blockchainUtilsMock = mock(RfqBlockchainUtils);
            when(blockchainUtilsMock.getAccountBalanceAsync(workerAddress)).thenResolve(WORKER_FULL_BALANCE_WEI);

            const dbUtilsMock = mock(RfqmDbUtils);
            when(dbUtilsMock.findV2UnresolvedJobsAsync(workerAddress, anything())).thenResolve([rfqmV2Job]);
            when(dbUtilsMock.findUnresolvedMetaTransactionJobsAsync(workerAddress, anything())).thenResolve([
                metaTransactionJob,
            ]);
            when(dbUtilsMock.findUnresolvedMetaTransactionV2JobsAsync(workerAddress, anything())).thenResolve([
                metaTransactionV2Job,
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(dbUtilsMock),
                rfqBlockchainUtils: instance(blockchainUtilsMock),
                gasStationAttendant: instance(gasStationAttendantMock),
            });
            const spiedRfqmService = spy(rfqmService);
            when(spiedRfqmService.processJobAsync(anything(), anything(), anything())).thenResolve();

            await rfqmService.workerBeforeLogicAsync(workerIndex, workerAddress);
            verify(spiedRfqmService.processJobAsync(orderHash, workerAddress, 'rfqm_v2_job')).once();
            verify(spiedRfqmService.processJobAsync(jobId, workerAddress, 'meta_transaction_job')).once();
            verify(spiedRfqmService.processJobAsync(jobId, workerAddress, 'meta_transaction_v2_job')).once();
        });
    });

    describe('processJobAsync', () => {
        it('fails if no rfqm v2 job is found', async () => {
            // Return `undefined` for v1 and v2 job for orderhash
            const dbUtilsMock = mock(RfqmDbUtils);
            when(dbUtilsMock.findV2JobByOrderHashAsync('0x01234567')).thenResolve(null);

            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(dbUtilsMock) });

            await rfqmService.processJobAsync('0x01234567', '0xworkeraddress');
            expect(capture(loggerSpy.error).last()[0]).to.include({
                errorMessage: 'No job found for identifier',
            });
        });

        it('fails if a worker ends up with a job assigned to a different worker for a rfqm v2 job', async () => {
            const dbUtilsMock = mock(RfqmDbUtils);
            when(dbUtilsMock.findV2JobByOrderHashAsync('0x01234567')).thenResolve(
                new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeOneMinuteAgoS),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: null,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(fakeOneMinuteAgoS.toString()),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '',
                            makerAmount: '',
                            makerToken: '',
                            taker: '',
                            takerAmount: '',
                            takerToken: '',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingEnqueued,
                    updatedAt: new Date(),
                    workerAddress: '0xwrongworkeraddress',
                    workflow: 'rfqm',
                }),
            );

            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(dbUtilsMock) });

            await rfqmService.processJobAsync('0x01234567', '0xworkeraddress');
            expect(capture(loggerSpy.error).last()[0]).to.include({
                errorMessage: 'Worker was sent a job claimed by a different worker',
            });
        });

        it('fails if no meta-transaction job is found', async () => {
            const dbUtilsMock = mock(RfqmDbUtils);
            const jobId = 'jobId';
            when(dbUtilsMock.findMetaTransactionJobByIdAsync(jobId)).thenResolve(null);

            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(dbUtilsMock) });

            await rfqmService.processJobAsync(jobId, '0xworkeraddress', 'meta_transaction_job');
            expect(capture(loggerSpy.error).last()[0]).to.include({
                errorMessage: 'No job found for identifier',
            });
        });

        it('fails if a worker ends up with a job assigned to a different worker for a meta-transaction job', async () => {
            const jobId = 'jobId';
            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: 'inputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xwrongworkeraddress',
                    approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                },
                jobId,
            );

            const dbUtilsMock = mock(RfqmDbUtils);
            when(dbUtilsMock.findMetaTransactionJobByIdAsync(jobId)).thenResolve(job);

            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(dbUtilsMock) });

            await rfqmService.processJobAsync(jobId, '0xworkeraddress', 'meta_transaction_job');
            expect(capture(loggerSpy.error).last()[0]).to.include({
                errorMessage: 'Worker was sent a job claimed by a different worker',
            });
        });

        it('fails if no meta-transaction v2 job is found', async () => {
            const dbUtilsMock = mock(RfqmDbUtils);
            const jobId = 'jobId';
            when(dbUtilsMock.findMetaTransactionV2JobByIdAsync(jobId)).thenResolve(null);

            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(dbUtilsMock) });

            await rfqmService.processJobAsync(jobId, '0xworkeraddress', 'meta_transaction_v2_job');
            expect(capture(loggerSpy.error).last()[0]).to.include({
                errorMessage: 'No job found for identifier',
            });
        });

        it('fails if a worker ends up with a job assigned to a different worker for a meta-transaction v2 job', async () => {
            const jobId = 'jobId';
            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xwrongworkeraddress',
                },
                jobId,
            );

            const dbUtilsMock = mock(RfqmDbUtils);
            when(dbUtilsMock.findMetaTransactionV2JobByIdAsync(jobId)).thenResolve(job);

            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(dbUtilsMock) });

            await rfqmService.processJobAsync(jobId, '0xworkeraddress', 'meta_transaction_v2_job');
            expect(capture(loggerSpy.error).last()[0]).to.include({
                errorMessage: 'Worker was sent a job claimed by a different worker',
            });
        });
    });

    describe('processAtomicApprovalAndTradeAsync', () => {
        it('throws if non-approval job is supplied to the method for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const rfqmService = buildWorkerServiceForUnitTest();

            try {
                await rfqmService.processAtomicApprovalAndTradeAsync(job, '0xworkeraddress');
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain(
                    'Non-approval job should not be processed by `processAtomicApprovalAndTradeAsync`',
                );
            }
        });

        it('should process an atomic approval and rfqm v2 job trade successfully', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(nowS + 60),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(nowS + 60),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                approval: MOCK_PERMIT_APPROVAL,
                approvalSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '0xworkeraddress',
                workflow: 'rfqm',
            });

            const mockTransactionRequest: providers.TransactionRequest = {};
            const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                type: RfqmTransactionSubmissionType.Trade,
            });

            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything(), anything())).thenResolve([]);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    anything(),
                    deepEqual([RfqmTransactionSubmissionType.ApprovalAndTrade]),
                ),
            ).thenResolve([]);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([]);
            when(mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash')).thenResolve(
                _.cloneDeep(mockTransaction),
            );

            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xcalldata');
            when(
                mockBlockchainUtils.generatePermitAndCallCalldataAsync(anything(), anything(), anything(), anything()),
            ).thenResolve('0xcalldata');
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
            when(
                mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
            ).thenReturn(mockTransactionRequest);
            when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve('0xsignedtransactionhash');
            when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                signedTransaction: 'signedTransaction',
                transactionHash: '0xsignedtransactionhash',
            });
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.processAtomicApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingLastLookAccepted);
            expect(updateRfqmJobCalledArgs[2].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
            verify(
                mockBlockchainUtils.generatePermitAndCallCalldataAsync(anything(), anything(), anything(), anything()),
            ).once();
        });

        it('should process an atomic approval and meta-transaction v1 job trade successfully', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    approval: MOCK_PERMIT_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockTransactionRequest: providers.TransactionRequest = {};
            const mockTransaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                },
                transactionSubmissionId,
            );
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.ApprovalAndTrade]),
                ),
            ).thenResolve([]);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByTransactionHashAsync(
                    '0xsignedtransactionhash',
                    RfqmTransactionSubmissionType.ApprovalAndTrade,
                ),
            ).thenResolve([_.cloneDeep(mockTransaction)]);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v2', anything(), anything()),
            ).thenReturn('0xcalldata');
            when(
                mockBlockchainUtils.generatePermitAndCallCalldataAsync(anything(), anything(), anything(), anything()),
            ).thenResolve('0xcalldata');
            when(mockBlockchainUtils.getPermitAndCallAddress()).thenReturn('0xpermitandcalladdress');
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(
                mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
            ).thenReturn(mockTransactionRequest);
            when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve('0xsignedtransactionhash');
            when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                signedTransaction: 'signedTransaction',
                transactionHash: '0xsignedtransactionhash',
            });
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processAtomicApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
            verify(
                mockBlockchainUtils.generatePermitAndCallCalldataAsync(anything(), anything(), anything(), anything()),
            ).once();
        });

        it('should process an atomic approval and meta-transaction v2 job trade successfully', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockTransactionRequest: providers.TransactionRequest = {};
            const mockTransaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId,
            );
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.ApprovalAndTrade]),
                ),
            ).thenResolve([]);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByTransactionHashAsync(
                    '0xsignedtransactionhash',
                    RfqmTransactionSubmissionType.ApprovalAndTrade,
                ),
            ).thenResolve([_.cloneDeep(mockTransaction)]);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v2', anything(), anything()),
            ).thenReturn('0xcalldata');
            when(
                mockBlockchainUtils.generatePermitAndCallCalldataAsync(anything(), anything(), anything(), anything()),
            ).thenResolve('0xcalldata');
            when(mockBlockchainUtils.getPermitAndCallAddress()).thenReturn('0xpermitandcalladdress');
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(
                mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
            ).thenReturn(mockTransactionRequest);
            when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve('0xsignedtransactionhash');
            when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                signedTransaction: 'signedTransaction',
                transactionHash: '0xsignedtransactionhash',
            });
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processAtomicApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
            verify(
                mockBlockchainUtils.generatePermitAndCallCalldataAsync(anything(), anything(), anything(), anything()),
            ).once();
        });
    });

    describe('processApprovalAndTradeAsync', () => {
        it('throws if non-approval job is supplied to the method for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const rfqmService = buildWorkerServiceForUnitTest();

            try {
                await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain(
                    'Non-approval job should not be processed by `processApprovalAndTradeAsync`',
                );
            }
        });

        it('should not proceed to trade transaction if the status of approval transaction is not `SucceededConfirmed` for a rfqm v2 job', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(nowS + 10),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(nowS + 10),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
                approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                approvalSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            });
            const mockPresubmitTransaction = new RfqmV2TransactionSubmissionEntity({
                createdAt: new Date(1233),
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                status: RfqmTransactionSubmissionStatus.Submitted,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                type: RfqmTransactionSubmissionType.Approval,
            });
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 0,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            // when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([]);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    anything(),
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockPresubmitTransaction]);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });

            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                '0xcalldata',
            );
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xpresubmittransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingLastLookAccepted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.FailedRevertedConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.FailedRevertedConfirmed);
        });

        it('should proceed to trade transaction if the status of approval transaction is `SucceededConfirmed` for a rfqm v2 job', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(nowS + 10),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(nowS + 10),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
                approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                approvalSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            });
            const mockPresubmitApprovalTransaction = new RfqmV2TransactionSubmissionEntity({
                createdAt: new Date(1233),
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                status: RfqmTransactionSubmissionStatus.Submitted,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                type: RfqmTransactionSubmissionType.Approval,
            });
            const mockPresubmitTradeTransaction = new RfqmV2TransactionSubmissionEntity({
                createdAt: new Date(1233),
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                status: RfqmTransactionSubmissionStatus.Submitted,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                type: RfqmTransactionSubmissionType.Trade,
            });
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            // when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([]);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    anything(),
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockPresubmitApprovalTransaction]);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    anything(),
                    deepEqual([RfqmTransactionSubmissionType.Trade]),
                ),
            ).thenResolve([mockPresubmitTradeTransaction]);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([
                mockPresubmitTradeTransaction,
            ]);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });

            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xcalldata');
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                '0xcalldata',
            );
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xpresubmittransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingLastLookAccepted);
            expect(updateRfqmJobCalledArgs[2].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
        });

        it('throws if non-approval job is supplied to the method for a meta-transaction job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const rfqmService = buildWorkerServiceForUnitTest();

            try {
                await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain(
                    'Non-approval job should not be processed by `processApprovalAndTradeAsync`',
                );
            }
        });

        it('should not proceed to trade transaction if the status of approval transaction is not `SucceededConfirmed` for a meta-transaction job', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';
            const inputToken = '0xinputToken';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken,
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                    approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                },
                jobId,
            );
            const mockTransaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Approval,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId,
            );
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 0,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xsignedtransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockTransaction]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(inputToken, anything(), anything())).thenResolve(
                '0xcalldata',
            );
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.FailedRevertedConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.FailedRevertedConfirmed);
        });

        it('should proceed to trade transaction if the status of approval transaction is `SucceededConfirmed` for a meta-transaction job', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId1 = 'submissionId1';
            const transactionSubmissionId2 = 'submissionId2';
            const inputToken = '0xinputToken';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken,
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                    approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                },
                jobId,
            );
            const mockApprovalTransaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash1',
                    type: RfqmTransactionSubmissionType.Approval,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId1,
            );
            const mockTradeTransaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash2',
                    type: RfqmTransactionSubmissionType.Trade,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId2,
            );
            const mockApprovalTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash1',
                transactionIndex: 0,
                type: 2,
            };
            const mockTradeTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash2',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xsignedtransactionhash1', '0xsignedtransactionhash2'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockApprovalTransaction]);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Trade]),
                ),
            ).thenResolve([mockTradeTransaction]);
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([mockTradeTransaction]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v1', anything(), anything()),
            ).thenReturn('0xcalldata');
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                '0xcalldata',
            );
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash1']))).thenResolve([
                mockApprovalTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash2']))).thenResolve([
                mockTradeTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
        });

        it('throws if non-approval job is supplied to the method for a meta-transaction v2 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const rfqmService = buildWorkerServiceForUnitTest();

            try {
                await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain(
                    'Non-approval job should not be processed by `processApprovalAndTradeAsync`',
                );
            }
        });

        it('should not proceed to trade transaction if the status of approval transaction is not `SucceededConfirmed` for a meta-transaction v2 job', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';
            const inputToken = '0xinputToken';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                    approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                },
                jobId,
            );
            const mockTransaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Approval,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId,
            );
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 0,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xsignedtransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockTransaction]);
            const updateRfqmJobCalledArgs: MetaTransactionV2JobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(inputToken, anything(), anything())).thenResolve(
                '0xcalldata',
            );
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.FailedRevertedConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.FailedRevertedConfirmed);
        });

        it('should proceed to trade transaction if the status of approval transaction is `SucceededConfirmed` for a meta-transaction v2 job', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId1 = 'submissionId1';
            const transactionSubmissionId2 = 'submissionId2';
            const inputToken = '0xinputToken';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    inputToken,
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                    approval: MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    approvalSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                },
                jobId,
            );
            const mockApprovalTransaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash1',
                    type: RfqmTransactionSubmissionType.Approval,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId1,
            );
            const mockTradeTransaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash2',
                    type: RfqmTransactionSubmissionType.Trade,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId2,
            );
            const mockApprovalTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash1',
                transactionIndex: 0,
                type: 2,
            };
            const mockTradeTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash2',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xsignedtransactionhash1', '0xsignedtransactionhash2'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockApprovalTransaction]);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Trade]),
                ),
            ).thenResolve([mockTradeTransaction]);
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([mockTradeTransaction]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(1000000000)]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v2', anything(), anything()),
            ).thenReturn('0xcalldata');
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                '0xcalldata',
            );
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash1']))).thenResolve([
                mockApprovalTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash2']))).thenResolve([
                mockTradeTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processApprovalAndTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
        });
    });

    describe('processTradeAsync', () => {
        it('should process a rfqm v2 job trade successfully', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(nowS + 10),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(nowS + 10),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '0xworkeraddress',
                workflow: 'rfqm',
            });

            const mockTransactionRequest: providers.TransactionRequest = {};
            const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                type: RfqmTransactionSubmissionType.Trade,
            });
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([]);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    anything(),
                    deepEqual([RfqmTransactionSubmissionType.Trade]),
                ),
            ).thenResolve([]);
            when(mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash')).thenResolve(
                _.cloneDeep(mockTransaction),
            );

            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xcalldata');
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
            when(
                mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
            ).thenReturn(mockTransactionRequest);
            when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve('0xsignedtransactionhash');
            when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                signedTransaction: 'signedTransaction',
                transactionHash: '0xsignedtransactionhash',
            });
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.processTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingLastLookAccepted);
            expect(updateRfqmJobCalledArgs[2].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
        });

        it('should process a meta-transaction job trade successfully', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockTransactionRequest: providers.TransactionRequest = {};
            const mockTransaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                },
                transactionSubmissionId,
            );
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Trade]),
                ),
            ).thenResolve([]);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByTransactionHashAsync(
                    '0xsignedtransactionhash',
                    RfqmTransactionSubmissionType.Trade,
                ),
            ).thenResolve([_.cloneDeep(mockTransaction)]);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v1', anything(), anything()),
            ).thenReturn('0xcalldata');
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(
                mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
            ).thenReturn(mockTransactionRequest);
            when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve('0xsignedtransactionhash');
            when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                signedTransaction: 'signedTransaction',
                transactionHash: '0xsignedtransactionhash',
            });
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
        });

        it('should process a meta-transaction v2 job trade successfully', async () => {
            const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockTransactionRequest: providers.TransactionRequest = {};
            const mockTransaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                    status: RfqmTransactionSubmissionStatus.Submitted,
                },
                transactionSubmissionId,
            );
            const mockTransactionReceipt: providers.TransactionReceipt = {
                blockHash: '0xblockhash',
                blockNumber: 1,
                byzantium: true,
                confirmations: 3,
                contractAddress: '0xexchangeproxyaddress',
                cumulativeGasUsed: EthersBigNumber.from(1000),
                effectiveGasPrice: EthersBigNumber.from(1000),
                from: '0xworkeraddress',
                gasUsed: EthersBigNumber.from(10000),
                logs: [],
                logsBloom: '',
                status: 1,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xsignedtransactionhash',
                transactionIndex: 0,
                type: 2,
            };
            const mockMinedBlock: providers.Block = {
                _difficulty: EthersBigNumber.from(2),
                difficulty: 2,
                extraData: '',
                gasLimit: EthersBigNumber.from(1000),
                gasUsed: EthersBigNumber.from(1000),
                hash: '0xblockhash',
                miner: '0xminer',
                nonce: '0x000',
                number: 21,
                parentHash: '0xparentblockhash',
                timestamp: 12345,
                transactions: ['0xpresubmittransactionhash'],
            };
            const mockNonce = 0;

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Trade]),
                ),
            ).thenResolve([]);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByTransactionHashAsync(
                    '0xsignedtransactionhash',
                    RfqmTransactionSubmissionType.Trade,
                ),
            ).thenResolve([_.cloneDeep(mockTransaction)]);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v2', anything(), anything()),
            ).thenReturn('0xcalldata');
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
            when(
                mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
            ).thenReturn(mockTransactionRequest);
            when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve('0xsignedtransactionhash');
            when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                signedTransaction: 'signedTransaction',
                transactionHash: '0xsignedtransactionhash',
            });
            when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                mockTransactionReceipt,
            ]);
            when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
            when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.processTradeAsync(job, '0xworkeraddress');
            expect(updateRfqmJobCalledArgs[0].status).to.equal(RfqmJobStatus.PendingProcessing);
            expect(updateRfqmJobCalledArgs[1].status).to.equal(RfqmJobStatus.PendingSubmitted);
            expect(updateRfqmJobCalledArgs[updateRfqmJobCalledArgs.length - 1].status).to.equal(
                RfqmJobStatus.SucceededConfirmed,
            );
            expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
        });
    });

    describe('validate job methods', () => {
        it('should return null for valid, unexpired RFQm v2 jobs', () => {
            const fakeInFiveMinutesS = fakeClockMs / ONE_SECOND_MS + 360;

            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeInFiveMinutesS),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            /* expiry */ new BigNumber(fakeInFiveMinutesS),
                            /* nonceBucket */ new BigNumber(21),
                            /* nonce */ new BigNumber(0),
                        ).toString(),
                        maker: '',
                        makerAmount: '',
                        makerToken: '',
                        taker: '',
                        takerAmount: '',
                        takerToken: '',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const result = WorkerService.validateRfqmV2Job(job, new Date(fakeClockMs));
            expect(result).to.equal(null);
        });

        it('should return a No Taker Signature status for RFQm v2 jobs with no taker signature', () => {
            const fakeInFiveMinutesS = fakeClockMs / ONE_SECOND_MS + 360;

            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeInFiveMinutesS),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            /* expiry */ new BigNumber(fakeInFiveMinutesS),
                            /* nonceBucket */ new BigNumber(21),
                            /* nonce */ new BigNumber(0),
                        ).toString(),
                        maker: '',
                        makerAmount: '',
                        makerToken: '',
                        taker: '',
                        takerAmount: '',
                        takerToken: '',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: null,
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const result = WorkerService.validateRfqmV2Job(job, new Date(fakeClockMs));
            expect(result).to.equal(RfqmJobStatus.FailedValidationNoTakerSignature);
        });

        it('should return null for valid, unexpired meta-transaction v1 and v2 jobs', () => {
            const fakeInFiveMinutesS = fakeClockMs / ONE_SECOND_MS + 360;

            const v1Job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeInFiveMinutesS),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );
            const v2Job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );

            expect(WorkerService.validateMetaTransactionJob(v1Job, new Date(fakeClockMs))).to.equal(null);
            expect(WorkerService.validateMetaTransactionJob(v2Job, new Date(fakeClockMs))).to.equal(null);
        });

        it('should return a failed expired status for meta-transaction v1 and v2 job that expire', () => {
            const v1Job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeClockMs / ONE_SECOND_MS),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );
            const v2Job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeClockMs / ONE_SECOND_MS),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );

            expect(WorkerService.validateMetaTransactionJob(v1Job, new Date(fakeClockMs + 1000000))).to.equal(
                RfqmJobStatus.FailedExpired,
            );
            expect(WorkerService.validateMetaTransactionJob(v2Job, new Date(fakeClockMs + 1000000))).to.equal(
                RfqmJobStatus.FailedExpired,
            );
        });
    });

    describe('shouldResubmitTransaction', () => {
        it('should return false if new gas price < 10% greater than previous', async () => {
            const gasFees = { maxFeePerGas: new BigNumber(100), maxPriorityFeePerGas: new BigNumber(10) };
            const newGasPrice = new BigNumber(105);

            expect(WorkerService.shouldResubmitTransaction(gasFees, newGasPrice)).to.equal(false);
        });
        it('should return true if new gas price is 10% greater than previous', async () => {
            const gasFees = { maxFeePerGas: new BigNumber(100), maxPriorityFeePerGas: new BigNumber(10) };
            const newGasPrice = new BigNumber(110);

            expect(WorkerService.shouldResubmitTransaction(gasFees, newGasPrice)).to.equal(true);
        });
        it('should return true if new gas price > 10% greater than previous', async () => {
            const gasFees = { maxFeePerGas: new BigNumber(100), maxPriorityFeePerGas: new BigNumber(10) };
            const newGasPrice = new BigNumber(120);

            expect(WorkerService.shouldResubmitTransaction(gasFees, newGasPrice)).to.equal(true);
        });
    });

    describe('checkJobPreprocessingAsync', () => {
        it('should update job staus and throw error if job validation failed for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeOneMinuteAgoS),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeOneMinuteAgoS.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            try {
                await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedExpired);
            }
        });

        it('should throw error if there is no taker signature for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: null,
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            try {
                await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedValidationNoTakerSignature);
            }
        });

        it('should update job staus to `PendingProcessing` if job status is `PendingEnqueued` for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
            expect(job.status).to.deep.equal(RfqmJobStatus.PendingProcessing);
        });

        it('should update job staus and throw error if job validation failed for a meta-transaction job', async () => {
            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeOneMinuteAgoS),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            try {
                await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedExpired);
            }
        });

        it('should update job staus to `PendingProcessing` if job status is `PendingEnqueued` for a meta-transaction job', async () => {
            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
            expect(job.status).to.deep.equal(RfqmJobStatus.PendingProcessing);
        });

        it('should update job staus and throw error if job validation failed for a meta-transaction v2 job', async () => {
            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeOneMinuteAgoS),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            try {
                await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedExpired);
            }
        });

        it('should update job staus to `PendingProcessing` if job status is `PendingEnqueued` for a meta-transaction v2 job', async () => {
            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                'jobId',
            );

            const mockDbUtils = mock(RfqmDbUtils);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
            });

            await rfqmService.checkJobPreprocessingAsync(job, new Date(fakeClockMs));
            expect(job.status).to.deep.equal(RfqmJobStatus.PendingProcessing);
        });
    });

    describe('prepareApprovalAsync', () => {
        it('should throw exception if there are submitted transactions but job maker signature is null for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                createdAt: new Date(1233),
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                status: RfqmTransactionSubmissionStatus.Submitted,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                type: RfqmTransactionSubmissionType.Trade,
            });

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    '0x01234567',
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockTransaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            try {
                await rfqmService.prepareApprovalAsync(
                    job,
                    '0xworkeraddress',
                    '0xtoken',
                    MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Encountered a job with submissions but no maker signature');
            }
        });

        it('should return generated calldata if there are submitted transactions for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                createdAt: new Date(1233),
                from: '0xworkeraddress',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 0,
                orderHash: '0x01234567',
                status: RfqmTransactionSubmissionStatus.Submitted,
                to: '0xexchangeproxyaddress',
                transactionHash: '0xpresubmittransactionhash',
                type: RfqmTransactionSubmissionType.Trade,
            });

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    '0x01234567',
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockTransaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            const calldata = await rfqmService.prepareApprovalAsync(
                job,
                '0xworkeraddress',
                '0xtoken',
                MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            );
            expect(calldata).to.deep.equal(MOCK_EXECUTE_META_TRANSACTION_CALLDATA);
        });

        it('should throw exception if eth_call failed for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    '0x01234567',
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenThrow(new Error('error'));
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            try {
                await rfqmService.prepareApprovalAsync(
                    job,
                    '0xworkeraddress',
                    '0xtoken',
                    MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Eth call approval validation failed');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedEthCallFailed);
            }
        });

        it('should return correct calldata if there is no submitted transaction for a rfqm v2 job', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                    '0x01234567',
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(10);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            const calldata = await rfqmService.prepareApprovalAsync(
                job,
                '0xworkeraddress',
                '0xtoken',
                MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            );
            expect(calldata).to.deep.equal(MOCK_EXECUTE_META_TRANSACTION_CALLDATA);
        });

        it('should return generated calldata if there are submitted transactions for a meta-transaction job', async () => {
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockTransaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Approval,
                },
                transactionSubmissionId,
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockTransaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            const calldata = await rfqmService.prepareApprovalAsync(
                job,
                '0xworkeraddress',
                '0xtoken',
                MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            );
            expect(calldata).to.deep.equal(MOCK_EXECUTE_META_TRANSACTION_CALLDATA);
            verify(mockBlockchainUtils.estimateGasForAsync(anything())).never();
        });

        it('should throw exception if eth_call failed for a meta-transaction job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenThrow(new Error('error'));
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            try {
                await rfqmService.prepareApprovalAsync(
                    job,
                    '0xworkeraddress',
                    '0xtoken',
                    MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Eth call approval validation failed');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedEthCallFailed);
            }
        });

        it('should return correct calldata if there is no submitted transaction for a meta-transaction job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(10);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            const calldata = await rfqmService.prepareApprovalAsync(
                job,
                '0xworkeraddress',
                '0xtoken',
                MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            );
            expect(calldata).to.deep.equal(MOCK_EXECUTE_META_TRANSACTION_CALLDATA);
        });

        it('should return generated calldata if there are submitted transactions for a meta-transaction v2 job', async () => {
            const jobId = 'jobId';
            const transactionSubmissionId = 'submissionId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockTransaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Approval,
                },
                transactionSubmissionId,
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([mockTransaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            const calldata = await rfqmService.prepareApprovalAsync(
                job,
                '0xworkeraddress',
                '0xtoken',
                MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            );
            expect(calldata).to.deep.equal(MOCK_EXECUTE_META_TRANSACTION_CALLDATA);
            verify(mockBlockchainUtils.estimateGasForAsync(anything())).never();
        });

        it('should throw exception if eth_call failed for a meta-transaction v2 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenThrow(new Error('error'));
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            try {
                await rfqmService.prepareApprovalAsync(
                    job,
                    '0xworkeraddress',
                    '0xtoken',
                    MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                    {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Eth call approval validation failed');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedEthCallFailed);
            }
        });

        it('should return correct calldata if there is no submitted transaction for a meta-transaction v2 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const mockDbUtils = mock(RfqmDbUtils);
            when(
                mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                    jobId,
                    deepEqual([RfqmTransactionSubmissionType.Approval]),
                ),
            ).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.generateApprovalCalldataAsync(anything(), anything(), anything())).thenResolve(
                MOCK_EXECUTE_META_TRANSACTION_CALLDATA,
            );
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(10);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            const calldata = await rfqmService.prepareApprovalAsync(
                job,
                '0xworkeraddress',
                '0xtoken',
                MOCK_EXECUTE_META_TRANSACTION_APPROVAL,
                {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
            );
            expect(calldata).to.deep.equal(MOCK_EXECUTE_META_TRANSACTION_CALLDATA);
        });
    });

    describe('prepareRfqmV2TradeAsync', () => {
        it('updates the job and throws upon validation failure when `shouldCheckLastLook` is true', async () => {
            const expiredJob = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeOneMinuteAgoS),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeOneMinuteAgoS.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '',
                        makerAmount: '',
                        makerToken: '',
                        taker: '',
                        takerAmount: '',
                        takerToken: '',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(expiredJob);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
            const rfqmService = buildWorkerServiceForUnitTest({ dbUtils: instance(mockDbUtils) });

            try {
                await rfqmService.prepareRfqmV2TradeAsync(
                    expiredJob,
                    '0xworkeraddress',
                    { shouldSimulate: true, shouldCheckLastLook: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(expiredJob).to.deep.equal({ ..._job, status: RfqmJobStatus.FailedExpired });
            }
        });

        it('handles a balance check failure', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([new BigNumber(100)]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(5),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.prepareRfqmV2TradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldSimulate: true, shouldCheckLastLook: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Order failed pre-sign validation');
                expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.PendingProcessing,
                });
                expect(updateRfqmJobCalledArgs[1]).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
            }
        });

        it('handles a decline to sign', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(undefined);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.prepareRfqmV2TradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldSimulate: true, shouldCheckLastLook: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Market Maker declined to sign');
                expect(job).to.deep.equal({
                    ..._job,
                    lastLookResult: false,
                    status: RfqmJobStatus.FailedLastLookDeclined,
                });
            }
        });

        it('handles a signature failure', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenReject(
                new Error('fake timeout'),
            );
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.prepareRfqmV2TradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldSimulate: true, shouldCheckLastLook: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed during market maker sign attempt');
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedSignFailed,
                });
            }
        });

        it('handles signer is not the maker', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(orderHash)).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            const invalidEIP712Sig = _.cloneDeep(validEIP712Sig);
            invalidEIP712Sig.r = '0xdc158f7b53b940863bc7b001552a90282e51033f29b73d44a2701bd16faa19d3';
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(invalidEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.prepareRfqmV2TradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldSimulate: true, shouldCheckLastLook: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Invalid order signer address');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedSignFailed);
            }
        });

        it('handles an eth_call failure', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(orderHash)).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenReject(new Error('fake eth call failure'));
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.prepareRfqmV2TradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldSimulate: true, shouldCheckLastLook: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Eth call validation failed');
                expect(job).to.deep.equal({
                    ..._job,
                    lastLookResult: true,
                    makerSignature: validEIP712Sig,
                    status: RfqmJobStatus.FailedEthCallFailed,
                });
            }
        });

        it('updates market maker signatures missing bytes', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(missingByteSig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xvalidcalldata');
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.prepareRfqmV2TradeAsync(
                job,
                '0xworkeraddress',
                { shouldSimulate: true, shouldCheckLastLook: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal({
                ..._job,
                lastLookResult: true,
                makerSignature: padSignature(missingByteSig),
                status: RfqmJobStatus.PendingLastLookAccepted,
            });
        });

        it('skips the eth_call for jobs with existing submissions', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: true,
                makerUri: 'http://foo.bar',
                makerSignature: validEIP712Sig,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingLastLookAccepted,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const transaction = new RfqmV2TransactionSubmissionEntity({
                orderHash,
                to: '0xexchangeproxyaddress',
                from: '0xworkeraddress',
                transactionHash: '0xsignedtransactionhash',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 21,
                type: RfqmTransactionSubmissionType.Trade,
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([transaction]);
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xvalidcalldata');
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            const calldata = await rfqmService.prepareRfqmV2TradeAsync(
                job,
                '0xworkeraddress',
                { shouldSimulate: true, shouldCheckLastLook: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal({
                ..._job,
                lastLookResult: true,
                makerSignature: validEIP712Sig,
                status: RfqmJobStatus.PendingLastLookAccepted,
            });
            expect(calldata).to.equal('0xvalidcalldata');
            verify(mockBlockchainUtils.estimateGasForAsync(anything())).never();
        });

        it('lets expired jobs with existing submissions fall through', async () => {
            // If the job isn't in a terminal status but there are existing submissions,
            // `prepareTradeAsync` will let the job continue to the submission step which
            // will allow the worker to check receipts for those submissions.
            const expiredJob = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeOneMinuteAgoS),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: true,
                makerUri: 'http://foo.bar',
                makerSignature: {
                    r: '0x01',
                    s: '0x02',
                    signatureType: SignatureType.EthSign,
                    v: 27,
                },
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeOneMinuteAgoS.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingSubmitted,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const transaction = new RfqmV2TransactionSubmissionEntity({
                orderHash: '0x01234567',
                to: '0xexchangeproxyaddress',
                from: '0xworkeraddress',
                transactionHash: '0xsignedtransactionhash',
                maxFeePerGas: new BigNumber(100000),
                maxPriorityFeePerGas: new BigNumber(100),
                nonce: 21,
                type: RfqmTransactionSubmissionType.Trade,
            });

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([transaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xvalidcalldata');

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
            });

            await rfqmService.prepareRfqmV2TradeAsync(
                expiredJob,
                '0xworkeraddress',
                { shouldSimulate: true, shouldCheckLastLook: true },
                new Date(fakeClockMs),
            );
            expect(expiredJob.status).to.equal(RfqmJobStatus.PendingSubmitted);
        });

        it('successfully prepares a job when checking last look', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '0xworkeraddress',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(orderHash)).thenResolve([]);
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(validEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xvalidcalldata');
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            const calldata = await rfqmService.prepareRfqmV2TradeAsync(
                job,
                '0xworkeraddress',
                { shouldSimulate: true, shouldCheckLastLook: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal({
                ..._job,
                lastLookResult: true,
                makerSignature: validEIP712Sig,
                status: RfqmJobStatus.PendingLastLookAccepted,
            });
            expect(calldata).to.equal('0xvalidcalldata');
            expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                ..._job,
                status: RfqmJobStatus.PendingProcessing,
            });
            expect(updateRfqmJobCalledArgs[1]).to.deep.equal({
                ..._job,
                lastLookResult: true,
                makerSignature: validEIP712Sig,
                status: RfqmJobStatus.PendingLastLookAccepted,
            });
        });

        it('successfully prepares a job if no last look is necessary', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: true,
                makerUri: 'http://foo.bar',
                makerSignature: validEIP712Sig,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingLastLookAccepted,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '0xworkeraddress',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(orderHash)).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xvalidcalldata');
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });
            const spiedRfqmService = spy(rfqmService);

            const calldata = await rfqmService.prepareRfqmV2TradeAsync(
                job,
                '0xworkeraddress',
                { shouldSimulate: true, shouldCheckLastLook: false },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal(_job);
            expect(calldata).to.equal('0xvalidcalldata');
            verify(spiedRfqmService.checkJobPreprocessingAsync(anything(), anything())).never();
            verify(spiedRfqmService.checkLastLookAsync(anything(), anything(), anything())).never();
        });

        describe('Gasless RFQt VIP', () => {
            it('handles a balance check failure', async () => {
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: null,
                    makerUri: 'http://foo.bar',
                    makerSignature: validEIP712Sig,
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(fakeFiveMinutesLater.toString()),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingEnqueued,
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'gasless-rfqt',
                });
                const _job = _.cloneDeep(job);

                const mockDbUtils = mock(RfqmDbUtils);
                when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
                const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const mockQuoteServerClient = mock(QuoteServerClient);
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                    new BigNumber(100),
                ]);
                const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
                when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                    new BigNumber(5),
                ]);

                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    quoteServerClient: instance(mockQuoteServerClient),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                    rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
                });

                try {
                    await rfqmService.prepareRfqmV2TradeAsync(
                        job,
                        '0xworkeraddress',
                        { shouldSimulate: true, shouldCheckLastLook: true },
                        new Date(fakeClockMs),
                    );
                    expect.fail();
                } catch (e) {
                    expect(e.message).to.contain('Order failed pre-submit validation');
                    verify(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).never();
                    expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                        ..._job,
                        status: RfqmJobStatus.PendingProcessing,
                    });
                    expect(updateRfqmJobCalledArgs[1]).to.deep.equal({
                        ..._job,
                        status: RfqmJobStatus.FailedPresubmitValidationFailed,
                    });
                    expect(job).to.deep.equal({
                        ..._job,
                        status: RfqmJobStatus.FailedPresubmitValidationFailed,
                    });
                }
            });
        });
    });

    describe('prepareMetaTransactionTradeAsync', () => {
        it('updates the job and throws upon validation failure if `shouldValidateJob` is true for meta-transaction v1 job', async () => {
            const jobId = 'jobId';
            const expiredJob = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeOneMinuteAgoS),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const _job = _.cloneDeep(expiredJob);
            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            try {
                await rfqmService.prepareMetaTransactionTradeAsync(
                    expiredJob,
                    '0xworkeraddress',
                    { shouldValidateJob: true, shouldSimulate: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(expiredJob).to.deep.equal({ ..._job, status: RfqmJobStatus.FailedExpired });
            }
        });

        it('handles an eth_call failure for meta-transaction v1 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const _job = _.cloneDeep(job);

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenReject(new Error('fake eth call failure'));

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            try {
                await rfqmService.prepareMetaTransactionTradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldValidateJob: true, shouldSimulate: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Eth call validation failed');
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedEthCallFailed,
                });
            }
        });

        it('skips the eth_call for jobs with existing submissions for meta-transaction v1 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingProcessing,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const transaction = createMetaTransactionSubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionJobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                },
                'submissionId',
            );
            const _job = _.cloneDeep(job);

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([transaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v1', anything(), anything()),
            ).thenReturn('0xvalidcalldata');

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            const calldata = await rfqmService.prepareMetaTransactionTradeAsync(
                job,
                '0xworkeraddress',
                { shouldValidateJob: true, shouldSimulate: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal(_job);
            expect(calldata).to.equal('0xvalidcalldata');
            verify(mockBlockchainUtils.estimateGasForAsync(anything())).never();
        });

        it('successfully prepares a job if `shouldValidateJob` is true for meta-transaction v1 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionJobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    fee: {
                        amount: new BigNumber(0),
                        token: '',
                        type: 'fixed',
                    },
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    metaTransaction: MOCK_META_TRANSACTION,
                    metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const _job = _.cloneDeep(job);

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(jobId)).thenResolve([]);
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v1', anything(), anything()),
            ).thenReturn('0xvalidcalldata');

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            const calldata = await rfqmService.prepareMetaTransactionTradeAsync(
                job,
                '0xworkeraddress',
                { shouldValidateJob: true, shouldSimulate: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal({
                ..._job,
                status: RfqmJobStatus.PendingProcessing,
            });
            expect(calldata).to.equal('0xvalidcalldata');
            expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                ..._job,
                status: RfqmJobStatus.PendingProcessing,
            });
        });

        it('updates the job and throws upon validation failure if `shouldValidateJob` is true for meta-transaction v2 job', async () => {
            const jobId = 'jobId';
            const expiredJob = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeOneMinuteAgoS),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const _job = _.cloneDeep(expiredJob);
            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            try {
                await rfqmService.prepareMetaTransactionTradeAsync(
                    expiredJob,
                    '0xworkeraddress',
                    { shouldValidateJob: true, shouldSimulate: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed validation');
                expect(expiredJob).to.deep.equal({ ..._job, status: RfqmJobStatus.FailedExpired });
            }
        });

        it('handles an eth_call failure for meta-transaction v2 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const _job = _.cloneDeep(job);

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenReject(new Error('fake eth call failure'));

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            try {
                await rfqmService.prepareMetaTransactionTradeAsync(
                    job,
                    '0xworkeraddress',
                    { shouldValidateJob: true, shouldSimulate: true },
                    new Date(fakeClockMs),
                );
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Eth call validation failed');
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedEthCallFailed,
                });
            }
        });

        it('skips the eth_call for jobs with existing submissions for meta-transaction v2 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingProcessing,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );

            const transaction = createMetaTransactionV2SubmissionEntity(
                {
                    from: '0xworkeraddress',
                    metaTransactionV2JobId: jobId,
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                },
                'submissionId',
            );
            const _job = _.cloneDeep(job);

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([transaction]);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v2', anything(), anything()),
            ).thenReturn('0xvalidcalldata');

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            const calldata = await rfqmService.prepareMetaTransactionTradeAsync(
                job,
                '0xworkeraddress',
                { shouldValidateJob: true, shouldSimulate: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal(_job);
            expect(calldata).to.equal('0xvalidcalldata');
            verify(mockBlockchainUtils.estimateGasForAsync(anything())).never();
        });

        it('successfully prepares a job if `shouldValidateJob` is true for meta-transaction v2 job', async () => {
            const jobId = 'jobId';

            const job = createMetaTransactionV2JobEntity(
                {
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(fakeFiveMinutesLater),
                    inputToken: '0xinputToken',
                    inputTokenAmount: new BigNumber(10),
                    integratorId: '0xintegrator',
                    calledFunction: 'transformERC20',
                    metaTransaction: MOCK_META_TRANSACTION_V2,
                    metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                    minOutputTokenAmount: new BigNumber(10),
                    outputToken: '0xoutputToken',
                    takerAddress: '0xtakerAddress',
                    takerSignature: {
                        signatureType: SignatureType.EthSign,
                        v: 27,
                        r: '0x01',
                        s: '0x02',
                    },
                    tokens: ['0xinputToken', '0xoutputToken'],
                    status: RfqmJobStatus.PendingEnqueued,
                    workerAddress: '0xworkeraddress',
                },
                jobId,
            );
            const _job = _.cloneDeep(job);

            const gasStationAttendantMock = mock(GasStationAttendantEthereum);
            when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                new BigNumber(10).shiftedBy(GWEI_DECIMALS),
            );
            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
            when(mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(jobId)).thenResolve([]);
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateMetaTransactionCallData(anything(), 'v2', anything(), anything()),
            ).thenReturn('0xvalidcalldata');

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                gasStationAttendant: instance(gasStationAttendantMock),
            });

            const calldata = await rfqmService.prepareMetaTransactionTradeAsync(
                job,
                '0xworkeraddress',
                { shouldValidateJob: true, shouldSimulate: true },
                new Date(fakeClockMs),
            );
            expect(job).to.deep.equal({
                ..._job,
                status: RfqmJobStatus.PendingProcessing,
            });
            expect(calldata).to.equal('0xvalidcalldata');
            expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                ..._job,
                status: RfqmJobStatus.PendingProcessing,
            });
        });
    });

    describe('checkLastLookAsync', () => {
        it('should call `getMinOfBalancesAndAllowancesAsync` when `shouldCheckAllowance` is true and throws when balance check fails', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingProcessing,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([new BigNumber(100)]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(5),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Order failed pre-sign validation');
                expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
                verify(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).once();
                verify(mockBlockchainUtils.getTokenBalancesAsync(anything())).never();
            }
        });

        it('should call `getTokenBalancesAsync` when `shouldCheckAllowance` is false and throws when balance check fails', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingProcessing,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getTokenBalancesAsync(anything())).thenResolve([new BigNumber(100)]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(5),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.checkLastLookAsync(job, '0xworkeraddress', false);
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Order failed pre-sign validation');
                expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });

                verify(mockBlockchainUtils.getTokenBalancesAsync(anything())).once();
                verify(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).never();
            }
        });

        it('should throw when taker signature is not present', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingProcessing,
                takerSignature: null,
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Order failed pre-sign validation due to empty takerSignature');
                expect(updateRfqmJobCalledArgs[0]).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedPresignValidationFailed,
                });
            }
        });

        it('handles decline to sign', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
            when(mockDbUtils.findV2QuoteByOrderHashAsync('0x01234567')).thenResolve(
                new RfqmV2QuoteEntity({
                    createdAt: new Date(),
                    chainId: job.chainId,
                    fee: job.fee,
                    makerUri: job.makerUri,
                    order: job.order,
                    orderHash: job.orderHash,
                    workflow: 'rfqm',
                }),
            );
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(undefined);

            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const mockCacheClient = mock(CacheClient);

            const mockRfqMakerManager = mock(RfqMakerManager);
            when(mockRfqMakerManager.findMakerIdWithRfqmUri(job.makerUri)).thenReturn('makerId1');

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
                rfqMakerManager: instance(mockRfqMakerManager),
                cacheClient: instance(mockCacheClient),
            });

            try {
                await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Market Maker declined to sign');
                expect(job).to.deep.equal({
                    ..._job,
                    lastLookResult: false,
                    status: RfqmJobStatus.FailedLastLookDeclined,
                });

                verify(
                    mockCacheClient.addMakerToCooldownAsync(
                        'makerId1',
                        anything(),
                        job.chainId,
                        job.order.order.makerToken,
                        job.order.order.takerToken,
                    ),
                ).once();

                verify(
                    mockDbUtils.writeV2LastLookRejectionCooldownAsync(
                        'makerId1',
                        job.chainId,
                        job.order.order.makerToken,
                        job.order.order.takerToken,
                        anything(),
                        anything(),
                        job.orderHash,
                    ),
                ).once();
            }
        });

        it('handles a signature failure', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker: '0xmaker',
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash: '0x01234567',
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync('0x01234567')).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenReject(
                new Error('fake timeout'),
            );
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Job failed during market maker sign attempt');
                expect(job).to.deep.equal({
                    ..._job,
                    status: RfqmJobStatus.FailedSignFailed,
                });
            }
        });

        it('handles signer is not the maker', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });

            const mockDbUtils = mock(RfqmDbUtils);
            const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
            when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
            });
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(orderHash)).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            const invalidEIP712Sig = _.cloneDeep(validEIP712Sig);
            invalidEIP712Sig.r = '0xdc158f7b53b940863bc7b001552a90282e51033f29b73d44a2701bd16faa19d3';
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(invalidEIP712Sig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            try {
                await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
                expect.fail();
            } catch (e) {
                expect(e.message).to.contain('Invalid order signer address');
                expect(job.status).to.deep.equal(RfqmJobStatus.FailedSignFailed);
            }
        });

        it('updates market maker signatures missing bytes', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: null,
                makerUri: 'http://foo.bar',
                makerSignature: null,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingEnqueued,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            when(mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(anything())).thenResolve([]);
            const mockQuoteServerClient = mock(QuoteServerClient);
            when(mockQuoteServerClient.signV2Async(anything(), anything(), anything())).thenResolve(missingByteSig);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            when(mockBlockchainUtils.isValidOrderSignerAsync(anything(), anything())).thenResolve(true);
            when(mockBlockchainUtils.getMinOfBalancesAndAllowancesAsync(anything())).thenResolve([
                new BigNumber(1000000000),
            ]);
            when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(0);
            when(
                mockBlockchainUtils.generateTakerSignedOtcOrderCallData(
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                    anything(),
                ),
            ).thenReturn('0xvalidcalldata');
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);
            when(mockRfqMakerBalanceCacheService.getERC20OwnerBalancesAsync(anything(), anything())).thenResolve([
                new BigNumber(1000000000),
            ]);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
            expect(job).to.deep.equal({
                ..._job,
                lastLookResult: true,
                makerSignature: padSignature(missingByteSig),
                status: RfqmJobStatus.PendingLastLookAccepted,
            });
        });

        it('does not sign if maker signature is already present', async () => {
            const job = new RfqmV2JobEntity({
                affiliateAddress: '',
                chainId: 1,
                createdAt: new Date(),
                expiry: new BigNumber(fakeFiveMinutesLater),
                fee: {
                    amount: '0',
                    token: '',
                    type: 'fixed',
                },
                integratorId: '',
                lastLookResult: true,
                makerUri: 'http://foo.bar',
                makerSignature: validEIP712Sig,
                order: {
                    order: {
                        chainId: '1',
                        expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                            new BigNumber(fakeFiveMinutesLater.toString()),
                            new BigNumber(1),
                            new BigNumber(1),
                        ).toString(),
                        maker,
                        makerAmount: '1000000',
                        makerToken: '0xmakertoken',
                        taker: '0xtaker',
                        takerAmount: '10000000',
                        takerToken: '0xtakertoken',
                        txOrigin: '',
                        verifyingContract: '',
                    },
                    type: RfqmOrderTypes.Otc,
                },
                orderHash,
                status: RfqmJobStatus.PendingLastLookAccepted,
                takerSignature: {
                    signatureType: SignatureType.EthSign,
                    v: 27,
                    r: '0x01',
                    s: '0x02',
                },
                updatedAt: new Date(),
                workerAddress: '',
                workflow: 'rfqm',
            });
            const _job = _.cloneDeep(job);

            const mockDbUtils = mock(RfqmDbUtils);
            const mockQuoteServerClient = mock(QuoteServerClient);
            const mockBlockchainUtils = mock(RfqBlockchainUtils);
            const mockRfqMakerBalanceCacheService = mock(RfqMakerBalanceCacheService);

            const rfqmService = buildWorkerServiceForUnitTest({
                dbUtils: instance(mockDbUtils),
                quoteServerClient: instance(mockQuoteServerClient),
                rfqBlockchainUtils: instance(mockBlockchainUtils),
                rfqMakerBalanceCacheService: instance(mockRfqMakerBalanceCacheService),
            });

            await rfqmService.checkLastLookAsync(job, '0xworkeraddress', true);
            expect(job).to.deep.equal({
                ..._job,
                lastLookResult: true,
                makerSignature: validEIP712Sig,
                status: RfqmJobStatus.PendingLastLookAccepted,
            });
        });
    });

    describe('submitToChainAsync', () => {
        describe('kind is `rfqm_v2_job`', () => {
            it('submits a transaction successfully when there is no previous transaction', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(nowS + 600),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingLastLookAccepted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xto',
                    from: '0xfrom',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeV2RfqmTransactionSubmissionToDbCalledArgs: RfqmTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeV2RfqmTransactionSubmissionToDbAsync(anything())).thenCall(
                    async (transactionArg) => {
                        writeV2RfqmTransactionSubmissionToDbCalledArgs.push(_.cloneDeep(transactionArg));
                        return _.cloneDeep(mockTransaction);
                    },
                );
                when(
                    mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash'),
                ).thenResolve(_.cloneDeep(mockTransaction));
                const updateRfqmTransactionSubmissionsCalledArgs: RfqmTransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });

                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };
                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.orderHash,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });
                verify(mockBlockchainUtils.estimateGasForAsync(anything()));
                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
                expect(writeV2RfqmTransactionSubmissionToDbCalledArgs[0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Presubmit,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
            });

            it("ignores an existing PRESUBMIT transaction which isn't found in the mempool or on chain", async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(nowS + 600),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingLastLookAccepted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockPresubmitTransaction = new RfqmV2TransactionSubmissionEntity({
                    createdAt: new Date(1233),
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    status: RfqmTransactionSubmissionStatus.Presubmit,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([mockPresubmitTransaction]);
                const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeV2RfqmTransactionSubmissionToDbCalledArgs: RfqmTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeV2RfqmTransactionSubmissionToDbAsync(anything())).thenCall(
                    async (transactionArg) => {
                        writeV2RfqmTransactionSubmissionToDbCalledArgs.push(_.cloneDeep(transactionArg));
                        return _.cloneDeep(mockTransaction);
                    },
                );
                when(
                    mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash'),
                ).thenResolve(_.cloneDeep(mockTransaction));
                const updateRfqmTransactionSubmissionsCalledArgs: RfqmV2TransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                // This mock response indicates that the presubmit transaction can't be found
                // on chain or in the mempool
                when(mockBlockchainUtils.getTransactionAsync('0xpresubmittransactionhash')).thenResolve(null);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });

                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };
                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.orderHash,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });

                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
                // Expectations are the same as if the presubmit transaction never existed
                expect(writeV2RfqmTransactionSubmissionToDbCalledArgs[0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Presubmit,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
            });

            it("marks a PRESUBMIT job as expired when existing transactions aren't found in \
            the mempool or on chain and the expiration time has passed", async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS - 60),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(nowS - 60),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingLastLookAccepted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockPresubmitTransaction = new RfqmV2TransactionSubmissionEntity({
                    createdAt: new Date(1233),
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    status: RfqmTransactionSubmissionStatus.Presubmit,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([mockPresubmitTransaction]);
                const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeV2RfqmTransactionSubmissionToDbCalledArgs: RfqmTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeV2RfqmTransactionSubmissionToDbAsync(anything())).thenCall(
                    async (transactionArg) => {
                        writeV2RfqmTransactionSubmissionToDbCalledArgs.push(_.cloneDeep(transactionArg));
                        return _.cloneDeep(mockTransaction);
                    },
                );
                when(
                    mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash'),
                ).thenResolve(_.cloneDeep(mockTransaction));
                const updateRfqmTransactionSubmissionsCalledArgs: RfqmV2TransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                // This mock response indicates that the presubmit transaction can't be found
                // on chain or in the mempool
                when(mockBlockchainUtils.getTransactionAsync('0xpresubmittransactionhash')).thenResolve(null);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);

                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                try {
                    await rfqmService.submitToChainAsync({
                        kind: job.kind,
                        to: '0xexchangeproxyaddress',
                        from: '0xworkeraddress',
                        calldata: '0xcalldata',
                        expiry: job.expiry,
                        identifier: job.orderHash,
                        submissionType: RfqmTransactionSubmissionType.Trade,
                        onSubmissionContextStatusUpdate: callback,
                    });
                    expect.fail();
                } catch (e) {
                    expect(e.message).to.contain('Exceed expiry');
                    // eth_createAccessList should not be called when not enabled
                    verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                    expect(job.status).to.equal(RfqmJobStatus.FailedExpired);
                }
            });

            it('recovers a PRESUBMIT transaction which actually submitted', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(nowS + 600),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingLastLookAccepted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockPresubmitTransaction = new RfqmV2TransactionSubmissionEntity({
                    createdAt: new Date(1233),
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    status: RfqmTransactionSubmissionStatus.Presubmit,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    blockHash: '0xblockhash',
                    blockNumber: 1,
                    byzantium: true,
                    confirmations: 3,
                    contractAddress: '0xexchangeproxyaddress',
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    from: '0xworkeraddress',
                    gasUsed: EthersBigNumber.from(10000),
                    logs: [],
                    logsBloom: '',
                    status: 1,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    transactionIndex: 0,
                    type: 2,
                };
                const mockTransactionResponse: providers.TransactionResponse = {
                    chainId: 1,
                    confirmations: 0,
                    data: '',
                    from: '0xworkeraddress',
                    gasLimit: EthersBigNumber.from(1000000),
                    hash: '0xpresubmittransactionhash',
                    nonce: 0,
                    type: 2,
                    value: EthersBigNumber.from(0),
                    wait: (_confirmations: number | undefined) => Promise.resolve(mockTransactionReceipt),
                };
                const mockMinedBlock: providers.Block = {
                    _difficulty: EthersBigNumber.from(2),
                    difficulty: 2,
                    extraData: '',
                    gasLimit: EthersBigNumber.from(1000),
                    gasUsed: EthersBigNumber.from(1000),
                    hash: '0xblockhash',
                    miner: '0xminer',
                    nonce: '0x000',
                    number: 21,
                    parentHash: '0xparentblockhash',
                    timestamp: 12345,
                    transactions: ['0xpresubmittransactionhash'],
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([mockPresubmitTransaction]);
                const updateRfqmTransactionSubmissionsCalledArgs: RfqmV2TransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                // This mock response indicates that the transaction is present in the mempool
                when(mockBlockchainUtils.getTransactionAsync('0xpresubmittransactionhash')).thenResolve(
                    mockTransactionResponse,
                );
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenReject(
                    new Error('estimateGasForAsync called during recovery'),
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xpresubmittransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.orderHash,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });

                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                // Logic should first check to see if the transaction was actually sent.
                // If it was (and it is being mock so in this test) then the logic first
                // updates the status of the transaction to "Submitted"
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                // The logic then enters the watch loop. On the first check, a transaction
                // receipt exists for this transaction and it will be marked "confirmed"
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
            });

            it('finalizes a job to FAILED_EXPIRED once the expiration window has passed', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const ninetySecondsAgo = nowS - 100;
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(ninetySecondsAgo),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(ninetySecondsAgo.toString()),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingSubmitted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                    createdAt: new Date(1233),
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    status: RfqmTransactionSubmissionStatus.Submitted,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([mockTransaction]);
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xpresubmittransactionhash']))).thenResolve([]);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                try {
                    await rfqmService.submitToChainAsync({
                        kind: job.kind,
                        to: '0xexchangeproxyaddress',
                        from: '0xworkeraddress',
                        calldata: '0xcalldata',
                        expiry: job.expiry,
                        identifier: job.orderHash,
                        submissionType: RfqmTransactionSubmissionType.Trade,
                        onSubmissionContextStatusUpdate: callback,
                    });
                } catch (e) {
                    expect(e.message).to.contain('Exceed expiry');
                    // eth_createAccessList should not be called when not enabled
                    verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                    expect(job.status).to.equal(RfqmJobStatus.FailedExpired);
                }
            });

            it('should call createAccessListForAsync and should not affect the overall method when RPC returns properly', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(nowS + 600),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingLastLookAccepted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeV2RfqmTransactionSubmissionToDbCalledArgs: RfqmTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeV2RfqmTransactionSubmissionToDbAsync(anything())).thenCall(
                    async (transactionArg) => {
                        writeV2RfqmTransactionSubmissionToDbCalledArgs.push(_.cloneDeep(transactionArg));
                        return _.cloneDeep(mockTransaction);
                    },
                );
                when(
                    mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash'),
                ).thenResolve(_.cloneDeep(mockTransaction));
                const updateRfqmTransactionSubmissionsCalledArgs: RfqmTransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                when(mockBlockchainUtils.createAccessListForAsync(anything())).thenResolve({
                    accessList: {
                        '0x1234': ['0x0'],
                        '0x12345': ['0x1'],
                    },
                    gasEstimate: 1000,
                });
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                    enableAccessList: true,
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.orderHash,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });
                verify(mockBlockchainUtils.estimateGasForAsync(anything()));
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).once();
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
                expect(writeV2RfqmTransactionSubmissionToDbCalledArgs[0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Presubmit,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
            });

            it('should call createAccessListForAsync and should not affect the overall method when RPC errors out', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const job = new RfqmV2JobEntity({
                    affiliateAddress: '',
                    chainId: 1,
                    createdAt: new Date(),
                    expiry: new BigNumber(nowS + 600),
                    fee: {
                        amount: '0',
                        token: '',
                        type: 'fixed',
                    },
                    integratorId: '',
                    lastLookResult: true,
                    makerUri: 'http://foo.bar',
                    order: {
                        order: {
                            chainId: '1',
                            expiryAndNonce: OtcOrder.encodeExpiryAndNonce(
                                new BigNumber(nowS + 600),
                                new BigNumber(1),
                                new BigNumber(1),
                            ).toString(),
                            maker: '0xmaker',
                            makerAmount: '1000000',
                            makerToken: '0xmakertoken',
                            taker: '0xtaker',
                            takerAmount: '10000000',
                            takerToken: '0xtakertoken',
                            txOrigin: '',
                            verifyingContract: '',
                        },
                        type: RfqmOrderTypes.Otc,
                    },
                    orderHash: '0x01234567',
                    status: RfqmJobStatus.PendingLastLookAccepted,
                    updatedAt: new Date(),
                    workerAddress: '',
                    workflow: 'rfqm',
                });

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = new RfqmV2TransactionSubmissionEntity({
                    from: '0xworkeraddress',
                    maxFeePerGas: new BigNumber(100000),
                    maxPriorityFeePerGas: new BigNumber(100),
                    nonce: 0,
                    orderHash: '0x01234567',
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xsignedtransactionhash',
                    type: RfqmTransactionSubmissionType.Trade,
                });
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xto',
                    from: '0xfrom',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findV2TransactionSubmissionsByOrderHashAsync(
                        '0x01234567',
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: RfqmJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeV2RfqmTransactionSubmissionToDbCalledArgs: RfqmTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeV2RfqmTransactionSubmissionToDbAsync(anything())).thenCall(
                    async (transactionArg) => {
                        writeV2RfqmTransactionSubmissionToDbCalledArgs.push(_.cloneDeep(transactionArg));
                        return _.cloneDeep(mockTransaction);
                    },
                );
                when(
                    mockDbUtils.findV2TransactionSubmissionByTransactionHashAsync('0xsignedtransactionhash'),
                ).thenResolve(_.cloneDeep(mockTransaction));
                const updateRfqmTransactionSubmissionsCalledArgs: RfqmTransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                when(mockBlockchainUtils.createAccessListForAsync(anything())).thenReject(new Error('error'));
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                    enableAccessList: true,
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.orderHash,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });
                verify(mockBlockchainUtils.estimateGasForAsync(anything()));
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).once();
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
                expect(writeV2RfqmTransactionSubmissionToDbCalledArgs[0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Presubmit,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
            });
        });

        // Not all tests from test block 'kind is `rfqm_v2_job`' is included here as most of the tests are similiar.
        // The tests below specifically test if corresponding methods are called for job kind `meta_transaction_job`.
        describe('kind is `meta_transaction_job`', () => {
            it('submits a transaction successfully when there is no previous transaction', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const jobId = 'jobId';
                const transactionSubmissionId = 'submissionId';
                const job = createMetaTransactionJobEntity(
                    {
                        chainId: 1,
                        createdAt: new Date(),
                        expiry: new BigNumber(nowS + 600),
                        fee: {
                            amount: new BigNumber(0),
                            token: '',
                            type: 'fixed',
                        },
                        inputToken: '0xinputToken',
                        inputTokenAmount: new BigNumber(10),
                        integratorId: '0xintegrator',
                        metaTransaction: MOCK_META_TRANSACTION,
                        metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                        minOutputTokenAmount: new BigNumber(10),
                        outputToken: '0xoutputToken',
                        takerAddress: '0xtakerAddress',
                        takerSignature: {
                            signatureType: SignatureType.EthSign,
                            v: 27,
                            r: '0x01',
                            s: '0x02',
                        },
                        status: RfqmJobStatus.PendingLastLookAccepted,
                        workerAddress: '0xworkeraddress',
                    },
                    jobId,
                );

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = createMetaTransactionSubmissionEntity(
                    {
                        from: '0xworkeraddress',
                        metaTransactionJobId: jobId,
                        maxFeePerGas: new BigNumber(100000),
                        maxPriorityFeePerGas: new BigNumber(100),
                        nonce: 0,
                        to: '0xexchangeproxyaddress',
                        transactionHash: '0xsignedtransactionhash',
                        type: RfqmTransactionSubmissionType.Trade,
                    },
                    transactionSubmissionId,
                );
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xto',
                    from: '0xfrom',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                        jobId,
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeMetaTransactionSubmissionAsyncCalledArgs: MetaTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeMetaTransactionSubmissionAsync(anything())).thenCall(async (transactionArg) => {
                    writeMetaTransactionSubmissionAsyncCalledArgs.push(_.cloneDeep(transactionArg));
                    return _.cloneDeep(mockTransaction);
                });
                when(
                    mockDbUtils.findMetaTransactionSubmissionsByTransactionHashAsync(
                        '0xsignedtransactionhash',
                        RfqmTransactionSubmissionType.Trade,
                    ),
                ).thenResolve([_.cloneDeep(mockTransaction)]);
                const updateRfqmTransactionSubmissionsCalledArgs: MetaTransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });

                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };
                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.id,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });
                verify(mockBlockchainUtils.estimateGasForAsync(anything()));
                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
                expect(writeMetaTransactionSubmissionAsyncCalledArgs[0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Presubmit,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
            });

            it('recovers a PRESUBMIT transaction which actually submitted', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const jobId = 'jobId';
                const transactionSubmissionId = 'submissionId';
                const job = createMetaTransactionJobEntity(
                    {
                        chainId: 1,
                        createdAt: new Date(),
                        expiry: new BigNumber(nowS + 600),
                        fee: {
                            amount: new BigNumber(0),
                            token: '',
                            type: 'fixed',
                        },
                        inputToken: '0xinputToken',
                        inputTokenAmount: new BigNumber(10),
                        integratorId: '0xintegrator',
                        metaTransaction: MOCK_META_TRANSACTION,
                        metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                        minOutputTokenAmount: new BigNumber(10),
                        outputToken: '0xoutputToken',
                        takerAddress: '0xtakerAddress',
                        takerSignature: {
                            signatureType: SignatureType.EthSign,
                            v: 27,
                            r: '0x01',
                            s: '0x02',
                        },
                        status: RfqmJobStatus.PendingLastLookAccepted,
                        workerAddress: '0xworkeraddress',
                    },
                    jobId,
                );

                const mockPresubmitTransaction = createMetaTransactionSubmissionEntity(
                    {
                        from: '0xworkeraddress',
                        metaTransactionJobId: jobId,
                        maxFeePerGas: new BigNumber(100000),
                        maxPriorityFeePerGas: new BigNumber(100),
                        nonce: 0,
                        status: RfqmTransactionSubmissionStatus.Presubmit,
                        to: '0xexchangeproxyaddress',
                        transactionHash: '0xpresubmittransactionhash',
                        type: RfqmTransactionSubmissionType.Trade,
                    },
                    transactionSubmissionId,
                );
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    blockHash: '0xblockhash',
                    blockNumber: 1,
                    byzantium: true,
                    confirmations: 3,
                    contractAddress: '0xexchangeproxyaddress',
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    from: '0xworkeraddress',
                    gasUsed: EthersBigNumber.from(10000),
                    logs: [],
                    logsBloom: '',
                    status: 1,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    transactionIndex: 0,
                    type: 2,
                };
                const mockTransactionResponse: providers.TransactionResponse = {
                    chainId: 1,
                    confirmations: 0,
                    data: '',
                    from: '0xworkeraddress',
                    gasLimit: EthersBigNumber.from(1000000),
                    hash: '0xpresubmittransactionhash',
                    nonce: 0,
                    type: 2,
                    value: EthersBigNumber.from(0),
                    wait: (_confirmations: number | undefined) => Promise.resolve(mockTransactionReceipt),
                };
                const mockMinedBlock: providers.Block = {
                    _difficulty: EthersBigNumber.from(2),
                    difficulty: 2,
                    extraData: '',
                    gasLimit: EthersBigNumber.from(1000),
                    gasUsed: EthersBigNumber.from(1000),
                    hash: '0xblockhash',
                    miner: '0xminer',
                    nonce: '0x000',
                    number: 21,
                    parentHash: '0xparentblockhash',
                    timestamp: 12345,
                    transactions: ['0xpresubmittransactionhash'],
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                        jobId,
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([mockPresubmitTransaction]);
                const updateRfqmTransactionSubmissionsCalledArgs: MetaTransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                // This mock response indicates that the transaction is present in the mempool
                when(mockBlockchainUtils.getTransactionAsync('0xpresubmittransactionhash')).thenResolve(
                    mockTransactionResponse,
                );
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenReject(
                    new Error('estimateGasForAsync called during recovery'),
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xpresubmittransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.id,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });

                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                // Logic should first check to see if the transaction was actually sent.
                // If it was (and it is being mock so in this test) then the logic first
                // updates the status of the transaction to "Submitted"
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                // The logic then enters the watch loop. On the first check, a transaction
                // receipt exists for this transaction and it will be marked "confirmed"
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
            });

            it('throws exception if there are more than 1 transaction submissions with the same transaction hash', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const jobId = 'jobId';
                const transactionSubmissionId = 'submissionId';
                const job = createMetaTransactionJobEntity(
                    {
                        chainId: 1,
                        createdAt: new Date(),
                        expiry: new BigNumber(nowS + 600),
                        fee: {
                            amount: new BigNumber(0),
                            token: '',
                            type: 'fixed',
                        },
                        inputToken: '0xinputToken',
                        inputTokenAmount: new BigNumber(10),
                        integratorId: '0xintegrator',
                        metaTransaction: MOCK_META_TRANSACTION,
                        metaTransactionHash: MOCK_META_TRANSACTION.getHash(),
                        minOutputTokenAmount: new BigNumber(10),
                        outputToken: '0xoutputToken',
                        takerAddress: '0xtakerAddress',
                        takerSignature: {
                            signatureType: SignatureType.EthSign,
                            v: 27,
                            r: '0x01',
                            s: '0x02',
                        },
                        status: RfqmJobStatus.PendingLastLookAccepted,
                        workerAddress: '0xworkeraddress',
                    },
                    jobId,
                );

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = createMetaTransactionSubmissionEntity(
                    {
                        from: '0xworkeraddress',
                        metaTransactionJobId: jobId,
                        maxFeePerGas: new BigNumber(100000),
                        maxPriorityFeePerGas: new BigNumber(100),
                        nonce: 0,
                        to: '0xexchangeproxyaddress',
                        transactionHash: '0xsignedtransactionhash',
                        type: RfqmTransactionSubmissionType.Trade,
                    },
                    transactionSubmissionId,
                );
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xto',
                    from: '0xfrom',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findMetaTransactionSubmissionsByJobIdAsync(
                        jobId,
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeMetaTransactionSubmissionAsyncCalledArgs: MetaTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeMetaTransactionSubmissionAsync(anything())).thenCall(async (transactionArg) => {
                    writeMetaTransactionSubmissionAsyncCalledArgs.push(_.cloneDeep(transactionArg));
                    return _.cloneDeep(mockTransaction);
                });
                when(
                    mockDbUtils.findMetaTransactionSubmissionsByTransactionHashAsync(
                        '0xsignedtransactionhash',
                        RfqmTransactionSubmissionType.Trade,
                    ),
                ).thenResolve([_.cloneDeep(mockTransaction), _.cloneDeep(mockTransaction)]);
                const updateRfqmTransactionSubmissionsCalledArgs: MetaTransactionSubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });

                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                try {
                    await rfqmService.submitToChainAsync({
                        kind: job.kind,
                        to: '0xexchangeproxyaddress',
                        from: '0xworkeraddress',
                        calldata: '0xcalldata',
                        expiry: job.expiry,
                        identifier: job.id,
                        submissionType: RfqmTransactionSubmissionType.Trade,
                        onSubmissionContextStatusUpdate: callback,
                    });
                    expect.fail();
                } catch (e) {
                    expect(e.message).to.contain('Transaction hash have been submitted not exactly once');
                }
            });
        });

        // Not all tests from test block 'kind is `rfqm_v2_job`' is included here as most of the tests are similiar.
        // The tests below specifically test if corresponding methods are called for job kind `meta_transaction_v2_job`.
        describe('kind is `meta_transaction_v2_job`', () => {
            it('submits a transaction successfully when there is no previous transaction', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const jobId = 'jobId';
                const job = createMetaTransactionV2JobEntity(
                    {
                        chainId: 1,
                        createdAt: new Date(),
                        expiry: new BigNumber(nowS + 600),
                        inputToken: '0xinputToken',
                        inputTokenAmount: new BigNumber(10),
                        integratorId: '0xintegrator',
                        calledFunction: 'transformERC20',
                        metaTransaction: MOCK_META_TRANSACTION_V2,
                        metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                        minOutputTokenAmount: new BigNumber(10),
                        outputToken: '0xoutputToken',
                        takerAddress: '0xtakerAddress',
                        takerSignature: {
                            signatureType: SignatureType.EthSign,
                            v: 27,
                            r: '0x01',
                            s: '0x02',
                        },
                        tokens: ['0xinputToken', '0xoutputToken'],
                        status: RfqmJobStatus.PendingLastLookAccepted,
                        workerAddress: '0xworkeraddress',
                    },
                    jobId,
                );
                const transactionSubmissionId = 'submissionId';
                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = createMetaTransactionV2SubmissionEntity(
                    {
                        from: '0xworkeraddress',
                        metaTransactionV2JobId: jobId,
                        maxFeePerGas: new BigNumber(100000),
                        maxPriorityFeePerGas: new BigNumber(100),
                        nonce: 0,
                        to: '0xexchangeproxyaddress',
                        transactionHash: '0xsignedtransactionhash',
                        type: RfqmTransactionSubmissionType.Trade,
                    },
                    transactionSubmissionId,
                );
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xto',
                    from: '0xfrom',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                        jobId,
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeMetaTransactionV2SubmissionAsyncCalledArgs: MetaTransactionSubmissionEntity[] = [];
                when(mockDbUtils.writeMetaTransactionV2SubmissionAsync(anything())).thenCall(async (transactionArg) => {
                    writeMetaTransactionV2SubmissionAsyncCalledArgs.push(_.cloneDeep(transactionArg));
                    return _.cloneDeep(mockTransaction);
                });
                when(
                    mockDbUtils.findMetaTransactionV2SubmissionsByTransactionHashAsync(
                        '0xsignedtransactionhash',
                        RfqmTransactionSubmissionType.Trade,
                    ),
                ).thenResolve([_.cloneDeep(mockTransaction)]);
                const updateRfqmTransactionSubmissionsCalledArgs: MetaTransactionV2SubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });

                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };
                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.id,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });
                verify(mockBlockchainUtils.estimateGasForAsync(anything()));
                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
                expect(writeMetaTransactionV2SubmissionAsyncCalledArgs[0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Presubmit,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
            });

            it('recovers a PRESUBMIT transaction which actually submitted', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const jobId = 'jobId';
                const transactionSubmissionId = 'submissionId';
                const job = createMetaTransactionV2JobEntity(
                    {
                        chainId: 1,
                        createdAt: new Date(),
                        expiry: new BigNumber(nowS + 600),
                        inputToken: '0xinputToken',
                        inputTokenAmount: new BigNumber(10),
                        integratorId: '0xintegrator',
                        calledFunction: 'transformERC20',
                        metaTransaction: MOCK_META_TRANSACTION_V2,
                        metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                        minOutputTokenAmount: new BigNumber(10),
                        outputToken: '0xoutputToken',
                        takerAddress: '0xtakerAddress',
                        takerSignature: {
                            signatureType: SignatureType.EthSign,
                            v: 27,
                            r: '0x01',
                            s: '0x02',
                        },
                        tokens: ['0xinputToken', '0xoutputToken'],
                        status: RfqmJobStatus.PendingLastLookAccepted,
                        workerAddress: '0xworkeraddress',
                    },
                    jobId,
                );

                const mockPresubmitTransaction = createMetaTransactionV2SubmissionEntity(
                    {
                        from: '0xworkeraddress',
                        metaTransactionV2JobId: jobId,
                        maxFeePerGas: new BigNumber(100000),
                        maxPriorityFeePerGas: new BigNumber(100),
                        nonce: 0,
                        status: RfqmTransactionSubmissionStatus.Presubmit,
                        to: '0xexchangeproxyaddress',
                        transactionHash: '0xpresubmittransactionhash',
                        type: RfqmTransactionSubmissionType.Trade,
                    },
                    transactionSubmissionId,
                );
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    blockHash: '0xblockhash',
                    blockNumber: 1,
                    byzantium: true,
                    confirmations: 3,
                    contractAddress: '0xexchangeproxyaddress',
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    from: '0xworkeraddress',
                    gasUsed: EthersBigNumber.from(10000),
                    logs: [],
                    logsBloom: '',
                    status: 1,
                    to: '0xexchangeproxyaddress',
                    transactionHash: '0xpresubmittransactionhash',
                    transactionIndex: 0,
                    type: 2,
                };
                const mockTransactionResponse: providers.TransactionResponse = {
                    chainId: 1,
                    confirmations: 0,
                    data: '',
                    from: '0xworkeraddress',
                    gasLimit: EthersBigNumber.from(1000000),
                    hash: '0xpresubmittransactionhash',
                    nonce: 0,
                    type: 2,
                    value: EthersBigNumber.from(0),
                    wait: (_confirmations: number | undefined) => Promise.resolve(mockTransactionReceipt),
                };
                const mockMinedBlock: providers.Block = {
                    _difficulty: EthersBigNumber.from(2),
                    difficulty: 2,
                    extraData: '',
                    gasLimit: EthersBigNumber.from(1000),
                    gasUsed: EthersBigNumber.from(1000),
                    hash: '0xblockhash',
                    miner: '0xminer',
                    nonce: '0x000',
                    number: 21,
                    parentHash: '0xparentblockhash',
                    timestamp: 12345,
                    transactions: ['0xpresubmittransactionhash'],
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                        jobId,
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([mockPresubmitTransaction]);
                const updateRfqmTransactionSubmissionsCalledArgs: MetaTransactionV2SubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                // This mock response indicates that the transaction is present in the mempool
                when(mockBlockchainUtils.getTransactionAsync('0xpresubmittransactionhash')).thenResolve(
                    mockTransactionResponse,
                );
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenReject(
                    new Error('estimateGasForAsync called during recovery'),
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xpresubmittransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getBlockAsync('0xblockhash')).thenResolve(mockMinedBlock);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });
                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                await rfqmService.submitToChainAsync({
                    kind: job.kind,
                    to: '0xexchangeproxyaddress',
                    from: '0xworkeraddress',
                    calldata: '0xcalldata',
                    expiry: job.expiry,
                    identifier: job.id,
                    submissionType: RfqmTransactionSubmissionType.Trade,
                    onSubmissionContextStatusUpdate: callback,
                });

                // eth_createAccessList should not be called when not enabled
                verify(mockBlockchainUtils.createAccessListForAsync(anything())).never();
                // Logic should first check to see if the transaction was actually sent.
                // If it was (and it is being mock so in this test) then the logic first
                // updates the status of the transaction to "Submitted"
                expect(updateRfqmTransactionSubmissionsCalledArgs[0][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.Submitted,
                );
                // The logic then enters the watch loop. On the first check, a transaction
                // receipt exists for this transaction and it will be marked "confirmed"
                expect(updateRfqmTransactionSubmissionsCalledArgs[1][0].status).to.equal(
                    RfqmTransactionSubmissionStatus.SucceededConfirmed,
                );
                expect(job.status).to.equal(RfqmJobStatus.SucceededConfirmed);
            });

            it('throws exception if there are more than 1 transaction submissions with the same transaction hash', async () => {
                const nowS = Math.round(new Date().getTime() / ONE_SECOND_MS);
                const jobId = 'jobId';
                const transactionSubmissionId = 'submissionId';

                const job = createMetaTransactionV2JobEntity(
                    {
                        chainId: 1,
                        createdAt: new Date(),
                        expiry: new BigNumber(nowS + 600),
                        inputToken: '0xinputToken',
                        inputTokenAmount: new BigNumber(10),
                        integratorId: '0xintegrator',
                        calledFunction: 'transformERC20',
                        metaTransaction: MOCK_META_TRANSACTION_V2,
                        metaTransactionHash: MOCK_META_TRANSACTION_V2.getHash(),
                        minOutputTokenAmount: new BigNumber(10),
                        outputToken: '0xoutputToken',
                        takerAddress: '0xtakerAddress',
                        takerSignature: {
                            signatureType: SignatureType.EthSign,
                            v: 27,
                            r: '0x01',
                            s: '0x02',
                        },
                        tokens: ['0xinputToken', '0xoutputToken'],
                        status: RfqmJobStatus.PendingLastLookAccepted,
                        workerAddress: '0xworkeraddress',
                    },
                    jobId,
                );

                const mockTransactionRequest: providers.TransactionRequest = {};
                const mockTransaction = createMetaTransactionV2SubmissionEntity(
                    {
                        from: '0xworkeraddress',
                        metaTransactionV2JobId: jobId,
                        maxFeePerGas: new BigNumber(100000),
                        maxPriorityFeePerGas: new BigNumber(100),
                        nonce: 0,
                        to: '0xexchangeproxyaddress',
                        transactionHash: '0xsignedtransactionhash',
                        type: RfqmTransactionSubmissionType.Trade,
                    },
                    transactionSubmissionId,
                );
                const mockTransactionReceipt: providers.TransactionReceipt = {
                    to: '0xto',
                    from: '0xfrom',
                    contractAddress: '0xexchangeproxyaddress',
                    transactionIndex: 0,
                    gasUsed: EthersBigNumber.from(10000),
                    logsBloom: '',
                    blockHash: '0xblockhash',
                    transactionHash: '0xsignedtransactionhash',
                    logs: [],
                    blockNumber: 1,
                    confirmations: 3,
                    cumulativeGasUsed: EthersBigNumber.from(1000),
                    effectiveGasPrice: EthersBigNumber.from(1000),
                    byzantium: true,
                    type: 2,
                    status: 1,
                };
                const mockNonce = 0;

                const gasStationAttendantMock = mock(GasStationAttendantEthereum);
                when(gasStationAttendantMock.getExpectedTransactionGasRateAsync()).thenResolve(
                    new BigNumber(10).shiftedBy(GWEI_DECIMALS),
                );
                const mockDbUtils = mock(RfqmDbUtils);
                when(
                    mockDbUtils.findMetaTransactionV2SubmissionsByJobIdAsync(
                        jobId,
                        deepEqual([RfqmTransactionSubmissionType.Trade]),
                    ),
                ).thenResolve([]);
                const updateRfqmJobCalledArgs: MetaTransactionJobEntity[] = [];
                when(mockDbUtils.updateRfqmJobAsync(anything())).thenCall(async (jobArg) => {
                    updateRfqmJobCalledArgs.push(_.cloneDeep(jobArg));
                });
                const writeMetaTransactionV2SubmissionAsyncCalledArgs: MetaTransactionV2SubmissionEntity[] = [];
                when(mockDbUtils.writeMetaTransactionV2SubmissionAsync(anything())).thenCall(async (transactionArg) => {
                    writeMetaTransactionV2SubmissionAsyncCalledArgs.push(_.cloneDeep(transactionArg));
                    return _.cloneDeep(mockTransaction);
                });
                when(
                    mockDbUtils.findMetaTransactionV2SubmissionsByTransactionHashAsync(
                        '0xsignedtransactionhash',
                        RfqmTransactionSubmissionType.Trade,
                    ),
                ).thenResolve([_.cloneDeep(mockTransaction), _.cloneDeep(mockTransaction)]);
                const updateRfqmTransactionSubmissionsCalledArgs: MetaTransactionV2SubmissionEntity[][] = [];
                when(mockDbUtils.updateRfqmTransactionSubmissionsAsync(anything())).thenCall(async (tranactionArg) => {
                    updateRfqmTransactionSubmissionsCalledArgs.push(_.cloneDeep(tranactionArg));
                });
                const mockBlockchainUtils = mock(RfqBlockchainUtils);
                when(mockBlockchainUtils.getNonceAsync('0xworkeraddress')).thenResolve(mockNonce);
                when(mockBlockchainUtils.estimateGasForAsync(anything())).thenResolve(100);
                when(
                    mockBlockchainUtils.transformTxDataToTransactionRequest(anything(), anything(), anything()),
                ).thenReturn(mockTransactionRequest);
                when(mockBlockchainUtils.signTransactionAsync(anything())).thenResolve({
                    signedTransaction: 'signedTransaction',
                    transactionHash: '0xsignedtransactionhash',
                });
                when(mockBlockchainUtils.getExchangeProxyAddress()).thenReturn('0xexchangeproxyaddress');
                when(mockBlockchainUtils.submitSignedTransactionAsync(anything())).thenResolve(
                    '0xsignedtransactionhash',
                );
                when(mockBlockchainUtils.getReceiptsAsync(deepEqual(['0xsignedtransactionhash']))).thenResolve([
                    mockTransactionReceipt,
                ]);
                when(mockBlockchainUtils.getCurrentBlockAsync()).thenResolve(4);
                const rfqmService = buildWorkerServiceForUnitTest({
                    dbUtils: instance(mockDbUtils),
                    gasStationAttendant: instance(gasStationAttendantMock),
                    rfqBlockchainUtils: instance(mockBlockchainUtils),
                });

                const callback = async (
                    newSubmissionContextStatus: SubmissionContextStatus,
                    oldSubmissionContextStatus?: SubmissionContextStatus,
                ): Promise<void> => {
                    if (newSubmissionContextStatus !== oldSubmissionContextStatus) {
                        const newJobStatus =
                            SubmissionContext.tradeSubmissionContextStatusToJobStatus(newSubmissionContextStatus);
                        job.status = newJobStatus;
                        await mockDbUtils.updateRfqmJobAsync(job);
                    }
                };

                try {
                    await rfqmService.submitToChainAsync({
                        kind: job.kind,
                        to: '0xexchangeproxyaddress',
                        from: '0xworkeraddress',
                        calldata: '0xcalldata',
                        expiry: job.expiry,
                        identifier: job.id,
                        submissionType: RfqmTransactionSubmissionType.Trade,
                        onSubmissionContextStatusUpdate: callback,
                    });
                    expect.fail();
                } catch (e) {
                    expect(e.message).to.contain('Transaction hash have been submitted not exactly once');
                }
            });
        });
    });
});