@opensea/seaport-js 1.0.0

package/lib/utils/item.d.ts

@@ -0,0 +1,29 @@
+import { BigNumber } from "ethers";
+import type { InputCriteria, Item, Order, OrderParameters } from "../types";
+export declare const isCurrencyItem: ({ itemType }: Item) => boolean;
+export declare const isNativeCurrencyItem: ({ itemType }: Item) => boolean;
+export declare const isErc20Item: (itemType: Item["itemType"]) => boolean;
+export declare const isErc721Item: (itemType: Item["itemType"]) => boolean;
+export declare const isErc1155Item: (itemType: Item["itemType"]) => boolean;
+export declare const isCriteriaItem: (itemType: Item["itemType"]) => boolean;
+export declare type TimeBasedItemParams = {
+    isConsiderationItem?: boolean;
+    currentBlockTimestamp: number;
+    ascendingAmountTimestampBuffer: number;
+} & Pick<OrderParameters, "startTime" | "endTime">;
+export declare const getPresentItemAmount: ({ startAmount, endAmount, timeBasedItemParams, }: Pick<Item, "startAmount" | "endAmount"> & {
+    timeBasedItemParams?: TimeBasedItemParams | undefined;
+}) => BigNumber;
+export declare const getSummedTokenAndIdentifierAmounts: ({ items, criterias, timeBasedItemParams, }: {
+    items: Item[];
+    criterias: InputCriteria[];
+    timeBasedItemParams?: TimeBasedItemParams | undefined;
+}) => Record<string, Record<string, BigNumber>>;
+/**
+ * Returns the maximum size of units possible for the order
+ * If any of the items on a partially fillable order specify a different "startAmount" and "endAmount
+ * (e.g. they are ascending-amount or descending-amount items), the fraction will be applied to both amounts
+ * prior to determining the current price. This ensures that cleanly divisible amounts can be chosen when
+ * constructing the order without a dependency on the time when the order is ultimately fulfilled.
+ */
+export declare const getMaximumSizeForOrder: ({ parameters: { offer, consideration }, }: Order) => BigNumber;

package/lib/utils/item.js

