@bosonprotocol/core-sdk 1.23.0-alpha.2 → 1.23.0-alpha.21

package/src/metadata/subgraph.ts

@@ -14,7 +14,11 @@ import {
   BaseProductV1ProductFieldsFragment,
   BaseProductV1CategoryFieldsFragment,
   OfferFieldsFragment,
-  ProductV1Variation
+  ProductV1Variation,
+  GetProductV1ProductsWithVariantsQueryQueryVariables,
+  BaseProductV1ProductWithNotVoidedVariantsFieldsFragment,
+  BaseProductV1ProductWithVariantsFieldsFragment,
+  GetAllProductsWithNotVoidedVariantsQueryQueryVariables
 } from "../subgraph";
 
 export type SingleBaseMetadataEntityQueryVariables = Omit<
@@ -121,6 +125,32 @@ export async function getProductV1Products(
   return productV1Products;
 }
 
+export async function getAllProductsWithVariants(
+  subgraphUrl: string,
+  queryVars: GetProductV1ProductsWithVariantsQueryQueryVariables = {}
+): Promise<BaseProductV1ProductWithVariantsFieldsFragment[]> {
+  const subgraphSdk = getSubgraphSdk(subgraphUrl);
+  const { productV1Products = [] } =
+    await subgraphSdk.getProductV1ProductsWithVariantsQuery({
+      ...queryVars
+    });
+
+  return productV1Products;
+}
+
+export async function getAllProductsWithNotVoidedVariants(
+  subgraphUrl: string,
+  queryVars: GetAllProductsWithNotVoidedVariantsQueryQueryVariables = {}
+): Promise<BaseProductV1ProductWithNotVoidedVariantsFieldsFragment[]> {
+  const subgraphSdk = getSubgraphSdk(subgraphUrl);
+  const { productV1Products = [] } =
+    await subgraphSdk.getAllProductsWithNotVoidedVariantsQuery({
+      ...queryVars
+    });
+
+  return productV1Products;
+}
+
 export async function getProductWithVariants(
   subgraphUrl: string,
   productUuid: string

package/src/mixins/base-core-sdk.ts

@@ -0,0 +1,96 @@
+import {
+  Web3LibAdapter,
+  MetadataStorage,
+  MetaTxConfig,
+  LensContracts
+} from "@bosonprotocol/common";
+import { TokenInfoManager } from "../utils/tokenInfoManager";
+
+export class BaseCoreSDK {
+  protected _web3Lib: Web3LibAdapter;
+  protected _metadataStorage?: MetadataStorage;
+  protected _theGraphStorage?: MetadataStorage;
+
+  protected _subgraphUrl: string;
+  protected _protocolDiamond: string;
+  protected _chainId: number;
+  protected _tokenInfoManager: TokenInfoManager;
+
+  protected _metaTxConfig?: Partial<MetaTxConfig>;
+  protected _lensContracts?: LensContracts;
+
+  /**
+   * Creates an instance of `BaseCoreSDK`
+   * @param args - Constructor args
+   */
+  constructor(opts: {
+    web3Lib: Web3LibAdapter;
+    subgraphUrl: string;
+    protocolDiamond: string;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
+    chainId: number;
+    metaTx?: Partial<MetaTxConfig>;
+    lensContracts?: LensContracts;
+  }) {
+    this._web3Lib = opts.web3Lib;
+    this._subgraphUrl = opts.subgraphUrl;
+    this._protocolDiamond = opts.protocolDiamond;
+    this._metadataStorage = opts.metadataStorage;
+    this._theGraphStorage = opts.theGraphStorage;
+    this._chainId = opts.chainId;
+    this._metaTxConfig = opts.metaTx;
+    this._lensContracts = opts.lensContracts;
+  }
+
+  protected assertAndGetMetaTxConfig(
+    overrides: Partial<{
+      contractAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
+    }> = {}
+  ) {
+    const contractAddress = overrides.contractAddress || this._protocolDiamond;
+    const metaTransactionMethod =
+      overrides.metaTransactionMethod || "executeMetaTransaction";
+    const metaTxRelayerUrl =
+      overrides.metaTxConfig?.relayerUrl || this._metaTxConfig?.relayerUrl;
+    const metaTxApiKey =
+      overrides.metaTxConfig?.apiKey || this._metaTxConfig?.apiKey;
+    // metaTxApiId is depending on the contract/method(=executeMetaTransaction) to be called with Biconomy
+    const apiIds = this._metaTxConfig?.apiIds[contractAddress.toLowerCase()];
+    const metaTxApiId =
+      overrides.metaTxConfig?.apiId ||
+      (apiIds && apiIds[metaTransactionMethod]);
+
+    if (!(metaTxRelayerUrl && metaTxApiKey && metaTxApiId)) {
+      throw new Error(
+        "CoreSDK not configured to relay meta transactions. Either pass in 'relayerUrl', 'apiKey' and 'apiId' during initialization OR as overrides arguments."
+      );
+    }
+
+    return {
+      metaTxRelayerUrl,
+      metaTxApiId,
+      metaTxApiKey,
+      contractAddress
+    };
+  }
+}
+
+// Doc: https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern
+export function applyMixins(
+  derivedCtor: typeof BaseCoreSDK,
+  constructors: typeof BaseCoreSDK[]
+) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
+          Object.create(null)
+      );
+    });
+  });
+}

