@bosonprotocol/core-sdk 1.24.0 → 1.24.1-alpha.1

package/src/offers/handler.ts

@@ -8,7 +8,8 @@ import {
 import {
   bosonOfferHandlerIface,
   encodeCreateOffer,
-  encodeCreateOfferBatch
+  encodeCreateOfferBatch,
+  encodeReserveRange
 } from "./interface";
 import { getOfferById, getOffers } from "./subgraph";
 import { storeMetadataOnTheGraph } from "./storage";
@@ -67,6 +68,29 @@ export async function createOfferBatch(args: {
   });
 }
 
+export async function reserveRange(args: {
+  contractAddress: string;
+  subgraphUrl: string;
+  offerId: BigNumberish;
+  length: BigNumberish;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  const offerFromSubgraph = await getOfferById(args.subgraphUrl, args.offerId);
+  const signerAddress = await args.web3Lib.getSignerAddress();
+
+  checkIfOfferReservable(
+    args.offerId,
+    args.length,
+    signerAddress,
+    offerFromSubgraph
+  );
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeReserveRange(args.offerId, args.length)
+  });
+}
+
 export async function voidOffer(args: {
   contractAddress: string;
   subgraphUrl: string;
@@ -143,3 +167,20 @@ function checkIfOfferVoidable(
     );
   }
 }
+
+function checkIfOfferReservable(
+  offerId: BigNumberish,
+  length: BigNumberish,
+  signerAddress: string,
+  offerFromSubgraph?: OfferFieldsFragment
+) {
+  checkIfOfferVoidable(offerId, signerAddress, offerFromSubgraph);
+
+  if (!length) {
+    throw new Error(`Range length is zero`);
+  }
+
+  if (offerFromSubgraph.quantityAvailable < length) {
+    throw new Error(`Range length is too large`);
+  }
+}

package/src/offers/interface.ts

@@ -129,3 +129,13 @@ export function argsToOfferDurationsStruct(
     resolutionPeriod: utils.timestamp.msToSec(resolutionPeriodDurationInMS)
   };
 }
+
+export function encodeReserveRange(
+  offerId: BigNumberish,
+  length: BigNumberish
+) {
+  return bosonOfferHandlerIface.encodeFunctionData("reserveRange", [
+    offerId,
+    length
+  ]);
+}

package/src/offers/mixin.ts

@@ -246,6 +246,28 @@ export class OfferMixin extends BaseCoreSDK {
     );
   }
 
+  /**
+   * Reserves a range of vouchers to be associated with an offer
+   * @param offerId -  Offer ID
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async reserveRange(
+    offerId: BigNumberish,
+    length: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.reserveRange({
+      offerId,
+      length,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
   /* -------------------------------------------------------------------------- */
   /*                   ERC20 / Exchange Token related methods                   */
   /* -------------------------------------------------------------------------- */

package/src/orchestration/handler.ts

@@ -7,13 +7,19 @@ import {
 } from "@bosonprotocol/common";
 import {
   encodeCreateOfferWithCondition,
+  encodeCreatePremintedOfferAddToGroup,
+  encodeCreatePremintedOfferWithCondition,
   encodeCreateSellerAndOffer,
-  encodeCreateSellerAndOfferWithCondition
+  encodeCreateSellerAndOfferWithCondition,
+  encodeCreateSellerAndPremintedOffer,
+  encodeCreateSellerAndPremintedOfferWithCondition,
+  encodeRaiseAndEscalateDispute
 } from "./interface";
 import { storeMetadataOnTheGraph } from "../offers/storage";
 
 import { CreateOfferArgs } from "../offers/types";
 import { CreateSellerArgs } from "../accounts/types";
+import { BigNumberish } from "@ethersproject/bignumber";
 
 export async function createOfferAndSeller(args: {
   offerToCreate: CreateOfferArgs;
@@ -95,3 +101,134 @@ export async function createSellerAndOfferWithCondition(args: {
     )
   });
 }