@@ -0,0 +1,136 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMaximumSizeForOrder = exports.getSummedTokenAndIdentifierAmounts = exports.getPresentItemAmount = exports.isCriteriaItem = exports.isErc1155Item = exports.isErc721Item = exports.isErc20Item = exports.isNativeCurrencyItem = exports.isCurrencyItem = void 0;
+var ethers_1 = require("ethers");
+var constants_1 = require("../constants");
+var criteria_1 = require("./criteria");
+var gcd_1 = require("./gcd");
+var isCurrencyItem = function (_a) {
+    var itemType = _a.itemType;
+    return [constants_1.ItemType.NATIVE, constants_1.ItemType.ERC20].includes(itemType);
+};
+exports.isCurrencyItem = isCurrencyItem;
+var isNativeCurrencyItem = function (_a) {
+    var itemType = _a.itemType;
+    return itemType === constants_1.ItemType.NATIVE;
+};
+exports.isNativeCurrencyItem = isNativeCurrencyItem;
+var isErc20Item = function (itemType) {
+    return itemType === constants_1.ItemType.ERC20;
+};
+exports.isErc20Item = isErc20Item;
+var isErc721Item = function (itemType) {
+    return [constants_1.ItemType.ERC721, constants_1.ItemType.ERC721_WITH_CRITERIA].includes(itemType);
+};
+exports.isErc721Item = isErc721Item;
+var isErc1155Item = function (itemType) {
+    return [constants_1.ItemType.ERC1155, constants_1.ItemType.ERC1155_WITH_CRITERIA].includes(itemType);
+};
+exports.isErc1155Item = isErc1155Item;
+var isCriteriaItem = function (itemType) {
+    return [constants_1.ItemType.ERC721_WITH_CRITERIA, constants_1.ItemType.ERC1155_WITH_CRITERIA].includes(itemType);
+};
+exports.isCriteriaItem = isCriteriaItem;
+var getPresentItemAmount = function (_a) {
+    var startAmount = _a.startAmount, endAmount = _a.endAmount, timeBasedItemParams = _a.timeBasedItemParams;
+    var startAmountBn = ethers_1.BigNumber.from(startAmount);
+    var endAmountBn = ethers_1.BigNumber.from(endAmount);
+    if (!timeBasedItemParams) {
+        return startAmountBn.gt(endAmountBn) ? startAmountBn : endAmountBn;
+    }
+    var isConsiderationItem = timeBasedItemParams.isConsiderationItem, currentBlockTimestamp = timeBasedItemParams.currentBlockTimestamp, ascendingAmountTimestampBuffer = timeBasedItemParams.ascendingAmountTimestampBuffer, startTime = timeBasedItemParams.startTime, endTime = timeBasedItemParams.endTime;
+    var duration = ethers_1.BigNumber.from(endTime).sub(startTime);
+    var isAscending = endAmountBn.gt(startAmount);
+    var adjustedBlockTimestamp = ethers_1.BigNumber.from(isAscending
+        ? currentBlockTimestamp + ascendingAmountTimestampBuffer
+        : currentBlockTimestamp);
+    if (adjustedBlockTimestamp.lt(startTime)) {
+        return startAmountBn;
+    }
+    var elapsed = (adjustedBlockTimestamp.gt(endTime)
+        ? ethers_1.BigNumber.from(endTime)
+        : adjustedBlockTimestamp).sub(startTime);
+    var remaining = duration.sub(elapsed);
+    // Adjust amounts based on current time
+    // For offer items, we round down
+    // For consideration items, we round up
+    return startAmountBn
+        .mul(remaining)
+        .add(endAmountBn.mul(elapsed))
+        .add(isConsiderationItem ? duration.sub(1) : 0)
+        .div(duration);
+};
+exports.getPresentItemAmount = getPresentItemAmount;
+var getSummedTokenAndIdentifierAmounts = function (_a) {
+    var items = _a.items, criterias = _a.criterias, timeBasedItemParams = _a.timeBasedItemParams;
+    var itemToCriteria = (0, criteria_1.getItemToCriteriaMap)(items, criterias);
+    var tokenAndIdentifierToSummedAmount = items.reduce(function (map, item) {
+        var _a, _b;
+        var _c, _d, _e, _f;
+        var identifierOrCriteria = (_d = (_c = itemToCriteria.get(item)) === null || _c === void 0 ? void 0 : _c.identifier) !== null && _d !== void 0 ? _d : item.identifierOrCriteria;
+        return __assign(__assign({}, map), (_a = {}, _a[item.token] = __assign(__assign({}, map[item.token]), (_b = {}, _b[identifierOrCriteria] = ((_f = (_e = map[item.token]) === null || _e === void 0 ? void 0 : _e[identifierOrCriteria]) !== null && _f !== void 0 ? _f : ethers_1.BigNumber.from(0)).add((0, exports.getPresentItemAmount)({
+            startAmount: item.startAmount,
+            endAmount: item.endAmount,
+            timeBasedItemParams: timeBasedItemParams,
+        })), _b)), _a));
+    }, {});
+    return tokenAndIdentifierToSummedAmount;
+};
+exports.getSummedTokenAndIdentifierAmounts = getSummedTokenAndIdentifierAmounts;
+/**
+ * Returns the maximum size of units possible for the order
+ * If any of the items on a partially fillable order specify a different "startAmount" and "endAmount
+ * (e.g. they are ascending-amount or descending-amount items), the fraction will be applied to both amounts
+ * prior to determining the current price. This ensures that cleanly divisible amounts can be chosen when
+ * constructing the order without a dependency on the time when the order is ultimately fulfilled.
+ */
+var getMaximumSizeForOrder = function (_a) {
+    var _b = _a.parameters, offer = _b.offer, consideration = _b.consideration;
+    var allItems = __spreadArray(__spreadArray([], __read(offer), false), __read(consideration), false);
+    var amounts = allItems.flatMap(function (_a) {
+        var startAmount = _a.startAmount, endAmount = _a.endAmount;
+        return [
+            startAmount,
+            endAmount,
+        ];
+    });
+    return (0, gcd_1.findGcd)(amounts);
+};
+exports.getMaximumSizeForOrder = getMaximumSizeForOrder;
+//# sourceMappingURL=item.js.map

package/lib/utils/item.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"item.js","sourceRoot":"","sources":["../../src/utils/item.ts"],"names":[],"mappings":"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"}

package/lib/utils/match.d.ts

