@human-protocol/sdk 1.0.4 → 1.0.5

package/dist/test/escrow.test.js

@@ -0,0 +1,827 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const vitest_1 = require("vitest");
+const ethers_1 = require("ethers");
+const escrow_1 = __importDefault(require("../src/escrow"));
+const constants_1 = require("./utils/constants");
+const error_1 = require("../src/error");
+const init_1 = __importDefault(require("../src/init"));
+const typechain_types_1 = require("@human-protocol/core/typechain-types");
+const constants_2 = require("../src/constants");
+const types_1 = require("../src/types");
+vitest_1.vi.mock('../src/init');
+(0, vitest_1.describe)('EscrowClient', () => {
+    const provider = new ethers_1.ethers.providers.JsonRpcProvider();
+    let escrowClient, mockSigner, mockEscrowContract, mockEscrowFactoryContract, mockTokenContract;
+    (0, vitest_1.beforeEach)(async () => {
+        mockSigner = {
+            ...provider.getSigner(),
+            getAddress: vitest_1.vi.fn().mockReturnValue(ethers_1.ethers.constants.AddressZero),
+        };
+        mockEscrowContract = {
+            createEscrow: vitest_1.vi.fn(),
+            setup: vitest_1.vi.fn(),
+            createAndSetupEscrow: vitest_1.vi.fn(),
+            fund: vitest_1.vi.fn(),
+            storeResults: vitest_1.vi.fn(),
+            complete: vitest_1.vi.fn(),
+            bulkPayOut: vitest_1.vi.fn(),
+            cancel: vitest_1.vi.fn(),
+            abort: vitest_1.vi.fn(),
+            addTrustedHandlers: vitest_1.vi.fn(),
+            getBalance: vitest_1.vi.fn(),
+            manifestUrl: vitest_1.vi.fn(),
+            finalResultsUrl: vitest_1.vi.fn(),
+            token: vitest_1.vi.fn(),
+            status: vitest_1.vi.fn(),
+            getLaunchedEscrows: vitest_1.vi.fn(),
+            getEscrowsFiltered: vitest_1.vi.fn(),
+            address: ethers_1.ethers.constants.AddressZero,
+            recordingOracle: vitest_1.vi.fn(),
+            reputationOracle: vitest_1.vi.fn(),
+        };
+        mockEscrowFactoryContract = {
+            createEscrow: vitest_1.vi.fn(),
+            hasEscrow: vitest_1.vi.fn(),
+            lastEscrow: vitest_1.vi.fn(),
+        };
+        mockTokenContract = {
+            allowance: vitest_1.vi.fn(),
+            approve: vitest_1.vi.fn(),
+            transfer: vitest_1.vi.fn(),
+        };
+        const getClientParamsMock = init_1.default.getParams;
+        getClientParamsMock.mockResolvedValue({
+            signerOrProvider: mockSigner,
+            network: constants_1.FAKE_NETWORK,
+        });
+        // Mock EscrowFactory__factory.connect to return the mock EscrowFactory
+        vitest_1.vi.spyOn(typechain_types_1.EscrowFactory__factory, 'connect').mockReturnValue(mockEscrowFactoryContract);
+        // Mock Escrow__factory.connect to return the mock Escrow
+        vitest_1.vi.spyOn(typechain_types_1.Escrow__factory, 'connect').mockReturnValue(mockEscrowContract);
+        // Mock HMToken__factory.connect to return the mock HMToken
+        vitest_1.vi.spyOn(typechain_types_1.HMToken__factory, 'connect').mockReturnValue(mockTokenContract);
+        escrowClient = new escrow_1.default(await init_1.default.getParams(mockSigner));
+        escrowClient.escrowContract = mockEscrowContract;
+        escrowClient.tokenContract = mockTokenContract;
+        escrowClient.escrowFactoryContract = mockEscrowFactoryContract;
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('createEscrow', () => {
+        (0, vitest_1.test)('should throw an error if tokenAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.createEscrow(invalidAddress, [
+                ethers_1.ethers.constants.AddressZero,
+            ])).rejects.toThrow(error_1.ErrorInvalidTokenAddress);
+        });
+        (0, vitest_1.test)('should throw an error if trustedHandlers contains an invalid address', async () => {
+            await (0, vitest_1.expect)(escrowClient.createEscrow(ethers_1.ethers.constants.AddressZero, [constants_1.FAKE_ADDRESS])).rejects.toThrow(new error_1.InvalidEthereumAddressError(constants_1.FAKE_ADDRESS));
+        });
+        (0, vitest_1.test)('should create an escrow and return its address', async () => {
+            const tokenAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            const expectedEscrowAddress = ethers_1.ethers.constants.AddressZero;
+            // Create a spy object for the createEscrow method
+            const createEscrowSpy = vitest_1.vi
+                .spyOn(escrowClient.escrowFactoryContract, 'createEscrow')
+                .mockImplementation(() => ({
+                wait: async () => ({
+                    events: [
+                        {
+                            args: {
+                                1: expectedEscrowAddress,
+                            },
+                        },
+                    ],
+                }),
+            }));
+            const result = await escrowClient.createEscrow(tokenAddress, trustedHandlers);
+            (0, vitest_1.expect)(createEscrowSpy).toHaveBeenCalledWith(tokenAddress, trustedHandlers);
+            (0, vitest_1.expect)(result).toBe(expectedEscrowAddress);
+        });
+        (0, vitest_1.test)('should throw an error if the create an escrow fails', async () => {
+            const tokenAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            escrowClient.escrowFactoryContract.createEscrow.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.createEscrow(tokenAddress, trustedHandlers)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowFactoryContract.createEscrow).toHaveBeenCalledWith(tokenAddress, trustedHandlers);
+        });
+    });
+    (0, vitest_1.describe)('setup', () => {
+        (0, vitest_1.test)('should throw an error if recordingOracle is an invalid address', async () => {
+            const escrowConfig = {
+                recordingOracle: constants_1.FAKE_ADDRESS,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(10),
+                reputationOracleFee: ethers_1.BigNumber.from(10),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorInvalidRecordingOracleAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if reputationOracle is an invalid address', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: constants_1.FAKE_ADDRESS,
+                recordingOracleFee: ethers_1.BigNumber.from(10),
+                reputationOracleFee: ethers_1.BigNumber.from(10),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorInvalidReputationOracleAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if reputationOracle is an invalid address', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(10),
+                reputationOracleFee: ethers_1.BigNumber.from(10),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            await (0, vitest_1.expect)(escrowClient.setup(constants_1.FAKE_ADDRESS, escrowConfig)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(10),
+                reputationOracleFee: ethers_1.BigNumber.from(10),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should throw an error if 0 <= recordingOracleFee or 0 <= reputationOracleFee', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(0),
+                reputationOracleFee: ethers_1.BigNumber.from(0),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorAmountMustBeGreaterThanZero);
+        });
+        (0, vitest_1.test)('should throw an error if recordingOracleFee > 100 or reputationOracleFee > 100', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(100),
+                reputationOracleFee: ethers_1.BigNumber.from(100),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorTotalFeeMustBeLessThanHundred);
+        });
+        (0, vitest_1.test)('should throw an error if manifestUrl is an empty string', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: '',
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorUrlIsEmptyString);
+        });
+        (0, vitest_1.test)('should throw an error if manifestUrl is an invalid url', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: constants_1.FAKE_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorInvalidUrl);
+        });
+        (0, vitest_1.test)('should throw an error if hash is an empty string', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: constants_1.VALID_URL,
+                hash: '',
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow(error_1.ErrorHashIsEmptyString);
+        });
+        (0, vitest_1.test)('should successfully setup escrow', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.setup.mockReturnValue(true);
+            await escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig);
+            (0, vitest_1.expect)(escrowClient.escrowContract.setup).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.BigNumber.from(50), ethers_1.BigNumber.from(50), constants_1.VALID_URL, constants_1.FAKE_HASH);
+        });
+        (0, vitest_1.test)('should throw an error if setup escrow fails', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.setup.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.setup).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.BigNumber.from(50), ethers_1.BigNumber.from(50), constants_1.VALID_URL, constants_1.FAKE_HASH);
+        });
+    });
+    (0, vitest_1.describe)('createAndSetupEscrow', () => {
+        (0, vitest_1.test)('should successfully create and setup escrow', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const tokenAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.createEscrow = vitest_1.vi.fn().mockReturnValue(escrowAddress);
+            escrowClient.escrowContract.setup.mockReturnValue(true);
+            await escrowClient.createAndSetupEscrow(tokenAddress, trustedHandlers, escrowConfig);
+            (0, vitest_1.expect)(escrowClient.createEscrow).toHaveBeenCalledWith(tokenAddress, trustedHandlers);
+            (0, vitest_1.expect)(escrowClient.escrowContract.setup).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.BigNumber.from(50), ethers_1.BigNumber.from(50), constants_1.VALID_URL, constants_1.FAKE_HASH);
+        });
+        (0, vitest_1.test)('should throw an error if setup escrow fails', async () => {
+            const escrowConfig = {
+                recordingOracle: ethers_1.ethers.constants.AddressZero,
+                reputationOracle: ethers_1.ethers.constants.AddressZero,
+                recordingOracleFee: ethers_1.BigNumber.from(50),
+                reputationOracleFee: ethers_1.BigNumber.from(50),
+                manifestUrl: constants_1.VALID_URL,
+                hash: constants_1.FAKE_HASH,
+            };
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.setup.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.setup(ethers_1.ethers.constants.AddressZero, escrowConfig)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.setup).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.BigNumber.from(50), ethers_1.BigNumber.from(50), constants_1.VALID_URL, constants_1.FAKE_HASH);
+        });
+    });
+    (0, vitest_1.describe)('fund', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            const amount = ethers_1.BigNumber.from(10);
+            await (0, vitest_1.expect)(escrowClient.fund(invalidAddress, amount)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const amount = ethers_1.BigNumber.from(10);
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.fund(escrowAddress, amount)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should throw an error if 0 <= amount', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const invalidAmount = ethers_1.BigNumber.from(0);
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.fund(escrowAddress, invalidAmount)).rejects.toThrow(error_1.ErrorAmountMustBeGreaterThanZero);
+        });
+        (0, vitest_1.test)('should successfully fund escrow', async () => {
+            const tokenAddress = ethers_1.ethers.constants.AddressZero;
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const amount = ethers_1.BigNumber.from(10);
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.token.mockReturnValue(tokenAddress);
+            await escrowClient.fund(escrowAddress, amount);
+            (0, vitest_1.expect)(escrowClient.escrowContract.token).toHaveBeenCalledWith();
+            (0, vitest_1.expect)(escrowClient.tokenContract.transfer).toHaveBeenCalledWith(escrowAddress, amount);
+        });
+        (0, vitest_1.test)('should throw an error if setup escrow fails', async () => {
+            const tokenAddress = ethers_1.ethers.constants.AddressZero;
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const amount = ethers_1.BigNumber.from(10);
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.token.mockReturnValue(tokenAddress);
+            escrowClient.tokenContract.transfer.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.fund(escrowAddress, amount)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.token).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('storeResults', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            const url = constants_1.VALID_URL;
+            const hash = constants_1.FAKE_HASH;
+            await (0, vitest_1.expect)(escrowClient.storeResults(invalidAddress, url, hash)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.VALID_URL;
+            const hash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.storeResults(escrowAddress, url, hash)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should throw an error if url is an empty string', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = '';
+            const hash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.storeResults(escrowAddress, url, hash)).rejects.toThrow(error_1.ErrorUrlIsEmptyString);
+        });
+        (0, vitest_1.test)('should throw an error if results url is invalid url', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.FAKE_URL;
+            const hash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.storeResults(escrowAddress, url, hash)).rejects.toThrow(error_1.ErrorInvalidUrl);
+        });
+        (0, vitest_1.test)('should throw an error if hash is an empty string', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.VALID_URL;
+            const hash = '';
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.storeResults(escrowAddress, url, hash)).rejects.toThrow(error_1.ErrorHashIsEmptyString);
+        });
+        (0, vitest_1.test)('should successfully store results', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.VALID_URL;
+            const hash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await escrowClient.storeResults(escrowAddress, url, hash);
+            (0, vitest_1.expect)(escrowClient.escrowContract.storeResults).toHaveBeenCalledWith(url, hash);
+        });
+        (0, vitest_1.test)('should throw an error if the store results fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.VALID_URL;
+            const hash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.storeResults.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.storeResults(escrowAddress, url, hash)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.storeResults).toHaveBeenCalledWith(url, hash);
+        });
+    });
+    (0, vitest_1.describe)('complete', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.complete(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.complete(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully complete escrow', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await escrowClient.complete(escrowAddress);
+            (0, vitest_1.expect)(escrowClient.escrowContract.complete).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if the complete fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.complete.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.complete(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.complete).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('bulkPayOut', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(invalidAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should throw an error if recipients length is equal to 0', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorRecipientCannotBeEmptyArray);
+        });
+        (0, vitest_1.test)('should throw an error if amounts length is equal to 0', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorAmountsCannotBeEmptyArray);
+        });
+        (0, vitest_1.test)('should throw an error if recipients and amounts do not have the same length', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [
+                ethers_1.BigNumber.from(100),
+                ethers_1.BigNumber.from(100),
+                ethers_1.BigNumber.from(100),
+            ];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorRecipientAndAmountsMustBeSameLength);
+        });
+        (0, vitest_1.test)('should throw an error if recipients contains invalid addresses', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [constants_1.FAKE_ADDRESS];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(new error_1.InvalidEthereumAddressError(constants_1.FAKE_ADDRESS));
+        });
+        (0, vitest_1.test)('should throw an error if url is an empty string', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = '';
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorUrlIsEmptyString);
+        });
+        (0, vitest_1.test)('should throw an error if final results url is an invalid url', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = constants_1.FAKE_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorInvalidUrl);
+        });
+        (0, vitest_1.test)('should throw an error if hash is an empty string', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [ethers_1.ethers.constants.AddressZero];
+            const amounts = [ethers_1.BigNumber.from(100)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = '';
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorHashIsEmptyString);
+        });
+        (0, vitest_1.test)('should throw an error if escrow does not have enough balance', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [
+                ethers_1.ethers.constants.AddressZero,
+                ethers_1.ethers.constants.AddressZero,
+            ];
+            const amounts = [ethers_1.BigNumber.from(90), ethers_1.BigNumber.from(20)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.getBalance = vitest_1.vi.fn().mockReturnValue(ethers_1.BigNumber.from(50));
+            await (0, vitest_1.expect)(escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash)).rejects.toThrow(error_1.ErrorEscrowDoesNotHaveEnoughBalance);
+        });
+        (0, vitest_1.test)('should successfully bulkPayOut escrow', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const recipients = [
+                ethers_1.ethers.constants.AddressZero,
+                ethers_1.ethers.constants.AddressZero,
+            ];
+            const amounts = [ethers_1.BigNumber.from(10), ethers_1.BigNumber.from(10)];
+            const finalResultsUrl = constants_1.VALID_URL;
+            const finalResultsHash = constants_1.FAKE_HASH;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.getBalance = vitest_1.vi.fn().mockReturnValue(ethers_1.BigNumber.from(100));
+            await escrowClient.bulkPayOut(escrowAddress, recipients, amounts, finalResultsUrl, finalResultsHash);
+            (0, vitest_1.expect)(escrowClient.escrowContract.bulkPayOut).toHaveBeenCalledWith(recipients, amounts, finalResultsUrl, finalResultsHash, constants_2.DEFAULT_TX_ID);
+        });
+        (0, vitest_1.test)('should throw an error if bulkPayOut fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.abort.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.abort(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.abort).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('cancel', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.cancel(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.cancel(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully cancel escrow', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await escrowClient.cancel(escrowAddress);
+            (0, vitest_1.expect)(escrowClient.escrowContract.cancel).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if the cancel fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.cancel.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.cancel(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.cancel).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('abort', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const invalidAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.abort(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.abort(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully abort escrow', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await escrowClient.abort(escrowAddress);
+            (0, vitest_1.expect)(escrowClient.escrowContract.abort).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if abort fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.abort.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.abort(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.abort).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('addTrustedHandlers', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            await (0, vitest_1.expect)(escrowClient.addTrustedHandlers(escrowAddress, trustedHandlers)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.addTrustedHandlers(escrowAddress, trustedHandlers)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should throw an error if trusted handlers length is equal to 0', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [];
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.addTrustedHandlers(escrowAddress, trustedHandlers)).rejects.toThrow(error_1.ErrorListOfHandlersCannotBeEmpty);
+        });
+        (0, vitest_1.test)('should throw an error if trusted handlers contains invalid addresses', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [constants_1.FAKE_ADDRESS];
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await (0, vitest_1.expect)(escrowClient.addTrustedHandlers(escrowAddress, trustedHandlers)).rejects.toThrow(new error_1.InvalidEthereumAddressError(constants_1.FAKE_ADDRESS));
+        });
+        (0, vitest_1.test)('should successfully addTrustedHandlers', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            await escrowClient.addTrustedHandlers(escrowAddress, trustedHandlers);
+            (0, vitest_1.expect)(escrowClient.escrowContract.addTrustedHandlers).toHaveBeenCalledWith(trustedHandlers);
+        });
+        (0, vitest_1.test)('should throw an error if addTrustedHandlers fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const trustedHandlers = [ethers_1.ethers.constants.AddressZero];
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.addTrustedHandlers.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.addTrustedHandlers(escrowAddress, trustedHandlers)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.addTrustedHandlers).toHaveBeenCalledWith(trustedHandlers);
+        });
+    });
+    (0, vitest_1.describe)('getBalance', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getBalance(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getBalance(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getBalance escrow', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const amount = ethers_1.BigNumber.from(100);
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.getBalance.mockReturnValue(amount);
+            const balance = await escrowClient.getBalance(escrowAddress);
+            (0, vitest_1.expect)(balance).toEqual(amount);
+            (0, vitest_1.expect)(escrowClient.escrowContract.getBalance).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if the getBalance fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.getBalance.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getBalance(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.getBalance).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('getManifestUrl', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getManifestUrl(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getManifestUrl(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getManifestUrl', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.FAKE_URL;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.manifestUrl.mockReturnValue(url);
+            const manifestUrl = await escrowClient.getManifestUrl(escrowAddress);
+            (0, vitest_1.expect)(manifestUrl).toEqual(url);
+            (0, vitest_1.expect)(escrowClient.escrowContract.manifestUrl).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if getManifestUrl fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.manifestUrl.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getManifestUrl(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.manifestUrl).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('getResultsUrl', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getResultsUrl(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getResultsUrl(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getResultsUrl', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            const url = constants_1.FAKE_URL;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.finalResultsUrl.mockReturnValue(url);
+            const finalResultsUrl = await escrowClient.getResultsUrl(escrowAddress);
+            (0, vitest_1.expect)(finalResultsUrl).toEqual(url);
+            (0, vitest_1.expect)(escrowClient.escrowContract.finalResultsUrl).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if getResultsUrl fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.finalResultsUrl.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getResultsUrl(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.finalResultsUrl).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('getTokenAddress', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getTokenAddress(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getTokenAddress(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getTokenAddress', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.token.mockReturnValue(ethers_1.ethers.constants.AddressZero);
+            const tokenAddress = await escrowClient.getTokenAddress(escrowAddress);
+            (0, vitest_1.expect)(tokenAddress).toEqual(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(escrowClient.escrowContract.token).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if getTokenAddress fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.token.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getTokenAddress(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.token).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('getStatus', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getStatus(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getStatus(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getStatus', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.status.mockReturnValue(types_1.EscrowStatus.Complete);
+            const status = await escrowClient.getStatus(escrowAddress);
+            (0, vitest_1.expect)(status).toEqual(types_1.EscrowStatus.Complete);
+            (0, vitest_1.expect)(escrowClient.escrowContract.status).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if getStatus fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.status.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getStatus(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.status).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('getLaunchedEscrows', () => {
+        (0, vitest_1.test)('should throw an error if requesterAddress is an invalid address', async () => {
+            const requesterAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getLaunchedEscrows(requesterAddress)).rejects.toThrow(error_1.ErrorInvalidAddress);
+        });
+        (0, vitest_1.test)('should successfully getLaunchedEscrows', async () => {
+            const requesterAddress = constants_1.FAKE_ADDRESS;
+            const mockLaunchedEscrowsResult = { id: ethers_1.ethers.constants.AddressZero };
+            vitest_1.vi.spyOn(escrowClient, 'getLaunchedEscrows').mockImplementation(() => Promise.resolve([mockLaunchedEscrowsResult, mockLaunchedEscrowsResult]));
+            const results = await escrowClient.getLaunchedEscrows(requesterAddress);
+            (0, vitest_1.expect)(results).toEqual([
+                mockLaunchedEscrowsResult,
+                mockLaunchedEscrowsResult,
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('getEscrowsFiltered', () => {
+        (0, vitest_1.test)('should throw an error if requesterAddress is an invalid address', async () => {
+            const requesterAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getEscrowsFiltered(requesterAddress)).rejects.toThrow(error_1.ErrorInvalidAddress);
+        });
+        (0, vitest_1.test)('should successfully getEscrowsFiltered', async () => {
+            const requesterAddress = constants_1.FAKE_ADDRESS;
+            const mockLaunchedEscrowsResult = { id: ethers_1.ethers.constants.AddressZero };
+            vitest_1.vi.spyOn(escrowClient, 'getEscrowsFiltered').mockImplementation(() => Promise.resolve([mockLaunchedEscrowsResult, mockLaunchedEscrowsResult]));
+            const results = await escrowClient.getEscrowsFiltered(requesterAddress);
+            (0, vitest_1.expect)(results).toEqual([
+                mockLaunchedEscrowsResult,
+                mockLaunchedEscrowsResult,
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('getRecordingOracleAddress', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getRecordingOracleAddress(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getRecordingOracleAddress(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getRecordingOracleAddress', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.recordingOracle.mockReturnValue(ethers_1.ethers.constants.AddressZero);
+            const recordingOracleAddress = await escrowClient.getRecordingOracleAddress(escrowAddress);
+            (0, vitest_1.expect)(recordingOracleAddress).toEqual(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(escrowClient.escrowContract.recordingOracle).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if getRecordingOracleAddress fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.recordingOracle.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getRecordingOracleAddress(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.recordingOracle).toHaveBeenCalledWith();
+        });
+    });
+    (0, vitest_1.describe)('getReputationOracleAddress', () => {
+        (0, vitest_1.test)('should throw an error if escrowAddress is an invalid address', async () => {
+            const escrowAddress = constants_1.FAKE_ADDRESS;
+            await (0, vitest_1.expect)(escrowClient.getReputationOracleAddress(escrowAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+        });
+        (0, vitest_1.test)('should throw an error if hasEscrow returns false', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(false);
+            await (0, vitest_1.expect)(escrowClient.getReputationOracleAddress(escrowAddress)).rejects.toThrow(error_1.ErrorEscrowAddressIsNotProvidedByFactory);
+        });
+        (0, vitest_1.test)('should successfully getReputationOracleAddress', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.reputationOracle.mockReturnValue(ethers_1.ethers.constants.AddressZero);
+            const reputationOracleAddress = await escrowClient.getReputationOracleAddress(escrowAddress);
+            (0, vitest_1.expect)(reputationOracleAddress).toEqual(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(escrowClient.escrowContract.reputationOracle).toHaveBeenCalledWith();
+        });
+        (0, vitest_1.test)('should throw an error if getReputationOracleAddress fails', async () => {
+            const escrowAddress = ethers_1.ethers.constants.AddressZero;
+            escrowClient.escrowFactoryContract.hasEscrow.mockReturnValue(true);
+            escrowClient.escrowContract.reputationOracle.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(escrowClient.getReputationOracleAddress(escrowAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(escrowClient.escrowContract.reputationOracle).toHaveBeenCalledWith();
+        });
+    });
+});