@human-protocol/sdk 6.1.0 → 7.0.0

package/dist/kvstore/kvstore_utils.d.ts

@@ -0,0 +1,105 @@
+import { ChainId } from '../enums';
+import { IKVStore, SubgraphOptions } from '../interfaces';
+/**
+ * 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 declare 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);
+     * ```
+     */
+    static getKVStoreData(chainId: ChainId, address: string, options?: SubgraphOptions): Promise<IKVStore[]>;
+    /**
+     * 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);
+     * ```
+     */
+    static get(chainId: ChainId, address: string, key: string, options?: SubgraphOptions): Promise<string>;
+    /**
+     * 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);
+     * ```
+     */
+    static getFileUrlAndVerifyHash(chainId: ChainId, address: string, urlKey?: string, options?: SubgraphOptions): Promise<string>;
+    /**
+     * 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);
+     * ```
+     */
+    static getPublicKey(chainId: ChainId, address: string, options?: SubgraphOptions): Promise<string>;
+}
+//# sourceMappingURL=kvstore_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"kvstore_utils.d.ts","sourceRoot":"","sources":["../../src/kvstore/kvstore_utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAYnC,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;OAkBG;WACiB,cAAc,CAChC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,QAAQ,EAAE,CAAC;IA0BtB;;;;;;;;;;;;;;;;;;;;;OAqBG;WACiB,GAAG,CACrB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC;IAwBlB;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,uBAAuB,CACzC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,MAAM,SAAQ,EACd,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC;IA8ClB;;;;;;;;;;;;;;;;;;;OAmBG;WACiB,YAAY,CAC9B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,MAAM,CAAC;CAgBnB"}

