@human-protocol/sdk 1.0.3 → 1.0.5

package/dist/test/init.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.test.d.ts.map

package/dist/test/init.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.test.d.ts","sourceRoot":"","sources":["../../test/init.test.ts"],"names":[],"mappings":""}

package/dist/test/init.test.js

@@ -0,0 +1,70 @@
+"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 error_1 = require("../src/error");
+const constants_1 = require("./utils/constants");
+const ethers_1 = require("ethers");
+const init_1 = __importDefault(require("../src/init"));
+const enums_1 = require("../src/enums");
+(0, vitest_1.describe)('InitClient', () => {
+    const provider = new ethers_1.ethers.providers.JsonRpcProvider();
+    let mockProvider;
+    let mockSigner;
+    (0, vitest_1.beforeEach)(async () => {
+        mockSigner = {
+            ...provider.getSigner(),
+            getNetwork: vitest_1.vi.fn().mockReturnValue({
+                name: constants_1.FAKE_NETWORK_NAME,
+                chainId: enums_1.ChainId.POLYGON_MUMBAI,
+            }),
+            getAddress: vitest_1.vi.fn().mockReturnValue(ethers_1.ethers.constants.AddressZero),
+        };
+        mockProvider = {
+            getNetwork: vitest_1.vi.fn().mockReturnValue({
+                name: constants_1.FAKE_NETWORK_NAME,
+                chainId: enums_1.ChainId.POLYGON_MUMBAI,
+            }),
+            getAddress: vitest_1.vi.fn().mockReturnValue(ethers_1.ethers.constants.AddressZero),
+        };
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('getParams', () => {
+        (0, vitest_1.test)('should throw an error if Signer provider does not exist', async () => {
+            const invalidSigner = ethers_1.ethers.Wallet.createRandom();
+            await (0, vitest_1.expect)(init_1.default.getParams(invalidSigner)).rejects.toThrow(error_1.ErrorInitProviderDoesNotExist);
+        });
+        (0, vitest_1.test)('should throw an error if chainId is not supported', async () => {
+            const invalidNetwork = { name: constants_1.FAKE_NETWORK_NAME, chainId: enums_1.ChainId.ALL };
+            mockProvider.getNetwork.mockResolvedValueOnce(invalidNetwork);
+            await (0, vitest_1.expect)(init_1.default.getParams(mockProvider)).rejects.toThrow(error_1.ErrorInitUnsupportedChainID);
+        });
+        (0, vitest_1.test)('should return the client parameters for a Signer', async () => {
+            const expectedClientParams = {
+                signerOrProvider: mockSigner,
+                network: constants_1.FAKE_NETWORK,
+            };
+            init_1.default.getParams = vitest_1.vi
+                .fn()
+                .mockImplementation(() => Promise.resolve(expectedClientParams));
+            const clientParams = await init_1.default.getParams(mockSigner);
+            (0, vitest_1.expect)(clientParams).toEqual(expectedClientParams);
+        });
+        (0, vitest_1.test)('should return the client parameters for a Provider', async () => {
+            const expectedClientParams = {
+                signerOrProvider: mockProvider,
+                network: constants_1.FAKE_NETWORK,
+            };
+            init_1.default.getParams = vitest_1.vi
+                .fn()
+                .mockImplementation(() => Promise.resolve(expectedClientParams));
+            const clientParams = await init_1.default.getParams(mockProvider);
+            (0, vitest_1.expect)(clientParams).toEqual(expectedClientParams);
+        });
+    });
+});

package/dist/test/kvstore.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kvstore.test.d.ts.map

package/dist/test/kvstore.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kvstore.test.d.ts","sourceRoot":"","sources":["../../test/kvstore.test.ts"],"names":[],"mappings":""}

package/dist/test/kvstore.test.js

@@ -0,0 +1,125 @@
+"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 kvstore_1 = __importDefault(require("../src/kvstore"));
+const error_1 = require("../src/error");
+const init_1 = __importDefault(require("../src/init"));
+const enums_1 = require("../src/enums");
+const constants_1 = require("../src/constants");
+vitest_1.vi.mock('../src/init');
+(0, vitest_1.describe)('KVStoreClient', () => {
+    let provider;
+    let signer;
+    let network;
+    let kvStoreClient;
+    let mockKVStoreContract;
+    let mockGetClientParams;
+    (0, vitest_1.beforeAll)(async () => {
+        provider = new ethers_1.ethers.providers.JsonRpcProvider();
+        signer = provider.getSigner();
+        network = constants_1.NETWORKS[enums_1.ChainId.LOCALHOST];
+        mockGetClientParams = init_1.default.getParams;
+    });
+    (0, vitest_1.beforeEach)(async () => {
+        mockGetClientParams.mockResolvedValue({
+            signerOrProvider: signer,
+            network,
+        });
+        kvStoreClient = new kvstore_1.default(await init_1.default.getParams(signer));
+        mockKVStoreContract = {
+            ...kvStoreClient.contract,
+            set: vitest_1.vi.fn(),
+            setBulk: vitest_1.vi.fn(),
+            get: vitest_1.vi.fn(),
+            address: network?.kvstoreAddress,
+        };
+        kvStoreClient.contract = mockKVStoreContract;
+    });
+    (0, vitest_1.describe)('set', () => {
+        (0, vitest_1.test)('should throw an error if key is empty', async () => {
+            const setSpy = vitest_1.vi.spyOn(kvStoreClient, 'set');
+            await (0, vitest_1.expect)(kvStoreClient.set('', 'test')).rejects.toThrow(error_1.ErrorKVStoreEmptyKey);
+            (0, vitest_1.expect)(setSpy).toHaveBeenCalledWith('', 'test');
+        });
+        (0, vitest_1.test)('should set the key-value pair if both key and value are provided', async () => {
+            mockKVStoreContract.set.mockResolvedValue(null);
+            (0, vitest_1.expect)(kvStoreClient.set('key1', 'value1')).resolves.toBeUndefined();
+            (0, vitest_1.expect)(mockKVStoreContract.set).toHaveBeenCalledWith('key1', 'value1');
+        });
+        (0, vitest_1.test)('should throw an error when attempting to set a value without signer', async () => {
+            mockGetClientParams.mockResolvedValue({
+                signerOrProvider: provider,
+                network,
+            });
+            kvStoreClient = new kvstore_1.default(await init_1.default.getParams(provider));
+            await (0, vitest_1.expect)(kvStoreClient.set('key1', 'value1')).rejects.toThrow(error_1.ErrorSigner);
+        });
+        (0, vitest_1.test)('should throw an error when a network error occurs', async () => {
+            mockKVStoreContract.set.mockRejectedValue(new Error('could not detect network'));
+            await (0, vitest_1.expect)(kvStoreClient.set('key1', 'value1')).rejects.toThrow(Error('Failed to set value: could not detect network'));
+            (0, vitest_1.expect)(mockKVStoreContract.set).toHaveBeenCalledWith('key1', 'value1');
+        });
+    });
+    (0, vitest_1.describe)('setBulk', () => {
+        (0, vitest_1.test)('should throw an error if keys and values arrays are not of the same length', async () => {
+            const setBulkSpy = vitest_1.vi.spyOn(kvStoreClient, 'setBulk');
+            await (0, vitest_1.expect)(kvStoreClient.setBulk(['key1', 'key2'], ['value1'])).rejects.toThrow(error_1.ErrorKVStoreArrayLength);
+            (0, vitest_1.expect)(setBulkSpy).toHaveBeenCalledWith(['key1', 'key2'], ['value1']);
+        });
+        (0, vitest_1.test)('should throw an error if any of the keys is empty', async () => {
+            const setBulkSpy = vitest_1.vi.spyOn(kvStoreClient, 'setBulk');
+            await (0, vitest_1.expect)(kvStoreClient.setBulk(['key1', ''], ['value1', 'value2'])).rejects.toThrow(error_1.ErrorKVStoreEmptyKey);
+            (0, vitest_1.expect)(setBulkSpy).toHaveBeenCalledWith(['key1', ''], ['value1', 'value2']);
+        });
+        (0, vitest_1.test)('should set the key-value pairs if both keys and values arrays are provided correctly', async () => {
+            mockKVStoreContract.setBulk.mockResolvedValue(null);
+            (0, vitest_1.expect)(kvStoreClient.setBulk(['key1', 'key2'], ['value1', 'value2'])).resolves.resolves.toBeUndefined();
+            (0, vitest_1.expect)(mockKVStoreContract.setBulk).toHaveBeenCalledWith(['key1', 'key2'], ['value1', 'value2']);
+        });
+        (0, vitest_1.test)('should throw an error when attempting to set values without signer', async () => {
+            mockGetClientParams.mockResolvedValue({
+                provider,
+                network,
+            });
+            kvStoreClient = new kvstore_1.default(await init_1.default.getParams(provider));
+            await (0, vitest_1.expect)(kvStoreClient.setBulk(['key1', 'key2'], ['value1', 'value2'])).rejects.toThrow(error_1.ErrorSigner);
+        });
+        (0, vitest_1.test)('should throw an error if a network error occurs', async () => {
+            mockKVStoreContract.setBulk.mockRejectedValue(new Error('could not detect network'));
+            await (0, vitest_1.expect)(kvStoreClient.setBulk(['key1', 'key2'], ['value1', 'value2'])).rejects.toThrow(new Error('Failed to set bulk values: could not detect network'));
+            (0, vitest_1.expect)(mockKVStoreContract.setBulk).toHaveBeenCalledWith(['key1', 'key2'], ['value1', 'value2']);
+        });
+    });
+    (0, vitest_1.describe)('get', () => {
+        (0, vitest_1.test)('should throw an error if key is empty', async () => {
+            await (0, vitest_1.expect)(kvStoreClient.get('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', '')).rejects.toThrow(error_1.ErrorKVStoreEmptyKey);
+        });
+        (0, vitest_1.test)('should throw an error if address is not valid', async () => {
+            await (0, vitest_1.expect)(kvStoreClient.get('invalid_address', 'key1')).rejects.toThrow(error_1.ErrorInvalidAddress);
+        });
+        (0, vitest_1.test)('should return empty string if both address and key are valid and address does not set any value', async () => {
+            const getSpy = vitest_1.vi.spyOn(kvStoreClient, 'get').mockResolvedValue('');
+            const result = await kvStoreClient.get('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1');
+            (0, vitest_1.expect)(result).toBe('');
+            (0, vitest_1.expect)(getSpy).toHaveBeenCalledWith('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1');
+        });
+        (0, vitest_1.test)('should return value if both address and key are valid and address set a value', async () => {
+            mockKVStoreContract.get.mockResolvedValue('value1');
+            const getSpy = vitest_1.vi.spyOn(kvStoreClient, 'get');
+            const result = await kvStoreClient.get('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1');
+            (0, vitest_1.expect)(result).toBe('value1');
+            (0, vitest_1.expect)(getSpy).toHaveBeenCalledWith('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1');
+            (0, vitest_1.expect)(mockKVStoreContract.get).toHaveBeenCalledWith('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1');
+        });
+        (0, vitest_1.test)('should throw an error if a network error occurs', async () => {
+            mockKVStoreContract.get.mockRejectedValue(new Error('could not detect network'));
+            await (0, vitest_1.expect)(kvStoreClient.get('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1')).rejects.toThrow(Error('Failed to get value: could not detect network'));
+            (0, vitest_1.expect)(mockKVStoreContract.get).toHaveBeenCalledWith('0x42d75a16b04a02d1abd7f2386b1c5b567bc7ef71', 'key1');
+        });
+    });
+});

package/dist/test/staking.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=staking.test.d.ts.map

package/dist/test/staking.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staking.test.d.ts","sourceRoot":"","sources":["../../test/staking.test.ts"],"names":[],"mappings":""}

package/dist/test/staking.test.js

@@ -0,0 +1,375 @@
+"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 staking_1 = __importDefault(require("../src/staking"));
+const constants_1 = require("./utils/constants");
+const error_1 = require("../src/error");
+const init_1 = __importDefault(require("../src/init"));
+vitest_1.vi.mock('../src/init');
+(0, vitest_1.describe)('StakingClient', () => {
+    const provider = new ethers_1.ethers.providers.JsonRpcProvider();
+    let stakingClient, mockSigner, mockStakingContract, mockEscrowFactoryContract, mockTokenContract;
+    (0, vitest_1.beforeEach)(async () => {
+        mockSigner = {
+            ...provider.getSigner(),
+            getAddress: vitest_1.vi.fn().mockReturnValue(ethers_1.ethers.constants.AddressZero),
+        };
+        mockStakingContract = {
+            stake: vitest_1.vi.fn(),
+            unstake: vitest_1.vi.fn(),
+            withdraw: vitest_1.vi.fn(),
+            slash: vitest_1.vi.fn(),
+            allocate: vitest_1.vi.fn(),
+            closeAllocation: vitest_1.vi.fn(),
+            distributeRewards: vitest_1.vi.fn(),
+            getRewards: vitest_1.vi.fn(),
+            getStaker: vitest_1.vi.fn(),
+            getListOfStakers: vitest_1.vi.fn(),
+            getAllocation: vitest_1.vi.fn(),
+            rewardPool: vitest_1.vi.fn().mockResolvedValueOnce(ethers_1.ethers.constants.AddressZero),
+            address: constants_1.FAKE_NETWORK.stakingAddress,
+        };
+        mockEscrowFactoryContract = {
+            hasEscrow: vitest_1.vi.fn(),
+        };
+        mockTokenContract = {
+            allowance: vitest_1.vi.fn(),
+            approve: vitest_1.vi.fn(),
+        };
+        const getClientParamsMock = init_1.default.getParams;
+        getClientParamsMock.mockResolvedValue({
+            signerOrProvider: mockSigner,
+            network: constants_1.FAKE_NETWORK,
+        });
+        stakingClient = new staking_1.default(await init_1.default.getParams(mockSigner));
+        stakingClient.stakingContract = mockStakingContract;
+        stakingClient.tokenContract = mockTokenContract;
+        stakingClient.escrowFactoryContract = mockEscrowFactoryContract;
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('approveStake', () => {
+        const amount = ethers_1.BigNumber.from(constants_1.FAKE_AMOUNT);
+        const negativeAmount = ethers_1.BigNumber.from(constants_1.FAKE_NEGATIVE_AMOUNT);
+        (0, vitest_1.test)('should throw an error if the amount is not a BigNumber', async () => {
+            await (0, vitest_1.expect)(stakingClient.approveStake('foo')).rejects.toThrow(error_1.ErrorInvalidStakingValueType);
+            (0, vitest_1.expect)(mockTokenContract.approve).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should throw an error if the amount is negative', async () => {
+            await (0, vitest_1.expect)(stakingClient.approveStake(negativeAmount)).rejects.toThrow(error_1.ErrorInvalidStakingValueSign);
+            (0, vitest_1.expect)(mockTokenContract.approve).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should not fail and return void if the allowance is sufficient and the approval is successful', async () => {
+            stakingClient.isAllowance = vitest_1.vi.fn().mockResolvedValue(true);
+            mockTokenContract.approve = vitest_1.vi.fn().mockResolvedValue({
+                hash: constants_1.FAKE_TRANSACTION_HASH,
+                blockNumber: constants_1.FAKE_BLOCK_NUMBER,
+                confirmations: constants_1.FAKE_TRANSACTION_CONFIRMATIONS,
+            });
+            await (0, vitest_1.expect)(stakingClient.approveStake(amount)).resolves.toBeUndefined();
+            (0, vitest_1.expect)(mockTokenContract.approve).toBeCalledWith(ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockTokenContract.approve).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if the approval fails', async () => {
+            stakingClient.isAllowance = vitest_1.vi.fn().mockResolvedValue(true);
+            mockTokenContract.approve = vitest_1.vi.fn().mockRejectedValue(new Error());
+            await (0, vitest_1.expect)(stakingClient.approveStake(amount)).rejects.toThrow();
+            (0, vitest_1.expect)(mockTokenContract.approve).toBeCalledWith(ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockTokenContract.approve).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('stake', () => {
+        const amount = ethers_1.BigNumber.from(constants_1.FAKE_AMOUNT);
+        const negativeAmount = ethers_1.BigNumber.from(constants_1.FAKE_NEGATIVE_AMOUNT);
+        (0, vitest_1.test)('should throw an error if amount is not a BigNumber', async () => {
+            await (0, vitest_1.expect)(stakingClient.stake('foo')).rejects.toThrow(error_1.ErrorInvalidStakingValueType);
+            (0, vitest_1.expect)(mockStakingContract.stake).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should throw an error if amount is negative', async () => {
+            await (0, vitest_1.expect)(stakingClient.stake(negativeAmount)).rejects.toThrow(error_1.ErrorInvalidStakingValueSign);
+            (0, vitest_1.expect)(mockStakingContract.stake).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should call the stake function on the staking contract with the given amount', async () => {
+            mockTokenContract.allowance.mockResolvedValueOnce(amount);
+            await stakingClient.stake(amount);
+            (0, vitest_1.expect)(mockStakingContract.stake).toHaveBeenCalledWith(amount);
+            (0, vitest_1.expect)(mockStakingContract.stake).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if the stake function on the staking contract fails', async () => {
+            mockTokenContract.allowance.mockResolvedValueOnce(amount);
+            mockStakingContract.stake.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.stake(amount)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.stake).toHaveBeenCalledWith(amount);
+            (0, vitest_1.expect)(mockStakingContract.stake).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('unstake', () => {
+        const amount = ethers_1.BigNumber.from(constants_1.FAKE_AMOUNT);
+        const negativeAmount = ethers_1.BigNumber.from(constants_1.FAKE_NEGATIVE_AMOUNT);
+        (0, vitest_1.test)('should throw an error if amount is not a BigNumber', async () => {
+            await (0, vitest_1.expect)(stakingClient.unstake('foo')).rejects.toThrow(error_1.ErrorInvalidStakingValueType);
+            (0, vitest_1.expect)(mockStakingContract.unstake).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should throw an error if amount is negative', async () => {
+            await (0, vitest_1.expect)(stakingClient.unstake(negativeAmount)).rejects.toThrow(error_1.ErrorInvalidStakingValueSign);
+            (0, vitest_1.expect)(mockStakingContract.unstake).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should call the unstake function on the staking contract with the given amount', async () => {
+            await stakingClient.unstake(amount);
+            (0, vitest_1.expect)(mockStakingContract.unstake).toHaveBeenCalledWith(amount);
+            (0, vitest_1.expect)(mockStakingContract.unstake).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if the unstake function on the staking contract fails', async () => {
+            mockStakingContract.unstake.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.unstake(amount)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.unstake).toHaveBeenCalledWith(amount);
+            (0, vitest_1.expect)(mockStakingContract.unstake).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('withdraw', () => {
+        (0, vitest_1.test)('should call the withdraw method with the correct parameters', async () => {
+            mockStakingContract.withdraw.mockResolvedValueOnce();
+            await stakingClient.withdraw();
+            (0, vitest_1.expect)(mockStakingContract.withdraw).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if the withdraw method of the staking contract fails', async () => {
+            mockStakingContract.withdraw.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.withdraw()).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.withdraw).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('slash', () => {
+        const amount = ethers_1.BigNumber.from(constants_1.FAKE_AMOUNT);
+        const negativeAmount = ethers_1.BigNumber.from(constants_1.FAKE_NEGATIVE_AMOUNT);
+        const invalidAddress = 'InvalidAddress';
+        (0, vitest_1.test)('throws an error if amount is not a BigNumber', async () => {
+            await (0, vitest_1.expect)(stakingClient.slash(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, 'foo')).rejects.toThrow(error_1.ErrorInvalidStakingValueType);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if amount is negative', async () => {
+            await (0, vitest_1.expect)(stakingClient.slash(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, negativeAmount)).rejects.toThrow(error_1.ErrorInvalidStakingValueSign);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if slasher address is invalid', async () => {
+            await (0, vitest_1.expect)(stakingClient.slash(invalidAddress, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, amount)).rejects.toThrow(error_1.ErrorInvalidSlasherAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if staker address is invalid', async () => {
+            await (0, vitest_1.expect)(stakingClient.slash(ethers_1.ethers.constants.AddressZero, invalidAddress, ethers_1.ethers.constants.AddressZero, amount)).rejects.toThrow(error_1.ErrorInvalidStakerAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if escrow address is invalid', async () => {
+            await (0, vitest_1.expect)(stakingClient.slash(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, invalidAddress, amount)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if escrow address is not provided by the factory', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.slash(invalidAddress, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, amount)).rejects.toThrow(error_1.ErrorInvalidSlasherAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if slashing fails', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.slash.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.slash(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, amount)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('calls the staking contract to slash the given amount', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.slash.mockResolvedValueOnce();
+            await stakingClient.slash(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockStakingContract.slash).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('allocate', () => {
+        const amount = ethers_1.BigNumber.from(constants_1.FAKE_AMOUNT);
+        const negativeAmount = ethers_1.BigNumber.from(constants_1.FAKE_NEGATIVE_AMOUNT);
+        const invalidAddress = 'InvalidAddress';
+        (0, vitest_1.test)('throws an error if escrow address is invalid', async () => {
+            await (0, vitest_1.expect)(stakingClient.allocate(invalidAddress, amount)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if amount is not a BigNumber', async () => {
+            await (0, vitest_1.expect)(stakingClient.allocate(ethers_1.ethers.constants.AddressZero, 'foo')).rejects.toThrow(error_1.ErrorInvalidStakingValueType);
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if amount is negative', async () => {
+            await (0, vitest_1.expect)(stakingClient.allocate(ethers_1.ethers.constants.AddressZero, negativeAmount)).rejects.toThrow(error_1.ErrorInvalidStakingValueSign);
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if escrow address is not provided by the factory', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.allocate(ethers_1.ethers.constants.AddressZero, amount)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should call the allocate method with the correct parameters', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            await stakingClient.allocate(ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if the allocate method fails', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.allocate.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.allocate(ethers_1.ethers.constants.AddressZero, amount)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero, amount);
+            (0, vitest_1.expect)(mockStakingContract.allocate).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('closeAllocation', () => {
+        const invalidAddress = 'InvalidAddress';
+        (0, vitest_1.test)('should throws an error if escrow address is invalid', async () => {
+            await (0, vitest_1.expect)(stakingClient.closeAllocation(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.closeAllocation).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if escrow address is not provided by the factory', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.closeAllocation(ethers_1.ethers.constants.AddressZero)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.closeAllocation).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should throw an error when stakingContract.closeAllocation throws an error', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.closeAllocation.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.closeAllocation(ethers_1.ethers.constants.AddressZero)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.closeAllocation).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(mockStakingContract.closeAllocation).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should call the closeAllocation method with the correct parameters', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.closeAllocation.mockResolvedValueOnce();
+            await stakingClient.closeAllocation(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(mockStakingContract.closeAllocation).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(mockStakingContract.closeAllocation).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('distributeRewards', () => {
+        const invalidAddress = 'InvalidAddress';
+        (0, vitest_1.test)('should throw an error if an invalid escrow address is provided', async () => {
+            await (0, vitest_1.expect)(stakingClient.distributeRewards(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.distributeRewards).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if escrow address is not provided by the factory', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.distributeRewards(ethers_1.ethers.constants.AddressZero)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.distributeRewards).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should call distributeReward on the reward pool contract', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            vitest_1.vi.spyOn(stakingClient, 'distributeRewards').mockImplementation(() => Promise.resolve(undefined));
+            const results = await stakingClient.distributeRewards(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(results).toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('getStaker', () => {
+        const stakerAddress = ethers_1.ethers.constants.AddressZero;
+        const invalidAddress = 'InvalidAddress';
+        (0, vitest_1.test)('should return staker information', async () => {
+            const mockStaker = {
+                tokensStaked: ethers_1.ethers.utils.parseEther('100'),
+                tokensAllocated: ethers_1.ethers.utils.parseEther('50'),
+                tokensLocked: ethers_1.ethers.utils.parseEther('25'),
+                tokensLockedUntil: ethers_1.ethers.BigNumber.from(0),
+                tokensAvailable: ethers_1.ethers.utils.parseEther('25'),
+            };
+            mockStakingContract.getStaker.mockResolvedValueOnce(mockStaker);
+            const result = await stakingClient.getStaker(stakerAddress);
+            (0, vitest_1.expect)(result).toEqual(mockStaker);
+            (0, vitest_1.expect)(mockStakingContract.getStaker).toHaveBeenCalledWith(stakerAddress);
+            (0, vitest_1.expect)(mockStakingContract.getStaker).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error for an invalid staker address', async () => {
+            await (0, vitest_1.expect)(stakingClient.getStaker(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidStakerAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.getStaker).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should throw an error if the staking contract call fails', async () => {
+            mockStakingContract.getStaker.mockRejectedValue(new Error());
+            await (0, vitest_1.expect)(stakingClient.getStaker(stakerAddress)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.getStaker).toHaveBeenCalledWith(stakerAddress);
+            (0, vitest_1.expect)(mockStakingContract.getStaker).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('getAllStakers()', () => {
+        const mockStaker = {
+            tokensStaked: ethers_1.ethers.utils.parseEther('100'),
+            tokensAllocated: ethers_1.ethers.utils.parseEther('50'),
+            tokensLocked: ethers_1.ethers.utils.parseEther('25'),
+            tokensLockedUntil: ethers_1.ethers.BigNumber.from(0),
+            tokensAvailable: ethers_1.ethers.utils.parseEther('25'),
+        };
+        const stakerAddress = ethers_1.ethers.constants.AddressZero;
+        (0, vitest_1.test)('should return an array of stakers', async () => {
+            mockStakingContract.getListOfStakers.mockResolvedValueOnce([
+                [stakerAddress, stakerAddress],
+                [mockStaker, mockStaker],
+            ]);
+            const stakers = await stakingClient.getAllStakers();
+            (0, vitest_1.expect)(stakers).toEqual([mockStaker, mockStaker]);
+            (0, vitest_1.expect)(mockStakingContract.getListOfStakers).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if no stakers are found', async () => {
+            mockStakingContract.getListOfStakers.mockResolvedValue([[], []]);
+            await (0, vitest_1.expect)(stakingClient.getAllStakers()).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.getListOfStakers).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if there is an error in getting stakers', async () => {
+            mockStakingContract.getListOfStakers.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.getAllStakers()).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.getListOfStakers).toHaveBeenCalledTimes(1);
+        });
+    });
+    (0, vitest_1.describe)('getAllocation', () => {
+        const invalidAddress = 'InvalidAddress';
+        (0, vitest_1.test)('should throw an error for invalid escrow address', async () => {
+            await (0, vitest_1.expect)(stakingClient.getAllocation(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidEscrowAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.getAllocation).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('throws an error if escrow address is not provided by the factory', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockRejectedValueOnce(new Error());
+            await (0, vitest_1.expect)(stakingClient.getAllocation(ethers_1.ethers.constants.AddressZero)).rejects.toThrow();
+            (0, vitest_1.expect)(mockStakingContract.getAllocation).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should return allocation information', async () => {
+            const mockAllocation = {
+                escrowAddress: ethers_1.ethers.constants.AddressZero,
+                staker: ethers_1.ethers.constants.AddressZero,
+                tokens: ethers_1.ethers.utils.parseEther('100'),
+                createdAt: ethers_1.ethers.utils.parseEther('100'),
+                closedAt: ethers_1.ethers.utils.parseEther('100'),
+            };
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.getAllocation.mockResolvedValueOnce(mockAllocation);
+            const result = await stakingClient.getAllocation(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(result).toEqual(mockAllocation);
+            (0, vitest_1.expect)(mockStakingContract.getAllocation).toHaveBeenCalledWith(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(mockStakingContract.getAllocation).toHaveBeenCalledTimes(1);
+        });
+        (0, vitest_1.test)('should throw an error if the allocation data cannot be retrieved', async () => {
+            mockEscrowFactoryContract.hasEscrow.mockResolvedValueOnce(true);
+            mockStakingContract.getAllocation.mockRejectedValue(new Error());
+            await (0, vitest_1.expect)(stakingClient.getAllocation(ethers_1.ethers.constants.AddressZero)).rejects.toThrow();
+        });
+    });
+    (0, vitest_1.describe)('getRewards', () => {
+        const invalidAddress = 'InvalidAddress';
+        const mockReward = {
+            escrowAddress: ethers_1.ethers.constants.AddressZero,
+            amount: ethers_1.ethers.utils.parseEther('100'),
+        };
+        (0, vitest_1.test)('should throw an error if an invalid escrow address is provided', async () => {
+            await (0, vitest_1.expect)(stakingClient.getRewards(invalidAddress)).rejects.toThrow(error_1.ErrorInvalidSlasherAddressProvided);
+            (0, vitest_1.expect)(mockStakingContract.getRewards).toHaveBeenCalledTimes(0);
+        });
+        (0, vitest_1.test)('should return an array of rewards', async () => {
+            vitest_1.vi.spyOn(stakingClient, 'getRewards').mockImplementation(() => Promise.resolve([mockReward, mockReward]));
+            const results = await stakingClient.getRewards(ethers_1.ethers.constants.AddressZero);
+            (0, vitest_1.expect)(results).toEqual([mockReward, mockReward]);
+        });
+    });
+});

package/dist/test/storage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storage.test.d.ts.map

package/dist/test/storage.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.test.d.ts","sourceRoot":"","sources":["../../test/storage.test.ts"],"names":[],"mappings":""}