@human-protocol/sdk 6.1.0 → 7.1.0

package/src/interfaces.ts

@@ -87,9 +87,6 @@ export interface IEscrowConfig {
   recordingOracle: string;
   reputationOracle: string;
   exchangeOracle: string;
-  recordingOracleFee: bigint;
-  reputationOracleFee: bigint;
-  exchangeOracleFee: bigint;
   manifest: string;
   manifestHash: string;
 }
@@ -179,12 +176,12 @@ export interface IStatusEventFilter extends IPagination {
   from?: Date;
   to?: Date;
   launcher?: string;
+  escrowAddress?: string;
 }
 
 export interface IWorker {
   id: string;
   address: string;
-  totalHMTAmountReceived: bigint;
   payoutCount: number;
 }
 
@@ -254,9 +251,7 @@ export interface IWorkerStatistics {
 
 export interface IDailyPayment {
   timestamp: number;
-  totalAmountPaid: bigint;
   totalCount: number;
-  averageAmountPerWorker: bigint;
 }
 
 export interface IPaymentStatistics {
@@ -285,8 +280,10 @@ export interface IDailyHMT {
 export interface IStatusEvent {
   timestamp: number;
   escrowAddress: string;
-  status: EscrowStatus;
+  status: keyof typeof EscrowStatus;
   chainId: ChainId;
+  block: bigint;
+  txHash: string;
 }
 
 export interface ICancellationRefund {

package/src/kvstore/index.ts

@@ -0,0 +1,2 @@
+export { KVStoreClient } from './kvstore_client';
+export { KVStoreUtils } from './kvstore_utils';

package/src/{kvstore.ts → kvstore/kvstore_client.ts}

@@ -3,28 +3,20 @@ import {
   KVStore__factory,
 } from '@human-protocol/core/typechain-types';
 import { ContractRunner, ethers } from 'ethers';
-import { BaseEthersClient } from './base';
-import { KVStoreKeys, NETWORKS } from './constants';
-import { requiresSigner } from './decorators';
-import { ChainId } from './enums';
+import { BaseEthersClient } from '../base';
+import { NETWORKS } from '../constants';
+import { requiresSigner } from '../decorators';
+import { ChainId } from '../enums';
 import {
   ErrorInvalidAddress,
-  ErrorInvalidHash,
   ErrorInvalidUrl,
   ErrorKVStoreArrayLength,
   ErrorKVStoreEmptyKey,
   ErrorProviderDoesNotExist,
   ErrorUnsupportedChainID,
-  InvalidKeyError,
-} from './error';
-import { NetworkData, TransactionOverrides } from './types';
-import { getSubgraphUrl, customGqlFetch, isValidUrl } from './utils';
-import {
-  GET_KVSTORE_BY_ADDRESS_AND_KEY_QUERY,
-  GET_KVSTORE_BY_ADDRESS_QUERY,
-} from './graphql/queries/kvstore';
-import { KVStoreData } from './graphql';
-import { IKVStore, SubgraphOptions } from './interfaces';
+} from '../error';
+import { NetworkData, TransactionOverrides } from '../types';
+import { isValidUrl } from '../utils';
 /**
  * Client for interacting with the KVStore contract.
  *
@@ -159,13 +151,17 @@ export class KVStoreClient extends BaseEthersClient {
     txOptions: TransactionOverrides = {}
   ): Promise<void> {
     if (key === '') throw ErrorKVStoreEmptyKey;
+
     try {
       await this.sendTxAndWait(
         (overrides) => this.contract.set(key, value, overrides),
         txOptions
       );
     } catch (e) {
-      if (e instanceof Error) throw Error(`Failed to set value: ${e.message}`);
+      if (e instanceof Error) {
+        throw Error(`Failed to set value: ${e.message}`);
+      }
+      throw e;
     }
   }
 
@@ -202,8 +198,10 @@ export class KVStoreClient extends BaseEthersClient {
         txOptions
       );
     } catch (e) {
-      if (e instanceof Error)
+      if (e instanceof Error) {
         throw Error(`Failed to set bulk values: ${e.message}`);
+      }
+      throw e;
     }
   }
 
@@ -249,8 +247,10 @@ export class KVStoreClient extends BaseEthersClient {
         txOptions
       );
     } catch (e) {
-      if (e instanceof Error)
+      if (e instanceof Error) {
         throw Error(`Failed to set URL and hash: ${e.message}`);
+      }
+      throw e;
     }
   }
   /**
@@ -270,236 +270,22 @@ export class KVStoreClient extends BaseEthersClient {
    * ```
    */
   public async get(address: string, key: string): Promise<string> {
-    if (key === '') throw ErrorKVStoreEmptyKey;
-    if (!ethers.isAddress(address)) throw ErrorInvalidAddress;
-
-    try {
-      const result = await this.contract?.get(address, key);
-      return result;
-    } catch (e) {
-      if (e instanceof Error) throw Error(`Failed to get value: ${e.message}`);
-      return e;
+    if (key === '') {
+      throw ErrorKVStoreEmptyKey;
     }
-  }
-}
-
-/**
- * Utility helpers for KVStore-related queries.
- *
- * @example
- * ```ts
- * import { ChainId, KVStoreUtils } from '@human-protocol/sdk';
- *
- * const kvStoreData = await KVStoreUtils.getKVStoreData(
- *   ChainId.POLYGON_AMOY,
- *   "0x1234567890123456789012345678901234567890"
- * );
- * console.log('KVStore data:', kvStoreData);
- * ```
- */
-export class KVStoreUtils {
-  /**
-   * This function returns the KVStore data for a given address.
-   *
-   * @param chainId - Network in which the KVStore is deployed
-   * @param address - Address of the KVStore
-   * @param options - Optional configuration for subgraph requests.
-   * @returns KVStore data
-   * @throws ErrorUnsupportedChainID If the network's chainId is not supported
-   * @throws ErrorInvalidAddress If the address is invalid
-   *
-   * @example
-   * ```ts
-   * const kvStoreData = await KVStoreUtils.getKVStoreData(
-   *   ChainId.POLYGON_AMOY,
-   *   "0x1234567890123456789012345678901234567890"
-   * );
-   * console.log('KVStore data:', kvStoreData);
-   * ```
-   */
-  public static async getKVStoreData(
-    chainId: ChainId,
-    address: string,
-    options?: SubgraphOptions
-  ): Promise<IKVStore[]> {
-    const networkData = NETWORKS[chainId];
 
-    if (!networkData) {
-      throw ErrorUnsupportedChainID;
-    }
-
-    if (address && !ethers.isAddress(address)) {
+    if (!ethers.isAddress(address)) {
       throw ErrorInvalidAddress;
     }
 
-    const { kvstores } = await customGqlFetch<{ kvstores: KVStoreData[] }>(
-      getSubgraphUrl(networkData),
-      GET_KVSTORE_BY_ADDRESS_QUERY(),
-      { address: address.toLowerCase() },
-      options
-    );
-
-    const kvStoreData = kvstores.map((item) => ({
-      key: item.key,
-      value: item.value,
-    }));
-
-    return kvStoreData || [];
-  }
-
-  /**
-   * Gets the value of a key-value pair in the KVStore using the subgraph.
-   *
-   * @param chainId - Network in which the KVStore is deployed
-   * @param address - Address from which to get the key value.
-   * @param key - Key to obtain the value.
-   * @param options - Optional configuration for subgraph requests.
-   * @returns Value of the key.
-   * @throws ErrorUnsupportedChainID If the network's chainId is not supported
-   * @throws ErrorInvalidAddress If the address is invalid
-   * @throws ErrorKVStoreEmptyKey If the key is empty
-   * @throws InvalidKeyError If the key is not found
-   *
-   * @example
-   * ```ts
-   * const value = await KVStoreUtils.get(
-   *   ChainId.POLYGON_AMOY,
-   *   '0x1234567890123456789012345678901234567890',
-   *   'role'
-   * );
-   * console.log('Value:', value);
-   * ```
-   */
-  public static async get(
-    chainId: ChainId,
-    address: string,
-    key: string,
-    options?: SubgraphOptions
-  ): Promise<string> {
-    if (key === '') throw ErrorKVStoreEmptyKey;
-    if (!ethers.isAddress(address)) throw ErrorInvalidAddress;
-
-    const networkData = NETWORKS[chainId];
-
-    if (!networkData) {
-      throw ErrorUnsupportedChainID;
-    }
-
-    const { kvstores } = await customGqlFetch<{ kvstores: KVStoreData[] }>(
-      getSubgraphUrl(networkData),
-      GET_KVSTORE_BY_ADDRESS_AND_KEY_QUERY(),
-      { address: address.toLowerCase(), key },
-      options
-    );
-
-    if (!kvstores || kvstores.length === 0) {
-      throw new InvalidKeyError(key, address);
-    }
-
-    return kvstores[0].value;
-  }
-
-  /**
-   * Gets the URL value of the given entity, and verifies its hash.
-   *
-   * @param chainId - Network in which the KVStore is deployed
-   * @param address - Address from which to get the URL value.
-   * @param urlKey - Configurable URL key. `url` by default.
-   * @param options - Optional configuration for subgraph requests.
-   * @returns URL value for the given address if it exists, and the content is valid
-   * @throws ErrorInvalidAddress If the address is invalid
-   * @throws ErrorInvalidHash If the hash verification fails
-   * @throws Error If fetching URL or hash fails
-   *
-   * @example
-   * ```ts
-   * const url = await KVStoreUtils.getFileUrlAndVerifyHash(
-   *   ChainId.POLYGON_AMOY,
-   *   '0x1234567890123456789012345678901234567890'
-   * );
-   * console.log('Verified URL:', url);
-   * ```
-   */
-  public static async getFileUrlAndVerifyHash(
-    chainId: ChainId,
-    address: string,
-    urlKey = 'url',
-    options?: SubgraphOptions
-  ): Promise<string> {
-    if (!ethers.isAddress(address)) throw ErrorInvalidAddress;
-    const hashKey = urlKey + '_hash';
-
-    let url = '',
-      hash = '';
-
-    try {
-      url = await this.get(chainId, address, urlKey, options);
-    } 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.get(chainId, address, hashKey);
+      const result = await this.contract?.get(address, key);
+      return result;
     } 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.keccak256(ethers.toUtf8Bytes(content));
-
-    const formattedHash = hash?.replace(/^0x/, '');
-    const formattedContentHash = contentHash?.replace(/^0x/, '');
-
-    if (formattedHash !== formattedContentHash) {
-      throw ErrorInvalidHash;
+      if (e instanceof Error) {
+        throw Error(`Failed to get value: ${e.message}`);
+      }
+      throw e;
     }
-
-    return url;
-  }
-
-  /**
-   * Gets the public key of the given entity, and verifies its hash.
-   *
-   * @param chainId - Network in which the KVStore is deployed
-   * @param address - Address from which to get the public key.
-   * @param options - Optional configuration for subgraph requests.
-   * @returns Public key for the given address if it exists, and the content is valid
-   * @throws ErrorInvalidAddress If the address is invalid
-   * @throws ErrorInvalidHash If the hash verification fails
-   * @throws Error If fetching the public key fails
-   *
-   * @example
-   * ```ts
-   * const publicKey = await KVStoreUtils.getPublicKey(
-   *   ChainId.POLYGON_AMOY,
-   *   '0x1234567890123456789012345678901234567890'
-   * );
-   * console.log('Public key:', publicKey);
-   * ```
-   */
-  public static async getPublicKey(
-    chainId: ChainId,
-    address: string,
-    options?: SubgraphOptions
-  ): Promise<string> {
-    const publicKeyUrl = await this.getFileUrlAndVerifyHash(
-      chainId,
-      address,
-      KVStoreKeys.publicKey,
-      options
-    );
-
-    if (publicKeyUrl === '') {
-      return '';
-    }
-
-    const publicKey = await fetch(publicKeyUrl).then((res) => res.text());
-
-    return publicKey;
   }
 }

package/src/kvstore/kvstore_utils.ts

@@ -0,0 +1,244 @@
+import { ethers } from 'ethers';
+import { KVStoreKeys, NETWORKS } from '../constants';
+import { ChainId } from '../enums';
+import {
+  ErrorInvalidAddress,
+  ErrorInvalidHash,
+  ErrorKVStoreEmptyKey,
+  ErrorUnsupportedChainID,
+} from '../error';
+import { KVStoreData } from '../graphql';
+import {
+  GET_KVSTORE_BY_ADDRESS_AND_KEY_QUERY,
+  GET_KVSTORE_BY_ADDRESS_QUERY,
+} from '../graphql/queries/kvstore';
+import { IKVStore, SubgraphOptions } from '../interfaces';
+import { customGqlFetch, getSubgraphUrl } from '../utils';
+/**
+ * Utility helpers for KVStore-related queries.
+ *
+ * @example
+ * ```ts
+ * import { ChainId, KVStoreUtils } from '@human-protocol/sdk';
+ *
+ * const kvStoreData = await KVStoreUtils.getKVStoreData(
+ *   ChainId.POLYGON_AMOY,
+ *   "0x1234567890123456789012345678901234567890"
+ * );
+ * console.log('KVStore data:', kvStoreData);
+ * ```
+ */
+export class KVStoreUtils {
+  /**
+   * This function returns the KVStore data for a given address.
+   *
+   * @param chainId - Network in which the KVStore is deployed
+   * @param address - Address of the KVStore
+   * @param options - Optional configuration for subgraph requests.
+   * @returns KVStore data
+   * @throws ErrorUnsupportedChainID If the network's chainId is not supported
+   * @throws ErrorInvalidAddress If the address is invalid
+   *
+   * @example
+   * ```ts
+   * const kvStoreData = await KVStoreUtils.getKVStoreData(
+   *   ChainId.POLYGON_AMOY,
+   *   "0x1234567890123456789012345678901234567890"
+   * );
+   * console.log('KVStore data:', kvStoreData);
+   * ```
+   */
+  public static async getKVStoreData(
+    chainId: ChainId,
+    address: string,
+    options?: SubgraphOptions
+  ): Promise<IKVStore[]> {
+    const networkData = NETWORKS[chainId];
+
+    if (!networkData) {
+      throw ErrorUnsupportedChainID;
+    }
+
+    if (address && !ethers.isAddress(address)) {
+      throw ErrorInvalidAddress;
+    }
+
+    const { kvstores } = await customGqlFetch<{ kvstores: KVStoreData[] }>(
+      getSubgraphUrl(networkData),
+      GET_KVSTORE_BY_ADDRESS_QUERY(),
+      { address: address.toLowerCase() },
+      options
+    );
+
+    const kvStoreData = kvstores.map((item) => ({
+      key: item.key,
+      value: item.value,
+    }));
+
+    return kvStoreData || [];
+  }
+
+  /**
+   * Gets the value of a key-value pair in the KVStore using the subgraph.
+   *
+   * @param chainId - Network in which the KVStore is deployed
+   * @param address - Address from which to get the key value.
+   * @param key - Key to obtain the value.
+   * @param options - Optional configuration for subgraph requests.
+   * @returns Value of the key.
+   * @throws ErrorUnsupportedChainID If the network's chainId is not supported
+   * @throws ErrorInvalidAddress If the address is invalid
+   * @throws ErrorKVStoreEmptyKey If the key is empty
+   *
+   * @example
+   * ```ts
+   * const value = await KVStoreUtils.get(
+   *   ChainId.POLYGON_AMOY,
+   *   '0x1234567890123456789012345678901234567890',
+   *   'role'
+   * );
+   * console.log('Value:', value);
+   * ```
+   */
+  public static async get(
+    chainId: ChainId,
+    address: string,
+    key: string,
+    options?: SubgraphOptions
+  ): Promise<string> {
+    if (key === '') throw ErrorKVStoreEmptyKey;
+    if (!ethers.isAddress(address)) throw ErrorInvalidAddress;
+
+    const networkData = NETWORKS[chainId];
+
+    if (!networkData) {
+      throw ErrorUnsupportedChainID;
+    }
+
+    const { kvstores } = await customGqlFetch<{ kvstores: KVStoreData[] }>(
+      getSubgraphUrl(networkData),
+      GET_KVSTORE_BY_ADDRESS_AND_KEY_QUERY(),
+      { address: address.toLowerCase(), key },
+      options
+    );
+
+    if (!kvstores || kvstores.length === 0) {
+      return '';
+    }
+
+    return kvstores[0].value;
+  }
+
+  /**
+   * Gets the URL value of the given entity, and verifies its hash.
+   *
+   * @param chainId - Network in which the KVStore is deployed
+   * @param address - Address from which to get the URL value.
+   * @param urlKey - Configurable URL key. `url` by default.
+   * @param options - Optional configuration for subgraph requests.
+   * @returns URL value for the given address if it exists, and the content is valid
+   * @throws ErrorInvalidAddress If the address is invalid
+   * @throws ErrorInvalidHash If the hash verification fails
+   * @throws Error If fetching URL or hash fails
+   *
+   * @example
+   * ```ts
+   * const url = await KVStoreUtils.getFileUrlAndVerifyHash(
+   *   ChainId.POLYGON_AMOY,
+   *   '0x1234567890123456789012345678901234567890'
+   * );
+   * console.log('Verified URL:', url);
+   * ```
+   */
+  public static async getFileUrlAndVerifyHash(
+    chainId: ChainId,
+    address: string,
+    urlKey = 'url',
+    options?: SubgraphOptions
+  ): Promise<string> {
+    if (!ethers.isAddress(address)) throw ErrorInvalidAddress;
+    const hashKey = urlKey + '_hash';
+
+    let url: string;
+
+    try {
+      url = await this.get(chainId, address, urlKey, options);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw Error(`Failed to get URL: ${e.message}`);
+      }
+      throw e;
+    }
+
+    if (!url) {
+      throw new Error('No URL found for the given address and key');
+    }
+
+    let hash: string;
+    try {
+      hash = await this.get(chainId, address, hashKey);
+    } catch (e) {
+      if (e instanceof Error) {
+        throw Error(`Failed to get Hash: ${e.message}`);
+      }
+      throw e;
+    }
+
+    if (!hash) {
+      throw new Error('No hash found for the given address and url');
+    }
+
+    const content = await fetch(url).then((res) => res.text());
+    const contentHash = ethers.keccak256(ethers.toUtf8Bytes(content));
+
+    const formattedHash = hash?.replace(/^0x/, '');
+    const formattedContentHash = contentHash?.replace(/^0x/, '');
+
+    if (formattedHash !== formattedContentHash) {
+      throw ErrorInvalidHash;
+    }
+
+    return url;
+  }
+
+  /**
+   * Gets the public key of the given entity, and verifies its hash.
+   *
+   * @param chainId - Network in which the KVStore is deployed
+   * @param address - Address from which to get the public key.
+   * @param options - Optional configuration for subgraph requests.
+   * @returns Public key for the given address if it exists, and the content is valid
+   * @throws ErrorInvalidAddress If the address is invalid
+   * @throws ErrorInvalidHash If the hash verification fails
+   * @throws Error If fetching the public key fails
+   *
+   * @example
+   * ```ts
+   * const publicKey = await KVStoreUtils.getPublicKey(
+   *   ChainId.POLYGON_AMOY,
+   *   '0x1234567890123456789012345678901234567890'
+   * );
+   * console.log('Public key:', publicKey);
+   * ```
+   */
+  public static async getPublicKey(
+    chainId: ChainId,
+    address: string,
+    options?: SubgraphOptions
+  ): Promise<string> {
+    const publicKeyUrl = await this.getFileUrlAndVerifyHash(
+      chainId,
+      address,
+      KVStoreKeys.publicKey,
+      options
+    );
+
+    if (publicKeyUrl === '') {
+      return '';
+    }
+
+    const publicKey = await fetch(publicKeyUrl).then((res) => res.text());
+
+    return publicKey;
+  }
+}

package/src/operator/index.ts

@@ -0,0 +1 @@
+export { OperatorUtils } from './operator_utils';

package/src/{operator.ts → operator/operator_utils.ts}

@@ -4,27 +4,27 @@ import {
   IOperatorsFilter,
   IReward,
   SubgraphOptions,
-} from './interfaces';
-import { GET_REWARD_ADDED_EVENTS_QUERY } from './graphql/queries/reward';
+} from '../interfaces';
+import { GET_REWARD_ADDED_EVENTS_QUERY } from '../graphql/queries/reward';
 import {
   IOperatorSubgraph,
   IReputationNetworkSubgraph,
   RewardAddedEventData,
-} from './graphql';
+} from '../graphql';
 import {
   GET_LEADER_QUERY,
   GET_LEADERS_QUERY,
   GET_REPUTATION_NETWORK_QUERY,
-} from './graphql/queries/operator';
+} from '../graphql/queries/operator';
 import { ethers } from 'ethers';
 import {
   ErrorInvalidSlasherAddressProvided,
   ErrorInvalidStakerAddressProvided,
   ErrorUnsupportedChainID,
-} from './error';
-import { getSubgraphUrl, customGqlFetch } from './utils';
-import { ChainId, OrderDirection } from './enums';
-import { NETWORKS } from './constants';
+} from '../error';
+import { getSubgraphUrl, customGqlFetch } from '../utils';
+import { ChainId, OrderDirection } from '../enums';
+import { NETWORKS } from '../constants';
 
 /**
  * Utility helpers for operator-related queries.

package/src/staking/index.ts

@@ -0,0 +1,2 @@
+export { StakingClient } from './staking_client';
+export { StakingUtils } from './staking_utils';