@bosonprotocol/core-sdk 1.6.0-alpha.13 → 1.6.0-alpha.2

package/src/accounts/subgraph.ts

@@ -1,92 +1,91 @@
-import { getSubgraphSdk } from "../utils/graphql";
-import {
-  SellerFieldsFragment,
-  GetSellersQueryQueryVariables,
-  GetSellerByIdQueryQueryVariables
-} from "../subgraph";
-import { BigNumberish } from "@ethersproject/bignumber";
+import { fetchSubgraph } from "../utils/subgraph";
+import { RawSellerFromSubgraph } from "./types";
 
-export type SingleSellerQueryVariables = Omit<
-  GetSellerByIdQueryQueryVariables,
-  "sellerId"
->;
-
-export async function getSellerById(
-  subgraphUrl: string,
-  sellerId: BigNumberish,
-  queryVars: SingleSellerQueryVariables = {}
-): Promise<SellerFieldsFragment> {
-  const sdk = getSubgraphSdk(subgraphUrl);
-  const { seller } = await sdk.getSellerByIdQuery({
-    sellerId: sellerId.toString(),
-    ...queryVars
-  });
-  return seller;
+export const sellerFieldsFragment = `
+fragment sellerFields on Seller {
+  id
+  operator
+  admin
+  clerk
+  treasury
+  active
 }
+`;
 
-export async function getSellers(
-  subgraphUrl: string,
-  queryVars: GetSellersQueryQueryVariables = {}
-): Promise<SellerFieldsFragment[]> {
-  const sdk = getSubgraphSdk(subgraphUrl);
-  const { sellers = [] } = await sdk.getSellersQuery(queryVars);
-  return sellers;
+export const getSellerByOperatorQuery = `
+query GetSellersByOperator($operator: String!) {
+  sellers(where: {
+    operator: $operator
+  }) {
+    ...sellerFields
+  }
 }
+${sellerFieldsFragment}
+`;
 
 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
-  });
+  operatorAddress: string
+): Promise<RawSellerFromSubgraph> {
+  const { sellers = [] } = await fetchSubgraph<{
+    sellers: RawSellerFromSubgraph[];
+  }>(subgraphUrl, getSellerByOperatorQuery, { operator: operatorAddress });
+
   return sellers[0];
 }
 
+export const getSellerByAdminQuery = `
+query GetSellersByAdmin($admin: String!) {
+  sellers(where: {
+    admin: $admin
+  }) {
+    ...sellerFields
+  }
+}
+${sellerFieldsFragment}
+`;
+
 export async function getSellerByAdmin(
   subgraphUrl: string,
-  adminAddress: string,
-  queryVars: GetSellersQueryQueryVariables = {}
-): Promise<SellerFieldsFragment> {
-  const sellers = await getSellers(subgraphUrl, {
-    sellersFilter: {
-      ...queryVars.sellersFilter,
-      admin: adminAddress.toLowerCase()
-    },
-    ...queryVars
-  });
+  adminAddress: string
+): Promise<RawSellerFromSubgraph> {
+  const { sellers = [] } = await fetchSubgraph<{
+    sellers: RawSellerFromSubgraph[];
+  }>(subgraphUrl, getSellerByAdminQuery, { admin: adminAddress });
+
   return sellers[0];
 }
 