@@ -0,0 +1,54 @@
+/** Giant TODO for match orders
+# Match orders
+
+- Format: list of fulfillments
+    - Each fulfillment represents a single transfer or “execution”
+    - Each fulfillment specifies an array of offer “components” corresponding to offer items to spend as well as an array of consideration “components” corresponding to consideration items to receive
+    - every offer component and consideration component contains an index of the order it is from as well as an index of the item in the respective offer or consideration array on that order
+    - the “from” address will be the offerer of whatever offer items are being spent
+    - the “to” address will be the recipient of whatever consideration items are being received
+- the “One rule” to follow for the whole set of fulfillments:
+    - All consideration items must be fully accounted for after adjusting for partial fills and ascending/descending amounts
+- the “Four rules” to follow for each distinct fulfillment:
+    1. you need at least one offer component and at least one consideration component for each fulfillment; otherwise you don’t know what the “from” or “to” address should be
+    2. the offer item corresponding to the first offer component has to match the consideration item corresponding to the first consideration component (with the exception of the amount); otherwise you’re not sending the item that the recipient is expecting
+    3. any additional offer items need to match the original offer items (with the exception of the amount) and the same *the offerer*; otherwise you’re composing different items or different origins.
+        1. This implies that ERC721 fulfillments will always have a single offer component (even if that corresponding offer item is present in multiple fulfillments, i.e. criteria-based partial fills)
+
+Example: Bulk purchase
+
+- Five distinct sellers create orders to sell ERC721 NFTs for ETH.
+    - single offer item on each order: the NFT
+    - two consideration items on each order: 10 ETH to the offerer and 1 ETH to OpenSea
+    - order index 1 through 5
+- To fulfill this, fulfiller creates a *sixth* order to buy all 5 NFTs for ETH
+    - single offer item: 55 ETH or `(10 + 1) * 5`
+    - five consideration items: all five NFTs
+    - order index 0 (by convention)
+- This order requires exactly 11 transfers or executions (assuming 5 distinct sellers), translating to 11 fulfillments:
+    - 5 transfers of 10 ETH each from order 0 offerer (i.e. fulfiller) to order 1-5 offerers
+        - These fulfillments will have a single offer component and single consideration component (offer component: order 0 index 0 and consideration component: orders 1-5 index 0)
+    - 5 transfers of 1 NFT each from order 1-5 offers to order 0 offerer (i.e. fulfiller)
+        - These fulfillments will have a single offer component and single fulfillment component (offer component: orders 1-5 index 0 and consideration component order 0 index 0-4)
+    - 1 transfer of 5 ETH from order 0 offerer (i.e. fulfiller) to OpenSea
+        - This fulfillment will have a single offer component mapping to order index 0 + item index 0, but *five* consideration components mapping to order index 1-5 + item index 1
+
+The algorithm (broad-strokes first pass)
+
+1. Take all the orders you want to fulfill and retrieve the latest amounts for those orders based on amount filled, amount *desired* to fill, and ascending/descending amounts (include sufficient buffer on those)
+2. “flatten” those orders into:
+    - all the offer items (and include the order index, item index, and offerer alongside the item)
+    - all the consideration items (and include the order index and item index alongside the item; the recipient is already on the consideration items)
+3. Aggregate those items by type + token + identifier + (offerer / recipient), summing up all the amounts (we do need to track the original amounts as well here)
+4. Quickly check to see if there are any aggregated offer items with the same type + token + identifier + offerer as an aggregated consideration item’s type + token + identifier + recipient (i.e. offerer == recipient) — if so, create a fulfillment for those and decrement both (no execution / transfer will be created for these fulfillments)
+5. Retrieve all approvals and balances for each aggregated offer item; increment / decrement them as we go and ensure they never go below zero
+6. Search for fulfillments that can already be performed before the fulfiller’s order has even been created; if any exist, generate those fulfillments first (the goal is to reduce the number of items on the fulfiller’s order).
+    - To generate a fulfillment, subtract whatever is lower between the aggregated offer and aggregated consideration it is being matched with from both and register the fulfillment.
+    - There will likely be some combination that optimizes for total number of transfers; see if these can be optimized.
+        - By way of example, say a fulfiller is accepting offers to sell multiple NFTs at once, and the aggregate fees owed to OpenSea are exactly 1 WETH and it so happens that one of the NFTS has an offer for exactly 1 WETH — that offerer should pay the fees for all the orders being fulfilled in a single transaction.
+    - Repeat this process until the fulfillments cannot be compressed any further.
+7. Then, create the mirror order with an offer item for each remaining (aggregated) consideration item and a consideration item for each remaining (aggregated) offer item; check for sufficient approval on each derived offer item
+8. Run the same sequence as from in step 6, but include the last order as well
+9. Ensure that all consideration items have been met!
+  */
+export {};

