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

package/src/offers/handler.ts

@@ -73,6 +73,7 @@ export async function reserveRange(args: {
   subgraphUrl: string;
   offerId: BigNumberish;
   length: BigNumberish;
+  to: string;
   web3Lib: Web3LibAdapter;
 }): Promise<TransactionResponse> {
   const offerFromSubgraph = await getOfferById(args.subgraphUrl, args.offerId);
@@ -87,7 +88,7 @@ export async function reserveRange(args: {
 
   return args.web3Lib.sendTransaction({
     to: args.contractAddress,
-    data: encodeReserveRange(args.offerId, args.length)
+    data: encodeReserveRange(args.offerId, args.length, args.to)
   });
 }
 
@@ -145,6 +146,38 @@ export async function voidOfferBatch(args: {
   });
 }
 
+export async function extendOffer(args: {
+  contractAddress: string;
+  subgraphUrl: string;
+  offerId: BigNumberish;
+  validUntil: BigNumberish;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: bosonOfferHandlerIface.encodeFunctionData("extendOffer", [
+      args.offerId,
+      args.validUntil
+    ])
+  });
+}
+
+export async function extendOfferBatch(args: {
+  contractAddress: string;
+  subgraphUrl: string;
+  offerIds: BigNumberish[];
+  validUntil: BigNumberish;
+  web3Lib: Web3LibAdapter;
+}): Promise<TransactionResponse> {
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: bosonOfferHandlerIface.encodeFunctionData("extendOfferBatch", [
+      args.offerIds,
+      args.validUntil
+    ])
+  });
+}
+
 function checkIfOfferVoidable(
   offerId: BigNumberish,
   signerAddress: string,
@@ -159,11 +192,11 @@ function checkIfOfferVoidable(
   }
 
   if (
-    offerFromSubgraph.seller.operator.toLowerCase() !==
+    offerFromSubgraph.seller.assistant.toLowerCase() !==
     signerAddress.toLowerCase()
   ) {
     throw new Error(
-      `Signer with address "${signerAddress}" is not the operator "${offerFromSubgraph.seller.operator}" of offer with id "${offerId}"`
+      `Signer with address "${signerAddress}" is not the assistant "${offerFromSubgraph.seller.assistant}" of offer with id "${offerId}"`
     );
   }
 }

package/src/offers/interface.ts

