@bosonprotocol/core-sdk 1.29.0-ludo.1 → 1.29.0

package/dist/esm/offers/handler.js

@@ -1,119 +1,119 @@
-import { utils } from "@bosonprotocol/common";
-import { bosonOfferHandlerIface, encodeCreateOffer, encodeCreateOfferBatch, encodeReserveRange } from "./interface";
-import { getOfferById, getOffers } from "./subgraph";
-import { storeMetadataOnTheGraph } from "./storage";
-export async function createOffer(args) {
-    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: encodeCreateOffer(args.offerToCreate)
-    });
-}
-export async function createOfferBatch(args) {
-    for (const offerToCreate of args.offersToCreate) {
-        utils.validation.createOfferArgsSchema.validateSync(offerToCreate, {
-            abortEarly: false
-        });
-    }
-    await Promise.all(args.offersToCreate.map((offerToCreate) => storeMetadataOnTheGraph({
-        metadataUriOrHash: offerToCreate.metadataUri,
-        metadataStorage: args.metadataStorage,
-        theGraphStorage: args.theGraphStorage
-    })));
-    return args.web3Lib.sendTransaction({
-        to: args.contractAddress,
-        data: encodeCreateOfferBatch(args.offersToCreate)
-    });
-}
-export async function reserveRange(args) {
-    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, args.to)
-    });
-}
-export async function voidOffer(args) {
-    const offerFromSubgraph = await getOfferById(args.subgraphUrl, args.offerId);
-    const signerAddress = await args.web3Lib.getSignerAddress();
-    checkIfOfferVoidable(args.offerId, signerAddress, offerFromSubgraph);
-    return args.web3Lib.sendTransaction({
-        to: args.contractAddress,
-        data: bosonOfferHandlerIface.encodeFunctionData("voidOffer", [args.offerId])
-    });
-}
-export async function voidOfferBatch(args) {
-    const offersFromSubgraph = await getOffers(args.subgraphUrl, {
-        offersFilter: {
-            id_in: args.offerIds.map(String)
-        }
-    });
-    const signerAddress = await args.web3Lib.getSignerAddress();
-    const invalidOfferIdErrors = [];
-    for (const offerId of args.offerIds) {
-        const offerFromSubgraph = offersFromSubgraph.find((offer) => offer.id === offerId.toString());
-        try {
-            checkIfOfferVoidable(offerId, signerAddress, offerFromSubgraph);
-        }
-        catch (error) {
-            invalidOfferIdErrors.push(error);
-        }
-    }
-    if (invalidOfferIdErrors.length) {
-        throw new Error(`Some offers can not be voided. ${invalidOfferIdErrors}`);
-    }
-    return args.web3Lib.sendTransaction({
-        to: args.contractAddress,
-        data: bosonOfferHandlerIface.encodeFunctionData("voidOfferBatch", [
-            args.offerIds
-        ])
-    });
-}
-export async function extendOffer(args) {
-    return args.web3Lib.sendTransaction({
-        to: args.contractAddress,
-        data: bosonOfferHandlerIface.encodeFunctionData("extendOffer", [
-            args.offerId,
-            args.validUntil
-        ])
-    });
-}
-export async function extendOfferBatch(args) {
-    return args.web3Lib.sendTransaction({
-        to: args.contractAddress,
-        data: bosonOfferHandlerIface.encodeFunctionData("extendOfferBatch", [
-            args.offerIds,
-            args.validUntil
-        ])
-    });
-}
-function checkIfOfferVoidable(offerId, signerAddress, offerFromSubgraph) {
-    if (!offerFromSubgraph) {
-        throw new Error(`Offer with id "${offerId}" does not exist`);
-    }
-    if (offerFromSubgraph.voidedAt) {
-        throw new Error(`Offer with id "${offerId}" is already voided`);
-    }
-    if (offerFromSubgraph.seller.assistant.toLowerCase() !==
-        signerAddress.toLowerCase()) {
-        throw new Error(`Signer with address "${signerAddress}" is not the assistant "${offerFromSubgraph.seller.assistant}" of offer with id "${offerId}"`);
-    }
-}
-function checkIfOfferReservable(offerId, length, signerAddress, offerFromSubgraph) {
-    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`);
-    }
-}
+import { utils } from "@bosonprotocol/common";
+import { bosonOfferHandlerIface, encodeCreateOffer, encodeCreateOfferBatch, encodeReserveRange } from "./interface";
+import { getOfferById, getOffers } from "./subgraph";
+import { storeMetadataOnTheGraph } from "./storage";
+export async function createOffer(args) {
+    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: encodeCreateOffer(args.offerToCreate)
+    });
+}
+export async function createOfferBatch(args) {
+    for (const offerToCreate of args.offersToCreate) {
+        utils.validation.createOfferArgsSchema.validateSync(offerToCreate, {
+            abortEarly: false
+        });
+    }
+    await Promise.all(args.offersToCreate.map((offerToCreate) => storeMetadataOnTheGraph({
+        metadataUriOrHash: offerToCreate.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+    })));
+    return args.web3Lib.sendTransaction({
+        to: args.contractAddress,
+        data: encodeCreateOfferBatch(args.offersToCreate)
+    });
+}
+export async function reserveRange(args) {
+    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, args.to)
+    });
+}
+export async function voidOffer(args) {
+    const offerFromSubgraph = await getOfferById(args.subgraphUrl, args.offerId);
+    const signerAddress = await args.web3Lib.getSignerAddress();
+    checkIfOfferVoidable(args.offerId, signerAddress, offerFromSubgraph);
+    return args.web3Lib.sendTransaction({
+        to: args.contractAddress,
+        data: bosonOfferHandlerIface.encodeFunctionData("voidOffer", [args.offerId])
+    });
+}
+export async function voidOfferBatch(args) {
+    const offersFromSubgraph = await getOffers(args.subgraphUrl, {
+        offersFilter: {
+            id_in: args.offerIds.map(String)
+        }
+    });
+    const signerAddress = await args.web3Lib.getSignerAddress();
+    const invalidOfferIdErrors = [];
+    for (const offerId of args.offerIds) {
+        const offerFromSubgraph = offersFromSubgraph.find((offer) => offer.id === offerId.toString());
+        try {
+            checkIfOfferVoidable(offerId, signerAddress, offerFromSubgraph);
+        }
+        catch (error) {
+            invalidOfferIdErrors.push(error);
+        }
+    }
+    if (invalidOfferIdErrors.length) {
+        throw new Error(`Some offers can not be voided. ${invalidOfferIdErrors}`);
+    }
+    return args.web3Lib.sendTransaction({
+        to: args.contractAddress,
+        data: bosonOfferHandlerIface.encodeFunctionData("voidOfferBatch", [
+            args.offerIds
+        ])
+    });
+}
+export async function extendOffer(args) {
+    return args.web3Lib.sendTransaction({
+        to: args.contractAddress,
+        data: bosonOfferHandlerIface.encodeFunctionData("extendOffer", [
+            args.offerId,
+            args.validUntil
+        ])
+    });
+}
+export async function extendOfferBatch(args) {
+    return args.web3Lib.sendTransaction({
+        to: args.contractAddress,
+        data: bosonOfferHandlerIface.encodeFunctionData("extendOfferBatch", [
+            args.offerIds,
+            args.validUntil
+        ])
+    });
+}
+function checkIfOfferVoidable(offerId, signerAddress, offerFromSubgraph) {
+    if (!offerFromSubgraph) {
+        throw new Error(`Offer with id "${offerId}" does not exist`);
+    }
+    if (offerFromSubgraph.voidedAt) {
+        throw new Error(`Offer with id "${offerId}" is already voided`);
+    }
+    if (offerFromSubgraph.seller.assistant.toLowerCase() !==
+        signerAddress.toLowerCase()) {
+        throw new Error(`Signer with address "${signerAddress}" is not the assistant "${offerFromSubgraph.seller.assistant}" of offer with id "${offerId}"`);
+    }
+}
+function checkIfOfferReservable(offerId, length, signerAddress, offerFromSubgraph) {
+    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`);
+    }
+}
 //# sourceMappingURL=handler.js.map

