@bosonprotocol/core-sdk 1.32.0 → 1.33.0-alpha.1

package/src/offers/mixin.ts

@@ -11,11 +11,17 @@ import {
   TransactionResponse,
   Log,
   TokenType,
-  EvaluationMethod
+  EvaluationMethod,
+  GatingType
 } from "@bosonprotocol/common";
+import groupBy from "lodash/groupBy";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { getValueFromLogs, getValuesFromLogs } from "../utils/logs";
 import { ITokenInfo, TokenInfoManager } from "../utils/tokenInfoManager";
+import { batchTasks } from "../utils/promises";
+import { ExchangesMixin } from "../exchanges/mixin";
+import { EventLogsMixin } from "../event-logs/mixin";
+import { MetadataMixin } from "../metadata/mixin";
 
 export class OfferMixin extends BaseCoreSDK {
   /* -------------------------------------------------------------------------- */
@@ -405,53 +411,231 @@ export class OfferMixin extends BaseCoreSDK {
   }
 
   public async checkTokenGatedCondition(
-    offerCondition: subgraph.OfferFieldsFragment["condition"],
+    offerId: subgraph.OfferFieldsFragment["id"],
     buyerAddress: string
   ): Promise<boolean> {
+    const offer = await this.getOfferById(offerId);
+
+    if (!offer?.condition) {
+      return true;
+    }
+    const getCanTokenIdBeUsedToCommit = async (): Promise<
+      (tokenId: string) => boolean
+    > => {
+      const conditionalCommitLogs = await (
+        this as unknown as EventLogsMixin
+      ).getConditionalCommitAuthorizedEventLogs({
+        conditionalCommitAuthorizedLogsFilter: {
+          groupId: offer.condition.id, // all offers of the same product have the same condition.id
+          buyerAddress
+        }
+      });
+
+      const tokenIdMapWithMultipleEntries = groupBy(
+        conditionalCommitLogs,
+        (log) => log.tokenId
+      );
+      type TokenId = string;
+      // build a map of tokenId -> log with the min available commits (or the most recent log) in all the logs
+      const tokenIdToAvailableCommitsMap = new Map<
+        TokenId,
+        subgraph.BaseConditionalCommitAuthorizedEventLogsFieldsFragment
+      >();
+      Object.entries(tokenIdMapWithMultipleEntries).forEach(
+        ([tokenId, logs]) => {
+          let logWithMinAvailableCommits = logs[0];
+          for (const log of logs) {
+            const currentAvailableCommits =
+              Number(log.maxCommits) - Number(log.commitCount);
+            const savedAvailableCommits =
+              Number(logWithMinAvailableCommits.maxCommits) -
+              Number(logWithMinAvailableCommits.commitCount);
+            if (currentAvailableCommits < savedAvailableCommits) {
+              logWithMinAvailableCommits = log;
+            }
+          }
+          tokenIdToAvailableCommitsMap.set(tokenId, logWithMinAvailableCommits);
+        }
+      );
+      const canTokenIdBeUsedToCommit = (tokenId: TokenId): boolean => {
+        if (!tokenIdToAvailableCommitsMap.has(tokenId)) {
+          return true;
+        }
+        const log = tokenIdToAvailableCommitsMap.get(tokenId);
+        return Number(log.maxCommits) - Number(log.commitCount) > 0;
+      };
+      return canTokenIdBeUsedToCommit;
+    };
+
+    const getCurrentCommits = async (): Promise<number> => {
+      const exchanges = await (this as unknown as ExchangesMixin).getExchanges({
+        exchangesFilter: {
+          buyer: buyerAddress,
+          offer_: {
+            condition: offer.condition.id
+          }
+        }
+      });
+
+      const currentCommits = exchanges.length;
+      return currentCommits;
+    };
+
+    const concurrencyLimit = 5;
     const {
-      minTokenId: tokenId,
+      minTokenId: _minTokenId,
+      maxTokenId: _maxTokenId,
       tokenType,
       threshold,
       method,
-      tokenAddress
-    } = offerCondition;
+      tokenAddress,
+      gatingType,
+      maxCommits: _maxCommits
+    } = offer.condition;
+    const maxCommits = Number(_maxCommits);
+
     if (tokenType === TokenType.FungibleToken) {
       const balance: string = await erc20.handler.balanceOf({
         contractAddress: tokenAddress,
         owner: buyerAddress,
         web3Lib: this._web3Lib
       });
-      return BigNumber.from(balance).gte(threshold);
+      if (!BigNumber.from(balance).gte(threshold)) {
+        return false;
+      }
+      const currentCommits = await getCurrentCommits();
+      return currentCommits < maxCommits;
     }
+
+    const minTokenId = Number(_minTokenId);
+    const maxTokenId = Number(_maxTokenId);
+
     if (tokenType === TokenType.NonFungibleToken) {
-      if (method === EvaluationMethod.Threshold) {
-        const balance: string = await erc721.handler.balanceOf({
-          contractAddress: tokenAddress,
-          owner: buyerAddress,
-          web3Lib: this._web3Lib
-        });
-        return BigNumber.from(balance).gte(threshold);
+      if (gatingType === GatingType.PerAddress) {
+        if (method === EvaluationMethod.Threshold) {
+          const balance: string = await erc721.handler.balanceOf({
+            contractAddress: tokenAddress,
+            owner: buyerAddress,
+            web3Lib: this._web3Lib
+          });
+          if (!BigNumber.from(balance).gte(threshold)) {
+            return false;
+          }
+          const currentCommits = await getCurrentCommits();
+          return currentCommits < maxCommits;
+        }
+        if (method === EvaluationMethod.TokenRange) {
+          const promises: (() => Promise<string>)[] = [];
+          for (let i = minTokenId; i <= maxTokenId; i++) {
+            const tokenId = i;
+            promises.push(() =>
+              erc721.handler.ownerOf({
+                contractAddress: tokenAddress,
+                tokenId,
+                web3Lib: this._web3Lib
+              })
+            );
+          }
+          const currentCommits = await getCurrentCommits();
+          for await (const owners of batchTasks(promises, concurrencyLimit)) {
+            if (owners.some((owner) => owner === buyerAddress)) {
+              return currentCommits < maxCommits;
+            }
+          }
+          return false;
+        }
+        throw new Error(
+          `Unsupported method=${method} for this tokenType=${tokenType} and gatingType=${gatingType}`
+        );
       }
-      if (method === EvaluationMethod.SpecificToken) {
-        const owner: string = await erc721.handler.ownerOf({
-          contractAddress: tokenAddress,
-          tokenId,
-          web3Lib: this._web3Lib
-        });
-        return owner === buyerAddress;
+      if (gatingType === GatingType.PerTokenId) {
+        if (method === EvaluationMethod.TokenRange) {
+          const canTokenIdBeUsedToCommit = await getCanTokenIdBeUsedToCommit();
+          const promises: (() => Promise<string>)[] = [];
+          for (let i = minTokenId; i <= maxTokenId; i++) {
+            const tokenId = i;
+            promises.push(() =>
+              erc721.handler.ownerOf({
+                contractAddress: tokenAddress,
+                tokenId,
+                web3Lib: this._web3Lib
+              })
+            );
+          }
+          let tokenId = minTokenId;
+          for await (const owners of batchTasks(promises, concurrencyLimit)) {
+            if (
+              owners.some((owner) => owner === buyerAddress) &&
+              canTokenIdBeUsedToCommit(tokenId.toString())
+            ) {
+              return true;
+            }
+            tokenId++;
+          }
+          return false;
+        }
+        throw new Error(
+          `Unsupported method=${method} for this tokenType=${tokenType} and gatingType=${gatingType}`
+        );
       }
       throw new Error(
-        `Unsupported method=${method} for this tokenType=${tokenType}`
+        `Unsupported gatingType=${gatingType} for this tokenType=${tokenType}`
       );
     }
     if (tokenType === TokenType.MultiToken) {
-      const balance: string = await erc1155.handler.balanceOf({
-        contractAddress: tokenAddress,
-        tokenId,
-        owner: buyerAddress,
-        web3Lib: this._web3Lib
-      });
-      return BigNumber.from(balance).gte(threshold);
+      if (gatingType === GatingType.PerAddress) {
+        const promises: (() => Promise<string>)[] = [];
+        for (let i = minTokenId; i <= maxTokenId; i++) {
+          const tokenId = i;
+          promises.push(() =>
+            erc1155.handler.balanceOf({
+              contractAddress: tokenAddress,
+              tokenId,
+              owner: buyerAddress,
+              web3Lib: this._web3Lib
+            })
+          );
+        }
+        for await (const balances of batchTasks(promises, concurrencyLimit)) {
+          if (
+            balances.some((balance) => BigNumber.from(balance).gte(threshold))
+          ) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (gatingType === GatingType.PerTokenId) {
+        const canTokenIdBeUsedToCommit = await getCanTokenIdBeUsedToCommit();
+        const promises: (() => Promise<string>)[] = [];
+        for (let i = minTokenId; i <= maxTokenId; i++) {
+          const tokenId = i;
+          promises.push(() =>
+            erc1155.handler.balanceOf({
+              contractAddress: tokenAddress,
+              tokenId,
+              owner: buyerAddress,
+              web3Lib: this._web3Lib
+            })
+          );
+        }
+        let tokenId = minTokenId;
+        for await (const balances of batchTasks(promises, concurrencyLimit)) {
+          if (
+            balances.some((balance) =>
+              BigNumber.from(balance).gte(threshold)
+            ) &&
+            canTokenIdBeUsedToCommit(tokenId.toString())
+          ) {
+            return true;
+          }
+          tokenId++;
+        }
+        return false;
+      }
+      throw new Error(
+        `Unsupported gatingType=${gatingType} for this tokenType=${tokenType}`
+      );
     }
     throw new Error(`Unsupported tokenType=${tokenType}`);
   }

package/src/subgraph.ts

@@ -806,6 +806,172 @@ export enum ConditionEntity_OrderBy {
   TokenType = "tokenType"
 }
 
+export type ConditionalCommitAuthorizedEventLog = {
+  __typename?: "ConditionalCommitAuthorizedEventLog";
+  buyerAddress: Scalars["String"];
+  commitCount: Scalars["BigInt"];
+  gating: Scalars["Int"];
+  groupId: Scalars["String"];
+  hash: Scalars["String"];
+  id: Scalars["ID"];
+  maxCommits: Scalars["BigInt"];
+  offerId: Scalars["String"];
+  timestamp: Scalars["BigInt"];
+  tokenId: Scalars["BigInt"];
+  type: EventType;
+};
+
+export type ConditionalCommitAuthorizedEventLog_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  buyerAddress?: InputMaybe<Scalars["String"]>;
+  buyerAddress_contains?: InputMaybe<Scalars["String"]>;
+  buyerAddress_contains_nocase?: InputMaybe<Scalars["String"]>;
+  buyerAddress_ends_with?: InputMaybe<Scalars["String"]>;
+  buyerAddress_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  buyerAddress_gt?: InputMaybe<Scalars["String"]>;
+  buyerAddress_gte?: InputMaybe<Scalars["String"]>;
+  buyerAddress_in?: InputMaybe<Array<Scalars["String"]>>;
+  buyerAddress_lt?: InputMaybe<Scalars["String"]>;
+  buyerAddress_lte?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not_contains?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not_contains_nocase?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not_ends_with?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not_in?: InputMaybe<Array<Scalars["String"]>>;
+  buyerAddress_not_starts_with?: InputMaybe<Scalars["String"]>;
+  buyerAddress_not_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  buyerAddress_starts_with?: InputMaybe<Scalars["String"]>;
+  buyerAddress_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  commitCount?: InputMaybe<Scalars["BigInt"]>;
+  commitCount_gt?: InputMaybe<Scalars["BigInt"]>;
+  commitCount_gte?: InputMaybe<Scalars["BigInt"]>;
+  commitCount_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  commitCount_lt?: InputMaybe<Scalars["BigInt"]>;
+  commitCount_lte?: InputMaybe<Scalars["BigInt"]>;
+  commitCount_not?: InputMaybe<Scalars["BigInt"]>;
+  commitCount_not_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  gating?: InputMaybe<Scalars["Int"]>;
+  gating_gt?: InputMaybe<Scalars["Int"]>;
+  gating_gte?: InputMaybe<Scalars["Int"]>;
+  gating_in?: InputMaybe<Array<Scalars["Int"]>>;
+  gating_lt?: InputMaybe<Scalars["Int"]>;
+  gating_lte?: InputMaybe<Scalars["Int"]>;
+  gating_not?: InputMaybe<Scalars["Int"]>;
+  gating_not_in?: InputMaybe<Array<Scalars["Int"]>>;
+  groupId?: InputMaybe<Scalars["String"]>;
+  groupId_contains?: InputMaybe<Scalars["String"]>;
+  groupId_contains_nocase?: InputMaybe<Scalars["String"]>;
+  groupId_ends_with?: InputMaybe<Scalars["String"]>;
+  groupId_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  groupId_gt?: InputMaybe<Scalars["String"]>;
+  groupId_gte?: InputMaybe<Scalars["String"]>;
+  groupId_in?: InputMaybe<Array<Scalars["String"]>>;
+  groupId_lt?: InputMaybe<Scalars["String"]>;
+  groupId_lte?: InputMaybe<Scalars["String"]>;
+  groupId_not?: InputMaybe<Scalars["String"]>;
+  groupId_not_contains?: InputMaybe<Scalars["String"]>;
+  groupId_not_contains_nocase?: InputMaybe<Scalars["String"]>;
+  groupId_not_ends_with?: InputMaybe<Scalars["String"]>;
+  groupId_not_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  groupId_not_in?: InputMaybe<Array<Scalars["String"]>>;
+  groupId_not_starts_with?: InputMaybe<Scalars["String"]>;
+  groupId_not_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  groupId_starts_with?: InputMaybe<Scalars["String"]>;
+  groupId_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  hash?: InputMaybe<Scalars["String"]>;
+  hash_contains?: InputMaybe<Scalars["String"]>;
+  hash_contains_nocase?: InputMaybe<Scalars["String"]>;
+  hash_ends_with?: InputMaybe<Scalars["String"]>;
+  hash_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  hash_gt?: InputMaybe<Scalars["String"]>;
+  hash_gte?: InputMaybe<Scalars["String"]>;
+  hash_in?: InputMaybe<Array<Scalars["String"]>>;
+  hash_lt?: InputMaybe<Scalars["String"]>;
+  hash_lte?: InputMaybe<Scalars["String"]>;
+  hash_not?: InputMaybe<Scalars["String"]>;
+  hash_not_contains?: InputMaybe<Scalars["String"]>;
+  hash_not_contains_nocase?: InputMaybe<Scalars["String"]>;
+  hash_not_ends_with?: InputMaybe<Scalars["String"]>;
+  hash_not_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  hash_not_in?: InputMaybe<Array<Scalars["String"]>>;
+  hash_not_starts_with?: InputMaybe<Scalars["String"]>;
+  hash_not_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  hash_starts_with?: InputMaybe<Scalars["String"]>;
+  hash_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  id?: InputMaybe<Scalars["ID"]>;
+  id_gt?: InputMaybe<Scalars["ID"]>;
+  id_gte?: InputMaybe<Scalars["ID"]>;
+  id_in?: InputMaybe<Array<Scalars["ID"]>>;
+  id_lt?: InputMaybe<Scalars["ID"]>;
+  id_lte?: InputMaybe<Scalars["ID"]>;
+  id_not?: InputMaybe<Scalars["ID"]>;
+  id_not_in?: InputMaybe<Array<Scalars["ID"]>>;
+  maxCommits?: InputMaybe<Scalars["BigInt"]>;
+  maxCommits_gt?: InputMaybe<Scalars["BigInt"]>;
+  maxCommits_gte?: InputMaybe<Scalars["BigInt"]>;
+  maxCommits_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  maxCommits_lt?: InputMaybe<Scalars["BigInt"]>;
+  maxCommits_lte?: InputMaybe<Scalars["BigInt"]>;
+  maxCommits_not?: InputMaybe<Scalars["BigInt"]>;
+  maxCommits_not_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  offerId?: InputMaybe<Scalars["String"]>;
+  offerId_contains?: InputMaybe<Scalars["String"]>;
+  offerId_contains_nocase?: InputMaybe<Scalars["String"]>;
+  offerId_ends_with?: InputMaybe<Scalars["String"]>;
+  offerId_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  offerId_gt?: InputMaybe<Scalars["String"]>;
+  offerId_gte?: InputMaybe<Scalars["String"]>;
+  offerId_in?: InputMaybe<Array<Scalars["String"]>>;
+  offerId_lt?: InputMaybe<Scalars["String"]>;
+  offerId_lte?: InputMaybe<Scalars["String"]>;
+  offerId_not?: InputMaybe<Scalars["String"]>;
+  offerId_not_contains?: InputMaybe<Scalars["String"]>;
+  offerId_not_contains_nocase?: InputMaybe<Scalars["String"]>;
+  offerId_not_ends_with?: InputMaybe<Scalars["String"]>;
+  offerId_not_ends_with_nocase?: InputMaybe<Scalars["String"]>;
+  offerId_not_in?: InputMaybe<Array<Scalars["String"]>>;
+  offerId_not_starts_with?: InputMaybe<Scalars["String"]>;
+  offerId_not_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  offerId_starts_with?: InputMaybe<Scalars["String"]>;
+  offerId_starts_with_nocase?: InputMaybe<Scalars["String"]>;
+  timestamp?: InputMaybe<Scalars["BigInt"]>;
+  timestamp_gt?: InputMaybe<Scalars["BigInt"]>;
+  timestamp_gte?: InputMaybe<Scalars["BigInt"]>;
+  timestamp_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  timestamp_lt?: InputMaybe<Scalars["BigInt"]>;
+  timestamp_lte?: InputMaybe<Scalars["BigInt"]>;
+  timestamp_not?: InputMaybe<Scalars["BigInt"]>;
+  timestamp_not_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  tokenId?: InputMaybe<Scalars["BigInt"]>;
+  tokenId_gt?: InputMaybe<Scalars["BigInt"]>;
+  tokenId_gte?: InputMaybe<Scalars["BigInt"]>;
+  tokenId_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  tokenId_lt?: InputMaybe<Scalars["BigInt"]>;
+  tokenId_lte?: InputMaybe<Scalars["BigInt"]>;
+  tokenId_not?: InputMaybe<Scalars["BigInt"]>;
+  tokenId_not_in?: InputMaybe<Array<Scalars["BigInt"]>>;
+  type?: InputMaybe<EventType>;
+  type_in?: InputMaybe<Array<EventType>>;
+  type_not?: InputMaybe<EventType>;
+  type_not_in?: InputMaybe<Array<EventType>>;
+};
+
+export enum ConditionalCommitAuthorizedEventLog_OrderBy {
+  BuyerAddress = "buyerAddress",
+  CommitCount = "commitCount",
+  Gating = "gating",
+  GroupId = "groupId",
+  Hash = "hash",
+  Id = "id",
+  MaxCommits = "maxCommits",
+  OfferId = "offerId",
+  Timestamp = "timestamp",
+  TokenId = "tokenId",
+  Type = "type"
+}
+
 export type Dispute = {
   __typename?: "Dispute";
   buyer: Buyer;
@@ -1598,6 +1764,7 @@ export enum EventType {
   /** ExchangeHandler events */
   BuyerCommitted = "BUYER_COMMITTED",
   BuyerCreated = "BUYER_CREATED",
+  ConditionalCommit = "CONDITIONAL_COMMIT",
   DisputeDecided = "DISPUTE_DECIDED",
   DisputeEscalated = "DISPUTE_ESCALATED",
   DisputeExpired = "DISPUTE_EXPIRED",
@@ -6868,6 +7035,8 @@ export type Query = {
   buyers: Array<Buyer>;
   conditionEntities: Array<ConditionEntity>;
   conditionEntity?: Maybe<ConditionEntity>;
+  conditionalCommitAuthorizedEventLog?: Maybe<ConditionalCommitAuthorizedEventLog>;
+  conditionalCommitAuthorizedEventLogs: Array<ConditionalCommitAuthorizedEventLog>;
   dispute?: Maybe<Dispute>;
   disputeEventLog?: Maybe<DisputeEventLog>;
   disputeEventLogs: Array<DisputeEventLog>;
@@ -7044,6 +7213,22 @@ export type QueryConditionEntityArgs = {
   subgraphError?: _SubgraphErrorPolicy_;
 };
 
+export type QueryConditionalCommitAuthorizedEventLogArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars["ID"];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+export type QueryConditionalCommitAuthorizedEventLogsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars["Int"]>;
+  orderBy?: InputMaybe<ConditionalCommitAuthorizedEventLog_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars["Int"]>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<ConditionalCommitAuthorizedEventLog_Filter>;
+};
+
 export type QueryDisputeArgs = {
   block?: InputMaybe<Block_Height>;
   id: Scalars["ID"];
@@ -8775,6 +8960,8 @@ export type Subscription = {
   buyers: Array<Buyer>;
   conditionEntities: Array<ConditionEntity>;
   conditionEntity?: Maybe<ConditionEntity>;
+  conditionalCommitAuthorizedEventLog?: Maybe<ConditionalCommitAuthorizedEventLog>;
+  conditionalCommitAuthorizedEventLogs: Array<ConditionalCommitAuthorizedEventLog>;
   dispute?: Maybe<Dispute>;
   disputeEventLog?: Maybe<DisputeEventLog>;
   disputeEventLogs: Array<DisputeEventLog>;
@@ -8951,6 +9138,22 @@ export type SubscriptionConditionEntityArgs = {
   subgraphError?: _SubgraphErrorPolicy_;
 };
 
+export type SubscriptionConditionalCommitAuthorizedEventLogArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars["ID"];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+export type SubscriptionConditionalCommitAuthorizedEventLogsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars["Int"]>;
+  orderBy?: InputMaybe<ConditionalCommitAuthorizedEventLog_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars["Int"]>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<ConditionalCommitAuthorizedEventLog_Filter>;
+};
+
 export type SubscriptionDisputeArgs = {
   block?: InputMaybe<Block_Height>;
   id: Scalars["ID"];
@@ -13311,6 +13514,32 @@ export type GetDisputeResolversQueryQuery = {
   }>;
 };
 
+export type GetConditionalCommitAuthorizedEventLogsQueryQueryVariables = Exact<{
+  conditionalCommitAuthorizedLogsSkip?: InputMaybe<Scalars["Int"]>;
+  conditionalCommitAuthorizedLogsFirst?: InputMaybe<Scalars["Int"]>;
+  conditionalCommitAuthorizedLogsOrderBy?: InputMaybe<ConditionalCommitAuthorizedEventLog_OrderBy>;
+  conditionalCommitAuthorizedLogsOrderDirection?: InputMaybe<OrderDirection>;
+  conditionalCommitAuthorizedLogsFilter?: InputMaybe<ConditionalCommitAuthorizedEventLog_Filter>;
+}>;
+
+export type GetConditionalCommitAuthorizedEventLogsQueryQuery = {
+  __typename?: "Query";
+  conditionalCommitAuthorizedEventLogs: Array<{
+    __typename?: "ConditionalCommitAuthorizedEventLog";
+    id: string;
+    hash: string;
+    groupId: string;
+    gating: number;
+    commitCount: string;
+    buyerAddress: string;
+    maxCommits: string;
+    offerId: string;
+    timestamp: string;
+    tokenId: string;
+    type: EventType;
+  }>;
+};
+
 export type SellerFieldsFragment = {
   __typename?: "Seller";
   id: string;
@@ -15251,6 +15480,21 @@ export type BaseDisputeResolutionTermsEntityFieldsFragment = {
   buyerEscalationDeposit: string;
 };
 
+export type BaseConditionalCommitAuthorizedEventLogsFieldsFragment = {
+  __typename?: "ConditionalCommitAuthorizedEventLog";
+  id: string;
+  hash: string;
+  groupId: string;
+  gating: number;
+  commitCount: string;
+  buyerAddress: string;
+  maxCommits: string;
+  offerId: string;
+  timestamp: string;
+  tokenId: string;
+  type: EventType;
+};
+
 export type GetDisputeByIdQueryQueryVariables = Exact<{
   disputeId: Scalars["ID"];
   offersSkip?: InputMaybe<Scalars["Int"]>;
@@ -35404,6 +35648,21 @@ export const DisputeResolverFieldsFragmentDoc = gql`
   ${BaseOfferFieldsFragmentDoc}
   ${BaseEventLogFieldsFragmentDoc}
 `;
+export const BaseConditionalCommitAuthorizedEventLogsFieldsFragmentDoc = gql`
+  fragment BaseConditionalCommitAuthorizedEventLogsFields on ConditionalCommitAuthorizedEventLog {
+    id
+    hash
+    groupId
+    gating
+    commitCount
+    buyerAddress
+    maxCommits
+    offerId
+    timestamp
+    tokenId
+    type
+  }
+`;
 export const DisputeFieldsFragmentDoc = gql`
   fragment DisputeFields on Dispute {
     ...BaseDisputeFields
@@ -35845,6 +36104,26 @@ export const GetDisputeResolversQueryDocument = gql`
   }
   ${DisputeResolverFieldsFragmentDoc}
 `;
+export const GetConditionalCommitAuthorizedEventLogsQueryDocument = gql`
+  query getConditionalCommitAuthorizedEventLogsQuery(
+    $conditionalCommitAuthorizedLogsSkip: Int
+    $conditionalCommitAuthorizedLogsFirst: Int
+    $conditionalCommitAuthorizedLogsOrderBy: ConditionalCommitAuthorizedEventLog_orderBy
+    $conditionalCommitAuthorizedLogsOrderDirection: OrderDirection
+    $conditionalCommitAuthorizedLogsFilter: ConditionalCommitAuthorizedEventLog_filter
+  ) {
+    conditionalCommitAuthorizedEventLogs(
+      skip: $conditionalCommitAuthorizedLogsSkip
+      first: $conditionalCommitAuthorizedLogsFirst
+      orderBy: $conditionalCommitAuthorizedLogsOrderBy
+      orderDirection: $conditionalCommitAuthorizedLogsOrderDirection
+      where: $conditionalCommitAuthorizedLogsFilter
+    ) {
+      ...BaseConditionalCommitAuthorizedEventLogsFields
+    }
+  }
+  ${BaseConditionalCommitAuthorizedEventLogsFieldsFragmentDoc}
+`;
 export const GetDisputeByIdQueryDocument = gql`
   query getDisputeByIdQuery(
     $disputeId: ID!
@@ -36389,6 +36668,21 @@ export function getSdk(
         "query"
       );
     },
+    getConditionalCommitAuthorizedEventLogsQuery(
+      variables?: GetConditionalCommitAuthorizedEventLogsQueryQueryVariables,
+      requestHeaders?: Dom.RequestInit["headers"]
+    ): Promise<GetConditionalCommitAuthorizedEventLogsQueryQuery> {
+      return withWrapper(
+        (wrappedRequestHeaders) =>
+          client.request<GetConditionalCommitAuthorizedEventLogsQueryQuery>(
+            GetConditionalCommitAuthorizedEventLogsQueryDocument,
+            variables,
+            { ...requestHeaders, ...wrappedRequestHeaders }
+          ),
+        "getConditionalCommitAuthorizedEventLogsQuery",
+        "query"
+      );
+    },
     getDisputeByIdQuery(
       variables: GetDisputeByIdQueryQueryVariables,
       requestHeaders?: Dom.RequestInit["headers"]

package/src/utils/promises.ts

@@ -0,0 +1,18 @@
+export async function* batchTasks<T>(
+  tasks: (() => Promise<T>)[],
+  limit: number,
+  taskCallback = (r: T): T => r
+) {
+  // iterate over tasks
+  for (let i = 0; i < tasks.length; i = i + limit) {
+    // grab the batch of tasks for current iteration
+    const batch = tasks.slice(i, i + limit);
+    // wait for them to resolve concurrently
+    const result = await Promise.all(
+      // optionally attach callback to perform any side effects
+      batch.map((task) => task().then((r) => taskCallback(r)))
+    );
+    // yield the batched result and let consumer know
+    yield result;
+  }
+}