@human-protocol/sdk 6.1.0 → 7.0.0

package/dist/escrow/escrow_utils.d.ts

@@ -0,0 +1,172 @@
+import { ChainId } from '../enums';
+import { ICancellationRefund, ICancellationRefundFilter, IEscrow, IEscrowsFilter, IPayout, IPayoutFilter, IStatusEvent, IStatusEventFilter, SubgraphOptions } from '../interfaces';
+/**
+ * Utility helpers for escrow-related queries.
+ *
+ * @example
+ * ```ts
+ * import { ChainId, EscrowUtils } from '@human-protocol/sdk';
+ *
+ * const escrows = await EscrowUtils.getEscrows({
+ *   chainId: ChainId.POLYGON_AMOY
+ * });
+ * console.log('Escrows:', escrows);
+ * ```
+ */
+export declare class EscrowUtils {
+    /**
+     * This function returns an array of escrows based on the specified filter parameters.
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns List of escrows that match the filter.
+     * @throws ErrorInvalidAddress If any filter address is invalid
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     *
+     * @example
+     * ```ts
+     * import { ChainId, EscrowStatus } from '@human-protocol/sdk';
+     *
+     * const filters = {
+     *   status: EscrowStatus.Pending,
+     *   from: new Date(2023, 4, 8),
+     *   to: new Date(2023, 5, 8),
+     *   chainId: ChainId.POLYGON_AMOY
+     * };
+     * const escrows = await EscrowUtils.getEscrows(filters);
+     * console.log('Found escrows:', escrows.length);
+     * ```
+     */
+    static getEscrows(filter: IEscrowsFilter, options?: SubgraphOptions): Promise<IEscrow[]>;
+    /**
+     * This function returns the escrow data for a given address.
+     *
+     * > This uses Subgraph
+     *
+     * @param chainId - Network in which the escrow has been deployed
+     * @param escrowAddress - Address of the escrow
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Escrow data or null if not found.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidAddress If the escrow address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const escrow = await EscrowUtils.getEscrow(
+     *   ChainId.POLYGON_AMOY,
+     *   "0x1234567890123456789012345678901234567890"
+     * );
+     * if (escrow) {
+     *   console.log('Escrow status:', escrow.status);
+     * }
+     * ```
+     */
+    static getEscrow(chainId: ChainId, escrowAddress: string, options?: SubgraphOptions): Promise<IEscrow | null>;
+    /**
+     * This function returns the status events for a given set of networks within an optional date range.
+     *
+     * > This uses Subgraph
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Array of status events with their corresponding statuses.
+     * @throws ErrorInvalidAddress If the launcher address is invalid
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     *
+     * @example
+     * ```ts
+     * import { ChainId, EscrowStatus } from '@human-protocol/sdk';
+     *
+     * const fromDate = new Date('2023-01-01');
+     * const toDate = new Date('2023-12-31');
+     * const statusEvents = await EscrowUtils.getStatusEvents({
+     *   chainId: ChainId.POLYGON,
+     *   statuses: [EscrowStatus.Pending, EscrowStatus.Complete],
+     *   from: fromDate,
+     *   to: toDate
+     * });
+     * console.log('Status events:', statusEvents.length);
+     * ```
+     */
+    static getStatusEvents(filter: IStatusEventFilter, options?: SubgraphOptions): Promise<IStatusEvent[]>;
+    /**
+     * This function returns the payouts for a given set of networks.
+     *
+     * > This uses Subgraph
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns List of payouts matching the filters.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidAddress If any filter address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const payouts = await EscrowUtils.getPayouts({
+     *   chainId: ChainId.POLYGON,
+     *   escrowAddress: '0x1234567890123456789012345678901234567890',
+     *   recipient: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdef',
+     *   from: new Date('2023-01-01'),
+     *   to: new Date('2023-12-31')
+     * });
+     * console.log('Payouts:', payouts.length);
+     * ```
+     */
+    static getPayouts(filter: IPayoutFilter, options?: SubgraphOptions): Promise<IPayout[]>;
+    /**
+     * This function returns the cancellation refunds for a given set of networks.
+     *
+     * > This uses Subgraph
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns List of cancellation refunds matching the filters.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidEscrowAddressProvided If the escrow address is invalid
+     * @throws ErrorInvalidAddress If the receiver address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const cancellationRefunds = await EscrowUtils.getCancellationRefunds({
+     *    chainId: ChainId.POLYGON_AMOY,
+     *    escrowAddress: '0x1234567890123456789012345678901234567890',
+     * });
+     * console.log('Cancellation refunds:', cancellationRefunds.length);
+     * ```
+     */
+    static getCancellationRefunds(filter: ICancellationRefundFilter, options?: SubgraphOptions): Promise<ICancellationRefund[]>;
+    /**
+     * This function returns the cancellation refund for a given escrow address.
+     *
+     * > This uses Subgraph
+     *
+     * @param chainId - Network in which the escrow has been deployed
+     * @param escrowAddress - Address of the escrow
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Cancellation refund data or null if not found.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidEscrowAddressProvided If the escrow address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     *
+     * const cancellationRefund = await EscrowUtils.getCancellationRefund(
+     *   ChainId.POLYGON_AMOY,
+     *   "0x1234567890123456789012345678901234567890"
+     * );
+     * if (cancellationRefund) {
+     *   console.log('Refund amount:', cancellationRefund.amount);
+     * }
+     * ```
+     */
+    static getCancellationRefund(chainId: ChainId, escrowAddress: string, options?: SubgraphOptions): Promise<ICancellationRefund | null>;
+}
+//# sourceMappingURL=escrow_utils.d.ts.map