@@ -132,10 +132,12 @@ export function argsToOfferDurationsStruct(
 
 export function encodeReserveRange(
   offerId: BigNumberish,
-  length: BigNumberish
+  length: BigNumberish,
+  to: string
 ) {
   return bosonOfferHandlerIface.encodeFunctionData("reserveRange", [
     offerId,
-    length
+    length,
+    to
   ]);
 }

package/src/offers/mixin.ts

@@ -146,7 +146,7 @@ export class OfferMixin extends BaseCoreSDK {
 
   /**
    * Voids an existing offer by calling the `OfferHandlerFacet` contract.
-   * This transaction only succeeds if the connected signer is the `operator`.
+   * This transaction only succeeds if the connected signer is the `assistant`.
    * @param offerId - ID of offer to void.
    * @param overrides - Optional overrides.
    * @returns Transaction response.
@@ -167,7 +167,7 @@ export class OfferMixin extends BaseCoreSDK {
 
   /**
    * Voids a batch of existing offers by calling the `OfferHandlerFacet` contract.
-   * This transaction only succeeds if the connected signer is the `operator` of all
+   * This transaction only succeeds if the connected signer is the `assistant` of all
    * provided offers.
    * @param offerIds - IDs of offers to void.
    * @param overrides - Optional overrides.
@@ -187,6 +187,55 @@ export class OfferMixin extends BaseCoreSDK {
     });
   }
 
+  /**
+   * Extends an existing offer by calling the `OfferHandlerFacet` contract.
+   * This transaction only succeeds if the connected signer is the `assistant`.
+   * @param offerId - ID of offer to void.
+   * @param validUntil - new validity date.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async extendOffer(
+    offerId: BigNumberish,
+    validUntil: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.extendOffer({
+      offerId,
+      validUntil,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
+  /**
+   * Extends a batch of existing offers by calling the `OfferHandlerFacet` contract.
+   * This transaction only succeeds if the connected signer is the `assistant` of all
+   * provided offers.
+   * @param offerIds - IDs of offers to void.
+   * @param validUntil - new validity date.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async extendOfferBatch(
+    offerIds: BigNumberish[],
+    validUntil: BigNumberish,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return offers.handler.extendOfferBatch({
+      offerIds,
+      validUntil,
+      web3Lib: this._web3Lib,
+      subgraphUrl: this._subgraphUrl,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
   /**
    * Returns offer from subgraph.
    * @param offerId - ID of offer.
@@ -255,13 +304,19 @@ export class OfferMixin extends BaseCoreSDK {
   public async reserveRange(
     offerId: BigNumberish,
     length: BigNumberish,
+    to: "seller" | "contract",
     overrides: Partial<{
       contractAddress: string;
     }> = {}
   ): Promise<TransactionResponse> {
+    const offer = await this.getOfferById(offerId);
     return offers.handler.reserveRange({
       offerId,
       length,
+      to:
+        to === "contract"
+          ? offer.seller.voucherCloneAddress
+          : offer.seller.assistant,
       subgraphUrl: this._subgraphUrl,
       contractAddress: overrides.contractAddress || this._protocolDiamond,
       web3Lib: this._web3Lib

package/src/offers/queries.graphql

@@ -94,6 +94,9 @@ fragment BaseOfferFields on Offer {
     description
     externalUrl
     animationUrl
+    animationMetadata {
+      ...BaseAnimationMetadataFields
+    }
     licenseUrl
     condition
     schemaUrl
@@ -128,4 +131,14 @@ fragment BaseOfferFields on Offer {
       }
     }
   }
+  range {
+    ...BaseRangeFields
+  }
+}
+
+fragment BaseRangeFields on RangeEntity {
+  id
+  start
+  end
+  owner
 }

package/src/offers/renderContractualAgreement.ts

@@ -292,21 +292,18 @@ export async function renderContractualAgreementForOffer(
       `Invalid Offer Metadata: Type is not supported: '${existingOfferData.metadata.type}'`
     );
   }
-  if (
-    !(existingOfferData.metadata as productV1.ProductV1Metadata).exchangePolicy
-  ) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (!(existingOfferData.metadata as any).exchangePolicy) {
     throw new Error(`Invalid Offer Metadata: exchangePolicy is not defined`);
   }
-  if (
-    !(existingOfferData.metadata as productV1.ProductV1Metadata).exchangePolicy
-      .template
-  ) {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  if (!(existingOfferData.metadata as any).exchangePolicy.template) {
     throw new Error(
       `Invalid Offer Metadata: exchangePolicy.template is not defined`
     );
   }
-  const template = (existingOfferData.metadata as productV1.ProductV1Metadata)
-    .exchangePolicy.template;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const template = (existingOfferData.metadata as any).exchangePolicy.template;
   const convertedOfferArgs = convertExistingOfferData(existingOfferData);
   return renderContractualAgreement(
     template,

package/src/seaport/abi.ts

@@ -0,0 +1,149 @@
+export const seaportAbi = [
+  {
+    inputs: [
+      {
+        components: [
+          {
+            components: [
+              {
+                internalType: "address",
+                name: "offerer",
+                type: "address"
+              },
+              {
+                internalType: "address",
+                name: "zone",
+                type: "address"
+              },
+              {
+                components: [
+                  {
+                    internalType: "enum ItemType",
+                    name: "itemType",
+                    type: "uint8"
+                  },
+                  {
+                    internalType: "address",
+                    name: "token",
+                    type: "address"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "identifierOrCriteria",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "startAmount",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "endAmount",
+                    type: "uint256"
+                  }
+                ],
+                internalType: "struct OfferItem[]",
+                name: "offer",
+                type: "tuple[]"
+              },
+              {
+                components: [
+                  {
+                    internalType: "enum ItemType",
+                    name: "itemType",
+                    type: "uint8"
+                  },
+                  {
+                    internalType: "address",
+                    name: "token",
+                    type: "address"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "identifierOrCriteria",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "startAmount",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "uint256",
+                    name: "endAmount",
+                    type: "uint256"
+                  },
+                  {
+                    internalType: "address payable",
+                    name: "recipient",
+                    type: "address"
+                  }
+                ],
+                internalType: "struct ConsiderationItem[]",
+                name: "consideration",
+                type: "tuple[]"
+              },
+              {
+                internalType: "enum OrderType",
+                name: "orderType",
+                type: "uint8"
+              },
+              {
+                internalType: "uint256",
+                name: "startTime",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "endTime",
+                type: "uint256"
+              },
+              {
+                internalType: "bytes32",
+                name: "zoneHash",
+                type: "bytes32"
+              },
+              {
+                internalType: "uint256",
+                name: "salt",
+                type: "uint256"
+              },
+              {
+                internalType: "bytes32",
+                name: "conduitKey",
+                type: "bytes32"
+              },
+              {
+                internalType: "uint256",
+                name: "totalOriginalConsiderationItems",
+                type: "uint256"
+              }
+            ],
+            internalType: "struct OrderParameters",
+            name: "parameters",
+            type: "tuple"
+          },
+          {
+            internalType: "bytes",
+            name: "signature",
+            type: "bytes"
+          }
+        ],
+        internalType: "struct Order[]",
+        name: "",
+        type: "tuple[]"
+      }
+    ],
+    name: "validate",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];

package/src/seaport/handler.ts

@@ -0,0 +1,57 @@
+import { BigNumberish } from "@ethersproject/bignumber";
+import { Interface } from "@ethersproject/abi";
+import { seaportAbi } from "./abi";
+
+const seaportIface = new Interface(seaportAbi);
+
+export enum eOrderType {
+  FULL_OPEN = 0,
+  PARTIAL_OPEN = 1,
+  FULL_RESTRICTED = 2,
+  PARTIAL_RESTRICTED = 3,
+  CONTRACT = 4
+}
+
+export enum eItemType {
+  NATIVE = 0,
+  ERC20 = 1,
+  ERC721 = 2,
+  ERC1155 = 3,
+  ERC721_WITH_CRITERIA = 4,
+  ERC1155_WITH_CRITERIA = 5
+}
+
+type OfferItem = {
+  itemType: eItemType;
+  token: string;
+  identifierOrCriteria: BigNumberish;
+  startAmount: BigNumberish;
+  endAmount: BigNumberish;
+};
+
+type ConsiderationItem = OfferItem & {
+  recipient: string;
+};
+
+type OrderParameters = {
+  offerer: string;
+  zone: string;
+  offer: OfferItem[];
+  consideration: ConsiderationItem[];
+  orderType: eOrderType;
+  startTime: BigNumberish;
+  endTime: BigNumberish;
+  zoneHash: string;
+  salt: BigNumberish;
+  conduitKey: string;
+  totalOriginalConsiderationItems: BigNumberish;
+};
+
+export type Order = {
+  parameters: OrderParameters;
+  signature: string;
+};
+
+export function encodeValidate(orders: Order[]) {
+  return seaportIface.encodeFunctionData("validate", [orders]);
+}

package/src/seaport/index.ts

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