@bosonprotocol/core-sdk 1.16.0-alpha.8 → 1.16.0

package/dist/esm/utils/errors.js

@@ -0,0 +1,8 @@
+export class ApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/esm/utils/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../src/utils/errors.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,QAAS,SAAQ,KAAK;IACd;IAAnB,YAAmB,MAAc,EAAE,OAAe;QAChD,KAAK,CAAC,OAAO,CAAC,CAAC;QADE,WAAM,GAAN,MAAM,CAAQ;IAEjC,CAAC;CACF"}

package/dist/esm/utils/graphql.d.ts

@@ -16,9 +16,15 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         exchangesOrderBy?: import("../subgraph").Exchange_OrderBy;
         exchangesOrderDirection?: import("../subgraph").OrderDirection;
         exchangesFilter?: import("../subgraph").Exchange_Filter;
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
         includeExchanges?: boolean;
         includeOffers?: boolean;
         includeFunds?: boolean;
+        includeLogs?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetSellerByIdQueryQuery>;
     getSellersQuery(variables?: import("../subgraph").Exact<{
         sellersSkip?: number;
@@ -41,9 +47,15 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         exchangesOrderBy?: import("../subgraph").Exchange_OrderBy;
         exchangesOrderDirection?: import("../subgraph").OrderDirection;
         exchangesFilter?: import("../subgraph").Exchange_Filter;
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
         includeExchanges?: boolean;
         includeOffers?: boolean;
         includeFunds?: boolean;
+        includeLogs?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetSellersQueryQuery>;
     getBuyerByIdQuery(variables: import("../subgraph").Exact<{
         buyerId: string;
@@ -57,8 +69,14 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         exchangesOrderBy?: import("../subgraph").Exchange_OrderBy;
         exchangesOrderDirection?: import("../subgraph").OrderDirection;
         exchangesFilter?: import("../subgraph").Exchange_Filter;
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
         includeExchanges?: boolean;
         includeFunds?: boolean;
+        includeLogs?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetBuyerByIdQueryQuery>;
     getBuyersQuery(variables?: import("../subgraph").Exact<{
         buyersSkip?: number;
@@ -81,9 +99,15 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         exchangesOrderBy?: import("../subgraph").Exchange_OrderBy;
         exchangesOrderDirection?: import("../subgraph").OrderDirection;
         exchangesFilter?: import("../subgraph").Exchange_Filter;
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
         includeExchanges?: boolean;
         includeOffers?: boolean;
         includeFunds?: boolean;
+        includeLogs?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetBuyersQueryQuery>;
     getDisputeResolverByIdQuery(variables: import("../subgraph").Exact<{
         disputeResolverId: string;
@@ -92,7 +116,13 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         offersOrderBy?: import("../subgraph").Offer_OrderBy;
         offersOrderDirection?: import("../subgraph").OrderDirection;
         offersFilter?: import("../subgraph").Offer_Filter;
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
         includeOffers?: boolean;
+        includeLogs?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetDisputeResolverByIdQueryQuery>;
     getDisputeResolversQuery(variables?: import("../subgraph").Exact<{
         disputeResolversSkip?: number;
@@ -105,7 +135,13 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         offersOrderBy?: import("../subgraph").Offer_OrderBy;
         offersOrderDirection?: import("../subgraph").OrderDirection;
         offersFilter?: import("../subgraph").Offer_Filter;
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
         includeOffers?: boolean;
+        includeLogs?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetDisputeResolversQueryQuery>;
     getDisputeByIdQuery(variables: import("../subgraph").Exact<{
         disputeId: string;
@@ -162,6 +198,13 @@ export declare function getSubgraphSdk(subgraphUrl: string): {
         fundsFilter?: import("../subgraph").FundsEntity_Filter;
         includeFunds?: boolean;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetExchangeTokensQueryQuery>;
+    getEventLogsQuery(variables?: import("../subgraph").Exact<{
+        logsSkip?: number;
+        logsFirst?: number;
+        logsOrderBy?: import("../subgraph").EventLog_OrderBy;
+        logsOrderDirection?: import("../subgraph").OrderDirection;
+        logsFilter?: import("../subgraph").EventLog_Filter;
+    }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetEventLogsQueryQuery>;
     getExchangeByIdQuery(variables: import("../subgraph").Exact<{
         exchangeId: string;
     }>, requestHeaders?: Record<string, string> | import("graphql-request/dist/types.dom").Headers | string[][]): Promise<import("../subgraph").GetExchangeByIdQueryQuery>;

package/dist/esm/utils/graphql.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/utils/graphql.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD"}
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/utils/graphql.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bosonprotocol/core-sdk",
-  "version": "1.16.0-alpha.8",
+  "version": "1.16.0",
   "description": "> TODO: description",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
@@ -33,7 +33,7 @@
     "access": "restricted"
   },
   "dependencies": {
-    "@bosonprotocol/common": "^1.12.0-alpha.10",
+    "@bosonprotocol/common": "^1.12.0",
     "@ethersproject/abi": "^5.5.0",
     "@ethersproject/address": "^5.5.0",
     "@ethersproject/bignumber": "^5.5.0",
@@ -54,5 +54,5 @@
     "ts-jest": "^27.1.3",
     "typescript": "^4.5.5"
   },
-  "gitHead": "d73b097b552a2b6128b9aa82f6c3759a98c6aee3"
+  "gitHead": "8678a1542dcdeec7991c9fcb99525ba7102d74a3"
 }

package/src/accounts/queries.graphql

@@ -15,9 +15,15 @@ query getSellerByIdQuery(
   $exchangesOrderBy: Exchange_orderBy
   $exchangesOrderDirection: OrderDirection
   $exchangesFilter: Exchange_filter
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
   $includeExchanges: Boolean = false
   $includeOffers: Boolean = false
   $includeFunds: Boolean = false
+  $includeLogs: Boolean = false
 ) {
   seller(id: $sellerId) {
     ...SellerFields
@@ -45,9 +51,15 @@ query getSellersQuery(
   $exchangesOrderBy: Exchange_orderBy
   $exchangesOrderDirection: OrderDirection
   $exchangesFilter: Exchange_filter
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
   $includeExchanges: Boolean = false
   $includeOffers: Boolean = false
   $includeFunds: Boolean = false
+  $includeLogs: Boolean = false
 ) {
   sellers(
     skip: $sellersSkip
@@ -72,8 +84,14 @@ query getBuyerByIdQuery(
   $exchangesOrderBy: Exchange_orderBy
   $exchangesOrderDirection: OrderDirection
   $exchangesFilter: Exchange_filter
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
   $includeExchanges: Boolean = false
   $includeFunds: Boolean = false
+  $includeLogs: Boolean = false
 ) {
   buyer(id: $buyerId) {
     ...BuyerFields
@@ -101,9 +119,15 @@ query getBuyersQuery(
   $exchangesOrderBy: Exchange_orderBy
   $exchangesOrderDirection: OrderDirection
   $exchangesFilter: Exchange_filter
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
   $includeExchanges: Boolean = false
   $includeOffers: Boolean = false
   $includeFunds: Boolean = false
+  $includeLogs: Boolean = false
 ) {
   buyers(
     skip: $buyersSkip
@@ -123,7 +147,13 @@ query getDisputeResolverByIdQuery(
   $offersOrderBy: Offer_orderBy
   $offersOrderDirection: OrderDirection
   $offersFilter: Offer_filter
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
   $includeOffers: Boolean = false
+  $includeLogs: Boolean = false
 ) {
   disputeResolver(id: $disputeResolverId) {
     ...DisputeResolverFields
@@ -141,7 +171,13 @@ query getDisputeResolversQuery(
   $offersOrderBy: Offer_orderBy
   $offersOrderDirection: OrderDirection
   $offersFilter: Offer_filter
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
   $includeOffers: Boolean = false
+  $includeLogs: Boolean = false
 ) {
   disputeResolvers(
     skip: $disputeResolversSkip
@@ -183,6 +219,15 @@ fragment SellerFields on Seller {
   ) @include(if: $includeExchanges) {
     ...BaseExchangeFields
   }
+  logs(
+    skip: $logsSkip
+    first: $logsFirst
+    orderBy: $logsOrderBy
+    orderDirection: $logsOrderDirection
+    where: $logsFilter
+  ) @include(if: $includeLogs) {
+    ...BaseEventLogFields
+  }
 }
 
 fragment BaseSellerFields on Seller {
@@ -217,6 +262,15 @@ fragment BuyerFields on Buyer {
   ) @include(if: $includeExchanges) {
     ...BaseExchangeFields
   }
+  logs(
+    skip: $logsSkip
+    first: $logsFirst
+    orderBy: $logsOrderBy
+    orderDirection: $logsOrderDirection
+    where: $logsFilter
+  ) @include(if: $includeLogs) {
+    ...BaseEventLogFields
+  }
 }
 
 fragment BaseBuyerFields on Buyer {
@@ -236,6 +290,15 @@ fragment DisputeResolverFields on DisputeResolver {
   ) @include(if: $includeOffers) {
     ...BaseOfferFields
   }
+  logs(
+    skip: $logsSkip
+    first: $logsFirst
+    orderBy: $logsOrderBy
+    orderDirection: $logsOrderDirection
+    where: $logsFilter
+  ) @include(if: $includeLogs) {
+    ...BaseEventLogFields
+  }
 }
 
 fragment BaseDisputeResolverFields on DisputeResolver {

package/src/core-sdk.ts

@@ -5,12 +5,14 @@ import {
   getDefaultConfig,
   MetadataStorage,
   AnyMetadata,
-  Log
+  Log,
+  MetaTxConfig
 } from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { AddressZero } from "@ethersproject/constants";
 import { BytesLike } from "@ethersproject/bytes";
 import { EnvironmentType } from "@bosonprotocol/common/src/types";
+import { ContractTransaction } from "ethers";
 
 import * as accounts from "./accounts";
 import * as disputes from "./disputes";
@@ -22,6 +24,7 @@ import * as funds from "./funds";
 import * as metaTx from "./meta-tx";
 import * as metadata from "./metadata";
 import * as subgraph from "./subgraph";
+import * as eventLogs from "./event-logs";
 
 import { getValueFromLogs } from "./utils/logs";
 
@@ -35,6 +38,8 @@ export class CoreSDK {
   private _chainId: number;
   private _tokenInfoManager: TokenInfoManager;
 
+  private _metaTxConfig?: Partial<MetaTxConfig>;
+
   /**
    * Creates an instance of `CoreSDK`
    * @param args - Constructor args
@@ -46,6 +51,7 @@ export class CoreSDK {
     metadataStorage?: MetadataStorage;
     theGraphStorage?: MetadataStorage;
     chainId: number;
+    metaTx?: Partial<MetaTxConfig>;
   }) {
     this._web3Lib = opts.web3Lib;
     this._subgraphUrl = opts.subgraphUrl;
@@ -53,6 +59,7 @@ export class CoreSDK {
     this._metadataStorage = opts.metadataStorage;
     this._theGraphStorage = opts.theGraphStorage;
     this._chainId = opts.chainId;
+    this._metaTxConfig = opts.metaTx;
   }
 
   /**
@@ -76,6 +83,7 @@ export class CoreSDK {
     envName: EnvironmentType;
     metadataStorage?: MetadataStorage;
     theGraphStorage?: MetadataStorage;
+    metaTx?: Partial<MetaTxConfig>;
   }) {
     const defaultConfig = getDefaultConfig(args.envName);
 
@@ -85,10 +93,27 @@ export class CoreSDK {
       theGraphStorage: args.theGraphStorage,
       subgraphUrl: defaultConfig.subgraphUrl,
       protocolDiamond: defaultConfig.contracts.protocolDiamond,
-      chainId: defaultConfig.chainId
+      chainId: defaultConfig.chainId,
+      metaTx: {
+        ...defaultConfig.metaTx,
+        ...args.metaTx
+      }
     });
   }
 
+  public get metaTxConfig() {
+    return this._metaTxConfig;
+  }
+
+  public get isMetaTxConfigSet() {
+    return (
+      !!this._metaTxConfig &&
+      !!this._metaTxConfig.apiId &&
+      !!this._metaTxConfig.apiKey &&
+      !!this._metaTxConfig.relayerUrl
+    );
+  }
+
   /* -------------------------------------------------------------------------- */
   /*                          Metadata related methods                          */
   /* -------------------------------------------------------------------------- */
@@ -979,6 +1004,23 @@ export class CoreSDK {
     });
   }
 
+  /**
+   * Completes a batch of existing vouchers by calling the `ExchangeHandlerContract`.
+   * Callable by buyer or seller operator.
+   * @param exchangeIds - IDs of exchange to complete.
+   * @returns Transaction response.
+   */
+  public async completeExchangeBatch(
+    exchangeIds: BigNumberish[]
+  ): Promise<TransactionResponse> {
+    return exchanges.handler.completeExchangeBatch({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeIds,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
   /**
    * Expires an existing voucher by calling the `ExchangeHandlerContract`.
    * @param exchangeId - ID of exchange to expire.
@@ -1388,4 +1430,77 @@ export class CoreSDK {
       ...args
     });
   }
+
+  /**
+   * Relay a meta transaction,
+   * @param metaTxParams - Required params for meta transaction.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async relayMetaTransaction(
+    metaTxParams: {
+      functionName: string;
+      functionSignature: BytesLike;
+      nonce: BigNumberish;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+    },
+    overrides: Partial<{
+      userAddress: string;
+      contractAddress: string;
+      metaTxConfig: Partial<MetaTxConfig>;
+    }> = {}
+  ): Promise<ContractTransaction> {
+    const metaTxRelayerUrl =
+      this._metaTxConfig?.relayerUrl || overrides.metaTxConfig?.relayerUrl;
+    const metaTxApiKey =
+      this._metaTxConfig?.apiKey || overrides.metaTxConfig?.apiKey;
+    const metaTxApiId =
+      this._metaTxConfig?.apiId || overrides.metaTxConfig?.apiId;
+
+    if (!this.isMetaTxConfigSet) {
+      throw new Error(
+        "CoreSDK not configured to relay meta transactions. Either pass in 'relayerUrl', 'apiKey' and 'apiId' during initialization OR as overrides arguments."
+      );
+    }
+
+    return metaTx.handler.relayMetaTransaction({
+      web3LibAdapter: this._web3Lib,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      chainId: this._chainId,
+      metaTx: {
+        config: {
+          relayerUrl: metaTxRelayerUrl,
+          apiId: metaTxApiId,
+          apiKey: metaTxApiKey
+        },
+        params: {
+          userAddress:
+            overrides.userAddress || (await this._web3Lib.getSignerAddress()),
+          functionName: metaTxParams.functionName,
+          functionSignature: metaTxParams.functionSignature,
+          nonce: metaTxParams.nonce,
+          sigR: metaTxParams.sigR,
+          sigS: metaTxParams.sigS,
+          sigV: metaTxParams.sigV
+        }
+      }
+    });
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                                 Event logs                                 */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Returns event logs from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Event log entities from subgraph.
+   */
+  public async getEventLogs(
+    queryVars?: subgraph.GetEventLogsQueryQueryVariables
+  ) {
+    return eventLogs.subgraph.getEventLogs(this._subgraphUrl, queryVars);
+  }
 }

package/src/disputes/queries.graphql

@@ -32,6 +32,15 @@ query getDisputesQuery(
 
 fragment DisputeFields on Dispute {
   ...BaseDisputeFields
+  exchange {
+    ...BaseExchangeFields
+  }
+  seller {
+    ...BaseSellerFields
+  }
+  buyer {
+    ...BaseBuyerFields
+  }
 }
 
 fragment BaseDisputeFields on Dispute {
@@ -47,13 +56,4 @@ fragment BaseDisputeFields on Dispute {
   decidedDate
   refusedDate
   timeout
-  exchange {
-    ...BaseExchangeFields
-  }
-  seller {
-    ...BaseSellerFields
-  }
-  buyer {
-    ...BaseBuyerFields
-  }
 }

package/src/event-logs/index.ts

@@ -0,0 +1 @@
+export * as subgraph from "./subgraph";

package/src/event-logs/queries.graphql

@@ -0,0 +1,53 @@
+query getEventLogsQuery(
+  $logsSkip: Int
+  $logsFirst: Int
+  $logsOrderBy: EventLog_orderBy
+  $logsOrderDirection: OrderDirection
+  $logsFilter: EventLog_filter
+) {
+  eventLogs(
+    skip: $logsSkip
+    first: $logsFirst
+    orderBy: $logsOrderBy
+    orderDirection: $logsOrderDirection
+    where: $logsFilter
+  ) {
+    ...BaseEventLogFields
+  }
+}
+
+fragment BaseEventLogFields on EventLog {
+  id
+  hash
+  type
+  timestamp
+  executedBy
+
+  account {
+    id
+  }
+
+  ... on OfferEventLog {
+    offer {
+      id
+    }
+  }
+
+  ... on ExchangeEventLog {
+    exchange {
+      id
+    }
+  }
+
+  ... on FundsEventLog {
+    funds {
+      id
+    }
+  }
+
+  ... on DisputeEventLog {
+    dispute {
+      id
+    }
+  }
+}

package/src/event-logs/subgraph.ts

@@ -0,0 +1,14 @@
+import { getSubgraphSdk } from "../utils/graphql";
+import {
+  GetEventLogsQueryQueryVariables,
+  BaseEventLogFieldsFragment
+} from "../subgraph";
+
+export async function getEventLogs(
+  subgraphUrl: string,
+  queryVars: GetEventLogsQueryQueryVariables = {}
+): Promise<BaseEventLogFieldsFragment[]> {
+  const subgraphSdk = getSubgraphSdk(subgraphUrl);
+  const { eventLogs = [] } = await subgraphSdk.getEventLogsQuery(queryVars);
+  return eventLogs;
+}

package/src/exchanges/handler.ts

@@ -5,12 +5,13 @@ import {
   encodeCancelVoucher,
   encodeCommitToOffer,
   encodeCompleteExchange,
+  encodeCompleteExchangeBatch,
   encodeRevokeVoucher,
   encodeExpireVoucher,
   encodeRedeemVoucher
 } from "./interface";
 import { getOfferById } from "../offers/subgraph";
-import { getExchangeById } from "../exchanges/subgraph";
+import { getExchangeById, getExchanges } from "../exchanges/subgraph";
 import { ExchangeFieldsFragment, ExchangeState } from "../subgraph";
 
 type BaseExchangeHandlerArgs = {
@@ -65,31 +66,35 @@ export async function completeExchange(
     args.web3Lib.getSignerAddress()
   ]);
 
-  assertExchange(args.exchangeId, exchange);
+  assertCompletableExchange(args.exchangeId, exchange, signerAddress);
 
-  const { isSignerOperator } = assertSignerIsBuyerOrOperator(
-    signerAddress,
-    exchange
-  );
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCompleteExchange(args.exchangeId)
+  });
+}
 
-  if (isSignerOperator) {
-    const elapsedSinceRedeemMS =
-      Date.now() - Number(exchange.redeemedDate || "0") * 1000;
-    const didFulfillmentPeriodElapse =
-      elapsedSinceRedeemMS >
-      Number(exchange.offer.fulfillmentPeriodDuration) * 1000;
-    if (!didFulfillmentPeriodElapse) {
-      throw new Error(
-        `Fulfillment period of ${
-          Number(exchange.offer.fulfillmentPeriodDuration) * 1000
-        } ms did not elapsed since redeem.`
-      );
-    }
+export async function completeExchangeBatch(
+  args: BaseExchangeHandlerArgs & {
+    exchangeIds: BigNumberish[];
+  }
+) {
+  const [exchanges, signerAddress] = await Promise.all([
+    getExchanges(args.subgraphUrl, {
+      exchangesFilter: {
+        id_in: args.exchangeIds.map((id) => id.toString())
+      }
+    }),
+    args.web3Lib.getSignerAddress()
+  ]);
+
+  for (const exchange of exchanges) {
+    assertCompletableExchange(exchange.id, exchange, signerAddress);
   }
 
   return args.web3Lib.sendTransaction({
     to: args.contractAddress,
-    data: encodeCompleteExchange(args.exchangeId)
+    data: encodeCompleteExchangeBatch(args.exchangeIds)
   });
 }
 
@@ -238,3 +243,28 @@ function assertSignerIsBuyerOrOperator(
 
   return { isSignerBuyer, isSignerOperator };
 }
+
+function assertCompletableExchange(
+  exchangeId: BigNumberish,
+  exchange: ExchangeFieldsFragment | null,
+  signer: string
+) {
+  assertExchange(exchangeId, exchange);
+
+  const { isSignerOperator } = assertSignerIsBuyerOrOperator(signer, exchange);
+
+  if (isSignerOperator) {
+    const elapsedSinceRedeemMS =
+      Date.now() - Number(exchange.redeemedDate || "0") * 1000;
+    const didFulfillmentPeriodElapse =
+      elapsedSinceRedeemMS >
+      Number(exchange.offer.fulfillmentPeriodDuration) * 1000;
+    if (!didFulfillmentPeriodElapse) {
+      throw new Error(
+        `Fulfillment period of ${
+          Number(exchange.offer.fulfillmentPeriodDuration) * 1000
+        } ms did not elapsed since redeem.`
+      );
+    }
+  }
+}

package/src/exchanges/interface.ts

@@ -19,6 +19,12 @@ export function encodeCompleteExchange(exchangeId: BigNumberish) {
   ]);
 }
 
+export function encodeCompleteExchangeBatch(exchangeIds: BigNumberish[]) {
+  return bosonExchangeHandlerIface.encodeFunctionData("completeExchangeBatch", [
+    exchangeIds
+  ]);
+}
+
 export function encodeRevokeVoucher(exchangeId: BigNumberish) {
   return bosonExchangeHandlerIface.encodeFunctionData("revokeVoucher", [
     exchangeId