@bosonprotocol/core-sdk 1.12.0-alpha.0 → 1.12.0-alpha.10

package/src/accounts/subgraph.ts

@@ -2,10 +2,13 @@ import { getSubgraphSdk } from "../utils/graphql";
 import {
   BuyerFieldsFragment,
   GetBuyerByIdQueryQueryVariables,
+  GetBuyersQueryQueryVariables,
   SellerFieldsFragment,
   GetSellersQueryQueryVariables,
-  GetBuyersQueryQueryVariables,
-  GetSellerByIdQueryQueryVariables
+  GetSellerByIdQueryQueryVariables,
+  GetDisputeResolverByIdQueryQueryVariables,
+  GetDisputeResolversQueryQueryVariables,
+  DisputeResolverFieldsFragment
 } from "../subgraph";
 import { BigNumberish } from "@ethersproject/bignumber";
 
@@ -19,6 +22,11 @@ export type SingleBuyerQueryVariables = Omit<
   "buyerId"
 >;
 
+export type SingleDisputeResolverQueryVariables = Omit<
+  GetDisputeResolverByIdQueryQueryVariables,
+  "disputeResolverId"
+>;
+
 export async function getBuyerById(
   subgraphUrl: string,
   buyerId: BigNumberish,
@@ -137,3 +145,27 @@ export async function getSellerByAddress(
 
   return operator || admin || clerk || treasury;
 }
+
+export async function getDisputeResolverById(
+  subgraphUrl: string,
+  disputeResolverId: BigNumberish,
+  queryVars: SingleDisputeResolverQueryVariables = {}
+): Promise<DisputeResolverFieldsFragment> {
+  const sdk = getSubgraphSdk(subgraphUrl);
+  const { disputeResolver } = await sdk.getDisputeResolverByIdQuery({
+    disputeResolverId: disputeResolverId.toString(),
+    ...queryVars
+  });
+  return disputeResolver;
+}
+
+export async function getDisputeResolvers(
+  subgraphUrl: string,
+  queryVars: GetDisputeResolversQueryQueryVariables = {}
+): Promise<DisputeResolverFieldsFragment[]> {
+  const sdk = getSubgraphSdk(subgraphUrl);
+  const { disputeResolvers = [] } = await sdk.getDisputeResolversQuery(
+    queryVars
+  );
+  return disputeResolvers;
+}

package/src/accounts/types.ts

@@ -1 +1,34 @@
-export { CreateSellerArgs } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { DisputeResolverStruct } from "@bosonprotocol/common";
+
+export { CreateSellerArgs, DisputeResolverStruct } from "@bosonprotocol/common";
+
+export type CreateDisputeResolverArgs = {
+  escalationResponsePeriodInMS: number;
+  operator: string;
+  admin: string;
+  clerk: string;
+  treasury: string;
+  metadataUri: string;
+  /**
+   * List of supported fees. Should contain at lest one element.
+   */
+  fees: DisputeResolutionFee[];
+  /**
+   * Ids of sellers that are allowed to use the dispute resolver.
+   * If empty or `undefined`, then any seller can use the dispute resolver.
+   */
+  sellerAllowList?: BigNumberish[];
+};
+
+export type DisputeResolutionFee = {
+  tokenAddress: string;
+  tokenName: string;
+  feeAmount: BigNumberish;
+};
+
+export type DisputeResolverUpdates = Partial<
+  Omit<DisputeResolverStruct, "id" | "active" | "escalationResponsePeriod"> & {
+    escalationResponsePeriodInMS: BigNumberish;
+  }
+>;

package/src/core-sdk.ts

@@ -1,3 +1,4 @@
+import { ITokenInfo, TokenInfoManager } from "./utils/tokenInfoManager";
 import {
   Web3LibAdapter,
   TransactionResponse,
@@ -8,8 +9,10 @@ import {
 } from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { AddressZero } from "@ethersproject/constants";
+import { BytesLike } from "@ethersproject/bytes";
 
 import * as accounts from "./accounts";
+import * as disputes from "./disputes";
 import * as exchanges from "./exchanges";
 import * as offers from "./offers";
 import * as orchestration from "./orchestration";
@@ -28,6 +31,8 @@ export class CoreSDK {
 
   private _subgraphUrl: string;
   private _protocolDiamond: string;
+  private _chainId: number;
+  private _tokenInfoManager: TokenInfoManager;
 
   /**
    * Creates an instance of `CoreSDK`
@@ -39,12 +44,14 @@ export class CoreSDK {
     protocolDiamond: string;
     metadataStorage?: MetadataStorage;
     theGraphStorage?: MetadataStorage;
+    chainId?: number;
   }) {
     this._web3Lib = opts.web3Lib;
     this._subgraphUrl = opts.subgraphUrl;
     this._protocolDiamond = opts.protocolDiamond;
     this._metadataStorage = opts.metadataStorage;
     this._theGraphStorage = opts.theGraphStorage;
+    this._chainId = opts.chainId;
   }
 
   /**
@@ -80,7 +87,8 @@ export class CoreSDK {
       metadataStorage: args.metadataStorage,
       theGraphStorage: args.theGraphStorage,
       subgraphUrl: defaultConfig.subgraphUrl,
-      protocolDiamond: defaultConfig.contracts.protocolDiamond
+      protocolDiamond: defaultConfig.contracts.protocolDiamond,
+      chainId: args.chainId
     });
   }
 
@@ -201,6 +209,40 @@ export class CoreSDK {
     );
   }
 
+  /**
+   * Returns seller entity from subgraph.
+   * @param admin - Admin address of seller entity to query for.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Seller entity from subgraph.
+   */
+  public async getSellerByAdmin(
+    admin: string,
+    queryVars?: subgraph.GetSellersQueryQueryVariables
+  ): Promise<subgraph.SellerFieldsFragment> {
+    return accounts.subgraph.getSellerByAdmin(
+      this._subgraphUrl,
+      admin,
+      queryVars
+    );
+  }
+
+  /**
+   * Returns seller entity from subgraph.
+   * @param treasury - Treasury address of seller entity to query for.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Seller entity from subgraph.
+   */
+  public async getSellerByTreasury(
+    treasury: string,
+    queryVars?: subgraph.GetSellersQueryQueryVariables
+  ): Promise<subgraph.SellerFieldsFragment> {
+    return accounts.subgraph.getSellerByTreasury(
+      this._subgraphUrl,
+      treasury,
+      queryVars
+    );
+  }
+
   /**
    * Returns seller entity from subgraph. Matches `operator`, `clerk`, `admin` or `treasury`.
    * @param address - Address of seller entity to query for.
@@ -231,7 +273,7 @@ export class CoreSDK {
 
   /**
    * Creates seller account by calling the `AccountHandlerFacet` contract.
-   * @param sellerToCreate - Addresses to set in the seller account.
+   * @param sellerToCreate - Addresses and contract URI to set in the seller account.
    * @param overrides - Optional overrides.
    * @returns Transaction response.
    */
@@ -295,7 +337,7 @@ export class CoreSDK {
   /**
    * Returns buyer entities from subgraph.
    * @param queryVars - Optional query variables to skip, order or filter.
-   * @returns Seller entities from subgraph.
+   * @returns Buyer entities from subgraph.
    */
   public async getBuyers(
     queryVars?: subgraph.GetBuyersQueryQueryVariables
@@ -303,6 +345,184 @@ export class CoreSDK {
     return accounts.subgraph.getBuyers(this._subgraphUrl, queryVars);
   }
 
+  /* ---------------------------- Dispute Resolver ---------------------------- */
+
+  /**
+   * Creates a dispute resolver account by calling the `AccountHandlerFacet` contract.
+   * @param disputeResolverToCreate - Dispute resolver arguments.
+   * @returns Transaction response.
+   */
+  public async createDisputeResolver(
+    disputeResolverToCreate: accounts.CreateDisputeResolverArgs
+  ): Promise<TransactionResponse> {
+    return accounts.handler.createDisputeResolver({
+      disputeResolverToCreate,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Utility method to retrieve the created `exchangeId` from logs after calling `commitToOffer`.
+   * @param logs - Logs to search in.
+   * @returns Created exchange id.
+   */
+  public getDisputeResolverIdFromLogs(logs: Log[]): string | null {
+    return getValueFromLogs({
+      iface: accounts.iface.bosonAccountHandlerIface,
+      logs,
+      eventArgsKey: "disputeResolverId",
+      eventName: "DisputeResolverCreated"
+    });
+  }
+
+  /**
+   * Updates a dispute resolver account by calling the `AccountHandlerFacet` contract.
+   * Note, that the caller must be the specified `admin` address of the dispute resolver account.
+   * @param disputeResolverId - Id of dispute resolver to update.
+   * @param updates - Values to update for the given dispute resolver.
+   * @returns Transaction response.
+   */
+  public async updateDisputeResolver(
+    disputeResolverId: BigNumberish,
+    updates: accounts.DisputeResolverUpdates
+  ): Promise<TransactionResponse> {
+    return accounts.handler.updateDisputeResolver({
+      disputeResolverId,
+      updates,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Activates a dispute resolver account by calling the `AccountHandlerFacet` contract.
+   * Note, that the caller needs to have the ADMIN role.
+   * @param disputeResolverId - Id of dispute resolver to activate.
+   * @returns Transaction response.
+   */
+  public async activateDisputeResolver(
+    disputeResolverId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return accounts.handler.activateDisputeResolver({
+      disputeResolverId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Adds fees to a dispute resolver account by calling the `AccountHandlerFacet`
+   * contract. Note, that the caller must be the specified `admin` address of the dispute
+   * resolver account.
+   * @param disputeResolverId - Id of dispute resolver.
+   * @param fees - Dispute resolution fees. Should only contain token addresses that are
+   * not already specified.
+   * @returns Transaction response.
+   */
+  public async addFeesToDisputeResolver(
+    disputeResolverId: BigNumberish,
+    fees: accounts.DisputeResolutionFee[]
+  ): Promise<TransactionResponse> {
+    return accounts.handler.addFeesToDisputeResolver({
+      disputeResolverId,
+      fees,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Adds sellers to the allow list of a dispute resolver account by calling the
+   * `AccountHandlerFacet` contract. Note, that the caller must be the specified
+   * `admin` address of the dispute resolver account.
+   * @param disputeResolverId - Id of dispute resolver.
+   * @param sellerAllowList - List of seller ids that are allowed to use the dispute resolver.
+   *  Should only contain seller ids that are not part of the current allow list.
+   * @returns Transaction response.
+   */
+  public async addSellersToDisputeResolverAllowList(
+    disputeResolverId: BigNumberish,
+    sellerAllowList: BigNumberish[]
+  ): Promise<TransactionResponse> {
+    return accounts.handler.addSellersToAllowList({
+      disputeResolverId,
+      sellerAllowList,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Removes fees from a dispute resolver account by calling the `AccountHandlerFacet`
+   * contract. Note, that the caller must be the specified `admin` address of the dispute
+   * resolver account.
+   * @param disputeResolverId - Id of dispute resolver.
+   * @param feeTokenAddresses - Addresses of fee tokens to remove.
+   * @returns Transaction response.
+   */
+  public async removeFeesFromDisputeResolver(
+    disputeResolverId: BigNumberish,
+    feeTokenAddresses: string[]
+  ): Promise<TransactionResponse> {
+    return accounts.handler.removeFeesFromDisputeResolver({
+      disputeResolverId,
+      feeTokenAddresses,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Removes sellers from the allow list of a dispute resolver account by calling the
+   * `AccountHandlerFacet` contract. Note, that the caller must be the specified
+   * `admin` address of the dispute resolver account.
+   * @param disputeResolverId - Id of dispute resolver.
+   * @param sellerAllowList - List of seller ids that should be removed from the allow
+   * list of a dispute resolver.
+   * @returns Transaction response.
+   */
+  public async removeSellersFromDisputeResolverAllowList(
+    disputeResolverId: BigNumberish,
+    sellerAllowList: string[]
+  ): Promise<TransactionResponse> {
+    return accounts.handler.removeSellersFromAllowList({
+      disputeResolverId,
+      sellerAllowList,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Returns dispute resolver entity from subgraph.
+   * @param disputeResolverId - ID of dispute resolver entity to query for.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Dispute resolver entity from subgraph.
+   */
+  public async getDisputeResolverById(
+    disputeResolverId: BigNumberish,
+    queryVars?: accounts.subgraph.SingleDisputeResolverQueryVariables
+  ): Promise<subgraph.DisputeResolverFieldsFragment> {
+    return accounts.subgraph.getDisputeResolverById(
+      this._subgraphUrl,
+      disputeResolverId,
+      queryVars
+    );
+  }
+
+  /**
+   * Returns dispute resolver entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Dispute resolver entities from subgraph.
+   */
+  public async getDisputeResolvers(
+    queryVars?: subgraph.GetDisputeResolversQueryQueryVariables
+  ): Promise<subgraph.DisputeResolverFieldsFragment[]> {
+    return accounts.subgraph.getDisputeResolvers(this._subgraphUrl, queryVars);
+  }
+
   /* -------------------------------------------------------------------------- */
   /*                            Offer related methods                           */
   /* -------------------------------------------------------------------------- */
@@ -429,22 +649,21 @@ export class CoreSDK {
    * @param exchangeToken - Address exchange token.
    * @returns Decimals, name and symbol.
    */
-  public async getExchangeTokenInfo(exchangeToken: string): Promise<{
-    name: string;
-    decimals: number;
-    symbol: string;
-  }> {
-    const args = {
-      web3Lib: this._web3Lib,
-      contractAddress: exchangeToken
-    };
-    const [decimals, name, symbol] = await Promise.all([
-      erc20.handler.getDecimals(args),
-      erc20.handler.getName(args),
-      erc20.handler.getSymbol(args)
-    ]);
+  public async getExchangeTokenInfo(
+    exchangeToken: string
+  ): Promise<ITokenInfo> {
+    if (this._chainId === undefined) {
+      this._chainId = await this._web3Lib.getChainId();
+    }
 
-    return { decimals, name, symbol };
+    if (this._tokenInfoManager === undefined) {
+      this._tokenInfoManager = new TokenInfoManager(
+        this._chainId,
+        this._web3Lib
+      );
+    }
+
+    return this._tokenInfoManager.getExchangeTokenInfo(exchangeToken);
   }
 
   /**
@@ -707,6 +926,171 @@ export class CoreSDK {
     });
   }
 
+  /* -------------------------------------------------------------------------- */
+  /*                           Dispute related methods                          */
+  /* -------------------------------------------------------------------------- */
+
+  public async getDisputeById(
+    disputeId: BigNumberish,
+    queryVars?: disputes.subgraph.SingleDisputeQueryVariables
+  ) {
+    return disputes.subgraph.getDisputeById(
+      this._subgraphUrl,
+      disputeId,
+      queryVars
+    );
+  }
+
+  public async getDisputes(
+    queryVars?: subgraph.GetDisputesQueryQueryVariables
+  ) {
+    return disputes.subgraph.getDisputes(this._subgraphUrl, queryVars);
+  }
+
+  public async raiseDispute(
+    exchangeId: BigNumberish,
+    complaint: string
+  ): Promise<TransactionResponse> {
+    return disputes.handler.raiseDispute({
+      exchangeId,
+      complaint,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async retractDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.retractDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async extendDisputeTimeout(
+    exchangeId: BigNumberish,
+    newDisputeTimeout: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.extendDisputeTimeout({
+      exchangeId,
+      newDisputeTimeout,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async expireDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.expireDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async expireDisputeBatch(
+    exchangeIds: BigNumberish[]
+  ): Promise<TransactionResponse> {
+    return disputes.handler.expireDisputeBatch({
+      exchangeIds,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async resolveDispute(args: {
+    exchangeId: BigNumberish;
+    buyerPercent: BigNumberish;
+    sigR: BytesLike;
+    sigS: BytesLike;
+    sigV: BigNumberish;
+  }): Promise<TransactionResponse> {
+    return disputes.handler.resolveDispute({
+      ...args,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async escalateDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.escalateDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async decideDispute(
+    exchangeId: BigNumberish,
+    buyerPercent: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.decideDispute({
+      exchangeId,
+      buyerPercent,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async refuseEscalatedDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.refuseEscalatedDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async expireEscalatedDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return disputes.handler.expireEscalatedDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  public async signMutualAgreement(args: {
+    exchangeId: string;
+    buyerPercent: string;
+  }) {
+    // Set the message Type, needed for signature
+    const resolutionType = [
+      { name: "exchangeId", type: "uint256" },
+      { name: "buyerPercent", type: "uint256" }
+    ];
+
+    const customSignatureType = {
+      Resolution: resolutionType
+    };
+
+    const message = {
+      exchangeId: args.exchangeId,
+      buyerPercent: args.buyerPercent
+    };
+
+    if (this._chainId === undefined) {
+      this._chainId = await this._web3Lib.getChainId();
+    }
+
+    return metaTx.handler.prepareDataSignatureParameters({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      customTransactionType: customSignatureType,
+      primaryType: "Resolution",
+      message,
+      nonce: "" // not used in this case
+    });
+  }
+
   /* -------------------------------------------------------------------------- */
   /*                           Meta Tx related methods                          */
   /* -------------------------------------------------------------------------- */
@@ -767,4 +1151,22 @@ export class CoreSDK {
       ...args
     });
   }
+
+  public async renderContractualAgreementForOffer(
+    offerId: BigNumberish
+  ): Promise<string> {
+    const offerData = await offers.subgraph.getOfferById(
+      this._subgraphUrl,
+      offerId
+    );
+    return offers.renderContractualAgreementForOffer(offerData);
+  }
+
+  public async renderContractualAgreement(
+    template: string,
+    offerData: offers.CreateOfferArgs
+  ): Promise<string> {
+    const tokenInfo = await this.getExchangeTokenInfo(offerData.exchangeToken);
+    return offers.renderContractualAgreement(template, offerData, tokenInfo);
+  }
 }