package/lib/utils/match.js

@@ -0,0 +1,56 @@
+"use strict";
+/** Giant TODO for match orders
+# Match orders
+
+- Format: list of fulfillments
+    - Each fulfillment represents a single transfer or “execution”
+    - Each fulfillment specifies an array of offer “components” corresponding to offer items to spend as well as an array of consideration “components” corresponding to consideration items to receive
+    - every offer component and consideration component contains an index of the order it is from as well as an index of the item in the respective offer or consideration array on that order
+    - the “from” address will be the offerer of whatever offer items are being spent
+    - the “to” address will be the recipient of whatever consideration items are being received
+- the “One rule” to follow for the whole set of fulfillments:
+    - All consideration items must be fully accounted for after adjusting for partial fills and ascending/descending amounts
+- the “Four rules” to follow for each distinct fulfillment:
+    1. you need at least one offer component and at least one consideration component for each fulfillment; otherwise you don’t know what the “from” or “to” address should be
+    2. the offer item corresponding to the first offer component has to match the consideration item corresponding to the first consideration component (with the exception of the amount); otherwise you’re not sending the item that the recipient is expecting
+    3. any additional offer items need to match the original offer items (with the exception of the amount) and the same *the offerer*; otherwise you’re composing different items or different origins.
+        1. This implies that ERC721 fulfillments will always have a single offer component (even if that corresponding offer item is present in multiple fulfillments, i.e. criteria-based partial fills)
+
+Example: Bulk purchase
+
+- Five distinct sellers create orders to sell ERC721 NFTs for ETH.
+    - single offer item on each order: the NFT
+    - two consideration items on each order: 10 ETH to the offerer and 1 ETH to OpenSea
+    - order index 1 through 5
+- To fulfill this, fulfiller creates a *sixth* order to buy all 5 NFTs for ETH
+    - single offer item: 55 ETH or `(10 + 1) * 5`
+    - five consideration items: all five NFTs
+    - order index 0 (by convention)
+- This order requires exactly 11 transfers or executions (assuming 5 distinct sellers), translating to 11 fulfillments:
+    - 5 transfers of 10 ETH each from order 0 offerer (i.e. fulfiller) to order 1-5 offerers
+        - These fulfillments will have a single offer component and single consideration component (offer component: order 0 index 0 and consideration component: orders 1-5 index 0)
+    - 5 transfers of 1 NFT each from order 1-5 offers to order 0 offerer (i.e. fulfiller)
+        - These fulfillments will have a single offer component and single fulfillment component (offer component: orders 1-5 index 0 and consideration component order 0 index 0-4)
+    - 1 transfer of 5 ETH from order 0 offerer (i.e. fulfiller) to OpenSea
+        - This fulfillment will have a single offer component mapping to order index 0 + item index 0, but *five* consideration components mapping to order index 1-5 + item index 1
+
+The algorithm (broad-strokes first pass)
+
+1. Take all the orders you want to fulfill and retrieve the latest amounts for those orders based on amount filled, amount *desired* to fill, and ascending/descending amounts (include sufficient buffer on those)
+2. “flatten” those orders into:
+    - all the offer items (and include the order index, item index, and offerer alongside the item)
+    - all the consideration items (and include the order index and item index alongside the item; the recipient is already on the consideration items)
+3. Aggregate those items by type + token + identifier + (offerer / recipient), summing up all the amounts (we do need to track the original amounts as well here)
+4. Quickly check to see if there are any aggregated offer items with the same type + token + identifier + offerer as an aggregated consideration item’s type + token + identifier + recipient (i.e. offerer == recipient) — if so, create a fulfillment for those and decrement both (no execution / transfer will be created for these fulfillments)
+5. Retrieve all approvals and balances for each aggregated offer item; increment / decrement them as we go and ensure they never go below zero
+6. Search for fulfillments that can already be performed before the fulfiller’s order has even been created; if any exist, generate those fulfillments first (the goal is to reduce the number of items on the fulfiller’s order).
+    - To generate a fulfillment, subtract whatever is lower between the aggregated offer and aggregated consideration it is being matched with from both and register the fulfillment.
+    - There will likely be some combination that optimizes for total number of transfers; see if these can be optimized.
+        - By way of example, say a fulfiller is accepting offers to sell multiple NFTs at once, and the aggregate fees owed to OpenSea are exactly 1 WETH and it so happens that one of the NFTS has an offer for exactly 1 WETH — that offerer should pay the fees for all the orders being fulfilled in a single transaction.
+    - Repeat this process until the fulfillments cannot be compressed any further.
+7. Then, create the mirror order with an offer item for each remaining (aggregated) consideration item and a consideration item for each remaining (aggregated) offer item; check for sufficient approval on each derived offer item
+8. Run the same sequence as from in step 6, but include the last order as well
+9. Ensure that all consideration items have been met!
+  */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=match.js.map