+export const getSellerByClerkQuery = `
+query GetSellersByOperator($clerk: String!) {
+  sellers(where: {
+    clerk: $clerk
+  }) {
+    ...sellerFields
+  }
+}
+${sellerFieldsFragment}
+`;
+
 export async function getSellerByClerk(
   subgraphUrl: string,
-  clerkAddress: string,
-  queryVars: GetSellersQueryQueryVariables = {}
-): Promise<SellerFieldsFragment> {
-  const sellers = await getSellers(subgraphUrl, {
-    sellersFilter: {
-      ...queryVars.sellersFilter,
-      clerk: clerkAddress.toLowerCase()
-    },
-    ...queryVars
-  });
+  clerkAddress: string
+): Promise<RawSellerFromSubgraph> {
+  const { sellers = [] } = await fetchSubgraph<{
+    sellers: RawSellerFromSubgraph[];
+  }>(subgraphUrl, getSellerByClerkQuery, { clerk: clerkAddress });
+
   return sellers[0];
 }
 
 export async function getSellerByAddress(
   subgraphUrl: string,
-  address: string,
-  queryVars: GetSellersQueryQueryVariables = {}
-): Promise<SellerFieldsFragment> {
+  address: string
+): Promise<RawSellerFromSubgraph> {
   const [operator, admin, clerk] = await Promise.all([
-    getSellerByOperator(subgraphUrl, address, queryVars),
-    getSellerByAdmin(subgraphUrl, address, queryVars),
-    getSellerByClerk(subgraphUrl, address, queryVars)
+    getSellerByOperator(subgraphUrl, address),
+    getSellerByAdmin(subgraphUrl, address),
+    getSellerByClerk(subgraphUrl, address)
   ]);
 
   return operator || admin || clerk;

package/src/accounts/types.ts

@@ -1 +1,10 @@
 export { CreateSellerArgs } from "@bosonprotocol/common";
+
+export type RawSellerFromSubgraph = {
+  id: string;
+  operator: string;
+  admin: string;
+  clerk: string;
+  treasury: string;
+  active: boolean;
+};

package/src/core-sdk.ts

@@ -15,9 +15,8 @@ import * as offers from "./offers";
 import * as orchestration from "./orchestration";
 import * as erc20 from "./erc20";
 import * as funds from "./funds";
-import * as subgraph from "./subgraph";
-
 import { getValueFromLogs } from "./utils/logs";
+import { MultiQueryOpts } from "./utils/subgraph";
 
 export class CoreSDK {
   private _web3Lib: Web3LibAdapter;
@@ -78,54 +77,22 @@ 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,
-    queryVars?: subgraph.GetSellersQueryQueryVariables
-  ): Promise<subgraph.SellerFieldsFragment> {
-    return accounts.subgraph.getSellerByOperator(
-      this._subgraphUrl,
-      operator,
-      queryVars
-    );
+    operator: string
+  ): Promise<accounts.RawSellerFromSubgraph> {
+    return accounts.subgraph.getSellerByOperator(this._subgraphUrl, operator);
   }
 
   public async getSellerByClerk(
-    clerk: string,
-    queryVars?: subgraph.GetSellersQueryQueryVariables
-  ): Promise<subgraph.SellerFieldsFragment> {
-    return accounts.subgraph.getSellerByClerk(
-      this._subgraphUrl,
-      clerk,
-      queryVars
-    );
+    clerk: string
+  ): Promise<accounts.RawSellerFromSubgraph> {
+    return accounts.subgraph.getSellerByClerk(this._subgraphUrl, clerk);
   }
 
   public async getSellerByAddress(
-    address: string,
-    queryVars?: subgraph.GetSellersQueryQueryVariables
-  ): Promise<subgraph.SellerFieldsFragment> {
-    return accounts.subgraph.getSellerByAddress(
-      this._subgraphUrl,
-      address,
-      queryVars
-    );
-  }
-
-  public async getSellers(
-    queryVars?: subgraph.GetSellersQueryQueryVariables
-  ): Promise<subgraph.SellerFieldsFragment[]> {
-    return accounts.subgraph.getSellers(this._subgraphUrl, queryVars);
+    address: string
+  ): Promise<accounts.RawSellerFromSubgraph> {
+    return accounts.subgraph.getSellerByAddress(this._subgraphUrl, address);
   }
 
   public async createSellerAndOffer(
@@ -194,16 +161,26 @@ export class CoreSDK {
   }
 
   public async getOfferById(
-    offerId: BigNumberish,
-    queryVars?: offers.subgraph.SingleOfferQueryVariables
-  ): Promise<subgraph.OfferFieldsFragment> {
-    return offers.subgraph.getOfferById(this._subgraphUrl, offerId, queryVars);
+    offerId: BigNumberish
+  ): Promise<offers.RawOfferFromSubgraph> {
+    return offers.subgraph.getOfferById(this._subgraphUrl, offerId);
   }
 
-  public async getOffers(
-    queryVars?: subgraph.GetOffersQueryQueryVariables
-  ): Promise<subgraph.OfferFieldsFragment[]> {
-    return offers.subgraph.getOffers(this._subgraphUrl, queryVars);
+  public async getAllOffersOfSeller(
+    sellerFilter: {
+      operatorAddress: string;
+      // TODO: add support for sellerId, adminAddress, clerkAddress, treasuryAddress
+    },
+    opts: MultiQueryOpts = {}
+  ): Promise<offers.RawOfferFromSubgraph[]> {
+    if (sellerFilter.operatorAddress) {
+      return offers.subgraph.getAllOffersOfOperator(
+        this._subgraphUrl,
+        sellerFilter.operatorAddress,
+        opts
+      );
+    }
+    return [];
   }
 
   public async commitToOffer(
@@ -292,66 +269,9 @@ export class CoreSDK {
     });
   }
 
-  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.getFunds(this._subgraphUrl, queryVars);
-  }
-
-  public async getExchangeById(
-    exchangeId: BigNumberish,
-    queryVars?: subgraph.GetExchangeByIdQueryQueryVariables
-  ): Promise<subgraph.ExchangeFieldsFragment> {
-    return exchanges.subgraph.getExchangeById(
-      this._subgraphUrl,
-      exchangeId,
-      queryVars
-    );
-  }
-
-  public async getExchanges(
-    queryVars?: subgraph.GetExchangesQueryQueryVariables
-  ): Promise<subgraph.ExchangeFieldsFragment[]> {
-    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
-    });
+  public async getFundsByAccountId(
+    accountId: BigNumberish
+  ): Promise<funds.RawFundsEntityFromSubgraph[]> {
+    return funds.subgraph.getFundsByAccountId(this._subgraphUrl, accountId);
   }
 }