package/src/native-meta-tx/mixin.ts

@@ -0,0 +1,77 @@
+import { MetaTxConfig, TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+import { handler } from ".";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+
+export class NativeMetaTxMixin extends BaseCoreSDK {
+  /**
+   * Encodes and signs a native "token.approve()" meta transaction that can be relayed.
+   * @param exchangeToken - The address of the token contract.
+   * @param value - The value to be approved.
+   * @param overrides - Optionally specify a spender address (default is the protocol contract address).
+   * @returns Signature.
+   */
+  public async signNativeMetaTxApproveExchangeToken(
+    exchangeToken: string,
+    value: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+    }> = {}
+  ) {
+    const user = await this._web3Lib.getSignerAddress();
+    return handler.signNativeMetaTxApproveExchangeToken({
+      web3Lib: this._web3Lib,
+      chainId: this._chainId,
+      user,
+      exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value
+    });
+  }
+
+  /**
+   * Relay a native meta transaction,
+   * @param metaTxParams - Required params for meta transaction.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async relayNativeMetaTransaction(
+    contractAddress: string,
+    metaTxParams: {
+      functionSignature: BytesLike;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+    },
+    overrides: Partial<{
+      userAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
+      this.assertAndGetMetaTxConfig({ ...overrides, contractAddress });
+
+    return handler.relayNativeMetaTransaction({
+      web3LibAdapter: this._web3Lib,
+      contractAddress,
+      chainId: this._chainId,
+      metaTx: {
+        config: {
+          relayerUrl: metaTxRelayerUrl,
+          apiId: metaTxApiId,
+          apiKey: metaTxApiKey
+        },
+        params: {
+          userAddress:
+            overrides.userAddress || (await this._web3Lib.getSignerAddress()),
+          functionSignature: metaTxParams.functionSignature,
+          sigR: metaTxParams.sigR,
+          sigS: metaTxParams.sigS,
+          sigV: metaTxParams.sigV
+        }
+      }
+    });
+  }
+}

package/src/offers/mixin.ts

@@ -0,0 +1,376 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as erc20 from "../erc20";
+import * as erc721 from "../erc721";
+import * as erc1155 from "../erc1155";
+import * as subgraph from "../subgraph";
+import * as offers from ".";
+import * as accounts from "../accounts";
+import * as orchestration from "../orchestration";
+import * as groups from "../groups";
+import {
+  TransactionResponse,
+  Log,
+  TokenType,
+  EvaluationMethod
+} from "@bosonprotocol/common";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
+import { getValueFromLogs, getValuesFromLogs } from "../utils/logs";
+import { ITokenInfo, TokenInfoManager } from "../utils/tokenInfoManager";
+
+export class OfferMixin extends BaseCoreSDK {
+  /* -------------------------------------------------------------------------- */
+  /*                            Offer related methods                           */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Creates offer by calling the `OfferHandlerFacet` contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
+   * @param offerToCreate - Offer arguments.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createOffer(
+    offerToCreate: offers.CreateOfferArgs,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.createOffer({
+      offerToCreate,
+      web3Lib: this._web3Lib,
+      theGraphStorage: this._theGraphStorage,
+      metadataStorage: this._metadataStorage,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
+  /**
+   * Creates a batch of offers by calling the `OfferHandlerFacet` contract.
+   * This transaction only succeeds if there is an existing seller account for connected signer.
+   * @param offersToCreate - Offer arguments.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createOfferBatch(
+    offersToCreate: offers.CreateOfferArgs[],
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.createOfferBatch({
+      offersToCreate,
+      web3Lib: this._web3Lib,
+      theGraphStorage: this._theGraphStorage,
+      metadataStorage: this._metadataStorage,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
+  /**
+   * Utility method to retrieve the created `offerId` from logs after calling `createOffer`
+   * or `createOfferAndSeller`.
+   * @param logs - Logs to search in.
+   * @returns Created offer id.
+   */
+  public getCreatedOfferIdFromLogs(logs: Log[]): string | null {
+    const offerId = getValueFromLogs({
+      iface: offers.iface.bosonOfferHandlerIface,
+      logs,
+      eventArgsKey: "offerId",
+      eventName: "OfferCreated"
+    });
+
+    return (
+      offerId ||
+      getValueFromLogs({
+        iface: orchestration.iface.bosonOrchestrationHandlerIface,
+        logs,
+        eventArgsKey: "offerId",
+        eventName: "OfferCreated"
+      })
+    );
+  }
+
+  /**
+   * Utility method to retrieve the created `offerIds` from logs after calling `createOfferBatch`
+   * @param logs - Logs to search in.
+   * @returns Array of created offerIds.
+   */
+  public getCreatedOfferIdsFromLogs(logs: Log[]): string[] {
+    return getValuesFromLogs({
+      iface: offers.iface.bosonOfferHandlerIface,
+      logs,
+      eventArgsKey: "offerId",
+      eventName: "OfferCreated"
+    });
+  }
+
+  /**
+   * Utility method to retrieve the created `groupIds` from logs after calling `createGroup`
+   * @param logs - Logs to search in.
+   * @returns Array of group Ids.
+   */
+  public getCreatedGroupIdsFromLogs(logs: Log[]): string[] {
+    return getValuesFromLogs({
+      iface: groups.iface.bosonGroupHandlerIface,
+      logs,
+      eventArgsKey: "groupId",
+      eventName: "GroupCreated"
+    });
+  }
+
+  /**
+   * Utility method to retrieve the created `sellerId` from logs after calling `createSeller`
+   * or `createOfferAndSeller`.
+   * @param logs - Logs to search in.
+   * @returns Created offer id.
+   */
+  public getCreatedSellerIdFromLogs(logs: Log[]): string | null {
+    const sellerId = getValueFromLogs({
+      iface: accounts.iface.bosonAccountHandlerIface,
+      logs,
+      eventArgsKey: "sellerId",
+      eventName: "SellerCreated"
+    });
+
+    return (
+      sellerId ||
+      getValueFromLogs({
+        iface: orchestration.iface.bosonOrchestrationHandlerIface,
+        logs,
+        eventArgsKey: "sellerId",
+        eventName: "SellerCreated"
+      })
+    );
+  }
+
+  /**
+   * Voids an existing offer by calling the `OfferHandlerFacet` contract.
+   * This transaction only succeeds if the connected signer is the `operator`.
+   * @param offerId - ID of offer to void.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async voidOffer(
+    offerId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.voidOffer({
+      offerId,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
+  /**
+   * Voids a batch of existing offers by calling the `OfferHandlerFacet` contract.
+   * This transaction only succeeds if the connected signer is the `operator` of all
+   * provided offers.
+   * @param offerIds - IDs of offers to void.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async voidOfferBatch(
+    offerIds: BigNumberish[],
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.voidOfferBatch({
+      offerIds,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
+  /**
+   * Returns offer from subgraph.
+   * @param offerId - ID of offer.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Offer entity from subgraph.
+   */
+  public async getOfferById(
+    offerId: BigNumberish,
+    queryVars?: offers.subgraph.SingleOfferQueryVariables
+  ): Promise<subgraph.OfferFieldsFragment> {
+    return offers.subgraph.getOfferById(this._subgraphUrl, offerId, queryVars);
+  }
+
+  /**
+   * Returns offers from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Offer entities from subgraph.
+   */
+  public async getOffers(
+    queryVars?: subgraph.GetOffersQueryQueryVariables
+  ): Promise<subgraph.OfferFieldsFragment[]> {
+    return offers.subgraph.getOffers(this._subgraphUrl, queryVars);
+  }
+
+  /**
+   * Renders contractual agreement for given offer.
+   * @param offerId - Id of offer to render agreement for.
+   * @returns Contractual agreement as string.
+   */
+  public async renderContractualAgreementForOffer(
+    offerId: BigNumberish
+  ): Promise<string> {
+    const offerData = await offers.subgraph.getOfferById(
+      this._subgraphUrl,
+      offerId
+    );
+    return offers.renderContractualAgreementForOffer(offerData);
+  }
+
+  /**
+   * Renders contractual agreement for given offer.
+   * @param template - Mustache syntax based template.
+   * @param offerData - Offer data.
+   * @returns Contractual agreement as string.
+   */
+  public async renderContractualAgreement(
+    template: string,
+    offerData: offers.CreateOfferArgs,
+    offerMetadata: offers.AdditionalOfferMetadata
+  ): Promise<string> {
+    const tokenInfo = await this.getExchangeTokenInfo(offerData.exchangeToken);
+    return offers.renderContractualAgreement(
+      template,
+      offerData,
+      offerMetadata,
+      tokenInfo
+    );
+  }
+
+  /* -------------------------------------------------------------------------- */
+  /*                   ERC20 / Exchange Token related methods                   */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Returns the current allowance of the given token by calling the contract.
+   * @param exchangeToken - Address of exchange token.
+   * @param overrides - Optional overrides.
+   * @returns Allowance for given signer.
+   */
+  public async getExchangeTokenAllowance(
+    exchangeToken: string,
+    overrides: Partial<{
+      spender: string;
+      owner: string;
+    }> = {}
+  ): Promise<string> {
+    return erc20.handler.getAllowance({
+      web3Lib: this._web3Lib,
+      contractAddress: exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      owner: overrides.owner || (await this._web3Lib.getSignerAddress())
+    });
+  }
+
+  /**
+   * Returns `name`, `decimals` and `symbol` of the given token by calling the contract.
+   * @param exchangeToken - Address exchange token.
+   * @returns Decimals, name and symbol.
+   */
+  public async getExchangeTokenInfo(
+    exchangeToken: string
+  ): Promise<ITokenInfo> {
+    if (this._tokenInfoManager === undefined) {
+      this._tokenInfoManager = new TokenInfoManager(
+        this._chainId,
+        this._web3Lib,
+        this._subgraphUrl
+      );
+    }
+
+    return this._tokenInfoManager.getExchangeTokenInfo(exchangeToken);
+  }
+
+  /**
+   * Approves the given amount for the main protocol contract.
+   * @param exchangeToken - Address of token to approve.
+   * @param value - Amount of allowance.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async approveExchangeToken(
+    exchangeToken: string,
+    value: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return erc20.handler.approve({
+      contractAddress: exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async getProtocolAllowance(
+    exchangeToken: string,
+    overrides: Partial<{
+      spender: string;
+      owner: string;
+    }> = {}
+  ): Promise<string> {
+    return erc20.handler.getAllowance({
+      contractAddress: exchangeToken,
+      owner: overrides.owner || (await this._web3Lib.getSignerAddress()),
+      spender: overrides.spender || this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async checkTokenGatedCondition(
+    offerCondition: subgraph.OfferFieldsFragment["condition"],
+    buyerAddress: string
+  ): Promise<boolean> {
+    const { tokenId, tokenType, threshold, method, tokenAddress } =
+      offerCondition;
+    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 (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 (method === EvaluationMethod.SpecificToken) {
+        const owner: string = await erc721.handler.ownerOf({
+          contractAddress: tokenAddress,
+          tokenId,
+          web3Lib: this._web3Lib
+        });
+        return owner === buyerAddress;
+      }
+      throw new Error(
+        `Unsupported method=${method} 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);
+    }
+    throw new Error(`Unsupported tokenType=${tokenType}`);
+  }
+}

package/src/offers/queries.graphql

@@ -98,8 +98,8 @@ fragment BaseOfferFields on Offer {
     condition
     schemaUrl
     type
+    image
     ... on ProductV1MetadataEntity {
-      image
       attributes {
         traitType
         value

package/src/orchestration/mixin.ts

@@ -0,0 +1,57 @@
+import { ConditionStruct, TransactionResponse } from "@bosonprotocol/common";
+import { handler } from ".";
+import { offers, accounts } from "..";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+
+export class OrchestrationMixin extends BaseCoreSDK {
+  /**
+   * Creates an offer with a specific conditions
+   * @param offerToCreate - Offer arguments.
+   * @param condition -  contract condition applied to the offer
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createOfferWithCondition(
+    offerToCreate: offers.CreateOfferArgs,
+    condition: ConditionStruct,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createOfferWithCondition({
+      offerToCreate,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage,
+      condition
+    });
+  }
+  /**
+   * Creates a seller account and offer with a specific conditions
+   * This transaction only succeeds if there is no existing seller account for the connected signer.
+   * @param sellerToCreate - Addresses to set in the seller account.
+   * @param offerToCreate - Offer arguments.
+   * @param condition -  contract condition applied to the offer
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createSellerAndOfferWithCondition(
+    sellerToCreate: accounts.CreateSellerArgs,
+    offerToCreate: offers.CreateOfferArgs,
+    condition: ConditionStruct,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createSellerAndOfferWithCondition({
+      sellerToCreate,
+      offerToCreate,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage,
+      condition
+    });
+  }
+}