package/lib/utils/match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","sourceRoot":"","sources":["../../src/utils/match.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoDI"}

package/lib/utils/merkletree.d.ts

@@ -0,0 +1,11 @@
+import MerkleTreeJS from "merkletreejs";
+/**
+ * Simple wrapper over the MerkleTree in merkletreejs.
+ * Handles hashing identifiers to be compatible with Seaport.
+ */
+export declare class MerkleTree {
+    tree: MerkleTreeJS;
+    constructor(identifiers: string[]);
+    getProof(identifier: string): string[];
+    getRoot(): string;
+}

package/lib/utils/merkletree.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleTree = void 0;
+var ethers_1 = require("ethers");
+var utils_1 = require("ethers/lib/utils");
+var merkletreejs_1 = __importDefault(require("merkletreejs"));
+var hashIdentifier = function (identifier) {
+    return (0, utils_1.keccak256)(Buffer.from(ethers_1.BigNumber.from(identifier).toHexString().slice(2).padStart(64, "0"), "hex"));
+};
+/**
+ * Simple wrapper over the MerkleTree in merkletreejs.
+ * Handles hashing identifiers to be compatible with Seaport.
+ */
+var MerkleTree = /** @class */ (function () {
+    function MerkleTree(identifiers) {
+        this.tree = new merkletreejs_1.default(identifiers.map(hashIdentifier), utils_1.keccak256, {
+            sort: true,
+        });
+    }
+    MerkleTree.prototype.getProof = function (identifier) {
+        return this.tree.getHexProof(hashIdentifier(identifier));
+    };
+    MerkleTree.prototype.getRoot = function () {
+        return this.tree.getRoot().toString("hex") ? this.tree.getHexRoot() : "0";
+    };
+    return MerkleTree;
+}());
+exports.MerkleTree = MerkleTree;
+//# sourceMappingURL=merkletree.js.map

package/lib/utils/merkletree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merkletree.js","sourceRoot":"","sources":["../../src/utils/merkletree.ts"],"names":[],"mappings":";;;;;;AAAA,iCAAmC;AACnC,0CAA6C;AAC7C,8DAAwC;AAExC,IAAM,cAAc,GAAG,UAAC,UAAkB;IACxC,OAAA,IAAA,iBAAS,EACP,MAAM,CAAC,IAAI,CACT,kBAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,EACnE,KAAK,CACN,CACF;AALD,CAKC,CAAC;AAEJ;;;GAGG;AACH;IAGE,oBAAY,WAAqB;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,sBAAY,CAAC,WAAW,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,iBAAS,EAAE;YACvE,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED,6BAAQ,GAAR,UAAS,UAAkB;QACzB,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED,4BAAO,GAAP;QACE,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC;IAC5E,CAAC;IACH,iBAAC;AAAD,CAAC,AAhBD,IAgBC;AAhBY,gCAAU"}

package/lib/utils/order.d.ts

