@bosonprotocol/core-sdk 1.6.0-alpha.9 → 1.6.0

package/src/accounts/queries.graphql

@@ -1,35 +1,107 @@
-query getSellerByOperatorQuery($operator: Bytes!, $fundsTokenAddress: Bytes) {
-  sellers(where: { operator: $operator }) {
+query getSellerByIdQuery(
+  $sellerId: ID!
+  $fundsSkip: Int
+  $fundsFirst: Int
+  $fundsOrderBy: FundsEntity_orderBy
+  $fundsOrderDirection: OrderDirection
+  $fundsFilter: FundsEntity_filter
+  $offersSkip: Int
+  $offersFirst: Int
+  $offersOrderBy: Offer_orderBy
+  $offersOrderDirection: OrderDirection
+  $offersFilter: Offer_filter
+  $exchangesSkip: Int
+  $exchangesFirst: Int
+  $exchangesOrderBy: Exchange_orderBy
+  $exchangesOrderDirection: OrderDirection
+  $exchangesFilter: Exchange_filter
+  $includeExchanges: Boolean = false
+  $includeOffers: Boolean = false
+  $includeFunds: Boolean = false
+) {
+  seller(id: $sellerId) {
     ...SellerFields
   }
 }
 
-query getSellerByAdminQuery($admin: Bytes!, $fundsTokenAddress: Bytes) {
-  sellers(where: { admin: $admin }) {
+query getSellersQuery(
+  $sellersSkip: Int
+  $sellersFirst: Int
+  $sellersOrderBy: Seller_orderBy
+  $sellersOrderDirection: OrderDirection
+  $sellersFilter: Seller_filter
+  $fundsSkip: Int
+  $fundsFirst: Int
+  $fundsOrderBy: FundsEntity_orderBy
+  $fundsOrderDirection: OrderDirection
+  $fundsFilter: FundsEntity_filter
+  $offersSkip: Int
+  $offersFirst: Int
+  $offersOrderBy: Offer_orderBy
+  $offersOrderDirection: OrderDirection
+  $offersFilter: Offer_filter
+  $exchangesSkip: Int
+  $exchangesFirst: Int
+  $exchangesOrderBy: Exchange_orderBy
+  $exchangesOrderDirection: OrderDirection
+  $exchangesFilter: Exchange_filter
+  $includeExchanges: Boolean = false
+  $includeOffers: Boolean = false
+  $includeFunds: Boolean = false
+) {
+  sellers(
+    skip: $sellersSkip
+    first: $sellersFirst
+    orderBy: $sellersOrderBy
+    orderDirection: $sellersOrderDirection
+    where: $sellersFilter
+  ) {
     ...SellerFields
   }
 }
 
-query getSellerByClerkQuery($clerk: Bytes!, $fundsTokenAddress: Bytes) {
-  sellers(where: { clerk: $clerk }) {
-    ...SellerFields
+fragment SellerFields on Seller {
+  ...BaseSellerFields
+  funds(
+    skip: $fundsSkip
+    first: $fundsFirst
+    orderBy: $fundsOrderBy
+    orderDirection: $fundsOrderDirection
+    where: $fundsFilter
+  ) @include(if: $includeFunds) {
+    ...FundsEntityFields
+  }
+  offers(
+    skip: $offersSkip
+    first: $offersFirst
+    orderBy: $offersOrderBy
+    orderDirection: $offersOrderDirection
+    where: $offersFilter
+  ) @include(if: $includeOffers) {
+    ...BaseOfferFields
+  }
+  exchanges(
+    skip: $exchangesSkip
+    first: $exchangesFirst
+    orderBy: $exchangesOrderBy
+    orderDirection: $exchangesOrderDirection
+    where: $exchangesFilter
+  ) @include(if: $includeExchanges) {
+    ...BaseExchangeFields
   }
 }
 
-fragment SellerFields on Seller {
+fragment BaseSellerFields on Seller {
   id
   operator
   admin
   clerk
   treasury
   active
-  funds(where: { tokenAddress: $fundsTokenAddress }) {
-    availableAmount
-    token {
-      address
-      decimals
-      name
-      symbol
-    }
-  }
+}
+
+fragment BaseBuyerFields on Buyer {
+  id
+  wallet
+  active
 }

package/src/accounts/subgraph.ts

@@ -1,57 +1,92 @@
 import { getSubgraphSdk } from "../utils/graphql";
-import { SellerFieldsFragment } from "../subgraph";
+import {
+  SellerFieldsFragment,
+  GetSellersQueryQueryVariables,
+  GetSellerByIdQueryQueryVariables
+} from "../subgraph";
+import { BigNumberish } from "@ethersproject/bignumber";
 
-export async function getSellerByOperator(
+export type SingleSellerQueryVariables = Omit<
+  GetSellerByIdQueryQueryVariables,
+  "sellerId"
+>;
+
+export async function getSellerById(
   subgraphUrl: string,
-  operatorAddress: string,
-  fundsTokenAddress?: string
+  sellerId: BigNumberish,
+  queryVars: SingleSellerQueryVariables = {}
 ): Promise<SellerFieldsFragment> {
   const sdk = getSubgraphSdk(subgraphUrl);
-  const { sellers = [] } = await sdk.getSellerByOperatorQuery({
-    operator: operatorAddress,
-    fundsTokenAddress
+  const { seller } = await sdk.getSellerByIdQuery({
+    sellerId: sellerId.toString(),
+    ...queryVars
   });
+  return seller;
+}
+
+export async function getSellers(
+  subgraphUrl: string,
+  queryVars: GetSellersQueryQueryVariables = {}
+): Promise<SellerFieldsFragment[]> {
+  const sdk = getSubgraphSdk(subgraphUrl);
+  const { sellers = [] } = await sdk.getSellersQuery(queryVars);
+  return sellers;
+}
 
+export async function getSellerByOperator(
+  subgraphUrl: string,
+  operatorAddress: string,
+  queryVars: GetSellersQueryQueryVariables = {}
+): Promise<SellerFieldsFragment | undefined> {
+  const sellers = await getSellers(subgraphUrl, {
+    sellersFilter: {
+      ...queryVars.sellersFilter,
+      operator: operatorAddress.toLowerCase()
+    },
+    ...queryVars
+  });
   return sellers[0];
 }
 
 export async function getSellerByAdmin(
   subgraphUrl: string,
   adminAddress: string,
-  fundsTokenAddress?: string
+  queryVars: GetSellersQueryQueryVariables = {}
 ): Promise<SellerFieldsFragment> {
-  const sdk = getSubgraphSdk(subgraphUrl);
-  const { sellers = [] } = await sdk.getSellerByAdminQuery({
-    admin: adminAddress,
-    fundsTokenAddress
+  const sellers = await getSellers(subgraphUrl, {
+    sellersFilter: {
+      ...queryVars.sellersFilter,
+      admin: adminAddress.toLowerCase()
+    },
+    ...queryVars
   });
-
   return sellers[0];
 }
 
 export async function getSellerByClerk(
   subgraphUrl: string,
   clerkAddress: string,
-  fundsTokenAddress?: string
+  queryVars: GetSellersQueryQueryVariables = {}
 ): Promise<SellerFieldsFragment> {
-  const sdk = getSubgraphSdk(subgraphUrl);
-  const { sellers = [] } = await sdk.getSellerByClerkQuery({
-    clerk: clerkAddress,
-    fundsTokenAddress
+  const sellers = await getSellers(subgraphUrl, {
+    sellersFilter: {
+      ...queryVars.sellersFilter,
+      clerk: clerkAddress.toLowerCase()
+    },
+    ...queryVars
   });
-
   return sellers[0];
 }
 
 export async function getSellerByAddress(
   subgraphUrl: string,
   address: string,
-  fundsTokenAddress?: string
+  queryVars: GetSellersQueryQueryVariables = {}
 ): Promise<SellerFieldsFragment> {
   const [operator, admin, clerk] = await Promise.all([
-    getSellerByOperator(subgraphUrl, address, fundsTokenAddress),
-    getSellerByAdmin(subgraphUrl, address, fundsTokenAddress),
-    getSellerByClerk(subgraphUrl, address, fundsTokenAddress)
+    getSellerByOperator(subgraphUrl, address, queryVars),
+    getSellerByAdmin(subgraphUrl, address, queryVars),
+    getSellerByClerk(subgraphUrl, address, queryVars)
   ]);
 
   return operator || admin || clerk;

package/src/core-sdk.ts

@@ -78,39 +78,56 @@ export class CoreSDK {
     return this._metadataStorage.getMetadata(metadataHashOrUri);
   }
 
+  public async getSellerById(
+    sellerId: BigNumberish,
+    queryVars?: accounts.subgraph.SingleSellerQueryVariables
+  ): Promise<subgraph.SellerFieldsFragment> {
+    return accounts.subgraph.getSellerById(
+      this._subgraphUrl,
+      sellerId,
+      queryVars
+    );
+  }
+
   public async getSellerByOperator(
     operator: string,
-    fundsTokenAddress?: string
+    queryVars?: subgraph.GetSellersQueryQueryVariables
   ): Promise<subgraph.SellerFieldsFragment> {
     return accounts.subgraph.getSellerByOperator(
       this._subgraphUrl,
       operator,
-      fundsTokenAddress
+      queryVars
     );
   }
 
   public async getSellerByClerk(
     clerk: string,
-    fundsTokenAddress?: string
+    queryVars?: subgraph.GetSellersQueryQueryVariables
   ): Promise<subgraph.SellerFieldsFragment> {
     return accounts.subgraph.getSellerByClerk(
       this._subgraphUrl,
       clerk,
-      fundsTokenAddress
+      queryVars
     );
   }
 
   public async getSellerByAddress(
     address: string,
-    fundsTokenAddress?: string
+    queryVars?: subgraph.GetSellersQueryQueryVariables
   ): Promise<subgraph.SellerFieldsFragment> {
     return accounts.subgraph.getSellerByAddress(
       this._subgraphUrl,
       address,
-      fundsTokenAddress
+      queryVars
     );
   }
 
+  public async getSellers(
+    queryVars?: subgraph.GetSellersQueryQueryVariables
+  ): Promise<subgraph.SellerFieldsFragment[]> {
+    return accounts.subgraph.getSellers(this._subgraphUrl, queryVars);
+  }
+
   public async createSellerAndOffer(
     sellerToCreate: accounts.CreateSellerArgs,
     offerToCreate: offers.CreateOfferArgs,
@@ -177,26 +194,16 @@ export class CoreSDK {
   }
 
   public async getOfferById(
-    offerId: BigNumberish
+    offerId: BigNumberish,
+    queryVars?: offers.subgraph.SingleOfferQueryVariables
   ): Promise<subgraph.OfferFieldsFragment> {
-    return offers.subgraph.getOfferById(this._subgraphUrl, offerId);
+    return offers.subgraph.getOfferById(this._subgraphUrl, offerId, queryVars);
   }
 
-  public async getAllOffersOfSeller(
-    sellerFilter: {
-      operatorAddress: string;
-      // TODO: add support for sellerId, adminAddress, clerkAddress, treasuryAddress
-    },
-    opts?: offers.subgraph.AllOffersQueryOpts
+  public async getOffers(
+    queryVars?: subgraph.GetOffersQueryQueryVariables
   ): Promise<subgraph.OfferFieldsFragment[]> {
-    if (sellerFilter.operatorAddress) {
-      return offers.subgraph.getAllOffersOfOperator(
-        this._subgraphUrl,
-        sellerFilter.operatorAddress,
-        opts
-      );
-    }
-    return [];
+    return offers.subgraph.getOffers(this._subgraphUrl, queryVars);
   }
 
   public async commitToOffer(
@@ -285,26 +292,66 @@ export class CoreSDK {
     });
   }
 
-  public async getFundsByAccountId(
-    accountId: BigNumberish
+  public async getFundsById(
+    fundsId: BigNumberish,
+    queryVars?: subgraph.GetFundsByIdQueryVariables
+  ): Promise<subgraph.FundsEntityFieldsFragment> {
+    return funds.subgraph.getFundsById(this._subgraphUrl, fundsId, queryVars);
+  }
+
+  public async getFunds(
+    queryVars?: subgraph.GetFundsQueryVariables
   ): Promise<subgraph.FundsEntityFieldsFragment[]> {
-    return funds.subgraph.getFundsByAccountId(this._subgraphUrl, accountId);
+    return funds.subgraph.getFunds(this._subgraphUrl, queryVars);
   }
 
   public async getExchangeById(
-    exchangeId: BigNumberish
+    exchangeId: BigNumberish,
+    queryVars?: subgraph.GetExchangeByIdQueryQueryVariables
   ): Promise<subgraph.ExchangeFieldsFragment> {
-    return exchanges.subgraph.getExchangeById(this._subgraphUrl, exchangeId);
+    return exchanges.subgraph.getExchangeById(
+      this._subgraphUrl,
+      exchangeId,
+      queryVars
+    );
   }
 
-  public async getExchangesByOfferId(
-    offerId: BigNumberish,
-    opts?: exchanges.subgraph.ExchangesQueryOpts
+  public async getExchanges(
+    queryVars?: subgraph.GetExchangesQueryQueryVariables
   ): Promise<subgraph.ExchangeFieldsFragment[]> {
-    return exchanges.subgraph.getExchangesByOfferId(
-      this._subgraphUrl,
-      offerId,
-      opts
-    );
+    return exchanges.subgraph.getExchanges(this._subgraphUrl, queryVars);
+  }
+
+  public async revokeVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return exchanges.handler.revokeVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
+  public async cancelVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return exchanges.handler.cancelVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
+  public async redeemVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return exchanges.handler.redeemVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
   }
 }

package/src/exchanges/handler.ts

@@ -1,7 +1,14 @@
 import { BigNumberish } from "@ethersproject/bignumber";
 import { Web3LibAdapter, TransactionResponse } from "@bosonprotocol/common";
-import { encodeCommitToOffer } from "./interface";
+import {
+  encodeCancelVoucher,
+  encodeCommitToOffer,
+  encodeRevokeVoucher,
+  encodeRedeemVoucher
+} from "./interface";
 import { getOfferById } from "../offers/subgraph";
+import { getExchangeById } from "../exchanges/subgraph";
+import { ExchangeFieldsFragment, ExchangeState } from "../subgraph";
 
 export async function commitToOffer(args: {
   buyer: string;
@@ -13,23 +20,23 @@ export async function commitToOffer(args: {
   const offer = await getOfferById(args.subgraphUrl, args.offerId);
 
   if (!offer) {
-    throw new Error(`Offer with id "${args.offerId}" does not exist`);
+    throw new Error(`Offer with id ${args.offerId} does not exist`);
   }
 
   if (offer.voidedAt) {
-    throw new Error(`Offer with id "${args.offerId}" has been voided`);
+    throw new Error(`Offer with id ${args.offerId} has been voided`);
   }
 
   if (Date.now() < Number(offer.validFromDate) * 1000) {
-    throw new Error(`Offer with id "${args.offerId}" is not valid yet`);
+    throw new Error(`Offer with id ${args.offerId} is not valid yet`);
   }
 
   if (Date.now() >= Number(offer.validUntilDate) * 1000) {
-    throw new Error(`Offer with id "${args.offerId}" is not valid anymore`);
+    throw new Error(`Offer with id ${args.offerId} is not valid anymore`);
   }
 
   if (Number(offer.quantityAvailable) === 0) {
-    throw new Error(`Offer with id "${args.offerId}" is sold out`);
+    throw new Error(`Offer with id ${args.offerId} is sold out`);
   }
 
   return args.web3Lib.sendTransaction({
@@ -38,3 +45,113 @@ export async function commitToOffer(args: {
     value: offer.price
   });
 }
+
+export async function revokeVoucher(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  const [exchange, signerAddress] = await Promise.all([
+    getExchangeById(args.subgraphUrl, args.exchangeId),
+    args.web3Lib.getSignerAddress()
+  ]);
+
+  assertExchange(args.exchangeId, exchange);
+  assertExchangeState(exchange, ExchangeState.Committed);
+  assertSignerIsOperator(signerAddress, exchange);
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRevokeVoucher(args.exchangeId)
+  });
+}
+
+export async function cancelVoucher(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  const [exchange, signerAddress] = await Promise.all([
+    getExchangeById(args.subgraphUrl, args.exchangeId),
+    args.web3Lib.getSignerAddress()
+  ]);
+
+  assertExchange(args.exchangeId, exchange);
+  assertExchangeState(exchange, ExchangeState.Committed);
+  assertSignerIsBuyer(signerAddress, exchange);
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCancelVoucher(args.exchangeId)
+  });
+}
+
+export async function redeemVoucher(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  subgraphUrl: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  const [exchange, signerAddress] = await Promise.all([
+    getExchangeById(args.subgraphUrl, args.exchangeId),
+    args.web3Lib.getSignerAddress()
+  ]);
+
+  assertExchange(args.exchangeId, exchange);
+  assertExchangeState(exchange, ExchangeState.Committed);
+  assertSignerIsBuyer(signerAddress, exchange);
+
+  if (Date.now() < Number(exchange.offer.voucherRedeemableFromDate) * 1000) {
+    throw new Error(`Voucher not redeemable yet`);
+  }
+
+  if (Date.now() > Number(exchange.validUntilDate) * 1000) {
+    throw new Error(`Voucher can not be redeemed anymore`);
+  }
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRedeemVoucher(args.exchangeId)
+  });
+}
+
+function assertExchange(
+  exchangeId: BigNumberish,
+  exchange?: ExchangeFieldsFragment
+) {
+  if (!exchange) {
+    throw new Error(`Exchange with id ${exchangeId} does not exist`);
+  }
+}
+
+function assertExchangeState(
+  exchange: ExchangeFieldsFragment,
+  requiredState: ExchangeState
+) {
+  if (exchange.state !== requiredState) {
+    throw new Error(
+      `Exchange with id ${exchange.id} not in required state: ${requiredState}, actual state: ${exchange.state}`
+    );
+  }
+}
+
+function assertSignerIsOperator(
+  signer: string,
+  exchange: ExchangeFieldsFragment
+) {
+  if (exchange.seller.operator.toLowerCase() !== signer.toLowerCase()) {
+    throw new Error(
+      `Signer ${signer} is not the operator ${exchange.seller.operator}`
+    );
+  }
+}
+
+function assertSignerIsBuyer(signer: string, exchange: ExchangeFieldsFragment) {
+  if (exchange.buyer.wallet.toLowerCase() !== signer.toLowerCase()) {
+    throw new Error(
+      `Signer ${signer} is not the buyer ${exchange.buyer.wallet}`
+    );
+  }
+}

package/src/exchanges/interface.ts

@@ -12,3 +12,31 @@ export function encodeCommitToOffer(buyer: string, offerId: BigNumberish) {
     offerId
   ]);
 }
+
+export function encodeCompleteExchange(exchangeId: BigNumberish) {
+  return bosonExchangeHandlerIface.encodeFunctionData("completeExchange", [
+    exchangeId
+  ]);
+}
+
+export function encodeRevokeVoucher(exchangeId: BigNumberish) {
+  return bosonExchangeHandlerIface.encodeFunctionData("revokeVoucher", [
+    exchangeId
+  ]);
+}
+
+export function encodeCancelVoucher(exchangeId: BigNumberish) {
+  return bosonExchangeHandlerIface.encodeFunctionData("cancelVoucher", [
+    exchangeId
+  ]);
+}
+export function encodeExpireVoucher(exchangeId: BigNumberish) {
+  return bosonExchangeHandlerIface.encodeFunctionData("expireVoucher", [
+    exchangeId
+  ]);
+}
+export function encodeRedeemVoucher(exchangeId: BigNumberish) {
+  return bosonExchangeHandlerIface.encodeFunctionData("redeemVoucher", [
+    exchangeId
+  ]);
+}

package/src/exchanges/queries.graphql

@@ -4,46 +4,46 @@ query getExchangeByIdQuery($exchangeId: ID!) {
   }
 }
 
-query getExchangesByOfferId(
-  $offerId: String!
-  $first: Int
-  $skip: Int
-  $orderBy: Exchange_orderBy
-  $orderDirection: OrderDirection
+query getExchangesQuery(
+  $exchangesSkip: Int
+  $exchangesFirst: Int
+  $exchangesOrderBy: Exchange_orderBy
+  $exchangesOrderDirection: OrderDirection
+  $exchangesFilter: Exchange_filter
 ) {
   exchanges(
-    where: { offer: $offerId }
-    first: $first
-    skip: $skip
-    orderBy: $orderBy
-    orderDirection: $orderDirection
+    skip: $exchangesSkip
+    first: $exchangesFirst
+    orderBy: $exchangesOrderBy
+    orderDirection: $exchangesOrderDirection
+    where: $exchangesFilter
   ) {
     ...ExchangeFields
   }
 }
 
 fragment ExchangeFields on Exchange {
-  id
+  ...BaseExchangeFields
   buyer {
-    id
-    wallet
-    active
+    ...BaseBuyerFields
   }
   seller {
-    operator
-    admin
-    clerk
-    treasury
-    active
+    ...BaseSellerFields
+  }
+  offer {
+    ...BaseOfferFields
   }
+}
+
+fragment BaseExchangeFields on Exchange {
+  id
   disputed
   state
   committedDate
   finalizedDate
   validUntilDate
   redeemedDate
+  revokedDate
+  cancelledDate
   expired
-  offer {
-    ...OfferFields
-  }
 }