@human-protocol/sdk 6.1.0 → 7.1.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;IAsE1B;;;;;;;;;;;;;;;;;;;;;;;;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,394 @@
+"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, escrowAddress, first = 10, skip = 0, orderDirection = enums_1.OrderDirection.DESC, } = filter;
+        if (launcher && !ethers_1.ethers.isAddress(launcher)) {
+            throw error_1.ErrorInvalidAddress;
+        }
+        if (escrowAddress && !ethers_1.ethers.isAddress(escrowAddress)) {
+            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, escrowAddress), {
+            status: statusNames,
+            from: from ? (0, utils_1.getUnixTimestamp)(from) : undefined,
+            to: to ? (0, utils_1.getUnixTimestamp)(to) : undefined,
+            launcher: launcher || undefined,
+            escrowAddress: escrowAddress || 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: event.status,
+            chainId,
+            block: BigInt(event.block),
+            txHash: event.txHash,
+        }));
+    }
+    /**
+     * 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/escrow.d.ts

@@ -1,7 +1,7 @@
 import { ICancellationRefundFilter, IEscrowsFilter } from '../../interfaces';
 export declare const GET_ESCROW_BY_ADDRESS_QUERY: () => import("graphql").DocumentNode;
 export declare const GET_ESCROWS_QUERY: (filter: IEscrowsFilter) => import("graphql").DocumentNode;
-export declare const GET_STATUS_UPDATES_QUERY: (from?: Date, to?: Date, launcher?: string) => import("graphql").DocumentNode;
+export declare const GET_STATUS_UPDATES_QUERY: (from?: Date, to?: Date, launcher?: string, escrowAddress?: string) => import("graphql").DocumentNode;
 export declare const GET_CANCELLATION_REFUNDS_QUERY: (filter: ICancellationRefundFilter) => import("graphql").DocumentNode;
 export declare const GET_CANCELLATION_REFUND_BY_ADDRESS_QUERY: () => import("graphql").DocumentNode;
 //# sourceMappingURL=escrow.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"escrow.d.ts","sourceRoot":"","sources":["../../../src/graphql/queries/escrow.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA2C7E,eAAO,MAAM,2BAA2B,sCAOvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,cAAc,mCAmDvD,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,OAAO,IAAI,EACX,KAAK,IAAI,EACT,WAAW,MAAM,mCAiClB,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,QAAQ,yBAAyB,mCA2BlC,CAAC;AAEF,eAAO,MAAM,wCAAwC,sCAOpD,CAAC"}
+{"version":3,"file":"escrow.d.ts","sourceRoot":"","sources":["../../../src/graphql/queries/escrow.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AA2C7E,eAAO,MAAM,2BAA2B,sCAOvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,cAAc,mCAmDvD,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,OAAO,IAAI,EACX,KAAK,IAAI,EACT,WAAW,MAAM,EACjB,gBAAgB,MAAM,mCAqCvB,CAAC;AAEF,eAAO,MAAM,8BAA8B,GACzC,QAAQ,yBAAyB,mCA2BlC,CAAC;AAEF,eAAO,MAAM,wCAAwC,sCAOpD,CAAC"}

package/dist/graphql/queries/escrow.js

@@ -95,13 +95,14 @@ const GET_ESCROWS_QUERY = (filter) => {
   `;
 };
 exports.GET_ESCROWS_QUERY = GET_ESCROWS_QUERY;
-const GET_STATUS_UPDATES_QUERY = (from, to, launcher) => {
+const GET_STATUS_UPDATES_QUERY = (from, to, launcher, escrowAddress) => {
     const WHERE_CLAUSE = `
     where: {
       status_in: $status
       ${from ? `timestamp_gte: $from` : ''}
       ${to ? `timestamp_lte: $to` : ''}
       ${launcher ? `launcher: $launcher` : ''}
+      ${escrowAddress ? `escrowAddress: $escrowAddress` : ''}
     }
   `;
     return (0, graphql_tag_1.default) `
@@ -110,6 +111,7 @@ const GET_STATUS_UPDATES_QUERY = (from, to, launcher) => {
       $from: Int
       $to: Int
       $launcher: String
+      $escrowAddress: String
       $orderDirection: String
       $first: Int
       $skip: Int
@@ -124,6 +126,8 @@ const GET_STATUS_UPDATES_QUERY = (from, to, launcher) => {
         escrowAddress,
         timestamp,
         status,
+        block,
+        txHash,
       }
     }
   `;

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"}