@@ -0,0 +1,37 @@
+import { BigNumber, BigNumberish } from "ethers";
+import type { ConsiderationItem, CreateInputItem, Fee, Item, OfferItem, Order, OrderParameters } from "../types";
+export declare const feeToConsiderationItem: ({ fee, token, baseAmount, baseEndAmount, }: {
+    fee: Fee;
+    token: string;
+    baseAmount: BigNumberish;
+    baseEndAmount?: BigNumberish | undefined;
+}) => ConsiderationItem;
+export declare const deductFees: <T extends Item>(items: T[], fees?: readonly Fee[] | undefined) => T[];
+export declare const mapInputItemToOfferItem: (item: CreateInputItem) => OfferItem;
+export declare const areAllCurrenciesSame: ({ offer, consideration, }: Pick<OrderParameters, "offer" | "consideration">) => boolean;
+export declare const totalItemsAmount: <T extends OfferItem>(items: T[]) => {
+    startAmount: BigNumber;
+    endAmount: BigNumber;
+};
+/**
+ * Maps order offer and consideration item amounts based on the order's filled status
+ * After applying the fraction, we can view this order as the "canonical" order for which we
+ * check approvals and balances
+ */
+export declare const mapOrderAmountsFromFilledStatus: (order: Order, { totalFilled, totalSize }: {
+    totalFilled: BigNumber;
+    totalSize: BigNumber;
+}) => Order;
+/**
+ * Maps order offer and consideration item amounts based on the units needed to fulfill
+ * After applying the fraction, we can view this order as the "canonical" order for which we
+ * check approvals and balances
+ * Returns the numerator and denominator as well, converting this to an AdvancedOrder
+ */
+export declare const mapOrderAmountsFromUnitsToFill: (order: Order, { unitsToFill, totalFilled, totalSize, }: {
+    unitsToFill: BigNumberish;
+    totalFilled: BigNumber;
+    totalSize: BigNumber;
+}) => Order;
+export declare const generateRandomSalt: () => string;
+export declare const shouldUseMatchForFulfill: () => boolean;

package/lib/utils/order.js

