@bosonprotocol/core-sdk 1.1.1 → 1.2.0-alpha.0

package/src/core-sdk.ts

@@ -7,8 +7,11 @@ import {
   Log
 } from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
+import * as accounts from "./accounts";
 import * as offers from "./offers";
+import * as orchestration from "./orchestration";
 import * as erc20 from "./erc20";
+import { getCreatedOfferIdFromLogs } from "./utils/logs";
 import { MultiQueryOpts } from "./utils/subgraph";
 
 export class CoreSDK {
@@ -70,6 +73,29 @@ export class CoreSDK {
     return this._metadataStorage.getMetadata(metadataHashOrUri);
   }
 
+  public async getSellerByOperator(
+    operator: string
+  ): Promise<accounts.RawSellerFromSubgraph> {
+    return accounts.subgraph.getSellerByOperator(this._subgraphUrl, operator);
+  }
+
+  public async createSellerAndOffer(
+    sellerToCreate: accounts.CreateSellerArgs,
+    offerToCreate: offers.CreateOfferArgs,
+    overrides: Partial<{
+      contractAddress: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    return orchestration.handler.createOfferAndSeller({
+      sellerToCreate,
+      offerToCreate,
+      web3Lib: this._web3Lib,
+      theGraphStorage: this._theGraphStorage,
+      metadataStorage: this._metadataStorage,
+      contractAddress: overrides.contractAddress || this._protocolDiamond
+    });
+  }
+
   public async createOffer(
     offerToCreate: offers.CreateOfferArgs,
     overrides: Partial<{
@@ -86,7 +112,17 @@ export class CoreSDK {
   }
 
   public getCreatedOfferIdFromLogs(logs: Log[]): string | null {
-    return offers.iface.getCreatedOfferIdFromLogs(logs);
+    try {
+      return getCreatedOfferIdFromLogs(
+        offers.iface.bosonOfferHandlerIface,
+        logs
+      );
+    } catch (offerError) {
+      return getCreatedOfferIdFromLogs(
+        orchestration.iface.bosonOrchestrationHandlerIface,
+        logs
+      );
+    }
   }
 
   public async voidOffer(
@@ -110,14 +146,20 @@ export class CoreSDK {
   }
 
   public async getAllOffersOfSeller(
-    sellerAddress: string,
+    sellerFilter: {
+      operatorAddress: string;
+      // TODO: add support for sellerId, adminAddress, clerkAddress, treasuryAddress
+    },
     opts: MultiQueryOpts = {}
   ): Promise<offers.RawOfferFromSubgraph[]> {
-    return offers.subgraph.getAllOffersOfSeller(
-      this._subgraphUrl,
-      sellerAddress,
-      opts
-    );
+    if (sellerFilter.operatorAddress) {
+      return offers.subgraph.getAllOffersOfOperator(
+        this._subgraphUrl,
+        sellerFilter.operatorAddress,
+        opts
+      );
+    }
+    return [];
   }
 
   public async getExchangeTokenAllowance(

package/src/offers/handler.ts

@@ -7,6 +7,7 @@ import {
 } from "@bosonprotocol/common";
 import { bosonOfferHandlerIface, encodeCreateOffer } from "./interface";
 import { getOfferById } from "./subgraph";
+import { storeMetadataOnTheGraph } from "./storage";
 import { CreateOfferArgs } from "./types";
 
 export async function createOffer(args: {
@@ -16,21 +17,15 @@ export async function createOffer(args: {
   metadataStorage?: MetadataStorage;
   theGraphStorage?: MetadataStorage;
 }): Promise<TransactionResponse> {
-  await utils.validation.createOfferArgsSchema.validate(args.offerToCreate, {
+  utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
     abortEarly: false
   });
 
-  // We use the feature `ipfsOnEthereum` in our subgraph to resolve metadata from IPFS
-  // and store them in the graph. In order for the graph node to reliably resolve them,
-  // we need to add the metadata additionally to the IPFS node of the graph.
-  // See https://thegraph.com/docs/en/developer/assemblyscript-api/#ipfs-api
-  if (args.metadataStorage && args.theGraphStorage) {
-    await storeMetadataOnTheGraph({
-      metadataUriOrHash: args.offerToCreate.metadataHash,
-      metadataStorage: args.metadataStorage,
-      theGraphStorage: args.theGraphStorage
-    });
-  }
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.offerToCreate.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
 
   return args.web3Lib.sendTransaction({
     to: args.contractAddress,
@@ -55,9 +50,9 @@ export async function voidOffer(args: {
   }
 
   const signerAddress = await args.web3Lib.getSignerAddress();
-  if (offer.seller.address.toLowerCase() !== signerAddress.toLowerCase()) {
+  if (offer.seller.operator.toLowerCase() !== signerAddress.toLowerCase()) {
     throw new Error(
-      `Signer with address "${signerAddress}" is not the seller "${offer.seller.address}"`
+      `Signer with address "${signerAddress}" is not the operator "${offer.seller.operator}"`
     );
   }
 
@@ -66,15 +61,3 @@ export async function voidOffer(args: {
     data: bosonOfferHandlerIface.encodeFunctionData("voidOffer", [args.offerId])
   });
 }
-
-export async function storeMetadataOnTheGraph(args: {
-  metadataUriOrHash: string;
-  metadataStorage: MetadataStorage;
-  theGraphStorage: MetadataStorage;
-}): Promise<string> {
-  const metadata = await args.metadataStorage.getMetadata(
-    args.metadataUriOrHash
-  );
-  const metadataUri = await args.theGraphStorage.storeMetadata(metadata);
-  return metadataUri;
-}

package/src/offers/index.ts

@@ -3,6 +3,7 @@ import { utils } from "@bosonprotocol/common";
 export * as handler from "./handler";
 export * as subgraph from "./subgraph";
 export * as iface from "./interface";
+export * as storage from "./storage";
 export * from "./types";
 
 export const validation = {

package/src/offers/interface.ts

@@ -1,28 +1,10 @@
-import { OfferStruct, utils, abis, Log } from "@bosonprotocol/common";
+import { OfferStruct, utils, abis } from "@bosonprotocol/common";
 import { Interface } from "@ethersproject/abi";
 import { getAddress } from "@ethersproject/address";
 import { CreateOfferArgs } from "./types";
 
 export const bosonOfferHandlerIface = new Interface(abis.IBosonOfferHandlerABI);
 
-export function getCreatedOfferIdFromLogs(logs: Log[]) {
-  const parsedLogs = logs.map((log) => parseLog(log.data, log.topics));
-
-  const [offerCreatedLog] = parsedLogs.filter(
-    (log) => log.name === "OfferCreated"
-  );
-
-  if (!offerCreatedLog) {
-    return null;
-  }
-
-  return String(offerCreatedLog.args.offerId);
-}
-
-export function parseLog(data: string, topics: string[]) {
-  return bosonOfferHandlerIface.parseLog({ data, topics });
-}
-
 export function encodeCreateOffer(args: CreateOfferArgs) {
   return bosonOfferHandlerIface.encodeFunctionData("createOffer", [
     createOfferArgsToStruct(args)
@@ -34,10 +16,9 @@ export function createOfferArgsToStruct(
 ): Partial<OfferStruct> {
   const {
     exchangeToken,
-    seller,
     validFromDateInMS,
     validUntilDateInMS,
-    redeemableDateInMS,
+    redeemableFromDateInMS,
     fulfillmentPeriodDurationInMS,
     voucherValidDurationInMS,
     ...restArgs
@@ -45,12 +26,12 @@ export function createOfferArgsToStruct(
 
   return {
     id: "0",
+    sellerId: "0",
     ...restArgs,
     exchangeToken: getAddress(exchangeToken),
-    seller: getAddress(seller),
     validFromDate: utils.timestamp.msToSec(validFromDateInMS),
     validUntilDate: utils.timestamp.msToSec(validUntilDateInMS),
-    redeemableDate: utils.timestamp.msToSec(redeemableDateInMS),
+    redeemableFromDate: utils.timestamp.msToSec(redeemableFromDateInMS),
     fulfillmentPeriodDuration: utils.timestamp.msToSec(
       fulfillmentPeriodDurationInMS
     ),

package/src/offers/storage.ts

@@ -0,0 +1,23 @@
+import { MetadataStorage } from "@bosonprotocol/common";
+
+/**
+ * We use the feature `ipfsOnEthereum` in our subgraph to resolve metadata from IPFS
+ * and store them in the graph. In order for the graph node to reliably resolve them,
+ * we need to add the metadata additionally to the IPFS node of the graph.
+ * See https://thegraph.com/docs/en/developer/assemblyscript-api/#ipfs-api
+ */
+export async function storeMetadataOnTheGraph(args: {
+  metadataUriOrHash: string;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+}): Promise<string | null> {
+  if (args.metadataStorage && args.theGraphStorage) {
+    const metadata = await args.metadataStorage.getMetadata(
+      args.metadataUriOrHash
+    );
+    const metadataUri = await args.theGraphStorage.storeMetadata(metadata);
+    return metadataUri;
+  }
+
+  return null;
+}

package/src/offers/subgraph.ts

@@ -7,19 +7,24 @@ fragment offerFields on Offer {
   id
   createdAt
   price
-  deposit
-  penalty
-  quantity
+  sellerDeposit
+  buyerCancelPenalty
+  quantityAvailable
   validFromDate
   validUntilDate
-  redeemableDate
+  redeemableFromDate
   fulfillmentPeriodDuration
   voucherValidDuration
   metadataUri
-  metadataHash
+  offerChecksum
   voidedAt
   seller {
-    address
+    id
+    operator
+    admin
+    clerk
+    treasury
+    active
   }
   exchangeToken {
     address
@@ -59,15 +64,17 @@ export async function getOfferById(
   return offer;
 }
 
-export const getAllOffersOfSellerQuery = `
-query GetAllOffersOfSellerQuery(
-  $seller: ID!,
+export const getAllOffersOfOperatorQuery = `
+query GetAllOffersOfOperatorQuery(
+  $operator: String!,
   $first: Int,
   $skip: Int,
   $orderBy: String,
   $orderDirection: String
 ) {
-  seller(id: $seller) {
+  sellers(where: {
+    operator: $operator
+  }) {
     offers(
       first: $first
       skip: $skip
@@ -81,15 +88,15 @@ query GetAllOffersOfSellerQuery(
 ${offerFieldsFragment}
 `;
 
-export async function getAllOffersOfSeller(
+export async function getAllOffersOfOperator(
   subgraphUrl: string,
-  sellerAddress: string,
+  operatorAddress: string,
   opts: MultiQueryOpts = {}
 ): Promise<RawOfferFromSubgraph[]> {
-  const { seller } = await fetchSubgraph<{
-    seller: { offers: RawOfferFromSubgraph[] };
-  }>(subgraphUrl, getAllOffersOfSellerQuery, {
-    seller: sellerAddress.toLowerCase(),
+  const { sellers } = await fetchSubgraph<{
+    sellers: { offers: RawOfferFromSubgraph[] };
+  }>(subgraphUrl, getAllOffersOfOperatorQuery, {
+    operator: operatorAddress.toLowerCase(),
     first: 100,
     skip: 0,
     orderBy: "createdAt",
@@ -97,9 +104,9 @@ export async function getAllOffersOfSeller(
     ...opts
   });
 
-  if (!seller) {
+  if (!sellers) {
     return [];
   }
 
-  return seller.offers;
+  return sellers[0].offers;
 }

package/src/offers/types.ts

@@ -4,19 +4,24 @@ export type RawOfferFromSubgraph = {
   id: string;
   createdAt: string;
   price: string;
-  deposit: string;
-  penalty: string;
-  quantity: string;
+  sellerDeposit: string;
+  buyerCancelPenalty: string;
+  quantityAvailable: string;
   validFromDate: string;
   validUntilDate: string;
-  redeemableDate: string;
+  redeemableFromDate: string;
   fulfillmentPeriodDuration: string;
   voucherValidDuration: string;
   metadataUri: string;
-  metadataHash: string;
+  offerChecksum: string;
   voidedAt: null | string;
   seller: {
-    address: string;
+    id: string;
+    operator: string;
+    admin: string;
+    clerk: string;
+    treasury: string;
+    active: boolean;
   };
   exchangeToken: {
     address: string;

package/src/orchestration/handler.ts

@@ -0,0 +1,39 @@
+import {
+  Web3LibAdapter,
+  TransactionResponse,
+  MetadataStorage,
+  utils
+} from "@bosonprotocol/common";
+import { encodeCreateSellerAndOffer } from "./interface";
+import { storeMetadataOnTheGraph } from "../offers/storage";
+
+import { CreateOfferArgs } from "../offers/types";
+import { CreateSellerArgs } from "../accounts/types";
+
+export async function createOfferAndSeller(args: {
+  offerToCreate: CreateOfferArgs;
+  sellerToCreate: CreateSellerArgs;
+  contractAddress: string;
+  web3Lib: Web3LibAdapter;
+  metadataStorage?: MetadataStorage;
+  theGraphStorage?: MetadataStorage;
+}): Promise<TransactionResponse> {
+  utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
+    abortEarly: false
+  });
+
+  utils.validation.createSellerArgsSchema.validateSync(args.sellerToCreate, {
+    abortEarly: false
+  });
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.offerToCreate.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
+  return args.web3Lib.sendTransaction({
+    to: args.contractAddress,
+    data: encodeCreateSellerAndOffer(args.sellerToCreate, args.offerToCreate)
+  });
+}

package/src/orchestration/index.ts

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

package/src/orchestration/interface.ts

@@ -0,0 +1,21 @@
+import { abis } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { createSellerArgsToStruct } from "../accounts/interface";
+import { createOfferArgsToStruct } from "../offers/interface";
+
+import { CreateSellerArgs } from "../accounts/types";
+import { CreateOfferArgs } from "../offers/types";
+
+export const bosonOrchestrationHandlerIface = new Interface(
+  abis.IBosonOrchestrationHandlerABI
+);
+
+export function encodeCreateSellerAndOffer(
+  seller: CreateSellerArgs,
+  offer: CreateOfferArgs
+) {
+  return bosonOrchestrationHandlerIface.encodeFunctionData(
+    "createSellerAndOffer",
+    [createSellerArgsToStruct(seller), createOfferArgsToStruct(offer)]
+  );
+}

package/src/utils/logs.ts

@@ -0,0 +1,16 @@
+import { Log } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+
+export function getCreatedOfferIdFromLogs(iface: Interface, logs: Log[]) {
+  const parsedLogs = logs.map((log) => iface.parseLog(log));
+
+  const [offerCreatedLog] = parsedLogs.filter(
+    (log) => log.name === "OfferCreated"
+  );
+
+  if (!offerCreatedLog) {
+    return null;
+  }
+
+  return String(offerCreatedLog.args.offerId);
+}