package/dist/escrow/escrow_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escrow_utils.d.ts","sourceRoot":"","sources":["../../src/escrow/escrow_utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAkB,MAAM,UAAU,CAAC;AAkBnD,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,OAAO,EACP,cAAc,EACd,OAAO,EACP,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,eAAe,EAChB,MAAM,eAAe,CAAC;AAGvB;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAW;IACtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACiB,UAAU,CAC5B,MAAM,EAAE,cAAc,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC;IAsDrB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,SAAS,CAC3B,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAsB1B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACiB,eAAe,CACjC,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,EAAE,CAAC;IA8D1B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACiB,UAAU,CAC5B,MAAM,EAAE,aAAa,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC;IA4CrB;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACiB,sBAAsB,CACxC,MAAM,EAAE,yBAAyB,EACjC,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,mBAAmB,EAAE,CAAC;IA+CjC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACiB,qBAAqB,CACvC,OAAO,EAAE,OAAO,EAChB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC;CA+BvC"}

package/dist/escrow/escrow_utils.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EscrowUtils = void 0;
+const ethers_1 = require("ethers");
+const constants_1 = require("../constants");
+const enums_1 = require("../enums");
+const error_1 = require("../error");
+const graphql_1 = require("../graphql");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+/**
+ * Utility helpers for escrow-related queries.
+ *
+ * @example
+ * ```ts
+ * import { ChainId, EscrowUtils } from '@human-protocol/sdk';
+ *
+ * const escrows = await EscrowUtils.getEscrows({
+ *   chainId: ChainId.POLYGON_AMOY
+ * });
+ * console.log('Escrows:', escrows);
+ * ```
+ */
+class EscrowUtils {
+    /**
+     * This function returns an array of escrows based on the specified filter parameters.
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns List of escrows that match the filter.
+     * @throws ErrorInvalidAddress If any filter address is invalid
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     *
+     * @example
+     * ```ts
+     * import { ChainId, EscrowStatus } from '@human-protocol/sdk';
+     *
+     * const filters = {
+     *   status: EscrowStatus.Pending,
+     *   from: new Date(2023, 4, 8),
+     *   to: new Date(2023, 5, 8),
+     *   chainId: ChainId.POLYGON_AMOY
+     * };
+     * const escrows = await EscrowUtils.getEscrows(filters);
+     * console.log('Found escrows:', escrows.length);
+     * ```
+     */
+    static async getEscrows(filter, options) {
+        if (filter.launcher && !ethers_1.ethers.isAddress(filter.launcher)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        if (filter.recordingOracle && !ethers_1.ethers.isAddress(filter.recordingOracle)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        if (filter.reputationOracle && !ethers_1.ethers.isAddress(filter.reputationOracle)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        if (filter.exchangeOracle && !ethers_1.ethers.isAddress(filter.exchangeOracle)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        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 networkData = constants_1.NETWORKS[filter.chainId];
+        if (!networkData) {
+            throw error_1.ErrorUnsupportedChainID;
+        }
+        let statuses;
+        if (filter.status !== undefined) {
+            statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+            statuses = statuses.map((status) => types_1.EscrowStatus[status]);
+        }
+        const { escrows } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, graphql_1.GET_ESCROWS_QUERY)(filter), {
+            ...filter,
+            launcher: filter.launcher?.toLowerCase(),
+            reputationOracle: filter.reputationOracle?.toLowerCase(),
+            recordingOracle: filter.recordingOracle?.toLowerCase(),
+            exchangeOracle: filter.exchangeOracle?.toLowerCase(),
+            status: statuses,
+            from: filter.from ? (0, utils_1.getUnixTimestamp)(filter.from) : undefined,
+            to: filter.to ? (0, utils_1.getUnixTimestamp)(filter.to) : undefined,
+            orderDirection: orderDirection,
+            first: first,
+            skip: skip,
+        }, options);
+        return (escrows || []).map((e) => mapEscrow(e, networkData.chainId));
+    }
+    /**
+     * This function returns the escrow data for a given address.
+     *
+     * > This uses Subgraph
+     *
+     * @param chainId - Network in which the escrow has been deployed
+     * @param escrowAddress - Address of the escrow
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Escrow data or null if not found.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidAddress If the escrow address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const escrow = await EscrowUtils.getEscrow(
+     *   ChainId.POLYGON_AMOY,
+     *   "0x1234567890123456789012345678901234567890"
+     * );
+     * if (escrow) {
+     *   console.log('Escrow status:', escrow.status);
+     * }
+     * ```
+     */
+    static async getEscrow(chainId, escrowAddress, options) {
+        const networkData = constants_1.NETWORKS[chainId];
+        if (!networkData) {
+            throw error_1.ErrorUnsupportedChainID;
+        }
+        if (escrowAddress && !ethers_1.ethers.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        const { escrow } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, graphql_1.GET_ESCROW_BY_ADDRESS_QUERY)(), { escrowAddress: escrowAddress.toLowerCase() }, options);
+        if (!escrow)
+            return null;
+        return mapEscrow(escrow, networkData.chainId);
+    }
+    /**
+     * This function returns the status events for a given set of networks within an optional date range.
+     *
+     * > This uses Subgraph
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Array of status events with their corresponding statuses.
+     * @throws ErrorInvalidAddress If the launcher address is invalid
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     *
+     * @example
+     * ```ts
+     * import { ChainId, EscrowStatus } from '@human-protocol/sdk';
+     *
+     * const fromDate = new Date('2023-01-01');
+     * const toDate = new Date('2023-12-31');
+     * const statusEvents = await EscrowUtils.getStatusEvents({
+     *   chainId: ChainId.POLYGON,
+     *   statuses: [EscrowStatus.Pending, EscrowStatus.Complete],
+     *   from: fromDate,
+     *   to: toDate
+     * });
+     * console.log('Status events:', statusEvents.length);
+     * ```
+     */
+    static async getStatusEvents(filter, options) {
+        const { chainId, statuses, from, to, launcher, first = 10, skip = 0, orderDirection = enums_1.OrderDirection.DESC, } = filter;
+        if (launcher && !ethers_1.ethers.isAddress(launcher)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        const networkData = constants_1.NETWORKS[chainId];
+        if (!networkData) {
+            throw error_1.ErrorUnsupportedChainID;
+        }
+        // If statuses are not provided, use all statuses except Launched
+        const effectiveStatuses = statuses ?? [
+            types_1.EscrowStatus.Launched,
+            types_1.EscrowStatus.Pending,
+            types_1.EscrowStatus.Partial,
+            types_1.EscrowStatus.Paid,
+            types_1.EscrowStatus.Complete,
+            types_1.EscrowStatus.Cancelled,
+        ];
+        const statusNames = effectiveStatuses.map((status) => types_1.EscrowStatus[status]);
+        const data = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, graphql_1.GET_STATUS_UPDATES_QUERY)(from, to, launcher), {
+            status: statusNames,
+            from: from ? (0, utils_1.getUnixTimestamp)(from) : undefined,
+            to: to ? (0, utils_1.getUnixTimestamp)(to) : undefined,
+            launcher: launcher || undefined,
+            orderDirection,
+            first: Math.min(first, 1000),
+            skip,
+        }, options);
+        if (!data || !data['escrowStatusEvents']) {
+            return [];
+        }
+        return data['escrowStatusEvents'].map((event) => ({
+            timestamp: Number(event.timestamp) * 1000,
+            escrowAddress: event.escrowAddress,
+            status: types_1.EscrowStatus[event.status],
+            chainId,
+        }));
+    }
+    /**
+     * This function returns the payouts for a given set of networks.
+     *
+     * > This uses Subgraph
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns List of payouts matching the filters.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidAddress If any filter address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const payouts = await EscrowUtils.getPayouts({
+     *   chainId: ChainId.POLYGON,
+     *   escrowAddress: '0x1234567890123456789012345678901234567890',
+     *   recipient: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcdef',
+     *   from: new Date('2023-01-01'),
+     *   to: new Date('2023-12-31')
+     * });
+     * console.log('Payouts:', payouts.length);
+     * ```
+     */
+    static async getPayouts(filter, options) {
+        const networkData = constants_1.NETWORKS[filter.chainId];
+        if (!networkData) {
+            throw error_1.ErrorUnsupportedChainID;
+        }
+        if (filter.escrowAddress && !ethers_1.ethers.isAddress(filter.escrowAddress)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        if (filter.recipient && !ethers_1.ethers.isAddress(filter.recipient)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        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 { payouts } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, graphql_1.GET_PAYOUTS_QUERY)(filter), {
+            escrowAddress: filter.escrowAddress?.toLowerCase(),
+            recipient: filter.recipient?.toLowerCase(),
+            from: filter.from ? (0, utils_1.getUnixTimestamp)(filter.from) : undefined,
+            to: filter.to ? (0, utils_1.getUnixTimestamp)(filter.to) : undefined,
+            first: Math.min(first, 1000),
+            skip,
+            orderDirection,
+        }, options);
+        if (!payouts) {
+            return [];
+        }
+        return payouts.map((payout) => ({
+            id: payout.id,
+            escrowAddress: payout.escrowAddress,
+            recipient: payout.recipient,
+            amount: BigInt(payout.amount),
+            createdAt: Number(payout.createdAt) * 1000,
+        }));
+    }
+    /**
+     * This function returns the cancellation refunds for a given set of networks.
+     *
+     * > This uses Subgraph
+     *
+     * @param filter - Filter parameters.
+     * @param options - Optional configuration for subgraph requests.
+     * @returns List of cancellation refunds matching the filters.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidEscrowAddressProvided If the escrow address is invalid
+     * @throws ErrorInvalidAddress If the receiver address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     * const cancellationRefunds = await EscrowUtils.getCancellationRefunds({
+     *    chainId: ChainId.POLYGON_AMOY,
+     *    escrowAddress: '0x1234567890123456789012345678901234567890',
+     * });
+     * console.log('Cancellation refunds:', cancellationRefunds.length);
+     * ```
+     */
+    static async getCancellationRefunds(filter, options) {
+        const networkData = constants_1.NETWORKS[filter.chainId];
+        if (!networkData)
+            throw error_1.ErrorUnsupportedChainID;
+        if (filter.escrowAddress && !ethers_1.ethers.isAddress(filter.escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        if (filter.receiver && !ethers_1.ethers.isAddress(filter.receiver)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        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 { cancellationRefundEvents } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, graphql_1.GET_CANCELLATION_REFUNDS_QUERY)(filter), {
+            escrowAddress: filter.escrowAddress?.toLowerCase(),
+            receiver: filter.receiver?.toLowerCase(),
+            from: filter.from ? (0, utils_1.getUnixTimestamp)(filter.from) : undefined,
+            to: filter.to ? (0, utils_1.getUnixTimestamp)(filter.to) : undefined,
+            first,
+            skip,
+            orderDirection,
+        }, options);
+        if (!cancellationRefundEvents || cancellationRefundEvents.length === 0) {
+            return [];
+        }
+        return cancellationRefundEvents.map((event) => ({
+            id: event.id,
+            escrowAddress: event.escrowAddress,
+            receiver: event.receiver,
+            amount: BigInt(event.amount),
+            block: Number(event.block),
+            timestamp: Number(event.timestamp) * 1000,
+            txHash: event.txHash,
+        }));
+    }
+    /**
+     * This function returns the cancellation refund for a given escrow address.
+     *
+     * > This uses Subgraph
+     *
+     * @param chainId - Network in which the escrow has been deployed
+     * @param escrowAddress - Address of the escrow
+     * @param options - Optional configuration for subgraph requests.
+     * @returns Cancellation refund data or null if not found.
+     * @throws ErrorUnsupportedChainID If the chain ID is not supported
+     * @throws ErrorInvalidEscrowAddressProvided If the escrow address is invalid
+     *
+     * @example
+     * ```ts
+     * import { ChainId } from '@human-protocol/sdk';
+     *
+     *
+     * const cancellationRefund = await EscrowUtils.getCancellationRefund(
+     *   ChainId.POLYGON_AMOY,
+     *   "0x1234567890123456789012345678901234567890"
+     * );
+     * if (cancellationRefund) {
+     *   console.log('Refund amount:', cancellationRefund.amount);
+     * }
+     * ```
+     */
+    static async getCancellationRefund(chainId, escrowAddress, options) {
+        const networkData = constants_1.NETWORKS[chainId];
+        if (!networkData)
+            throw error_1.ErrorUnsupportedChainID;
+        if (!ethers_1.ethers.isAddress(escrowAddress)) {
+            throw error_1.ErrorInvalidEscrowAddressProvided;
+        }
+        const { cancellationRefundEvents } = await (0, utils_1.customGqlFetch)((0, utils_1.getSubgraphUrl)(networkData), (0, graphql_1.GET_CANCELLATION_REFUND_BY_ADDRESS_QUERY)(), { escrowAddress: escrowAddress.toLowerCase() }, options);
+        if (!cancellationRefundEvents || cancellationRefundEvents.length === 0) {
+            return null;
+        }
+        return {
+            id: cancellationRefundEvents[0].id,
+            escrowAddress: cancellationRefundEvents[0].escrowAddress,
+            receiver: cancellationRefundEvents[0].receiver,
+            amount: BigInt(cancellationRefundEvents[0].amount),
+            block: Number(cancellationRefundEvents[0].block),
+            timestamp: Number(cancellationRefundEvents[0].timestamp) * 1000,
+            txHash: cancellationRefundEvents[0].txHash,
+        };
+    }
+}
+exports.EscrowUtils = EscrowUtils;
+function mapEscrow(e, chainId) {
+    return {
+        id: e.id,
+        address: e.address,
+        amountPaid: BigInt(e.amountPaid),
+        balance: BigInt(e.balance),
+        count: Number(e.count),
+        factoryAddress: e.factoryAddress,
+        finalResultsUrl: e.finalResultsUrl,
+        finalResultsHash: e.finalResultsHash,
+        intermediateResultsUrl: e.intermediateResultsUrl,
+        intermediateResultsHash: e.intermediateResultsHash,
+        launcher: e.launcher,
+        jobRequesterId: e.jobRequesterId,
+        manifestHash: e.manifestHash,
+        manifest: e.manifest,
+        recordingOracle: e.recordingOracle,
+        reputationOracle: e.reputationOracle,
+        exchangeOracle: e.exchangeOracle,
+        recordingOracleFee: e.recordingOracleFee
+            ? Number(e.recordingOracleFee)
+            : null,
+        reputationOracleFee: e.reputationOracleFee
+            ? Number(e.reputationOracleFee)
+            : null,
+        exchangeOracleFee: e.exchangeOracleFee ? Number(e.exchangeOracleFee) : null,
+        status: e.status,
+        token: e.token,
+        totalFundedAmount: BigInt(e.totalFundedAmount),
+        createdAt: Number(e.createdAt) * 1000,
+        chainId: Number(chainId),
+    };
+}

package/dist/escrow/index.d.ts

@@ -0,0 +1,3 @@
+export { EscrowClient } from './escrow_client';
+export { EscrowUtils } from './escrow_utils';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/escrow/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/escrow/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EscrowUtils = exports.EscrowClient = void 0;
+var escrow_client_1 = require("./escrow_client");
+Object.defineProperty(exports, "EscrowClient", { enumerable: true, get: function () { return escrow_client_1.EscrowClient; } });
+var escrow_utils_1 = require("./escrow_utils");
+Object.defineProperty(exports, "EscrowUtils", { enumerable: true, get: function () { return escrow_utils_1.EscrowUtils; } });

package/dist/graphql/queries/statistics.d.ts

@@ -2,4 +2,5 @@ import { IStatisticsFilter } from '../../interfaces';
 export declare const GET_HMTOKEN_STATISTICS_QUERY: import("graphql").DocumentNode;
 export declare const GET_ESCROW_STATISTICS_QUERY: import("graphql").DocumentNode;
 export declare const GET_EVENT_DAY_DATA_QUERY: (params: IStatisticsFilter) => import("graphql").DocumentNode;
+export declare const GET_HMT_EVENT_DAY_DATA_QUERY: (params: IStatisticsFilter) => import("graphql").DocumentNode;
 //# sourceMappingURL=statistics.d.ts.map

package/dist/graphql/queries/statistics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../src/graphql/queries/statistics.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAqDrD,eAAO,MAAM,4BAA4B,gCAOxC,CAAC;AAIF,eAAO,MAAM,2BAA2B,gCAOvC,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,iBAAiB,mCA6BjE,CAAC"}
+{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["../../../src/graphql/queries/statistics.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AA0DrD,eAAO,MAAM,4BAA4B,gCAOxC,CAAC;AAIF,eAAO,MAAM,2BAA2B,gCAOvC,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,QAAQ,iBAAiB,mCA6BjE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,QAAQ,iBAAiB,mCA6BrE,CAAC"}

package/dist/graphql/queries/statistics.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GET_EVENT_DAY_DATA_QUERY = exports.GET_ESCROW_STATISTICS_QUERY = exports.GET_HMTOKEN_STATISTICS_QUERY = void 0;
+exports.GET_HMT_EVENT_DAY_DATA_QUERY = exports.GET_EVENT_DAY_DATA_QUERY = exports.GET_ESCROW_STATISTICS_QUERY = exports.GET_HMTOKEN_STATISTICS_QUERY = void 0;
 const graphql_tag_1 = __importDefault(require("graphql-tag"));
 const HMTOKEN_STATISTICS_FRAGMENT = (0, graphql_tag_1.default) `
   fragment HMTokenStatisticsFields on HMTokenStatistics {
@@ -44,7 +44,11 @@ const EVENT_DAY_DATA_FRAGMENT = (0, graphql_tag_1.default) `
     dailyEscrowCount
     dailyWorkerCount
     dailyPayoutCount
-    dailyHMTPayoutAmount
+  }
+`;
+const HMT_EVENT_DAY_DATA_FRAGMENT = (0, graphql_tag_1.default) `
+  fragment HMTEventDayDataFields on EventDayData {
+    timestamp
     dailyHMTTransferCount
     dailyHMTTransferAmount
     dailyUniqueSenders
@@ -99,3 +103,33 @@ const GET_EVENT_DAY_DATA_QUERY = (params) => {
   `;
 };
 exports.GET_EVENT_DAY_DATA_QUERY = GET_EVENT_DAY_DATA_QUERY;
+const GET_HMT_EVENT_DAY_DATA_QUERY = (params) => {
+    const { from, to } = params;
+    const WHERE_CLAUSE = `
+    where: {
+      ${from !== undefined ? `timestamp_gte: $from` : ''}
+      ${to !== undefined ? `timestamp_lte: $to` : ''}
+    }
+  `;
+    return (0, graphql_tag_1.default) `
+    query GetHMTDayData(
+        $from: Int, 
+        $to: Int,
+        $orderDirection: String
+        $first: Int
+        $skip: Int
+    ) {
+      eventDayDatas(
+        ${WHERE_CLAUSE},
+        orderBy: timestamp,
+        orderDirection: $orderDirection,
+        first: $first,
+        skip: $skip
+      ) {
+        ...HMTEventDayDataFields
+      }
+    }
+    ${HMT_EVENT_DAY_DATA_FRAGMENT}
+  `;
+};
+exports.GET_HMT_EVENT_DAY_DATA_QUERY = GET_HMT_EVENT_DAY_DATA_QUERY;

package/dist/graphql/types.d.ts

@@ -88,7 +88,9 @@ export type EventDayData = {
     dailyEscrowCount: string;
     dailyWorkerCount: string;
     dailyPayoutCount: string;
-    dailyHMTPayoutAmount: string;
+};
+export type HMTEventDayData = {
+    timestamp: string;
     dailyHMTTransferCount: string;
     dailyHMTTransferAmount: string;
     dailyUniqueSenders: string;