@@ -0,0 +1,224 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldUseMatchForFulfill = exports.generateRandomSalt = exports.mapOrderAmountsFromUnitsToFill = exports.mapOrderAmountsFromFilledStatus = exports.totalItemsAmount = exports.areAllCurrenciesSame = exports.mapInputItemToOfferItem = exports.deductFees = exports.feeToConsiderationItem = void 0;
+var ethers_1 = require("ethers");
+var constants_1 = require("../constants");
+var item_1 = require("./item");
+var merkletree_1 = require("./merkletree");
+var multiplyBasisPoints = function (amount, basisPoints) {
+    return ethers_1.BigNumber.from(amount)
+        .mul(ethers_1.BigNumber.from(basisPoints))
+        .div(constants_1.ONE_HUNDRED_PERCENT_BP);
+};
+var feeToConsiderationItem = function (_a) {
+    var fee = _a.fee, token = _a.token, baseAmount = _a.baseAmount, _b = _a.baseEndAmount, baseEndAmount = _b === void 0 ? baseAmount : _b;
+    return {
+        itemType: token === ethers_1.ethers.constants.AddressZero ? constants_1.ItemType.NATIVE : constants_1.ItemType.ERC20,
+        token: token,
+        identifierOrCriteria: "0",
+        startAmount: multiplyBasisPoints(baseAmount, fee.basisPoints).toString(),
+        endAmount: multiplyBasisPoints(baseEndAmount, fee.basisPoints).toString(),
+        recipient: fee.recipient,
+    };
+};
+exports.feeToConsiderationItem = feeToConsiderationItem;
+var deductFees = function (items, fees) {
+    if (!fees) {
+        return items;
+    }
+    var totalBasisPoints = fees.reduce(function (accBasisPoints, fee) { return accBasisPoints + fee.basisPoints; }, 0);
+    return items.map(function (item) { return (__assign(__assign({}, item), { startAmount: (0, item_1.isCurrencyItem)(item)
+            ? ethers_1.BigNumber.from(item.startAmount)
+                .sub(multiplyBasisPoints(item.startAmount, totalBasisPoints))
+                .toString()
+            : item.startAmount, endAmount: (0, item_1.isCurrencyItem)(item)
+            ? ethers_1.BigNumber.from(item.endAmount)
+                .sub(multiplyBasisPoints(item.endAmount, totalBasisPoints))
+                .toString()
+            : item.endAmount })); });
+};
+exports.deductFees = deductFees;
+var mapInputItemToOfferItem = function (item) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    // Item is an NFT
+    if ("itemType" in item) {
+        // Convert this to a criteria based item
+        if ("identifiers" in item) {
+            var tree = new merkletree_1.MerkleTree(item.identifiers);
+            return {
+                itemType: item.itemType === constants_1.ItemType.ERC721
+                    ? constants_1.ItemType.ERC721_WITH_CRITERIA
+                    : constants_1.ItemType.ERC1155_WITH_CRITERIA,
+                token: item.token,
+                identifierOrCriteria: tree.getRoot(),
+                startAmount: (_a = item.amount) !== null && _a !== void 0 ? _a : "1",
+                endAmount: (_c = (_b = item.endAmount) !== null && _b !== void 0 ? _b : item.amount) !== null && _c !== void 0 ? _c : "1",
+            };
+        }
+        if ("amount" in item || "endAmount" in item) {
+            return {
+                itemType: item.itemType,
+                token: item.token,
+                identifierOrCriteria: item.identifier,
+                startAmount: item.amount,
+                endAmount: (_e = (_d = item.endAmount) !== null && _d !== void 0 ? _d : item.amount) !== null && _e !== void 0 ? _e : "1",
+            };
+        }
+        return {
+            itemType: item.itemType,
+            token: item.token,
+            identifierOrCriteria: item.identifier,
+            startAmount: "1",
+            endAmount: "1",
+        };
+    }
+    // Item is a currency
+    return {
+        itemType: item.token && item.token !== ethers_1.ethers.constants.AddressZero
+            ? constants_1.ItemType.ERC20
+            : constants_1.ItemType.NATIVE,
+        token: (_f = item.token) !== null && _f !== void 0 ? _f : ethers_1.ethers.constants.AddressZero,
+        identifierOrCriteria: "0",
+        startAmount: item.amount,
+        endAmount: (_g = item.endAmount) !== null && _g !== void 0 ? _g : item.amount,
+    };
+};
+exports.mapInputItemToOfferItem = mapInputItemToOfferItem;
+var areAllCurrenciesSame = function (_a) {
+    var offer = _a.offer, consideration = _a.consideration;
+    var allItems = __spreadArray(__spreadArray([], __read(offer), false), __read(consideration), false);
+    var currencies = allItems.filter(item_1.isCurrencyItem);
+    return currencies.every(function (_a) {
+        var itemType = _a.itemType, token = _a.token;
+        return itemType === currencies[0].itemType &&
+            token.toLowerCase() === currencies[0].token.toLowerCase();
+    });
+};
+exports.areAllCurrenciesSame = areAllCurrenciesSame;
+var totalItemsAmount = function (items) {
+    var initialValues = {
+        startAmount: ethers_1.BigNumber.from(0),
+        endAmount: ethers_1.BigNumber.from(0),
+    };
+    return items
+        .map(function (_a) {
+        var startAmount = _a.startAmount, endAmount = _a.endAmount;
+        return ({
+            startAmount: startAmount,
+            endAmount: endAmount,
+        });
+    })
+        .reduce(function (_a, _b) {
+        var totalStartAmount = _a.startAmount, totalEndAmount = _a.endAmount;
+        var startAmount = _b.startAmount, endAmount = _b.endAmount;
+        return ({
+            startAmount: totalStartAmount.add(startAmount),
+            endAmount: totalEndAmount.add(endAmount),
+        });
+    }, {
+        startAmount: ethers_1.BigNumber.from(0),
+        endAmount: ethers_1.BigNumber.from(0),
+    });
+};
+exports.totalItemsAmount = totalItemsAmount;
+/**
+ * Maps order offer and consideration item amounts based on the order's filled status
+ * After applying the fraction, we can view this order as the "canonical" order for which we
+ * check approvals and balances
+ */
+var mapOrderAmountsFromFilledStatus = function (order, _a) {
+    var totalFilled = _a.totalFilled, totalSize = _a.totalSize;
+    if (totalFilled.eq(0) || totalSize.eq(0)) {
+        return order;
+    }
+    // i.e if totalFilled is 3 and totalSize is 4, there are 1 / 4 order amounts left to fill.
+    var basisPoints = totalSize
+        .sub(totalFilled)
+        .mul(constants_1.ONE_HUNDRED_PERCENT_BP)
+        .div(totalSize);
+    return {
+        parameters: __assign(__assign({}, order.parameters), { offer: order.parameters.offer.map(function (item) { return (__assign(__assign({}, item), { startAmount: multiplyBasisPoints(item.startAmount, basisPoints).toString(), endAmount: multiplyBasisPoints(item.endAmount, basisPoints).toString() })); }), consideration: order.parameters.consideration.map(function (item) { return (__assign(__assign({}, item), { startAmount: multiplyBasisPoints(item.startAmount, basisPoints).toString(), endAmount: multiplyBasisPoints(item.endAmount, basisPoints).toString() })); }) }),
+        signature: order.signature,
+    };
+};
+exports.mapOrderAmountsFromFilledStatus = mapOrderAmountsFromFilledStatus;
+/**
+ * Maps order offer and consideration item amounts based on the units needed to fulfill
+ * After applying the fraction, we can view this order as the "canonical" order for which we
+ * check approvals and balances
+ * Returns the numerator and denominator as well, converting this to an AdvancedOrder
+ */
+var mapOrderAmountsFromUnitsToFill = function (order, _a) {
+    var unitsToFill = _a.unitsToFill, totalFilled = _a.totalFilled, totalSize = _a.totalSize;
+    var unitsToFillBn = ethers_1.BigNumber.from(unitsToFill);
+    if (unitsToFillBn.lte(0)) {
+        throw new Error("Units to fill must be greater than 1");
+    }
+    var maxUnits = (0, item_1.getMaximumSizeForOrder)(order);
+    if (totalSize.eq(0)) {
+        totalSize = maxUnits;
+    }
+    // This is the percentage of the order that is left to be fulfilled, and therefore we can't fill more than that.
+    var remainingOrderPercentageToBeFilled = totalSize
+        .sub(totalFilled)
+        .mul(constants_1.ONE_HUNDRED_PERCENT_BP)
+        .div(totalSize);
+    // i.e if totalSize is 8 and unitsToFill is 3, then we multiply every amount by 3 / 8
+    var unitsToFillBasisPoints = unitsToFillBn
+        .mul(constants_1.ONE_HUNDRED_PERCENT_BP)
+        .div(maxUnits);
+    // We basically choose the lesser between the units requested to be filled and the actual remaining order amount left
+    // This is so that if a user tries to fulfill an order that is 1/2 filled, and supplies a fraction such as 3/4, the maximum
+    // amount to fulfill is 1/2 instead of 3/4
+    var basisPoints = remainingOrderPercentageToBeFilled.gt(unitsToFillBasisPoints)
+        ? unitsToFillBasisPoints
+        : remainingOrderPercentageToBeFilled;
+    return {
+        parameters: __assign(__assign({}, order.parameters), { offer: order.parameters.offer.map(function (item) { return (__assign(__assign({}, item), { startAmount: multiplyBasisPoints(item.startAmount, basisPoints).toString(), endAmount: multiplyBasisPoints(item.endAmount, basisPoints).toString() })); }), consideration: order.parameters.consideration.map(function (item) { return (__assign(__assign({}, item), { startAmount: multiplyBasisPoints(item.startAmount, basisPoints).toString(), endAmount: multiplyBasisPoints(item.endAmount, basisPoints).toString() })); }) }),
+        signature: order.signature,
+    };
+};
+exports.mapOrderAmountsFromUnitsToFill = mapOrderAmountsFromUnitsToFill;
+var generateRandomSalt = function () {
+    return "0x".concat(Buffer.from(ethers_1.ethers.utils.randomBytes(16)).toString("hex"));
+};
+exports.generateRandomSalt = generateRandomSalt;
+var shouldUseMatchForFulfill = function () { return true; };
+exports.shouldUseMatchForFulfill = shouldUseMatchForFulfill;
+//# sourceMappingURL=order.js.map

package/lib/utils/order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order.js","sourceRoot":"","sources":["../../src/utils/order.ts"],"names":[],"mappings":"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"}

package/lib/utils/usecase.d.ts

@@ -0,0 +1,4 @@
+import { Contract } from "ethers";
+import { CreateOrderAction, ExchangeAction, OrderUseCase, TransactionMethods, ContractMethodReturnType } from "../types";
+export declare const executeAllActions: <T extends CreateOrderAction | ExchangeAction<unknown>>(actions: T extends CreateOrderAction ? import("../types").CreateOrderActions : import("../types").OrderExchangeActions<T extends ExchangeAction<infer U> ? U : never>) => Promise<import("ethers").ContractTransaction | import("../types").OrderWithCounter>;
+export declare const getTransactionMethods: <T extends Contract, U extends keyof T["functions"]>(contract: T, method: U, args: Parameters<T["functions"][U]>) => TransactionMethods<Awaited<ReturnType<T["callStatic"][U]>>>;