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

package/src/disputes/mixin.ts

@@ -0,0 +1,240 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as subgraph from "../subgraph";
+import { TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+import {
+  raiseDispute,
+  retractDispute,
+  extendDisputeTimeout,
+  expireDispute,
+  expireDisputeBatch,
+  resolveDispute,
+  escalateDispute,
+  decideDispute,
+  refuseEscalatedDispute,
+  expireEscalatedDispute,
+  signResolutionProposal
+} from "./handler";
+import {
+  SingleDisputeQueryVariables,
+  getDisputeById,
+  getDisputes
+} from "./subgraph";
+
+export class DisputesMixin extends BaseCoreSDK {
+  /* -------------------------------------------------------------------------- */
+  /*                           Dispute related methods                          */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Returns dispute entity from subgraph.
+   * @param disputeId - ID of dispute entity.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Dispute entity from subgraph.
+   */
+  public async getDisputeById(
+    disputeId: BigNumberish,
+    queryVars?: SingleDisputeQueryVariables
+  ) {
+    return getDisputeById(this._subgraphUrl, disputeId, queryVars);
+  }
+
+  /**
+   * Returns dispute entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Dispute entities from subgraph.
+   */
+  public async getDisputes(
+    queryVars?: subgraph.GetDisputesQueryQueryVariables
+  ) {
+    return getDisputes(this._subgraphUrl, queryVars);
+  }
+
+  /**
+   * Raises a dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of exchange to dispute.
+   * @returns Transaction response.
+   */
+  public async raiseDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return raiseDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Retracts a dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @returns Transaction response.
+   */
+  public async retractDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return retractDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Extends the dispute timeout by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @param newDisputeTimeout - New dispute timeout in seconds.
+   * @returns Transaction response.
+   */
+  public async extendDisputeTimeout(
+    exchangeId: BigNumberish,
+    newDisputeTimeout: BigNumberish
+  ): Promise<TransactionResponse> {
+    return extendDisputeTimeout({
+      exchangeId,
+      newDisputeTimeout,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Expires a dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @returns Transaction response.
+   */
+  public async expireDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return expireDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Expires many disputes by calling the `DisputeHandlerContract`.
+   * @param exchangeIds - IDs of disputed exchanges.
+   * @returns Transaction response.
+   */
+  public async expireDisputeBatch(
+    exchangeIds: BigNumberish[]
+  ): Promise<TransactionResponse> {
+    return expireDisputeBatch({
+      exchangeIds,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Resolves dispute by calling the `DisputeHandlerContract`. If caller is `buyer` then
+   * signature of `seller` is required as an argument. If caller if `seller` then vice-versa.
+   * The signature can be retrieved by calling the method
+   * `CoreSDK.signDisputeResolutionProposal`.
+   * @param args - Dispute resolve arguments:
+   * - `args.exchangeId` - ID of disputed exchange.
+   * - `args.buyerPercent` - Percentage of deposit the buyer gets.
+   * - `args.sigR` - r signature value of counterparty.
+   * - `args.sigS` - s signature value of counterparty.
+   * - `args.sigV` - v signature value of counterparty.
+   * @returns Transaction response.
+   */
+  public async resolveDispute(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+    sigR: BytesLike;
+    sigS: BytesLike;
+    sigV: BigNumberish;
+  }): Promise<TransactionResponse> {
+    return resolveDispute({
+      ...args,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Escalates dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @returns Transaction response.
+   */
+  public async escalateDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return escalateDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Decides dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @param buyerPercent - Percentage of deposit buyer gets.
+   * @returns Transaction response.
+   */
+  public async decideDispute(
+    exchangeId: BigNumberish,
+    buyerPercent: BigNumberish
+  ): Promise<TransactionResponse> {
+    return decideDispute({
+      exchangeId,
+      buyerPercent,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Refuses escalated dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @returns Transaction response.
+   */
+  public async refuseEscalatedDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return refuseEscalatedDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Expires escalated dispute by calling the `DisputeHandlerContract`.
+   * @param exchangeId - ID of disputed exchange.
+   * @returns Transaction response.
+   */
+  public async expireEscalatedDispute(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return expireEscalatedDispute({
+      exchangeId,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Signs dispute resolution message.
+   * @param args - Dispute resolve arguments:
+   * - `args.exchangeId` - ID of disputed exchange.
+   * - `args.buyerPercentBasisPoints` - Percentage of deposit the buyer gets.
+   * @returns Signature.
+   */
+  public async signDisputeResolutionProposal(args: {
+    exchangeId: BigNumberish;
+    buyerPercentBasisPoints: BigNumberish;
+  }) {
+    return signResolutionProposal({
+      ...args,
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      chainId: this._chainId
+    });
+  }
+}

package/src/erc1155/handler.ts

@@ -0,0 +1,21 @@
+import { Web3LibAdapter } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { erc1155Iface } from "./interface";
+
+export async function balanceOf(args: {
+  contractAddress: string;
+  tokenId: BigNumberish;
+  owner: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<string> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: erc1155Iface.encodeFunctionData("balanceOf", [
+      args.owner,
+      args.tokenId
+    ])
+  });
+
+  const [balance] = erc1155Iface.decodeFunctionResult("balanceOf", result);
+  return String(balance);
+}

package/src/erc1155/index.ts

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

package/src/erc1155/interface.ts

@@ -0,0 +1,4 @@
+import { abis } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+
+export const erc1155Iface = new Interface(abis.ERC1155);

package/src/erc20/handler.ts

@@ -81,3 +81,17 @@ export async function ensureAllowance(args: {
     await approveTx.wait();
   }
 }
+
+export async function balanceOf(args: {
+  contractAddress: string;
+  owner: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<string> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: erc20Iface.encodeFunctionData("balanceOf", [args.owner])
+  });
+
+  const [balance] = erc20Iface.decodeFunctionResult("balanceOf", result);
+  return String(balance);
+}

package/src/erc721/handler.ts

@@ -16,6 +16,20 @@ export async function balanceOf(args: {
   return String(balance);
 }
 
+export async function ownerOf(args: {
+  contractAddress: string;
+  tokenId: BigNumberish;
+  web3Lib: Web3LibAdapter;
+}): Promise<string> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: erc721Iface.encodeFunctionData("ownerOf", [args.tokenId])
+  });
+
+  const [owner] = erc721Iface.decodeFunctionResult("ownerOf", result);
+  return String(owner);
+}
+
 export async function tokenOfOwnerByIndex(args: {
   contractAddress: string;
   owner: string;

package/src/event-logs/mixin.ts

@@ -0,0 +1,16 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as subgraph from "../subgraph";
+import { getEventLogs } from "./subgraph";
+
+export class EventLogsMixin extends BaseCoreSDK {
+  /**
+   * 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 getEventLogs(this._subgraphUrl, queryVars);
+  }
+}

package/src/exchanges/mixin.ts

@@ -0,0 +1,184 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as subgraph from "../subgraph";
+import { TransactionResponse, Log } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { getValueFromLogs } from "../utils/logs";
+import {
+  commitToOffer,
+  revokeVoucher,
+  cancelVoucher,
+  redeemVoucher,
+  completeExchange,
+  completeExchangeBatch,
+  expireVoucher
+} from "./handler";
+import { getExchangeById, getExchanges } from "./subgraph";
+import { bosonExchangeHandlerIface } from "./interface";
+
+export class ExchangesMixin extends BaseCoreSDK {
+  /* -------------------------------------------------------------------------- */
+  /*                          Exchange related methods                          */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Returns exchange entity from subgraph.
+   * @param exchangeId - ID of exchange entity.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Exchange entity from subgraph.
+   */
+  public async getExchangeById(
+    exchangeId: BigNumberish,
+    queryVars?: subgraph.GetExchangeByIdQueryQueryVariables
+  ): Promise<subgraph.ExchangeFieldsFragment> {
+    return getExchangeById(this._subgraphUrl, exchangeId, queryVars);
+  }
+
+  /**
+   * Returns exchange entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Exchange entities from subgraph.
+   */
+  public async getExchanges(
+    queryVars?: subgraph.GetExchangesQueryQueryVariables
+  ): Promise<subgraph.ExchangeFieldsFragment[]> {
+    return getExchanges(this._subgraphUrl, queryVars);
+  }
+
+  /**
+   * Commits to an offer by calling the `ExchangeHandlerContract`.
+   * This transaction only succeeds if the seller has deposited funds.
+   * @param offerId - ID of offer to commit to.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async commitToOffer(
+    offerId: BigNumberish,
+    overrides: Partial<{
+      buyer: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const buyer = overrides.buyer || (await this._web3Lib.getSignerAddress());
+    return commitToOffer({
+      buyer,
+      offerId,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: this._protocolDiamond
+    });
+  }
+
+  /**
+   * Utility method to retrieve the created `exchangeId` from logs after calling `commitToOffer`.
+   * @param logs - Logs to search in.
+   * @returns Created exchange id.
+   */
+  public getCommittedExchangeIdFromLogs(logs: Log[]): string | null {
+    return getValueFromLogs({
+      iface: bosonExchangeHandlerIface,
+      logs,
+      eventArgsKey: "exchangeId",
+      eventName: "BuyerCommitted"
+    });
+  }
+
+  /**
+   * Revokes an existing voucher by calling the `ExchangeHandlerContract`.
+   * Callable by seller `operator`.
+   * @param exchangeId - ID of exchange to revoke.
+   * @returns Transaction response.
+   */
+  public async revokeVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return revokeVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
+  /**
+   * Cancels an existing voucher by calling the `ExchangeHandlerContract`.
+   * Callable by buyer.
+   * @param exchangeId - ID of exchange to cancel.
+   * @returns Transaction response.
+   */
+  public async cancelVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return cancelVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
+  /**
+   * Redeems an existing voucher by calling the `ExchangeHandlerContract`.
+   * Callable by buyer.
+   * @param exchangeId - ID of exchange to redeem.
+   * @returns Transaction response.
+   */
+  public async redeemVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return redeemVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
+  /**
+   * Completes an existing voucher by calling the `ExchangeHandlerContract`.
+   * Callable by buyer or seller operator.
+   * @param exchangeId - ID of exchange to complete.
+   * @returns Transaction response.
+   */
+  public async completeExchange(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return completeExchange({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+
+  /**
+   * 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 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.
+   * @returns Transaction response.
+   */
+  public async expireVoucher(
+    exchangeId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return expireVoucher({
+      web3Lib: this._web3Lib,
+      contractAddress: this._protocolDiamond,
+      exchangeId,
+      subgraphUrl: this._subgraphUrl
+    });
+  }
+}

package/src/funds/mixin.ts

@@ -0,0 +1,99 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as subgraph from "../subgraph";
+import { TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { AddressZero } from "@ethersproject/constants";
+import {
+  withdrawFunds,
+  withdrawAllAvailableFunds,
+  depositFunds
+} from "./handler";
+import { getFundsById, getFunds } from "./subgraph";
+
+export class FundsMixin extends BaseCoreSDK {
+  /* -------------------------------------------------------------------------- */
+  /*                            Funds related methods                           */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Deposit funds by calling the `FundsHandlerFacet` contract.
+   * @param sellerId - ID of seller account to deposit funds for.
+   * @param fundsAmount - Amount of funds.
+   * @param fundsTokenAddress - Address of funds token.
+   * @returns Transaction response.
+   */
+  public async depositFunds(
+    sellerId: BigNumberish,
+    fundsAmount: BigNumberish,
+    fundsTokenAddress: string = AddressZero
+  ): Promise<TransactionResponse> {
+    return depositFunds({
+      sellerId,
+      fundsAmount,
+      fundsTokenAddress,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Returns funds entity from subgraph.
+   * @param fundsId - ID of funds entity.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Funds entity from subgraph.
+   */
+  public async getFundsById(
+    fundsId: BigNumberish,
+    queryVars?: subgraph.GetFundsByIdQueryVariables
+  ): Promise<subgraph.FundsEntityFieldsFragment> {
+    return getFundsById(this._subgraphUrl, fundsId, queryVars);
+  }
+
+  /**
+   * Returns funds entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns Funds entities from subgraph.
+   */
+  public async getFunds(
+    queryVars?: subgraph.GetFundsQueryVariables
+  ): Promise<subgraph.FundsEntityFieldsFragment[]> {
+    return getFunds(this._subgraphUrl, queryVars);
+  }
+
+  /**
+   * Withdraw selected funds by calling the `FundsHandlerFacet` contract.
+   * @param sellerId - ID of seller account to withdraw funds for.
+   * @param tokensToWithdraw - Addresses of funds tokens to withdraw.
+   * @param amountsToWithdraw - Amounts of funds token to withdraw.
+   * @returns Transaction response.
+   */
+  public async withdrawFunds(
+    sellerId: BigNumberish,
+    tokensToWithdraw: Array<string>,
+    amountsToWithdraw: Array<BigNumberish>
+  ): Promise<TransactionResponse> {
+    return withdrawFunds({
+      sellerId,
+      tokensToWithdraw,
+      amountsToWithdraw,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
+  /**
+   * Withdraw all available funds by calling the `FundsHandlerFacet` contract.
+   * @param sellerId - ID of seller account to withdraw funds for.
+   * @returns Transaction response.
+   */
+  public async withdrawAllAvailableFunds(
+    sellerId: BigNumberish
+  ): Promise<TransactionResponse> {
+    return withdrawAllAvailableFunds({
+      sellerId,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+}

package/src/groups/mixin.ts

@@ -0,0 +1,24 @@
+import { CreateGroupArgs, TransactionResponse } from "@bosonprotocol/common";
+import { handler } from ".";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+
+export class GroupsMixin extends BaseCoreSDK {
+  /**
+   * Creates a group of contract addresses
+   * @param groupToCreate -  group with the contract condition
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createGroup(
+    groupToCreate: CreateGroupArgs,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createGroup({
+      groupToCreate,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+}