@human-protocol/sdk 1.0.2 → 1.0.3

package/dist/staking.js

@@ -0,0 +1,381 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typechain_types_1 = require("@human-protocol/core/typechain-types");
+const ethers_1 = require("ethers");
+const error_1 = require("./error");
+const utils_1 = require("./utils");
+const queries_1 = require("./queries");
+const decorators_1 = require("./decorators");
+class StakingClient {
+    /**
+     * **Staking constructor**
+     *
+     * @param {IClientParams} clientParams - Init client parameters
+     */
+    constructor(clientParams) {
+        this.clientParams = clientParams;
+        this.signerOrProvider = clientParams.signerOrProvider;
+        this.network = clientParams.network;
+        this.stakingContract = typechain_types_1.Staking__factory.connect(this.network.stakingAddress, this.signerOrProvider);
+        this.escrowFactoryContract = typechain_types_1.EscrowFactory__factory.connect(this.network.factoryAddress, this.signerOrProvider);
+        this.tokenContract = typechain_types_1.HMToken__factory.connect(this.network.hmtAddress, this.signerOrProvider);
+    }
+    /**
+     * **Approves the staking contract to transfer a specified amount of tokens when the user stakes.
+     * **It increases the allowance for the staking contract.*
+     *
+     * @param {BigNumber} amount - Amount of tokens to approve for stake
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async approveStake(amount) {
+        if (!ethers_1.BigNumber.isBigNumber(amount)) {
+            throw error_1.ErrorInvalidStakingValueType;
+        }
+        if (amount.isNegative()) {
+            throw error_1.ErrorInvalidStakingValueSign;
+        }
+        try {
+            await this.tokenContract.approve(this.stakingContract.address, amount);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Stakes a specified amount of tokens on a specific network.*
+     *
+     * @param {BigNumber} amount - Amount of tokens to stake
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async stake(amount) {
+        if (!ethers_1.BigNumber.isBigNumber(amount)) {
+            throw error_1.ErrorInvalidStakingValueType;
+        }
+        if (amount.isNegative()) {
+            throw error_1.ErrorInvalidStakingValueSign;
+        }
+        try {
+            await this.stakingContract.stake(amount);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Unstakes tokens from staking contract.
+     * **The unstaked tokens stay locked for a period of time.*
+     *
+     * @param {BigNumber} amount - Amount of tokens to unstake
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async unstake(amount) {
+        if (!ethers_1.BigNumber.isBigNumber(amount)) {
+            throw error_1.ErrorInvalidStakingValueType;
+        }
+        if (amount.isNegative()) {
+            throw error_1.ErrorInvalidStakingValueSign;
+        }
+        try {
+            await this.stakingContract.unstake(amount);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Withdraws unstaked and non locked tokens form staking contract to the user wallet.*
+     *
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async withdraw() {
+        try {
+            await this.stakingContract.withdraw();
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Slash the allocated amount by an staker in an escrow and transfers those tokens to the reward pool.
+     * **This allows the slasher to claim them later.*
+     *
+     * @param {string} slasher - Wallet address from who requested the slash
+     * @param {string} staker - Wallet address from who is going to be slashed
+     * @param {string} escrowAddress - Address of the escrow which allocation will be slashed
+     * @param {BigNumber} amount - Amount of tokens to slash
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async slash(slasher, staker, escrowAddress, amount) {
+        if (!ethers_1.BigNumber.isBigNumber(amount)) {
+            throw error_1.ErrorInvalidStakingValueType;
+        }
+        if (amount.isNegative()) {
+            throw error_1.ErrorInvalidStakingValueSign;
+        }
+        if (!ethers_1.ethers.utils.isAddress(slasher)) {
+            throw error_1.ErrorInvalidSlasherAddressProvided;
+        }
+        if (!ethers_1.ethers.utils.isAddress(staker)) {
+            throw error_1.ErrorInvalidStakerAddressProvided;
+        }
+        if (!ethers_1.ethers.utils.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
+            throw error_1.ErrorEscrowAddressIsNotProvidedByFactory;
+        }
+        try {
+            await this.stakingContract.slash(slasher, staker, escrowAddress, amount);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Allocates a portion of the staked tokens to a specific escrow.*
+     *
+     * @param {string} escrowAddress - Address of the escrow contract
+     * @param {BigNumber} amount - Amount of tokens to allocate
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async allocate(escrowAddress, amount) {
+        if (!ethers_1.BigNumber.isBigNumber(amount)) {
+            throw error_1.ErrorInvalidStakingValueType;
+        }
+        if (amount.isNegative()) {
+            throw error_1.ErrorInvalidStakingValueSign;
+        }
+        if (!ethers_1.ethers.utils.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
+            throw error_1.ErrorEscrowAddressIsNotProvidedByFactory;
+        }
+        try {
+            await this.stakingContract.allocate(escrowAddress, amount);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Drops the allocation from a specific escrow.*
+     *
+     * @param {string} escrowAddress - Address of the escrow contract.
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async closeAllocation(escrowAddress) {
+        if (!ethers_1.ethers.utils.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
+            throw error_1.ErrorEscrowAddressIsNotProvidedByFactory;
+        }
+        try {
+            await this.stakingContract.closeAllocation(escrowAddress);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Pays out rewards to the slashers for the specified escrow address.*
+     *
+     * @param {string} escrowAddress - Escrow address from which rewards are distributed.
+     * @returns {Promise<void>}
+     * @throws {Error} - An error object if an error occurred, void otherwise
+     */
+    async distributeRewards(escrowAddress) {
+        if (!ethers_1.ethers.utils.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
+            throw error_1.ErrorEscrowAddressIsNotProvidedByFactory;
+        }
+        try {
+            const rewardPoolContract = typechain_types_1.RewardPool__factory.connect(await this.stakingContract.rewardPool(), this.signerOrProvider);
+            await rewardPoolContract.distributeReward(escrowAddress);
+            return;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Returns the staking information about an staker address.*
+     *
+     * @param {string} staker - Address of the staker
+     * @returns {Promise<IStaker>} - Return staking information of the specified address
+     * @throws {Error} - An error object if an error occurred, result otherwise
+     */
+    async getStaker(staker) {
+        if (!ethers_1.ethers.utils.isAddress(staker)) {
+            throw error_1.ErrorInvalidStakerAddressProvided;
+        }
+        try {
+            const result = await this.stakingContract.getStaker(staker);
+            const tokensStaked = ethers_1.BigNumber.from(result.tokensStaked), tokensAllocated = ethers_1.BigNumber.from(result.tokensAllocated), tokensLocked = ethers_1.BigNumber.from(result.tokensLocked), tokensLockedUntil = ethers_1.BigNumber.from(result.tokensLockedUntil);
+            const tokensAvailable = tokensStaked
+                .sub(tokensAllocated)
+                .sub(tokensLocked);
+            return {
+                tokensStaked,
+                tokensAllocated,
+                tokensLocked,
+                tokensLockedUntil,
+                tokensAvailable,
+            };
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Returns the staking information about all stakers of the protocol.*
+     *
+     * @returns {Promise<IStakerInfo>} - Return an array with all stakers information
+     * @throws {Error} - An error object if an error occurred, results otherwise
+     */
+    async getAllStakers() {
+        try {
+            const result = await this.stakingContract.getListOfStakers();
+            if (result[1].length === 0) {
+                throw error_1.ErrorStakingGetStakers;
+            }
+            return result[1].map((staker) => {
+                const tokensStaked = ethers_1.BigNumber.from(staker.tokensStaked), tokensAllocated = ethers_1.BigNumber.from(staker.tokensAllocated), tokensLocked = ethers_1.BigNumber.from(staker.tokensLocked), tokensLockedUntil = ethers_1.BigNumber.from(staker.tokensLockedUntil);
+                const tokensAvailable = tokensStaked
+                    .sub(tokensAllocated)
+                    .sub(tokensLocked);
+                return {
+                    tokensStaked,
+                    tokensAllocated,
+                    tokensLocked,
+                    tokensLockedUntil,
+                    tokensAvailable,
+                };
+            });
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Returns information about the allocation of the specified escrow.*
+     *
+     * @param {string} escrowAddress - The escrow address for the received allocation data
+     * @returns {Promise<IAllocation>} - Returns allocation info if exists
+     * @throws {Error} - An error object if an error occurred, result otherwise
+     */
+    async getAllocation(escrowAddress) {
+        if (!ethers_1.ethers.utils.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
+            throw error_1.ErrorEscrowAddressIsNotProvidedByFactory;
+        }
+        try {
+            const result = await this.stakingContract.getAllocation(escrowAddress);
+            return result;
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+    /**
+     * **Returns information about the rewards for a given escrow address.*
+     *
+     * @param {string} slasherAddress - Address of the slasher
+     * @returns {Promise<IReward[]>} - Returns rewards info if exists
+     * @throws {Error} - An error object if an error occurred, results otherwise
+     */
+    async getRewards(slasherAddress) {
+        if (!ethers_1.ethers.utils.isAddress(slasherAddress)) {
+            throw error_1.ErrorInvalidSlasherAddressProvided;
+        }
+        try {
+            const { data } = await (0, utils_1.gqlFetch)(this.network.subgraphUrl, (0, queries_1.RAW_REWARDS_QUERY)(slasherAddress));
+            return data.rewardAddedEvents.map((reward) => {
+                return {
+                    escrowAddress: reward.escrow,
+                    amount: reward.amount,
+                };
+            });
+        }
+        catch (e) {
+            return (0, utils_1.throwError)(e);
+        }
+    }
+}
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ethers_1.BigNumber]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "approveStake", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ethers_1.BigNumber]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "stake", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [ethers_1.BigNumber]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "unstake", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "withdraw", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, ethers_1.BigNumber]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "slash", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, ethers_1.BigNumber]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "allocate", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "closeAllocation", null);
+__decorate([
+    decorators_1.requiresSigner,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], StakingClient.prototype, "distributeRewards", null);
+exports.default = StakingClient;

package/dist/storage.d.ts

@@ -0,0 +1,48 @@
+import { UploadFile, StorageCredentials, StorageParams } from './types';
+export default class StorageClient {
+    private client;
+    /**
+     * **Storage client constructor**
+     *
+     * @param {StorageCredentials} credentials - Cloud storage access data
+     * @param {StorageParams} params - Cloud storage params
+     */
+    constructor(credentials: StorageCredentials, params: StorageParams);
+    /**
+     * **Download files from cloud storage**
+     *
+     * @param {string} keys - Keys of files
+     * @returns {Promise<File>} - Downloaded file
+     */
+    downloadFiles(keys: string[], bucket: string): Promise<any[]>;
+    /**
+     * **Download files from cloud storage.*
+     *
+     * @param {string} url - URL to the file
+     * @returns {Promise<File>} - Downloaded file
+     */
+    static downloadFileFromUrl(url: string): Promise<any>;
+    /**
+     * **Upload file to cloud storage**
+     *
+     * @param {File[]} files - Files to upload
+     * @param {string} bucket - Bucket name
+     * @returns {Promise<UploadFile>} - Uploaded file with key/hash
+     */
+    uploadFiles(files: any[], bucket: string): Promise<UploadFile[]>;
+    /**
+     * **Checks if a bucket exists**
+     *
+     * @param {string} bucket - Name of the bucket
+     * @returns {Promise<boolean>} - True if bucket exists, false otherwise
+     */
+    bucketExists(bucket: string): Promise<boolean>;
+    /**
+     * **Checks if a bucket exists**
+     *
+     * @param {string} bucket - Name of the bucket
+     * @returns {Promise<string[]>} - A list of filenames with their extensions in the bucket
+     */
+    listObjects(bucket: string): Promise<string[]>;
+}
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","sourceRoot":"","sources":["../src/storage.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAIxE,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,OAAO,CAAC,MAAM,CAAe;IAE7B;;;;;OAKG;gBACS,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,aAAa;IAYlE;;;;;OAKG;IACU,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IAoB1E;;;;;OAKG;WACiB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAsBlE;;;;;;OAMG;IACU,WAAW,CACtB,KAAK,EAAE,GAAG,EAAE,EACZ,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,UAAU,EAAE,CAAC;IA0BxB;;;;;OAKG;IACU,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI3D;;;;;OAKG;IACU,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAqB5D"}

package/dist/storage.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = __importDefault(require("crypto"));
+const Minio = __importStar(require("minio"));
+const error_1 = require("./error");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+class StorageClient {
+    /**
+     * **Storage client constructor**
+     *
+     * @param {StorageCredentials} credentials - Cloud storage access data
+     * @param {StorageParams} params - Cloud storage params
+     */
+    constructor(credentials, params) {
+        try {
+            this.client = new Minio.Client({
+                ...params,
+                accessKey: credentials.accessKey,
+                secretKey: credentials.secretKey,
+            });
+        }
+        catch (e) {
+            throw error_1.ErrorStorageClientNotInitialized;
+        }
+    }
+    /**
+     * **Download files from cloud storage**
+     *
+     * @param {string} keys - Keys of files
+     * @returns {Promise<File>} - Downloaded file
+     */
+    async downloadFiles(keys, bucket) {
+        const isBucketExists = await this.client.bucketExists(bucket);
+        if (!isBucketExists) {
+            throw error_1.ErrorStorageBucketNotFound;
+        }
+        return Promise.all(keys.map(async (key) => {
+            try {
+                const response = await this.client.getObject(bucket, key);
+                const content = response?.read();
+                return { key, content: JSON.parse(content?.toString('utf-8') || '') };
+            }
+            catch (e) {
+                throw error_1.ErrorStorageFileNotFound;
+            }
+        }));
+    }
+    /**
+     * **Download files from cloud storage.*
+     *
+     * @param {string} url - URL to the file
+     * @returns {Promise<File>} - Downloaded file
+     */
+    static async downloadFileFromUrl(url) {
+        if (!(0, utils_1.isValidUrl)(url)) {
+            throw error_1.ErrorInvalidUrl;
+        }
+        try {
+            const { data, status } = await axios_1.default.get(url, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (status !== constants_1.HttpStatus.OK) {
+                throw error_1.ErrorStorageFileNotFound;
+            }
+            return data;
+        }
+        catch (e) {
+            throw error_1.ErrorStorageFileNotFound;
+        }
+    }
+    /**
+     * **Upload file to cloud storage**
+     *
+     * @param {File[]} files - Files to upload
+     * @param {string} bucket - Bucket name
+     * @returns {Promise<UploadFile>} - Uploaded file with key/hash
+     */
+    async uploadFiles(files, bucket) {
+        const isBucketExists = await this.client.bucketExists(bucket);
+        if (!isBucketExists) {
+            throw error_1.ErrorStorageBucketNotFound;
+        }
+        return Promise.all(files.map(async (file) => {
+            const content = JSON.stringify(file);
+            const hash = crypto_1.default.createHash('sha1').update(content).digest('hex');
+            const key = hash;
+            try {
+                await this.client.putObject(bucket, key, content, {
+                    'Content-Type': 'application/json',
+                });
+                return { key, hash };
+            }
+            catch (e) {
+                throw error_1.ErrorStorageFileNotUploaded;
+            }
+        }));
+    }
+    /**
+     * **Checks if a bucket exists**
+     *
+     * @param {string} bucket - Name of the bucket
+     * @returns {Promise<boolean>} - True if bucket exists, false otherwise
+     */
+    async bucketExists(bucket) {
+        return this.client.bucketExists(bucket);
+    }
+    /**
+     * **Checks if a bucket exists**
+     *
+     * @param {string} bucket - Name of the bucket
+     * @returns {Promise<string[]>} - A list of filenames with their extensions in the bucket
+     */
+    async listObjects(bucket) {
+        const isBucketExists = await this.client.bucketExists(bucket);
+        if (!isBucketExists) {
+            throw error_1.ErrorStorageBucketNotFound;
+        }
+        try {
+            return new Promise((resolve, reject) => {
+                const keys = [];
+                const stream = this.client.listObjectsV2(bucket, '', true, '');
+                stream.on('data', (obj) => keys.push(obj.name));
+                stream.on('error', reject);
+                stream.on('end', () => {
+                    resolve(keys);
+                });
+            });
+        }
+        catch (e) {
+            throw new Error(String(e));
+        }
+    }
+}
+exports.default = StorageClient;