@human-protocol/sdk 1.1.16 → 1.1.18

package/src/kvstore.ts

@@ -5,11 +5,14 @@ import {
   KVStore__factory,
 } from '@human-protocol/core/typechain-types';
 import { Signer, ethers } from 'ethers';
+import { BaseEthersClient } from './base';
 import { NETWORKS } from './constants';
 import { requiresSigner } from './decorators';
 import { ChainId } from './enums';
 import {
   ErrorInvalidAddress,
+  ErrorInvalidHash,
+  ErrorInvalidUrl,
   ErrorKVStoreArrayLength,
   ErrorKVStoreEmptyKey,
   ErrorProviderDoesNotExist,
@@ -17,6 +20,7 @@ import {
   ErrorUnsupportedChainID,
 } from './error';
 import { NetworkData } from './types';
+import { isValidUrl } from './utils';
 
 /**
  * ## Introduction
@@ -87,33 +91,43 @@ import { NetworkData } from './types';
  * const kvstoreClient = await KVStoreClient.build(signer);
  * ```
  */
-export class KVStoreClient {
+export class KVStoreClient extends BaseEthersClient {
   private contract: KVStore;
-  private signerOrProvider: Signer | Provider;
 
   /**
    * **KVStoreClient constructor**
    *
    * @param {Signer | Provider} signerOrProvider - The Signer or Provider object to interact with the Ethereum network
    * @param {NetworkData} network - The network information required to connect to the KVStore contract
+   * @param {number | undefined} gasPriceMultiplier - The multiplier to apply to the gas price
    */
-  constructor(signerOrProvider: Signer | Provider, network: NetworkData) {
+  constructor(
+    signerOrProvider: Signer | Provider,
+    networkData: NetworkData,
+    gasPriceMultiplier?: number
+  ) {
+    super(signerOrProvider, networkData, gasPriceMultiplier);
+
     this.contract = KVStore__factory.connect(
-      network.kvstoreAddress,
+      networkData.kvstoreAddress,
       signerOrProvider
     );
-    this.signerOrProvider = signerOrProvider;
   }
 
   /**
    * Creates an instance of KVStoreClient from a Signer or Provider.
    *
    * @param {Signer | Provider} signerOrProvider - The Signer or Provider object to interact with the Ethereum network
+   * @param {number | undefined} gasPriceMultiplier - The multiplier to apply to the gas price
+   *
    * @returns {Promise<KVStoreClient>} - An instance of KVStoreClient
    * @throws {ErrorProviderDoesNotExist} - Thrown if the provider does not exist for the provided Signer
    * @throws {ErrorUnsupportedChainID} - Thrown if the network's chainId is not supported
    */
-  public static async build(signerOrProvider: Signer | Provider) {
+  public static async build(
+    signerOrProvider: Signer | Provider,
+    gasPriceMultiplier?: number
+  ) {
     let network: Network;
     if (Signer.isSigner(signerOrProvider)) {
       if (!signerOrProvider.provider) {
@@ -132,7 +146,7 @@ export class KVStoreClient {
       throw ErrorUnsupportedChainID;
     }
 
-    return new KVStoreClient(signerOrProvider, networkData);
+    return new KVStoreClient(signerOrProvider, networkData, gasPriceMultiplier);
   }
 
   /**
@@ -166,7 +180,9 @@ export class KVStoreClient {
     if (!Signer.isSigner(this.signerOrProvider)) throw ErrorSigner;
     if (key === '') throw ErrorKVStoreEmptyKey;
     try {
-      await this.contract?.set(key, value);
+      await this.contract?.set(key, value, {
+        ...(await this.gasPriceOptions()),
+      });
     } catch (e) {
       if (e instanceof Error) throw Error(`Failed to set value: ${e.message}`);
     }
@@ -195,7 +211,7 @@ export class KVStoreClient {
    * const signer = new Wallet(privateKey, provider);
    * const kvstoreClient = await KVStoreClient.build(signer);
    *
-   * const keys = ['Role', 'Webhook_url'];
+   * const keys = ['role', 'webhookUrl'];
    * const values = ['RecordingOracle', 'http://localhost'];
    * await kvstoreClient.set(keys, values);
    * ```
@@ -207,13 +223,67 @@ export class KVStoreClient {
     if (keys.includes('')) throw ErrorKVStoreEmptyKey;
 
     try {
-      await this.contract?.setBulk(keys, values);
+      await this.contract?.setBulk(keys, values, {
+        ...(await this.gasPriceOptions()),
+      });
     } catch (e) {
       if (e instanceof Error)
         throw Error(`Failed to set bulk values: ${e.message}`);
     }
   }
 
+  /**
+   * This function sets a URL value for the address that submits the transaction.
+   *
+   * @param {string} url URL to set
+   * @param {string | undefined} urlKey Configurable URL key. `url` by default.
+   * @returns Returns void if successful. Throws error if any.
+   *
+   *
+   * **Code example**
+   *
+   * ```ts
+   * import { Wallet, providers } from 'ethers';
+   * import { KVStoreClient } from '@human-protocol/sdk';
+   *
+   * const rpcUrl = 'YOUR_RPC_URL';
+   * const privateKey = 'YOUR_PRIVATE_KEY'
+   *
+   * const provider = new providers.JsonRpcProvider(rpcUrl);
+   * const signer = new Wallet(privateKey, provider);
+   * const kvstoreClient = await KVStoreClient.build(signer);
+   *
+   * await kvstoreClient.setURL('example.com');
+   * await kvstoreClient.setURL('linkedin.com/example', 'linkedinUrl);
+   * ```
+   */
+  @requiresSigner
+  public async setURL(url: string, urlKey = 'url'): Promise<void> {
+    if (!Signer.isSigner(this.signerOrProvider)) {
+      throw ErrorSigner;
+    }
+
+    if (!isValidUrl(url)) {
+      throw ErrorInvalidUrl;
+    }
+
+    const content = await fetch(url).then((res) => res.text());
+    const contentHash = ethers.utils.keccak256(
+      ethers.utils.toUtf8Bytes(content)
+    );
+
+    const hashKey = urlKey + 'Hash';
+
+    try {
+      await this.contract.setBulk([urlKey, hashKey], [url, contentHash], {
+        ...(await this.gasPriceOptions()),
+      });
+    } catch (e) {
+      if (e instanceof Error)
+        throw Error(`Failed to set URL and hash: ${e.message}`);
+    }
+  }
+
   /**
    * This function returns the value for a specified key and address.
    *
@@ -250,4 +320,66 @@ export class KVStoreClient {
       return e;
     }
   }
+
+  /**
+   * This function returns the URL value for the given entity.
+   *
+   * @param {string} address Address from which to get the URL value.
+   * @param {string} urlKey  Configurable URL key. `url` by default.
+   * @returns {string} URL value for the given address if exists, and the content is valid
+   *
+   *
+   * **Code example**
+   *
+   * ```ts
+   * import { providers } from 'ethers';
+   * import { KVStoreClient } from '@human-protocol/sdk';
+   *
+   * const rpcUrl = 'YOUR_RPC_URL';
+   *
+   * const provider = new providers.JsonRpcProvider(rpcUrl);
+   * const kvstoreClient = await KVStoreClient.build(provider);
+   *
+   * const url = await kvstoreClient.getURL('0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266');
+   * const linkedinUrl = await kvstoreClient.getURL(
+   *    '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+   *    'linkedinUrl'
+   * );
+   * ```
+   */
+  public async getURL(address: string, urlKey = 'url'): Promise<string> {
+    if (!ethers.utils.isAddress(address)) throw ErrorInvalidAddress;
+    const hashKey = urlKey + 'Hash';
+
+    let url = '',
+      hash = '';
+
+    try {
+      url = await this.contract?.get(address, urlKey);
+    } catch (e) {
+      if (e instanceof Error) throw Error(`Failed to get URL: ${e.message}`);
+    }
+
+    // Return empty string
+    if (!url?.length) {
+      return '';
+    }
+
+    try {
+      hash = await this.contract?.get(address, hashKey);
+    } catch (e) {
+      if (e instanceof Error) throw Error(`Failed to get Hash: ${e.message}`);
+    }
+
+    const content = await fetch(url).then((res) => res.text());
+    const contentHash = ethers.utils.keccak256(
+      ethers.utils.toUtf8Bytes(content)
+    );
+
+    if (hash !== contentHash) {
+      throw ErrorInvalidHash;
+    }
+
+    return url;
+  }
 }

package/src/staking.ts

@@ -13,6 +13,7 @@ import {
 } from '@human-protocol/core/typechain-types';
 import { BigNumber, Signer, ethers } from 'ethers';
 import gqlFetch from 'graphql-request';
+import { BaseEthersClient } from './base';
 import { NETWORKS } from './constants';
 import { requiresSigner } from './decorators';
 import { ChainId } from './enums';
@@ -102,48 +103,61 @@ import { GET_LEADER_QUERY, GET_LEADERS_QUERY } from './graphql/queries/staking';
  * const stakingClient = await StakingClient.build(provider);
  * ```
  */
-export class StakingClient {
-  public signerOrProvider: Signer | Provider;
-  public network: NetworkData;
+export class StakingClient extends BaseEthersClient {
   public tokenContract: HMToken;
   public stakingContract: Staking;
   public escrowFactoryContract: EscrowFactory;
+  public rewardPoolContract: RewardPool;
 
   /**
    * **StakingClient constructor**
    *
    * @param {Signer | Provider} signerOrProvider - The Signer or Provider object to interact with the Ethereum network
    * @param {NetworkData} network - The network information required to connect to the Staking contract
+   * @param {number | undefined} gasPriceMultiplier - The multiplier to apply to the gas price
    */
-  constructor(signerOrProvider: Signer | Provider, network: NetworkData) {
+  constructor(
+    signerOrProvider: Signer | Provider,
+    networkData: NetworkData,
+    gasPriceMultiplier?: number
+  ) {
+    super(signerOrProvider, networkData, gasPriceMultiplier);
+
     this.stakingContract = Staking__factory.connect(
-      network.stakingAddress,
+      networkData.stakingAddress,
       signerOrProvider
     );
 
     this.escrowFactoryContract = EscrowFactory__factory.connect(
-      network.factoryAddress,
+      networkData.factoryAddress,
       signerOrProvider
     );
 
     this.tokenContract = HMToken__factory.connect(
-      network.hmtAddress,
+      networkData.hmtAddress,
       signerOrProvider
     );
 
-    this.signerOrProvider = signerOrProvider;
-    this.network = network;
+    this.rewardPoolContract = RewardPool__factory.connect(
+      networkData.rewardPoolAddress,
+      this.signerOrProvider
+    );
   }
 
   /**
    * Creates an instance of StakingClient from a Signer or Provider.
    *
    * @param {Signer | Provider} signerOrProvider - The Signer or Provider object to interact with the Ethereum network
+   * @param {number | undefined} gasPriceMultiplier - The multiplier to apply to the gas price
+   *
    * @returns {Promise<StakingClient>} - An instance of StakingClient
    * @throws {ErrorProviderDoesNotExist} - Thrown if the provider does not exist for the provided Signer
    * @throws {ErrorUnsupportedChainID} - Thrown if the network's chainId is not supported
    */
-  public static async build(signerOrProvider: Signer | Provider) {
+  public static async build(
+    signerOrProvider: Signer | Provider,
+    gasPriceMultiplier?: number
+  ) {
     let network: Network;
     if (Signer.isSigner(signerOrProvider)) {
       if (!signerOrProvider.provider) {
@@ -162,7 +176,22 @@ export class StakingClient {
       throw ErrorUnsupportedChainID;
     }
 
-    return new StakingClient(signerOrProvider, networkData);
+    return new StakingClient(signerOrProvider, networkData, gasPriceMultiplier);
+  }
+
+  /**
+   * Check if escrow exists
+   *
+   * @param escrowAddress Escrow address to check against
+   */
+  private async checkValidEscrow(escrowAddress: string) {
+    if (!ethers.utils.isAddress(escrowAddress)) {
+      throw ErrorInvalidEscrowAddressProvided;
+    }
+
+    if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
+      throw ErrorEscrowAddressIsNotProvidedByFactory;
+    }
   }
 
   /**
@@ -200,7 +229,9 @@ export class StakingClient {
     }
 
     try {
-      await this.tokenContract.approve(this.stakingContract.address, amount);
+      await this.tokenContract.approve(this.stakingContract.address, amount, {
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -245,7 +276,9 @@ export class StakingClient {
     }
 
     try {
-      await this.stakingContract.stake(amount);
+      await this.stakingContract.stake(amount, {
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -289,7 +322,9 @@ export class StakingClient {
     }
 
     try {
-      await this.stakingContract.unstake(amount);
+      await this.stakingContract.unstake(amount, {
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -323,7 +358,9 @@ export class StakingClient {
   @requiresSigner
   public async withdraw(): Promise<void> {
     try {
-      await this.stakingContract.withdraw();
+      await this.stakingContract.withdraw({
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -380,16 +417,12 @@ export class StakingClient {
       throw ErrorInvalidStakerAddressProvided;
     }
 
-    if (!ethers.utils.isAddress(escrowAddress)) {
-      throw ErrorInvalidEscrowAddressProvided;
-    }
-
-    if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
-      throw ErrorEscrowAddressIsNotProvidedByFactory;
-    }
+    await this.checkValidEscrow(escrowAddress);
 
     try {
-      await this.stakingContract.slash(slasher, staker, escrowAddress, amount);
+      await this.stakingContract.slash(slasher, staker, escrowAddress, amount, {
+        ...(await this.gasPriceOptions()),
+      });
 
       return;
     } catch (e) {
@@ -437,16 +470,12 @@ export class StakingClient {
       throw ErrorInvalidStakingValueSign;
     }
 
-    if (!ethers.utils.isAddress(escrowAddress)) {
-      throw ErrorInvalidEscrowAddressProvided;
-    }
-
-    if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
-      throw ErrorEscrowAddressIsNotProvidedByFactory;
-    }
+    await this.checkValidEscrow(escrowAddress);
 
     try {
-      await this.stakingContract.allocate(escrowAddress, amount);
+      await this.stakingContract.allocate(escrowAddress, amount, {
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -481,16 +510,12 @@ export class StakingClient {
    */
   @requiresSigner
   public async closeAllocation(escrowAddress: string): Promise<void> {
-    if (!ethers.utils.isAddress(escrowAddress)) {
-      throw ErrorInvalidEscrowAddressProvided;
-    }
-
-    if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
-      throw ErrorEscrowAddressIsNotProvidedByFactory;
-    }
+    await this.checkValidEscrow(escrowAddress);
 
     try {
-      await this.stakingContract.closeAllocation(escrowAddress);
+      await this.stakingContract.closeAllocation(escrowAddress, {
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -519,26 +544,17 @@ export class StakingClient {
    * const signer = new Wallet(privateKey, provider);
    * const stakingClient = await StakingClient.build(signer);
    *
-   * await stakingClient.distributeRewards('0x62dD51230A30401C455c8398d06F85e4EaB6309f');
+   * await stakingClient.distributeReward('0x62dD51230A30401C455c8398d06F85e4EaB6309f');
    * ```
    */
   @requiresSigner
-  public async distributeRewards(escrowAddress: string): Promise<void> {
-    if (!ethers.utils.isAddress(escrowAddress)) {
-      throw ErrorInvalidEscrowAddressProvided;
-    }
-
-    if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
-      throw ErrorEscrowAddressIsNotProvidedByFactory;
-    }
+  public async distributeReward(escrowAddress: string): Promise<void> {
+    await this.checkValidEscrow(escrowAddress);
 
     try {
-      const rewardPoolContract: RewardPool = RewardPool__factory.connect(
-        await this.stakingContract.rewardPool(),
-        this.signerOrProvider
-      );
-
-      await rewardPoolContract.distributeReward(escrowAddress);
+      this.rewardPoolContract.distributeReward(escrowAddress, {
+        ...(await this.gasPriceOptions()),
+      });
       return;
     } catch (e) {
       return throwError(e);
@@ -574,7 +590,7 @@ export class StakingClient {
     try {
       const { leader } = await gqlFetch<{
         leader: ILeader;
-      }>(this.network.subgraphUrl, GET_LEADER_QUERY, {
+      }>(this.networkData.subgraphUrl, GET_LEADER_QUERY, {
         address: address.toLowerCase(),
       });
 
@@ -609,7 +625,7 @@ export class StakingClient {
     try {
       const { leaders } = await gqlFetch<{
         leaders: ILeader[];
-      }>(this.network.subgraphUrl, GET_LEADERS_QUERY(filter), {
+      }>(this.networkData.subgraphUrl, GET_LEADERS_QUERY(filter), {
         role: filter.role,
       });
 
@@ -641,13 +657,7 @@ export class StakingClient {
    * ```
    */
   public async getAllocation(escrowAddress: string): Promise<IAllocation> {
-    if (!ethers.utils.isAddress(escrowAddress)) {
-      throw ErrorInvalidEscrowAddressProvided;
-    }
-
-    if (!(await this.escrowFactoryContract.hasEscrow(escrowAddress))) {
-      throw ErrorEscrowAddressIsNotProvidedByFactory;
-    }
+    await this.checkValidEscrow(escrowAddress);
 
     try {
       const result = await this.stakingContract.getAllocation(escrowAddress);
@@ -686,7 +696,7 @@ export class StakingClient {
     try {
       const { rewardAddedEvents } = await gqlFetch<{
         rewardAddedEvents: RewardAddedEventData[];
-      }>(this.network.subgraphUrl, GET_REWARD_ADDED_EVENTS_QUERY, {
+      }>(this.networkData.subgraphUrl, GET_REWARD_ADDED_EVENTS_QUERY, {
         slasherAddress: slasherAddress.toLowerCase(),
       });
 

package/src/statistics.ts

@@ -58,15 +58,15 @@ import { throwError } from './utils';
  * ```
  */
 export class StatisticsClient {
-  public network: NetworkData;
+  public networkData: NetworkData;
 
   /**
    * **StatisticsClient constructor**
    *
-   * @param {NetworkData} network - The network information required to connect to the Statistics contract
+   * @param {NetworkData} networkData - The network information required to connect to the Statistics contract
    */
-  constructor(network: NetworkData) {
-    this.network = network;
+  constructor(networkData: NetworkData) {
+    this.networkData = networkData;
   }
 
   /**
@@ -124,11 +124,11 @@ export class StatisticsClient {
     try {
       const { escrowStatistics } = await gqlFetch<{
         escrowStatistics: EscrowStatisticsData;
-      }>(this.network.subgraphUrl, GET_ESCROW_STATISTICS_QUERY);
+      }>(this.networkData.subgraphUrl, GET_ESCROW_STATISTICS_QUERY);
 
       const { eventDayDatas } = await gqlFetch<{
         eventDayDatas: EventDayData[];
-      }>(this.network.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
+      }>(this.networkData.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
         from: params.from ? params.from.getTime() / 1000 : undefined,
         to: params.to ? params.to.getTime() / 1000 : undefined,
       });
@@ -199,7 +199,7 @@ export class StatisticsClient {
     try {
       const { eventDayDatas } = await gqlFetch<{
         eventDayDatas: EventDayData[];
-      }>(this.network.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
+      }>(this.networkData.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
         from: params.from ? params.from.getTime() / 1000 : undefined,
         to: params.to ? params.to.getTime() / 1000 : undefined,
       });
@@ -288,7 +288,7 @@ export class StatisticsClient {
     try {
       const { eventDayDatas } = await gqlFetch<{
         eventDayDatas: EventDayData[];
-      }>(this.network.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
+      }>(this.networkData.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
         from: params.from ? params.from.getTime() / 1000 : undefined,
         to: params.to ? params.to.getTime() / 1000 : undefined,
       });
@@ -398,15 +398,15 @@ export class StatisticsClient {
     try {
       const { hmtokenStatistics } = await gqlFetch<{
         hmtokenStatistics: HMTStatisticsData;
-      }>(this.network.subgraphUrl, GET_HMTOKEN_STATISTICS_QUERY);
+      }>(this.networkData.subgraphUrl, GET_HMTOKEN_STATISTICS_QUERY);
 
       const { holders } = await gqlFetch<{
         holders: HMTHolderData[];
-      }>(this.network.subgraphUrl, GET_HOLDERS_QUERY);
+      }>(this.networkData.subgraphUrl, GET_HOLDERS_QUERY);
 
       const { eventDayDatas } = await gqlFetch<{
         eventDayDatas: EventDayData[];
-      }>(this.network.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
+      }>(this.networkData.subgraphUrl, GET_EVENT_DAY_DATA_QUERY(params), {
         from: params.from ? params.from.getTime() / 1000 : undefined,
         to: params.to ? params.to.getTime() / 1000 : undefined,
       });

package/src/storage.ts

@@ -217,6 +217,7 @@ export class StorageClient {
         try {
           await this.client.putObject(bucket, key, content, {
             'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
           });
 
           return {

package/src/utils.ts

@@ -1,8 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { ethers } from 'ethers';
+import { Provider } from '@ethersproject/abstract-provider';
+import { BigNumber, Signer, ethers } from 'ethers';
 
 import {
   ContractExecutionError,
+  ErrorMissingGasPrice,
   EthereumError,
   InvalidArgumentError,
   NonceExpired,
@@ -71,3 +73,29 @@ export const isValidUrl = (url: string) => {
     return false;
   }
 };
+
+/**
+ * Increase/Decrease gas price
+ *
+ * @returns {Promise<BigNumber>} Returns the adjusted gas price
+ */
+export const gasPriceAdjusted = async (
+  signerOrProvider: Signer | Provider,
+  gasPriceMultiplier: number
+): Promise<BigNumber> => {
+  let gasPrice;
+
+  if (Signer.isSigner(signerOrProvider)) {
+    gasPrice = (await signerOrProvider.provider?.getFeeData())?.gasPrice;
+  } else {
+    gasPrice = (await signerOrProvider.getFeeData()).gasPrice;
+  }
+
+  if (!gasPrice) {
+    throw ErrorMissingGasPrice;
+  }
+
+  return gasPrice
+    .mul(ethers.utils.parseEther(gasPriceMultiplier.toString()))
+    .div(ethers.utils.parseEther('1'));
+};