+
+export async function createPremintedOfferAddToGroup(args: {
+  offerToCreate: CreateOfferArgs;
+  reservedRangeLength: BigNumberish;
+  groupId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+}): Promise<TransactionResponse> {
+  utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
+    abortEarly: false
+  });
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.offerToCreate.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCreatePremintedOfferAddToGroup(
+      args.offerToCreate,
+      args.reservedRangeLength,
+      args.groupId
+    )
+  });
+}
+
+export async function createPremintedOfferWithCondition(args: {
+  offerToCreate: CreateOfferArgs;
+  reservedRangeLength: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+}): Promise<TransactionResponse> {
+  utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
+    abortEarly: false
+  });
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.offerToCreate.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCreatePremintedOfferWithCondition(
+      args.offerToCreate,
+      args.reservedRangeLength,
+      args.condition
+    )
+  });
+}
+
+export async function createSellerAndPremintedOffer(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  reservedRangeLength: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+}): Promise<TransactionResponse> {
+  utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
+    abortEarly: false
+  });
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.offerToCreate.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCreateSellerAndPremintedOffer(
+      args.sellerToCreate,
+      args.offerToCreate,
+      args.reservedRangeLength
+    )
+  });
+}
+
+export async function createSellerAndPremintedOfferWithCondition(args: {
+  sellerToCreate: CreateSellerArgs;
+  offerToCreate: CreateOfferArgs;
+  reservedRangeLength: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+  condition: ConditionStruct;
+}): Promise<TransactionResponse> {
+  utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
+    abortEarly: false
+  });
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.offerToCreate.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCreateSellerAndPremintedOfferWithCondition(
+      args.sellerToCreate,
+      args.offerToCreate,
+      args.reservedRangeLength,
+      args.condition
+    )
+  });
+}
+
+export async function raiseAndEscalateDispute(args: {
+  exchangeId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeRaiseAndEscalateDispute(args.exchangeId)
+  });
+}

package/src/orchestration/interface.ts

@@ -5,6 +5,7 @@ import { createOfferArgsToStructs } from "../offers/interface";
 
 import { CreateSellerArgs } from "../accounts/types";
 import { CreateOfferArgs } from "../offers/types";
+import { BigNumberish } from "@ethersproject/bignumber";
 
 export const bosonOrchestrationHandlerIface = new Interface(
   abis.IBosonOrchestrationHandlerABI
@@ -71,3 +72,99 @@ export function encodeCreateSellerAndOfferWithCondition(
     ]
   );
 }
+
+export function encodeCreatePremintedOfferAddToGroup(
+  offer: CreateOfferArgs,
+  reservedRangeLength: BigNumberish,
+  groupId: BigNumberish
+) {
+  const offerArgs = createOfferArgsToStructs(offer);
+
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "createPremintedOfferAddToGroup",
+    [
+      offerArgs[0], // offer
+      offerArgs[1], // offerDates
+      offerArgs[2], // offerDurations
+      offerArgs[3], // disputeResolverId
+      reservedRangeLength,
+      groupId,
+      offerArgs[4] // agentId
+    ]
+  );
+}
+
+export function encodeCreatePremintedOfferWithCondition(
+  offer: CreateOfferArgs,
+  reservedRangeLength: BigNumberish,
+  condition: ConditionStruct
+) {
+  const offerArgs = createOfferArgsToStructs(offer);
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "createPremintedOfferWithCondition",
+    [
+      offerArgs[0], // offer
+      offerArgs[1], // offerDates
+      offerArgs[2], // offerDurations
+      offerArgs[3], // disputeResolverId
+      reservedRangeLength,
+      condition,
+      offerArgs[4] // agentId
+    ]
+  );
+}
+
+export function encodeCreateSellerAndPremintedOffer(
+  seller: CreateSellerArgs,
+  offer: CreateOfferArgs,
+  reservedRangeLength: BigNumberish
+) {
+  const sellerArgs = createSellerArgsToStruct(seller);
+  const offerArgs = createOfferArgsToStructs(offer);
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "createSellerAndPremintedOffer",
+    [
+      sellerArgs.sellerStruct,
+      offerArgs[0], // offer
+      offerArgs[1], // offerDates
+      offerArgs[2], // offerDurations
+      offerArgs[3], // disputeResolverId
+      reservedRangeLength,
+      sellerArgs.authTokenStruct,
+      sellerArgs.voucherInitValues,
+      offerArgs[4] // agentId
+    ]
+  );
+}
+
+export function encodeCreateSellerAndPremintedOfferWithCondition(
+  seller: CreateSellerArgs,
+  offer: CreateOfferArgs,
+  reservedRangeLength: BigNumberish,
+  condition: ConditionStruct
+) {
+  const sellerArgs = createSellerArgsToStruct(seller);
+  const offerArgs = createOfferArgsToStructs(offer);
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "createSellerAndPremintedOfferWithCondition",
+    [
+      sellerArgs.sellerStruct,
+      offerArgs[0], // offer
+      offerArgs[1], // offerDates
+      offerArgs[2], // offerDurations
+      offerArgs[3], // disputeResolverId
+      reservedRangeLength,
+      condition,
+      sellerArgs.authTokenStruct,
+      sellerArgs.voucherInitValues,
+      offerArgs[4] // agentId
+    ]
+  );
+}
+
+export function encodeRaiseAndEscalateDispute(exchangeId: BigNumberish) {
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "raiseAndEscalateDispute",
+    [exchangeId]
+  );
+}