package/dist/kvstore/kvstore_utils.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KVStoreUtils = void 0;
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+const error_1 = require("../error");
+const kvstore_1 = require("../graphql/queries/kvstore");
+const utils_1 = require("../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);
+ * ```
+ */
+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);
+     * ```
+     */
+    static async getKVStoreData(chainId, address, options) {
+        const networkData = constants_1.NETWORKS[chainId];
+        if (!networkData) {
+            throw error_1.ErrorUnsupportedChainID;
+        }
+        if (address && !ethers_1.ethers.isAddress(address)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        const { kvstores } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, kvstore_1.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);
+     * ```
+     */
+    static async get(chainId, address, key, options) {
+        if (key === '')
+            throw error_1.ErrorKVStoreEmptyKey;
+        if (!ethers_1.ethers.isAddress(address))
+            throw error_1.ErrorInvalidAddress;
+        const networkData = constants_1.NETWORKS[chainId];
+        if (!networkData) {
+            throw error_1.ErrorUnsupportedChainID;
+        }
+        const { kvstores } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, kvstore_1.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);
+     * ```
+     */
+    static async getFileUrlAndVerifyHash(chainId, address, urlKey = 'url', options) {
+        if (!ethers_1.ethers.isAddress(address))
+            throw error_1.ErrorInvalidAddress;
+        const hashKey = urlKey + '_hash';
+        let url;
+        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;
+        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_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(content));
+        const formattedHash = hash?.replace(/^0x/, '');
+        const formattedContentHash = contentHash?.replace(/^0x/, '');
+        if (formattedHash !== formattedContentHash) {
+            throw error_1.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);
+     * ```
+     */
+    static async getPublicKey(chainId, address, options) {
+        const publicKeyUrl = await this.getFileUrlAndVerifyHash(chainId, address, constants_1.KVStoreKeys.publicKey, options);
+        if (publicKeyUrl === '') {
+            return '';
+        }
+        const publicKey = await fetch(publicKeyUrl).then((res) => res.text());
+        return publicKey;
+    }
+}
+exports.KVStoreUtils = KVStoreUtils;

package/dist/operator/index.d.ts

@@ -0,0 +1,2 @@
+export { OperatorUtils } from './operator_utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/operator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/operator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/operator/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperatorUtils = void 0;
+var operator_utils_1 = require("./operator_utils");
+Object.defineProperty(exports, "OperatorUtils", { enumerable: true, get: function () { return operator_utils_1.OperatorUtils; } });

package/dist/{operator.d.ts → operator/operator_utils.d.ts}

@@ -1,5 +1,5 @@
-import { IOperator, IOperatorsFilter, IReward, SubgraphOptions } from './interfaces';
-import { ChainId } from './enums';
+import { IOperator, IOperatorsFilter, IReward, SubgraphOptions } from '../interfaces';
+import { ChainId } from '../enums';
 /**
  * Utility helpers for operator-related queries.
  *
@@ -102,4 +102,4 @@ export declare class OperatorUtils {
      */
     static getRewards(chainId: ChainId, slasherAddress: string, options?: SubgraphOptions): Promise<IReward[]>;
 }
-//# sourceMappingURL=operator.d.ts.map
+//# sourceMappingURL=operator_utils.d.ts.map

package/dist/operator/operator_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operator_utils.d.ts","sourceRoot":"","sources":["../../src/operator/operator_utils.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,gBAAgB,EAChB,OAAO,EACP,eAAe,EAChB,MAAM,eAAe,CAAC;AAmBvB,OAAO,EAAE,OAAO,EAAkB,MAAM,UAAU,CAAC;AAGnD;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa;IACxB;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,WAAW,CAC7B,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAwB5B;;;;;;;;;;;;;;;;;;OAkBG;WACiB,YAAY,CAC9B,MAAM,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,SAAS,EAAE,CAAC;IA+CvB;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,6BAA6B,CAC/C,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,SAAS,EAAE,CAAC;IAyBvB;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,UAAU,CAC5B,OAAO,EAAE,OAAO,EAChB,cAAc,EAAE,MAAM,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC;CA8BtB"}

package/dist/{operator.js → operator/operator_utils.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperatorUtils = void 0;
-const reward_1 = require("./graphql/queries/reward");
-const operator_1 = require("./graphql/queries/operator");
+const reward_1 = require("../graphql/queries/reward");
+const operator_1 = require("../graphql/queries/operator");
 const ethers_1 = require("ethers");
-const error_1 = require("./error");
-const utils_1 = require("./utils");
-const enums_1 = require("./enums");
-const constants_1 = require("./constants");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+const constants_1 = require("../constants");
 /**
  * Utility helpers for operator-related queries.
  *

package/dist/staking/index.d.ts

@@ -0,0 +1,3 @@
+export { StakingClient } from './staking_client';
+export { StakingUtils } from './staking_utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/staking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/staking/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingUtils = exports.StakingClient = void 0;
+var staking_client_1 = require("./staking_client");
+Object.defineProperty(exports, "StakingClient", { enumerable: true, get: function () { return staking_client_1.StakingClient; } });
+var staking_utils_1 = require("./staking_utils");
+Object.defineProperty(exports, "StakingUtils", { enumerable: true, get: function () { return staking_utils_1.StakingUtils; } });

package/dist/{staking.d.ts → staking/staking_client.d.ts}

@@ -1,9 +1,8 @@
 import { EscrowFactory, HMToken, Staking } from '@human-protocol/core/typechain-types';
 import { ContractRunner } from 'ethers';
-import { BaseEthersClient } from './base';
-import { ChainId } from './enums';
-import { IStaker, IStakersFilter, StakerInfo, SubgraphOptions } from './interfaces';
-import { NetworkData, TransactionOverrides } from './types';
+import { BaseEthersClient } from '../base';
+import { StakerInfo } from '../interfaces';
+import { NetworkData, TransactionOverrides } from '../types';
 /**
  * Client for staking actions on HUMAN Protocol.
  *
@@ -218,64 +217,4 @@ export declare class StakingClient extends BaseEthersClient {
      */
     getStakerInfo(stakerAddress: string): Promise<StakerInfo>;
 }
-/**
- * Utility helpers for Staking-related queries.
- *
- * @example
- * ```ts
- * import { StakingUtils, ChainId } from '@human-protocol/sdk';
- *
- * const staker = await StakingUtils.getStaker(
- *   ChainId.POLYGON_AMOY,
- *   '0xYourStakerAddress'
- * );
- * console.log('Staked amount:', staker.stakedAmount);
- * ```
- */
-export declare class StakingUtils {
-    /**
-     * Gets staking info for a staker from the subgraph.
-     *
-     * @param chainId - Network in which the staking contract is deployed
-     * @param stakerAddress - Address of the staker
-     * @param options - Optional configuration for subgraph requests.
-     * @returns Staker info from subgraph
-     * @throws ErrorInvalidStakerAddressProvided If the staker address is invalid
-     * @throws ErrorUnsupportedChainID If the chain ID is not supported
-     * @throws ErrorStakerNotFound If the staker is not found
-     *
-     * @example
-     * ```ts
-     * import { StakingUtils, ChainId } from '@human-protocol/sdk';
-     *
-     * const staker = await StakingUtils.getStaker(
-     *   ChainId.POLYGON_AMOY,
-     *   '0xYourStakerAddress'
-     * );
-     * console.log('Staked amount:', staker.stakedAmount);
-     * ```
-     */
-    static getStaker(chainId: ChainId, stakerAddress: string, options?: SubgraphOptions): Promise<IStaker>;
-    /**
-     * Gets all stakers from the subgraph with filters, pagination and ordering.
-     *
-     * @param filter - Stakers filter with pagination and ordering
-     * @param options - Optional configuration for subgraph requests.
-     * @returns Array of stakers
-     * @throws ErrorUnsupportedChainID If the chain ID is not supported
-     *
-     * @example
-     * ```ts
-     * import { ChainId } from '@human-protocol/sdk';
-     *
-     * const filter = {
-     *   chainId: ChainId.POLYGON_AMOY,
-     *   minStakedAmount: '1000000000000000000', // 1 token in WEI
-     * };
-     * const stakers = await StakingUtils.getStakers(filter);
-     * console.log('Stakers:', stakers.length);
-     * ```
-     */
-    static getStakers(filter: IStakersFilter, options?: SubgraphOptions): Promise<IStaker[]>;
-}
-//# sourceMappingURL=staking.d.ts.map
+//# sourceMappingURL=staking_client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staking_client.d.ts","sourceRoot":"","sources":["../../src/staking/staking_client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAEb,OAAO,EAEP,OAAO,EAER,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAU,MAAM,QAAQ,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAc3C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAG7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,qBAAa,aAAc,SAAQ,gBAAgB;IAC1C,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,qBAAqB,EAAE,aAAa,CAAC;IAE5C;;;;;OAKG;gBACS,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW;IAmB5D;;;;;;;;;;;;;;;;;;;;OAoBG;WACiB,KAAK,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;IAiBzE;;;;OAIG;YACW,gBAAgB;IAU9B;;;;;;;;;;;;;;;;OAgBG;IAEU,YAAY,CACvB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,oBAAyB,GACnC,OAAO,CAAC,IAAI,CAAC;IAyBhB;;;;;;;;;;;;;;;;;;;;OAoBG;IAEU,KAAK,CAChB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,oBAAyB,GACnC,OAAO,CAAC,IAAI,CAAC;IAoBhB;;;;;;;;;;;;;;;;;;;OAmBG;IAEU,OAAO,CAClB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,oBAAyB,GACnC,OAAO,CAAC,IAAI,CAAC;IAoBhB;;;;;;;;;;;;OAYG;IAEU,QAAQ,CAAC,SAAS,GAAE,oBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IAEU,KAAK,CAChB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,oBAAyB,GACnC,OAAO,CAAC,IAAI,CAAC;IAsChB;;;;;;;;;;;;OAYG;IACU,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;CAiCvE"}

package/dist/{staking.js → staking/staking_client.js}

@@ -9,16 +9,14 @@ 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 });
-exports.StakingUtils = exports.StakingClient = void 0;
+exports.StakingClient = void 0;
 const typechain_types_1 = require("@human-protocol/core/typechain-types");
 const ethers_1 = require("ethers");
-const base_1 = require("./base");
-const constants_1 = require("./constants");
-const decorators_1 = require("./decorators");
-const enums_1 = require("./enums");
-const error_1 = require("./error");
-const utils_1 = require("./utils");
-const staking_1 = require("./graphql/queries/staking");
+const base_1 = require("../base");
+const constants_1 = require("../constants");
+const decorators_1 = require("../decorators");
+const error_1 = require("../error");
+const utils_1 = require("../utils");
 /**
  * Client for staking actions on HUMAN Protocol.
  *
@@ -380,131 +378,3 @@ __decorate([
     __metadata("design:paramtypes", [String, String, String, BigInt, Object]),
     __metadata("design:returntype", Promise)
 ], StakingClient.prototype, "slash", null);
-/**
- * Utility helpers for Staking-related queries.
- *
- * @example
- * ```ts
- * import { StakingUtils, ChainId } from '@human-protocol/sdk';
- *
- * const staker = await StakingUtils.getStaker(
- *   ChainId.POLYGON_AMOY,
- *   '0xYourStakerAddress'
- * );
- * console.log('Staked amount:', staker.stakedAmount);
- * ```
- */
-class StakingUtils {
-    /**
-     * Gets staking info for a staker from the subgraph.
-     *
-     * @param chainId - Network in which the staking contract is deployed
-     * @param stakerAddress - Address of the staker
-     * @param options - Optional configuration for subgraph requests.
-     * @returns Staker info from subgraph
-     * @throws ErrorInvalidStakerAddressProvided If the staker address is invalid
-     * @throws ErrorUnsupportedChainID If the chain ID is not supported
-     * @throws ErrorStakerNotFound If the staker is not found
-     *
-     * @example
-     * ```ts
-     * import { StakingUtils, ChainId } from '@human-protocol/sdk';
-     *
-     * const staker = await StakingUtils.getStaker(
-     *   ChainId.POLYGON_AMOY,
-     *   '0xYourStakerAddress'
-     * );
-     * console.log('Staked amount:', staker.stakedAmount);
-     * ```
-     */
-    static async getStaker(chainId, stakerAddress, options) {
-        if (!ethers_1.ethers.isAddress(stakerAddress)) {
-            throw error_1.ErrorInvalidStakerAddressProvided;
-        }
-        const networkData = constants_1.NETWORKS[chainId];
-        if (!networkData) {
-            throw error_1.ErrorUnsupportedChainID;
-        }
-        const { staker } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), staking_1.GET_STAKER_BY_ADDRESS_QUERY, { id: stakerAddress.toLowerCase() }, options);
-        if (!staker) {
-            throw error_1.ErrorStakerNotFound;
-        }
-        return mapStaker(staker);
-    }
-    /**
-     * Gets all stakers from the subgraph with filters, pagination and ordering.
-     *
-     * @param filter - Stakers filter with pagination and ordering
-     * @param options - Optional configuration for subgraph requests.
-     * @returns Array of stakers
-     * @throws ErrorUnsupportedChainID If the chain ID is not supported
-     *
-     * @example
-     * ```ts
-     * import { ChainId } from '@human-protocol/sdk';
-     *
-     * const filter = {
-     *   chainId: ChainId.POLYGON_AMOY,
-     *   minStakedAmount: '1000000000000000000', // 1 token in WEI
-     * };
-     * const stakers = await StakingUtils.getStakers(filter);
-     * console.log('Stakers:', stakers.length);
-     * ```
-     */
-    static async getStakers(filter, options) {
-        const first = filter.first !== undefined ? Math.min(filter.first, 1000) : 10;
-        const skip = filter.skip || 0;
-        const orderDirection = filter.orderDirection || enums_1.OrderDirection.DESC;
-        const orderBy = filter.orderBy || 'lastDepositTimestamp';
-        const networkData = constants_1.NETWORKS[filter.chainId];
-        if (!networkData) {
-            throw error_1.ErrorUnsupportedChainID;
-        }
-        const { stakers } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, staking_1.GET_STAKERS_QUERY)(filter), {
-            minStakedAmount: filter.minStakedAmount
-                ? filter.minStakedAmount
-                : undefined,
-            maxStakedAmount: filter.maxStakedAmount
-                ? filter.maxStakedAmount
-                : undefined,
-            minLockedAmount: filter.minLockedAmount
-                ? filter.minLockedAmount
-                : undefined,
-            maxLockedAmount: filter.maxLockedAmount
-                ? filter.maxLockedAmount
-                : undefined,
-            minWithdrawnAmount: filter.minWithdrawnAmount
-                ? filter.minWithdrawnAmount
-                : undefined,
-            maxWithdrawnAmount: filter.maxWithdrawnAmount
-                ? filter.maxWithdrawnAmount
-                : undefined,
-            minSlashedAmount: filter.minSlashedAmount
-                ? filter.minSlashedAmount
-                : undefined,
-            maxSlashedAmount: filter.maxSlashedAmount
-                ? filter.maxSlashedAmount
-                : undefined,
-            orderBy: orderBy,
-            orderDirection: orderDirection,
-            first: first,
-            skip: skip,
-        }, options);
-        if (!stakers) {
-            return [];
-        }
-        return stakers.map((s) => mapStaker(s));
-    }
-}
-exports.StakingUtils = StakingUtils;
-function mapStaker(s) {
-    return {
-        address: s.address,
-        stakedAmount: BigInt(s.stakedAmount),
-        lockedAmount: BigInt(s.lockedAmount),
-        withdrawableAmount: BigInt(s.withdrawnAmount),
-        slashedAmount: BigInt(s.slashedAmount),
-        lockedUntil: Number(s.lockedUntilTimestamp) * 1000,
-        lastDepositTimestamp: Number(s.lastDepositTimestamp) * 1000,
-    };
-}

package/dist/staking/staking_utils.d.ts

@@ -0,0 +1,63 @@
+import { ChainId } from '../enums';
+import { IStaker, IStakersFilter, SubgraphOptions } from '../interfaces';
+/**
+ * Utility helpers for Staking-related queries.
+ *
+ * @example
+ * ```ts
+ * import { StakingUtils, ChainId } from '@human-protocol/sdk';
+ *
+ * const staker = await StakingUtils.getStaker(
+ *   ChainId.POLYGON_AMOY,
+ *   '0xYourStakerAddress'
+ * );
+ * console.log('Staked amount:', staker.stakedAmount);
+ * ```
+ */
+export declare class StakingUtils {
+    /**
+     * Gets staking info for a staker from the subgraph.
+     *
+     * @param chainId - Network in which the staking contract is deployed
+     * @param stakerAddress - Address of the staker
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Staker info from subgraph
+     * @throws ErrorInvalidStakerAddressProvided If the staker address is invalid
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorStakerNotFound If the staker is not found
+     *
+     * @example
+     * ```ts
+     * import { StakingUtils, ChainId } from '@human-protocol/sdk';
+     *
+     * const staker = await StakingUtils.getStaker(
+     *   ChainId.POLYGON_AMOY,
+     *   '0xYourStakerAddress'
+     * );
+     * console.log('Staked amount:', staker.stakedAmount);
+     * ```
+     */
+    static getStaker(chainId: ChainId, stakerAddress: string, options?: SubgraphOptions): Promise<IStaker>;
+    /**
+     * Gets all stakers from the subgraph with filters, pagination and ordering.
+     *
+     * @param filter - Stakers filter with pagination and ordering
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Array of stakers
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const filter = {
+     *   chainId: ChainId.POLYGON_AMOY,
+     *   minStakedAmount: '1000000000000000000', // 1 token in WEI
+     * };
+     * const stakers = await StakingUtils.getStakers(filter);
+     * console.log('Stakers:', stakers.length);
+     * ```
+     */
+    static getStakers(filter: IStakersFilter, options?: SubgraphOptions): Promise<IStaker[]>;
+}
+//# sourceMappingURL=staking_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"staking_utils.d.ts","sourceRoot":"","sources":["../../src/staking/staking_utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAkB,MAAM,UAAU,CAAC;AAWnD,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAGzE;;;;;;;;;;;;;GAaG;AACH,qBAAa,YAAY;IACvB;;;;;;;;;;;;;;;;;;;;;OAqBG;WACiB,SAAS,CAC3B,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,OAAO,CAAC;IAwBnB;;;;;;;;;;;;;;;;;;;OAmBG;WACiB,UAAU,CAC5B,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC;CAqDtB"}