package/src/exchanges/handler.ts

@@ -1,14 +1,7 @@
 import { BigNumberish } from "@ethersproject/bignumber";
 import { Web3LibAdapter, TransactionResponse } from "@bosonprotocol/common";
-import {
-  encodeCancelVoucher,
-  encodeCommitToOffer,
-  encodeRevokeVoucher,
-  encodeRedeemVoucher
-} from "./interface";
+import { encodeCommitToOffer } from "./interface";
 import { getOfferById } from "../offers/subgraph";
-import { getExchangeById } from "../exchanges/subgraph";
-import { ExchangeFieldsFragment, ExchangeState } from "../subgraph";
 
 export async function commitToOffer(args: {
   buyer: string;
@@ -20,23 +13,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({
@@ -45,113 +38,3 @@ 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/index.ts

@@ -1,3 +1,2 @@
 export * as handler from "./handler";
 export * as iface from "./interface";
-export * as subgraph from "./subgraph";

package/src/exchanges/interface.ts

@@ -12,31 +12,3 @@ 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/funds/index.ts

@@ -1,3 +1,4 @@
 export * as iface from "./interface";
 export * as subgraph from "./subgraph";
 export * as handler from "./handler";
+export * from "./types";

package/src/funds/subgraph.ts

@@ -1,35 +1,39 @@
-import { getSubgraphSdk } from "../utils/graphql";
-import {
-  FundsEntityFieldsFragment,
-  GetFundsByIdQueryVariables,
-  GetFundsQueryVariables
-} from "../subgraph";
 import { BigNumberish } from "@ethersproject/bignumber";
+import { fetchSubgraph } from "../utils/subgraph";
+import { RawFundsEntityFromSubgraph } from "./types";
 
-export type SingleFundsQueryVariables = Omit<
-  GetFundsByIdQueryVariables,
-  "fundsId"
->;
+export const fundsEntityFieldsFragment = `
+fragment fundsEntityFields on FundsEntity {
+  id
+  availableAmount
+  token {
+    address
+    name
+    symbol
+    decimals
+  }
+  accountId
+}
+`;
 
-export async function getFunds(
-  subgraphUrl: string,
-  queryVars: GetFundsQueryVariables = {}
-): Promise<FundsEntityFieldsFragment[]> {
-  const sdk = getSubgraphSdk(subgraphUrl);
-  const { fundsEntities = [] } = await sdk.getFunds(queryVars);
-  return fundsEntities;
+export const getFundsByAccountIdQuery = `
+query GetFundsByAccountIdQuery($accountId: String!) {
+  fundsEntities(where: {
+    accountId: $accountId
+  }) {
+    ...fundsEntityFields
+  }
 }
+${fundsEntityFieldsFragment}
+`;
 
-export async function getFundsById(
+export async function getFundsByAccountId(
   subgraphUrl: string,
-  fundsId: BigNumberish,
-  queryVars: SingleFundsQueryVariables = {}
-): Promise<FundsEntityFieldsFragment> {
-  const sdk = getSubgraphSdk(subgraphUrl);
-  const { fundsEntity } = await sdk.getFundsById({
-    fundsId: fundsId.toString(),
-    ...queryVars
-  });
+  accountId: BigNumberish
+): Promise<RawFundsEntityFromSubgraph[]> {
+  const { fundsEntities = [] } = await fetchSubgraph<{
+    fundsEntities: RawFundsEntityFromSubgraph[];
+  }>(subgraphUrl, getFundsByAccountIdQuery, { accountId });
 
-  return fundsEntity;
+  return fundsEntities;
 }

package/src/funds/types.ts

@@ -0,0 +1,11 @@
+export type RawFundsEntityFromSubgraph = {
+  id: string;
+  availableAmount: string;
+  token: {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+  };
+  accountId: string;
+};

package/src/index.ts

@@ -6,7 +6,6 @@ export * as exchanges from "./exchanges";
 export * as orchestration from "./orchestration";
 export * as erc20 from "./erc20";
 export * as funds from "./funds";
-export * as subgraph from "./subgraph";
 
 export { defaultConfigs, getDefaultConfig } from "@bosonprotocol/common";
 

package/src/offers/index.ts

@@ -5,7 +5,6 @@ export * as subgraph from "./subgraph";
 export * as iface from "./interface";
 export * as storage from "./storage";
 export * from "./types";
-export * from "./getOfferStatus";
 
 export const validation = {
   createOfferArgsSchema: utils.validation.createOfferArgsSchema