package/src/orchestration/mixin.ts

@@ -1,4 +1,5 @@
 import { ConditionStruct, TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
 import { handler } from ".";
 import { offers, accounts } from "..";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
@@ -54,4 +55,138 @@ export class OrchestrationMixin extends BaseCoreSDK {
       condition
     });
   }
+
+  /**
+   * Creates a preminted offer and adds it to an existing group
+   * @param offerToCreate - Offer arguments.
+   * @param reservedRangeLength - Already reserved range length.
+   * @param groupId -  Group ID the offer will be added to
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createPremintedOfferAddToGroup(
+    offerToCreate: offers.CreateOfferArgs,
+    reservedRangeLength: BigNumberish,
+    groupId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createPremintedOfferAddToGroup({
+      offerToCreate,
+      reservedRangeLength,
+      groupId,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage
+    });
+  }
+
+  /**
+   * Creates a seller account and preminted offer
+   * 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 createSellerAndPremintedOffer(
+    sellerToCreate: accounts.CreateSellerArgs,
+    offerToCreate: offers.CreateOfferArgs,
+    reservedRangeLength: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createSellerAndPremintedOffer({
+      sellerToCreate,
+      offerToCreate,
+      reservedRangeLength,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage
+    });
+  }
+
+  /**
+   * Creates a preminted offer and adds it to an existing group
+   * @param offerToCreate - Offer arguments.
+   * @param reservedRangeLength - Already reserved range length.
+   * @param groupId -  Group ID the offer will be added to
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createPremintedOfferWithCondition(
+    offerToCreate: offers.CreateOfferArgs,
+    reservedRangeLength: BigNumberish,
+    condition: ConditionStruct,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createPremintedOfferWithCondition({
+      offerToCreate,
+      reservedRangeLength,
+      condition,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage
+    });
+  }
+
+  /**
+   * Creates a seller account and preminted 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 reservedRangeLength -  Already reserved range length.
+   * @param condition -  contract condition applied to the offer
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async createSellerAndPremintedOfferWithCondition(
+    sellerToCreate: accounts.CreateSellerArgs,
+    offerToCreate: offers.CreateOfferArgs,
+    reservedRangeLength: BigNumberish,
+    condition: ConditionStruct,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.createSellerAndPremintedOfferWithCondition({
+      sellerToCreate,
+      offerToCreate,
+      reservedRangeLength,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage,
+      condition
+    });
+  }
+
+  /**
+   * Raises a dispute and immediately escalates it
+   * @param exchangeId - Exchange ID
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async raiseAndEscalateDispute(
+    exchangeId: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return handler.raiseAndEscalateDispute({
+      exchangeId,
+      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      web3Lib: this._web3Lib,
+      metadataStorage: this._metadataStorage,
+      theGraphStorage: this._theGraphStorage
+    });
+  }
 }

package/src/utils/signature.ts

@@ -27,6 +27,11 @@ export async function prepareDataSignatureParameters(args: SignatureArgs) {
     salt: hexZeroPad(BigNumber.from(args.chainId).toHexString(), 32),
     ...args.customDomainData
   };
+  Object.keys(domainData).forEach((key) => {
+    if (domainData[key] === undefined) {
+      delete domainData[key];
+    }
+  });
 
   const signatureTypes = {
     EIP712Domain: domainType,

package/src/voucher/handler.ts

@@ -0,0 +1,79 @@
+import { TransactionResponse, Web3LibAdapter } from "@bosonprotocol/common";
+import { Range } from "@bosonprotocol/common/src/types";
+import { BigNumberish } from "@ethersproject/bignumber";
+import {
+  decodeGetAvailablePreMints,
+  decodeGetRangeByOfferId,
+  encodeBurnPremintedVouchers,
+  encodeGetAvailablePreMints,
+  encodeGetRangeByOfferId,
+  encodePreMint,
+  encodeTransferFrom
+} from "./interface";
+
+export async function burnPremintedVouchers(args: {
+  offerId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeBurnPremintedVouchers(args.offerId)
+  });
+}
+
+export async function getAvailablePreMints(args: {
+  offerId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<string> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: encodeGetAvailablePreMints(args.offerId)
+  });
+  const [count] = decodeGetAvailablePreMints(result);
+  return String(count);
+}
+
+export async function getRangeByOfferId(args: {
+  offerId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<Range> {
+  const result = await args.web3Lib.call({
+    to: args.contractAddress,
+    data: encodeGetRangeByOfferId(args.offerId)
+  });
+  const [range] = decodeGetRangeByOfferId(result);
+  return {
+    start: range.start,
+    length: range._length,
+    minted: range.minted,
+    lastBurnedTokenId: range.lastBurnedTokenId
+  };
+}
+
+export async function preMint(args: {
+  offerId: BigNumberish;
+  amount: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodePreMint(args.offerId, args.amount)
+  });
+}
+
+export async function transferFrom(args: {
+  from: BigNumberish;
+  to: BigNumberish;
+  tokenId: BigNumberish;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeTransferFrom(args.from, args.to, args.tokenId)
+  });
+}

package/src/voucher/index.ts

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

package/src/voucher/interface.ts

@@ -0,0 +1,45 @@
+import { abis } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { BigNumberish } from "@ethersproject/bignumber";
+
+export const bosonVoucherIface = new Interface(abis.IBosonVoucherABI);
+
+export function encodeBurnPremintedVouchers(offerId: BigNumberish) {
+  return bosonVoucherIface.encodeFunctionData("burnPremintedVouchers", [
+    offerId
+  ]);
+}
+
+export function encodeGetAvailablePreMints(offerId: BigNumberish) {
+  return bosonVoucherIface.encodeFunctionData("getAvailablePreMints", [
+    offerId
+  ]);
+}
+
+export function decodeGetAvailablePreMints(result: string) {
+  return bosonVoucherIface.decodeFunctionResult("getAvailablePreMints", result);
+}
+
+export function encodeGetRangeByOfferId(offerId: BigNumberish) {
+  return bosonVoucherIface.encodeFunctionData("getRangeByOfferId", [offerId]);
+}
+
+export function decodeGetRangeByOfferId(result: string) {
+  return bosonVoucherIface.decodeFunctionResult("getRangeByOfferId", result);
+}
+
+export function encodePreMint(offerId: BigNumberish, amount: BigNumberish) {
+  return bosonVoucherIface.encodeFunctionData("preMint", [offerId, amount]);
+}
+
+export function encodeTransferFrom(
+  from: BigNumberish,
+  to: BigNumberish,
+  tokenId: BigNumberish
+) {
+  return bosonVoucherIface.encodeFunctionData("transferFrom", [
+    from,
+    to,
+    tokenId
+  ]);
+}