package/dist/esm/offers/index.d.ts

@@ -1,13 +1,13 @@
-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 * from "./getOfferStatus";
-export * from "./renderContractualAgreement";
-export * from "./checkExchangePolicy";
-export declare const validation: {
-    createOfferArgsSchema: typeof utils.validation.createOfferArgsSchema;
-};
+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 * from "./getOfferStatus";
+export * from "./renderContractualAgreement";
+export * from "./checkExchangePolicy";
+export declare const validation: {
+    createOfferArgsSchema: typeof utils.validation.createOfferArgsSchema;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/offers/index.js

@@ -1,13 +1,13 @@
-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 * from "./getOfferStatus";
-export * from "./renderContractualAgreement";
-export * from "./checkExchangePolicy";
-export const validation = {
-    createOfferArgsSchema: utils.validation.createOfferArgsSchema
-};
+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 * from "./getOfferStatus";
+export * from "./renderContractualAgreement";
+export * from "./checkExchangePolicy";
+export const validation = {
+    createOfferArgsSchema: utils.validation.createOfferArgsSchema
+};
 //# sourceMappingURL=index.js.map

package/dist/esm/offers/interface.d.ts

@@ -1,19 +1,19 @@
-import { OfferStruct, OfferDatesStruct, OfferDurationsStruct } from "@bosonprotocol/common";
-import { Interface } from "@ethersproject/abi";
-import { BigNumberish } from "@ethersproject/bignumber";
-import { CreateOfferArgs } from "./types";
-export declare const bosonOfferHandlerIface: Interface;
-export declare function encodeCreateOffer(args: CreateOfferArgs): string;
-export declare function encodeCreateOfferBatch(argsBatch: CreateOfferArgs[]): string;
-export declare function createOfferArgsToStructs(args: CreateOfferArgs): [
-    Partial<OfferStruct>,
-    Partial<OfferDatesStruct>,
-    Partial<OfferDurationsStruct>,
-    BigNumberish,
-    BigNumberish
-];
-export declare function argsToOfferStruct(args: CreateOfferArgs): Partial<OfferStruct>;
-export declare function argsToOfferDatesStruct(args: CreateOfferArgs): Partial<OfferDatesStruct>;
-export declare function argsToOfferDurationsStruct(args: CreateOfferArgs): Partial<OfferDurationsStruct>;
-export declare function encodeReserveRange(offerId: BigNumberish, length: BigNumberish, to: string): string;
+import { OfferStruct, OfferDatesStruct, OfferDurationsStruct } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { CreateOfferArgs } from "./types";
+export declare const bosonOfferHandlerIface: Interface;
+export declare function encodeCreateOffer(args: CreateOfferArgs): string;
+export declare function encodeCreateOfferBatch(argsBatch: CreateOfferArgs[]): string;
+export declare function createOfferArgsToStructs(args: CreateOfferArgs): [
+    Partial<OfferStruct>,
+    Partial<OfferDatesStruct>,
+    Partial<OfferDurationsStruct>,
+    BigNumberish,
+    BigNumberish
+];
+export declare function argsToOfferStruct(args: CreateOfferArgs): Partial<OfferStruct>;
+export declare function argsToOfferDatesStruct(args: CreateOfferArgs): Partial<OfferDatesStruct>;
+export declare function argsToOfferDurationsStruct(args: CreateOfferArgs): Partial<OfferDurationsStruct>;
+export declare function encodeReserveRange(offerId: BigNumberish, length: BigNumberish, to: string): string;
 //# sourceMappingURL=interface.d.ts.map

package/dist/esm/offers/interface.js

@@ -1,76 +1,76 @@
-import { utils, abis } from "@bosonprotocol/common";
-import { Interface } from "@ethersproject/abi";
-import { getAddress } from "@ethersproject/address";
-export const bosonOfferHandlerIface = new Interface(abis.IBosonOfferHandlerABI);
-export function encodeCreateOffer(args) {
-    return bosonOfferHandlerIface.encodeFunctionData("createOffer", createOfferArgsToStructs(args));
-}
-export function encodeCreateOfferBatch(argsBatch) {
-    const argsTuples = argsBatch.map((args) => [
-        argsToOfferStruct(args),
-        argsToOfferDatesStruct(args),
-        argsToOfferDurationsStruct(args),
-        args.disputeResolverId,
-        args.agentId
-    ]);
-    const [offers, offerDates, offerDurations, disputeResolverIds, agentIds] = argsTuples.reduce((acc, tuple) => {
-        const [offer, offerDates, offerDurations, disputeResolverId, agentId] = tuple;
-        return [
-            [...acc[0], offer],
-            [...acc[1], offerDates],
-            [...acc[2], offerDurations],
-            [...acc[3], disputeResolverId],
-            [...acc[4], agentId]
-        ];
-    }, [[], [], [], [], []]);
-    return bosonOfferHandlerIface.encodeFunctionData("createOfferBatch", [
-        offers,
-        offerDates,
-        offerDurations,
-        disputeResolverIds,
-        agentIds
-    ]);
-}
-export function createOfferArgsToStructs(args) {
-    return [
-        argsToOfferStruct(args),
-        argsToOfferDatesStruct(args),
-        argsToOfferDurationsStruct(args),
-        args.disputeResolverId,
-        args.agentId
-    ];
-}
-export function argsToOfferStruct(args) {
-    const { exchangeToken, ...restArgs } = args;
-    return {
-        id: "0",
-        sellerId: "0",
-        ...restArgs,
-        exchangeToken: getAddress(exchangeToken)
-    };
-}
-export function argsToOfferDatesStruct(args) {
-    const { validFromDateInMS, validUntilDateInMS, voucherRedeemableFromDateInMS, voucherRedeemableUntilDateInMS } = args;
-    return {
-        validFrom: utils.timestamp.msToSec(validFromDateInMS),
-        validUntil: utils.timestamp.msToSec(validUntilDateInMS),
-        voucherRedeemableFrom: utils.timestamp.msToSec(voucherRedeemableFromDateInMS),
-        voucherRedeemableUntil: utils.timestamp.msToSec(voucherRedeemableUntilDateInMS)
-    };
-}
-export function argsToOfferDurationsStruct(args) {
-    const { disputePeriodDurationInMS, voucherValidDurationInMS = 0, resolutionPeriodDurationInMS } = args;
-    return {
-        disputePeriod: utils.timestamp.msToSec(disputePeriodDurationInMS),
-        voucherValid: utils.timestamp.msToSec(voucherValidDurationInMS),
-        resolutionPeriod: utils.timestamp.msToSec(resolutionPeriodDurationInMS)
-    };
-}
-export function encodeReserveRange(offerId, length, to) {
-    return bosonOfferHandlerIface.encodeFunctionData("reserveRange", [
-        offerId,
-        length,
-        to
-    ]);
-}
+import { utils, abis } from "@bosonprotocol/common";
+import { Interface } from "@ethersproject/abi";
+import { getAddress } from "@ethersproject/address";
+export const bosonOfferHandlerIface = new Interface(abis.IBosonOfferHandlerABI);
+export function encodeCreateOffer(args) {
+    return bosonOfferHandlerIface.encodeFunctionData("createOffer", createOfferArgsToStructs(args));
+}
+export function encodeCreateOfferBatch(argsBatch) {
+    const argsTuples = argsBatch.map((args) => [
+        argsToOfferStruct(args),
+        argsToOfferDatesStruct(args),
+        argsToOfferDurationsStruct(args),
+        args.disputeResolverId,
+        args.agentId
+    ]);
+    const [offers, offerDates, offerDurations, disputeResolverIds, agentIds] = argsTuples.reduce((acc, tuple) => {
+        const [offer, offerDates, offerDurations, disputeResolverId, agentId] = tuple;
+        return [
+            [...acc[0], offer],
+            [...acc[1], offerDates],
+            [...acc[2], offerDurations],
+            [...acc[3], disputeResolverId],
+            [...acc[4], agentId]
+        ];
+    }, [[], [], [], [], []]);
+    return bosonOfferHandlerIface.encodeFunctionData("createOfferBatch", [
+        offers,
+        offerDates,
+        offerDurations,
+        disputeResolverIds,
+        agentIds
+    ]);
+}
+export function createOfferArgsToStructs(args) {
+    return [
+        argsToOfferStruct(args),
+        argsToOfferDatesStruct(args),
+        argsToOfferDurationsStruct(args),
+        args.disputeResolverId,
+        args.agentId
+    ];
+}
+export function argsToOfferStruct(args) {
+    const { exchangeToken, ...restArgs } = args;
+    return {
+        id: "0",
+        sellerId: "0",
+        ...restArgs,
+        exchangeToken: getAddress(exchangeToken)
+    };
+}
+export function argsToOfferDatesStruct(args) {
+    const { validFromDateInMS, validUntilDateInMS, voucherRedeemableFromDateInMS, voucherRedeemableUntilDateInMS } = args;
+    return {
+        validFrom: utils.timestamp.msToSec(validFromDateInMS),
+        validUntil: utils.timestamp.msToSec(validUntilDateInMS),
+        voucherRedeemableFrom: utils.timestamp.msToSec(voucherRedeemableFromDateInMS),
+        voucherRedeemableUntil: utils.timestamp.msToSec(voucherRedeemableUntilDateInMS)
+    };
+}
+export function argsToOfferDurationsStruct(args) {
+    const { disputePeriodDurationInMS, voucherValidDurationInMS = 0, resolutionPeriodDurationInMS } = args;
+    return {
+        disputePeriod: utils.timestamp.msToSec(disputePeriodDurationInMS),
+        voucherValid: utils.timestamp.msToSec(voucherValidDurationInMS),
+        resolutionPeriod: utils.timestamp.msToSec(resolutionPeriodDurationInMS)
+    };
+}
+export function encodeReserveRange(offerId, length, to) {
+    return bosonOfferHandlerIface.encodeFunctionData("reserveRange", [
+        offerId,
+        length,
+        to
+    ]);
+}
 //# sourceMappingURL=interface.js.map