@opensea/seaport-js 1.0.7 → 1.0.8

package/lib/__tests__/create-order.spec.js

@@ -1,1043 +0,0 @@
-"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-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;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var utils_1 = require("ethers/lib/utils");
-var hardhat_1 = require("hardhat");
-var seaport_1 = require("../seaport");
-var constants_1 = require("../constants");
-var order_1 = require("../utils/order");
-var setup_1 = require("./utils/setup");
-(0, setup_1.describeWithFixture)("As a user I want to create an order", function (fixture) {
-    it.only("should create the order after setting needed approvals", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, _a, offerer, zone, randomSigner, nftId, startTime, endTime, salt, exampleOrder, orderHash, actions, approvalAction, _b, createOrderAction, order, isValid;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_c.sent(), 3]), offerer = _a[0], zone = _a[1], randomSigner = _a[2];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _c.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    salt = (0, order_1.generateRandomSalt)();
-                    exampleOrder = {
-                        parameters: {
-                            offerer: "0x8eE2D9E28467b59aB49Df557DFff9d666FBb00a5",
-                            offer: [
-                                {
-                                    itemType: 3,
-                                    token: "0xA604060890923Ff400e8c6f5290461A83AEDACec",
-                                    identifierOrCriteria: "64629235721312828405373287309442025721362867731014072603052403049497356140545",
-                                    startAmount: "1",
-                                    endAmount: "1",
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    itemType: 0,
-                                    token: "0x0000000000000000000000000000000000000000",
-                                    identifierOrCriteria: "0",
-                                    startAmount: "36075000000000000",
-                                    endAmount: "36075000000000000",
-                                    recipient: "0x8eE2D9E28467b59aB49Df557DFff9d666FBb00a5",
-                                },
-                                {
-                                    itemType: 0,
-                                    token: "0x0000000000000000000000000000000000000000",
-                                    identifierOrCriteria: "0",
-                                    startAmount: "975000000000000",
-                                    endAmount: "975000000000000",
-                                    recipient: "0x0000a26b00c1F0DF003000390027140000fAa719",
-                                },
-                                {
-                                    itemType: 0,
-                                    token: "0x0000000000000000000000000000000000000000",
-                                    identifierOrCriteria: "0",
-                                    startAmount: "1950000000000000",
-                                    endAmount: "1950000000000000",
-                                    recipient: "0x8eE2D9E28467b59aB49Df557DFff9d666FBb00a5",
-                                },
-                            ],
-                            startTime: 1663321575,
-                            endTime: 1663407976,
-                            orderType: 3,
-                            zone: "0x004C00500000aD104D7DBd00e3ae0A5C00560C00",
-                            zoneHash: "0x3000000000000000000000000000000000000000000000000000000000000000",
-                            salt: "236043380710254310822797171314121828804",
-                            conduitKey: "0x0000007b02230091a7ed01230072f7006a004d60a8d4e71d599b8104250f0000",
-                            totalOriginalConsiderationItems: 3,
-                            counter: 0,
-                        },
-                        signature: "0xf68072db9b4fba3323f0c19cb189f120d0335e6fe25c439d2c522d706c92b01c5a419211a29fc3029aaf9999e85d1ffa3ce7982eba45993826cc323cbea2b2fc",
-                    };
-                    orderHash = seaport.getOrderHash(exampleOrder.parameters);
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 3:
-                    actions = (_c.sent()).actions;
-                    approvalAction = actions[0];
-                    (0, chai_1.expect)(approvalAction).to.be.deep.equal({
-                        type: "approval",
-                        token: testErc721.address,
-                        identifierOrCriteria: nftId,
-                        itemType: constants_1.ItemType.ERC721,
-                        transactionMethods: approvalAction.transactionMethods,
-                        operator: seaportContract.address,
-                    });
-                    return [4 /*yield*/, approvalAction.transactionMethods.transact()];
-                case 4:
-                    _c.sent();
-                    // NFT should now be approved
-                    _b = chai_1.expect;
-                    return [4 /*yield*/, testErc721.isApprovedForAll(offerer.address, seaportContract.address)];
-                case 5:
-                    // NFT should now be approved
-                    _b.apply(void 0, [_c.sent()]).to.be.true;
-                    createOrderAction = actions[1];
-                    return [4 /*yield*/, createOrderAction.createOrder()];
-                case 6:
-                    order = _c.sent();
-                    (0, chai_1.expect)(createOrderAction.type).to.equal("create");
-                    (0, chai_1.expect)(order).to.deep.equal({
-                        parameters: {
-                            consideration: [
-                                {
-                                    // Fees were deducted
-                                    endAmount: hardhat_1.ethers.utils.parseEther("9.75").toString(),
-                                    identifierOrCriteria: "0",
-                                    itemType: constants_1.ItemType.NATIVE,
-                                    recipient: offerer.address,
-                                    startAmount: hardhat_1.ethers.utils.parseEther("9.75").toString(),
-                                    token: hardhat_1.ethers.constants.AddressZero,
-                                },
-                                {
-                                    endAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                    identifierOrCriteria: "0",
-                                    itemType: constants_1.ItemType.NATIVE,
-                                    recipient: zone.address,
-                                    startAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                    token: hardhat_1.ethers.constants.AddressZero,
-                                },
-                            ],
-                            endTime: endTime,
-                            offer: [
-                                {
-                                    endAmount: "1",
-                                    identifierOrCriteria: nftId,
-                                    itemType: constants_1.ItemType.ERC721,
-                                    startAmount: "1",
-                                    token: testErc721.address,
-                                },
-                            ],
-                            offerer: offerer.address,
-                            orderType: constants_1.OrderType.FULL_OPEN,
-                            salt: salt,
-                            startTime: startTime,
-                            totalOriginalConsiderationItems: 2,
-                            zone: hardhat_1.ethers.constants.AddressZero,
-                            zoneHash: (0, utils_1.formatBytes32String)("0"),
-                            conduitKey: constants_1.NO_CONDUIT,
-                            counter: 0,
-                        },
-                        signature: order.signature,
-                    });
-                    return [4 /*yield*/, seaportContract
-                            .connect(randomSigner)
-                            .callStatic.validate([
-                            {
-                                parameters: __assign(__assign({}, order.parameters), { totalOriginalConsiderationItems: order.parameters.consideration.length }),
-                                signature: order.signature,
-                            },
-                        ])];
-                case 7:
-                    isValid = _c.sent();
-                    (0, chai_1.expect)(isValid).to.be.true;
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it("should create an order that offers ERC20 for ERC721", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc20, testErc721, _a, offerer, zone, randomSigner, nftId, startTime, endTime, salt, actions, approvalAction, _b, createOrderAction, order, isValid;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc20 = fixture.testErc20, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_c.sent(), 3]), offerer = _a[0], zone = _a[1], randomSigner = _a[2];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc20.mint(offerer.address, (0, utils_1.parseEther)("10").toString())];
-                case 2:
-                    _c.sent();
-                    return [4 /*yield*/, testErc721.mint(randomSigner.address, nftId)];
-                case 3:
-                    _c.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    salt = (0, order_1.generateRandomSalt)();
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    token: testErc20.address,
-                                    amount: (0, utils_1.parseEther)("10").toString(),
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 4:
-                    actions = (_c.sent()).actions;
-                    approvalAction = actions[0];
-                    (0, chai_1.expect)(approvalAction).to.be.deep.equal({
-                        type: "approval",
-                        token: testErc20.address,
-                        identifierOrCriteria: "0",
-                        itemType: constants_1.ItemType.ERC20,
-                        transactionMethods: approvalAction.transactionMethods,
-                        operator: seaportContract.address,
-                    });
-                    return [4 /*yield*/, approvalAction.transactionMethods.transact()];
-                case 5:
-                    _c.sent();
-                    // NFT should now be approved
-                    _b = chai_1.expect;
-                    return [4 /*yield*/, testErc20.allowance(offerer.address, seaportContract.address)];
-                case 6:
-                    // NFT should now be approved
-                    _b.apply(void 0, [_c.sent()]).to.equal(constants_1.MAX_INT);
-                    createOrderAction = actions[1];
-                    return [4 /*yield*/, createOrderAction.createOrder()];
-                case 7:
-                    order = _c.sent();
-                    (0, chai_1.expect)(createOrderAction.type).to.equal("create");
-                    (0, chai_1.expect)(order).to.deep.equal({
-                        parameters: {
-                            consideration: [
-                                {
-                                    endAmount: "1",
-                                    identifierOrCriteria: nftId,
-                                    itemType: constants_1.ItemType.ERC721,
-                                    startAmount: "1",
-                                    token: testErc721.address,
-                                    recipient: offerer.address,
-                                },
-                                {
-                                    endAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                    identifierOrCriteria: "0",
-                                    itemType: constants_1.ItemType.ERC20,
-                                    recipient: zone.address,
-                                    startAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                    token: testErc20.address,
-                                },
-                            ],
-                            endTime: endTime,
-                            offer: [
-                                {
-                                    // Fees were deducted
-                                    endAmount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    identifierOrCriteria: "0",
-                                    itemType: constants_1.ItemType.ERC20,
-                                    startAmount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    token: testErc20.address,
-                                },
-                            ],
-                            offerer: offerer.address,
-                            orderType: constants_1.OrderType.FULL_OPEN,
-                            salt: salt,
-                            startTime: startTime,
-                            totalOriginalConsiderationItems: 2,
-                            zone: hardhat_1.ethers.constants.AddressZero,
-                            zoneHash: (0, utils_1.formatBytes32String)("0"),
-                            conduitKey: constants_1.NO_CONDUIT,
-                            counter: 0,
-                        },
-                        signature: order.signature,
-                    });
-                    return [4 /*yield*/, seaportContract
-                            .connect(randomSigner)
-                            .callStatic.validate([
-                            {
-                                parameters: __assign(__assign({}, order.parameters), { totalOriginalConsiderationItems: order.parameters.consideration.length }),
-                                signature: order.signature,
-                            },
-                        ])];
-                case 8:
-                    isValid = _c.sent();
-                    (0, chai_1.expect)(isValid).to.be.true;
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it("should create an order with multiple item types after setting needed approvals", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, testErc1155, _a, offerer, zone, randomSigner, nftId, startTime, endTime, salt, actions, _b, _c, approvalAction, _d, erc1155ApprovalAction, _e, createOrderAction, order, isValid;
-        return __generator(this, function (_f) {
-            switch (_f.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721, testErc1155 = fixture.testErc1155;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_f.sent(), 3]), offerer = _a[0], zone = _a[1], randomSigner = _a[2];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _f.sent();
-                    return [4 /*yield*/, testErc1155.mint(offerer.address, nftId, 1)];
-                case 3:
-                    _f.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    salt = (0, order_1.generateRandomSalt)();
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                                {
-                                    itemType: constants_1.ItemType.ERC1155,
-                                    token: testErc1155.address,
-                                    identifier: nftId,
-                                    amount: "1",
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 4:
-                    actions = (_f.sent()).actions;
-                    _b = chai_1.expect;
-                    return [4 /*yield*/, testErc721.isApprovedForAll(offerer.address, seaportContract.address)];
-                case 5:
-                    _b.apply(void 0, [_f.sent()]).to.be.false;
-                    _c = chai_1.expect;
-                    return [4 /*yield*/, testErc1155.isApprovedForAll(offerer.address, seaportContract.address)];
-                case 6:
-                    _c.apply(void 0, [_f.sent()]).to.be.false;
-                    approvalAction = actions[0];
-                    (0, chai_1.expect)(approvalAction).to.be.deep.equal({
-                        type: "approval",
-                        token: testErc721.address,
-                        identifierOrCriteria: nftId,
-                        itemType: constants_1.ItemType.ERC721,
-                        transactionMethods: approvalAction.transactionMethods,
-                        operator: seaportContract.address,
-                    });
-                    return [4 /*yield*/, approvalAction.transactionMethods.transact()];
-                case 7:
-                    _f.sent();
-                    // NFT should now be approved
-                    _d = chai_1.expect;
-                    return [4 /*yield*/, testErc721.isApprovedForAll(offerer.address, seaportContract.address)];
-                case 8:
-                    // NFT should now be approved
-                    _d.apply(void 0, [_f.sent()]).to.be.true;
-                    erc1155ApprovalAction = actions[1];
-                    (0, chai_1.expect)(erc1155ApprovalAction).to.be.deep.equal({
-                        type: "approval",
-                        token: testErc1155.address,
-                        identifierOrCriteria: nftId,
-                        itemType: constants_1.ItemType.ERC1155,
-                        transactionMethods: erc1155ApprovalAction.transactionMethods,
-                        operator: seaportContract.address,
-                    });
-                    return [4 /*yield*/, erc1155ApprovalAction.transactionMethods.transact()];
-                case 9:
-                    _f.sent();
-                    // NFT should now be approved
-                    _e = chai_1.expect;
-                    return [4 /*yield*/, testErc1155.isApprovedForAll(offerer.address, seaportContract.address)];
-                case 10:
-                    // NFT should now be approved
-                    _e.apply(void 0, [_f.sent()]).to.be.true;
-                    createOrderAction = actions[2];
-                    return [4 /*yield*/, createOrderAction.createOrder()];
-                case 11:
-                    order = _f.sent();
-                    (0, chai_1.expect)(createOrderAction.type).to.equal("create");
-                    (0, chai_1.expect)(order).to.deep.equal({
-                        parameters: {
-                            consideration: [
-                                {
-                                    // Fees were deducted
-                                    endAmount: hardhat_1.ethers.utils.parseEther("9.75").toString(),
-                                    identifierOrCriteria: "0",
-                                    itemType: constants_1.ItemType.NATIVE,
-                                    recipient: offerer.address,
-                                    startAmount: hardhat_1.ethers.utils.parseEther("9.75").toString(),
-                                    token: hardhat_1.ethers.constants.AddressZero,
-                                },
-                                {
-                                    endAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                    identifierOrCriteria: "0",
-                                    itemType: constants_1.ItemType.NATIVE,
-                                    recipient: zone.address,
-                                    startAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                    token: hardhat_1.ethers.constants.AddressZero,
-                                },
-                            ],
-                            endTime: endTime,
-                            offer: [
-                                {
-                                    endAmount: "1",
-                                    identifierOrCriteria: nftId,
-                                    itemType: constants_1.ItemType.ERC721,
-                                    startAmount: "1",
-                                    token: testErc721.address,
-                                },
-                                {
-                                    endAmount: "1",
-                                    identifierOrCriteria: nftId,
-                                    itemType: constants_1.ItemType.ERC1155,
-                                    startAmount: "1",
-                                    token: testErc1155.address,
-                                },
-                            ],
-                            offerer: offerer.address,
-                            orderType: constants_1.OrderType.FULL_OPEN,
-                            salt: salt,
-                            startTime: startTime,
-                            totalOriginalConsiderationItems: 2,
-                            zone: hardhat_1.ethers.constants.AddressZero,
-                            zoneHash: (0, utils_1.formatBytes32String)("0"),
-                            conduitKey: constants_1.NO_CONDUIT,
-                            counter: 0,
-                        },
-                        signature: order.signature,
-                    });
-                    return [4 /*yield*/, seaportContract
-                            .connect(randomSigner)
-                            .callStatic.validate([
-                            {
-                                parameters: __assign(__assign({}, order.parameters), { totalOriginalConsiderationItems: order.parameters.consideration.length }),
-                                signature: order.signature,
-                            },
-                        ])];
-                case 12:
-                    isValid = _f.sent();
-                    (0, chai_1.expect)(isValid).to.be.true;
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    describe("check validations", function () {
-        it("throws if currencies are different", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var seaport, testErc721, testErc20, _a, offerer, zone, nftId, startTime, endTime, salt;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        seaport = fixture.seaport, testErc721 = fixture.testErc721, testErc20 = fixture.testErc20;
-                        return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                    case 1:
-                        _a = __read.apply(void 0, [_b.sent(), 2]), offerer = _a[0], zone = _a[1];
-                        nftId = "1";
-                        return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                    case 2:
-                        _b.sent();
-                        startTime = "0";
-                        endTime = constants_1.MAX_INT.toString();
-                        salt = (0, order_1.generateRandomSalt)();
-                        return [4 /*yield*/, testErc20.mint(offerer.address, 1)];
-                    case 3:
-                        _b.sent();
-                        return [4 /*yield*/, (0, chai_1.expect)(seaport.createOrder({
-                                startTime: startTime,
-                                endTime: endTime,
-                                salt: salt,
-                                offer: [
-                                    {
-                                        itemType: constants_1.ItemType.ERC721,
-                                        token: testErc721.address,
-                                        identifier: nftId,
-                                    },
-                                ],
-                                consideration: [
-                                    {
-                                        amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                        recipient: offerer.address,
-                                    },
-                                    {
-                                        token: testErc20.address,
-                                        amount: hardhat_1.ethers.utils.parseEther("1").toString(),
-                                        recipient: zone.address,
-                                    },
-                                ],
-                            })).to.be.rejectedWith("All currency tokens in the order must be the same token")];
-                    case 4:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("throws if offerer does not have sufficient balances", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var seaport, testErc721, testErc20, _a, offerer, zone, nftId, startTime, endTime, salt, createOrderInput;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        seaport = fixture.seaport, testErc721 = fixture.testErc721, testErc20 = fixture.testErc20;
-                        return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                    case 1:
-                        _a = __read.apply(void 0, [_b.sent(), 2]), offerer = _a[0], zone = _a[1];
-                        nftId = "1";
-                        return [4 /*yield*/, testErc721.mint(zone.address, nftId)];
-                    case 2:
-                        _b.sent();
-                        startTime = "0";
-                        endTime = constants_1.MAX_INT.toString();
-                        salt = (0, order_1.generateRandomSalt)();
-                        createOrderInput = {
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        };
-                        return [4 /*yield*/, (0, chai_1.expect)(seaport.createOrder(createOrderInput)).to.be.rejectedWith("The offerer does not have the amount needed to create or fulfill.")];
-                    case 3:
-                        _b.sent();
-                        return [4 /*yield*/, testErc721
-                                .connect(zone)
-                                .transferFrom(zone.address, offerer.address, nftId)];
-                    case 4:
-                        _b.sent();
-                        // It should not throw now as the offerer has sufficient balance
-                        return [4 /*yield*/, seaport.createOrder(createOrderInput)];
-                    case 5:
-                        // It should not throw now as the offerer has sufficient balance
-                        _b.sent();
-                        // Now it should as the offerer does not have any ERC20
-                        return [4 /*yield*/, (0, chai_1.expect)(seaport.createOrder(__assign(__assign({}, createOrderInput), { offer: [
-                                    {
-                                        itemType: constants_1.ItemType.ERC721,
-                                        token: testErc721.address,
-                                        identifier: nftId,
-                                    },
-                                    {
-                                        token: testErc20.address,
-                                        amount: "1",
-                                    },
-                                ], consideration: [
-                                    {
-                                        token: testErc20.address,
-                                        amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                        recipient: offerer.address,
-                                    },
-                                ] }))).to.be.rejectedWith("The offerer does not have the amount needed to create or fulfill.")];
-                    case 6:
-                        // Now it should as the offerer does not have any ERC20
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-        it("skips balance and approval validation if consideration config is set to skip on order creation", function () { return __awaiter(void 0, void 0, void 0, function () {
-            var seaportContract, testErc721, seaport, _a, offerer, zone, randomSigner, nftId, startTime, endTime, salt, actions, createOrderAction, order, isValid;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        seaportContract = fixture.seaportContract, testErc721 = fixture.testErc721;
-                        seaport = new seaport_1.Seaport(hardhat_1.ethers.provider, {
-                            balanceAndApprovalChecksOnOrderCreation: false,
-                            overrides: {
-                                contractAddress: seaportContract.address,
-                            },
-                        });
-                        return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                    case 1:
-                        _a = __read.apply(void 0, [_b.sent(), 3]), offerer = _a[0], zone = _a[1], randomSigner = _a[2];
-                        nftId = "1";
-                        startTime = "0";
-                        endTime = constants_1.MAX_INT.toString();
-                        salt = (0, order_1.generateRandomSalt)();
-                        return [4 /*yield*/, testErc721.mint(randomSigner.address, nftId)];
-                    case 2:
-                        _b.sent();
-                        return [4 /*yield*/, seaport.createOrder({
-                                startTime: startTime,
-                                endTime: endTime,
-                                salt: salt,
-                                offer: [
-                                    {
-                                        itemType: constants_1.ItemType.ERC721,
-                                        token: testErc721.address,
-                                        identifier: nftId,
-                                    },
-                                ],
-                                consideration: [
-                                    {
-                                        amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                        recipient: offerer.address,
-                                    },
-                                ],
-                                // 2.5% fee
-                                fees: [{ recipient: zone.address, basisPoints: 250 }],
-                            })];
-                    case 3:
-                        actions = (_b.sent()).actions;
-                        createOrderAction = actions[0];
-                        return [4 /*yield*/, createOrderAction.createOrder()];
-                    case 4:
-                        order = _b.sent();
-                        (0, chai_1.expect)(createOrderAction.type).to.equal("create");
-                        (0, chai_1.expect)(order).to.deep.equal({
-                            parameters: {
-                                consideration: [
-                                    {
-                                        endAmount: hardhat_1.ethers.utils.parseEther("9.75").toString(),
-                                        identifierOrCriteria: "0",
-                                        itemType: constants_1.ItemType.NATIVE,
-                                        recipient: offerer.address,
-                                        startAmount: hardhat_1.ethers.utils.parseEther("9.75").toString(),
-                                        token: hardhat_1.ethers.constants.AddressZero,
-                                    },
-                                    {
-                                        endAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                        identifierOrCriteria: "0",
-                                        itemType: constants_1.ItemType.NATIVE,
-                                        recipient: zone.address,
-                                        startAmount: hardhat_1.ethers.utils.parseEther(".25").toString(),
-                                        token: hardhat_1.ethers.constants.AddressZero,
-                                    },
-                                ],
-                                endTime: endTime,
-                                offer: [
-                                    {
-                                        endAmount: "1",
-                                        identifierOrCriteria: nftId,
-                                        itemType: constants_1.ItemType.ERC721,
-                                        startAmount: "1",
-                                        token: testErc721.address,
-                                    },
-                                ],
-                                offerer: offerer.address,
-                                orderType: constants_1.OrderType.FULL_OPEN,
-                                salt: salt,
-                                startTime: startTime,
-                                totalOriginalConsiderationItems: 2,
-                                zone: hardhat_1.ethers.constants.AddressZero,
-                                zoneHash: (0, utils_1.formatBytes32String)("0"),
-                                conduitKey: constants_1.NO_CONDUIT,
-                                counter: 0,
-                            },
-                            signature: order.signature,
-                        });
-                        return [4 /*yield*/, seaportContract
-                                .connect(randomSigner)
-                                .callStatic.validate([
-                                {
-                                    parameters: __assign(__assign({}, order.parameters), { totalOriginalConsiderationItems: order.parameters.consideration.length }),
-                                    signature: order.signature,
-                                },
-                            ])];
-                    case 5:
-                        isValid = _b.sent();
-                        (0, chai_1.expect)(isValid).to.be.true;
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    });
-    it("returns a valid message to sign", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, _a, offerer, zone, randomSigner, nftId, startTime, endTime, salt, actions, approvalAction, _b, createOrderAction, messageToSign, order, rawSignTypedMessage, isValid;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_c.sent(), 3]), offerer = _a[0], zone = _a[1], randomSigner = _a[2];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _c.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    salt = (0, order_1.generateRandomSalt)();
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 3:
-                    actions = (_c.sent()).actions;
-                    approvalAction = actions[0];
-                    (0, chai_1.expect)(approvalAction).to.be.deep.equal({
-                        type: "approval",
-                        token: testErc721.address,
-                        identifierOrCriteria: nftId,
-                        itemType: constants_1.ItemType.ERC721,
-                        transactionMethods: approvalAction.transactionMethods,
-                        operator: seaportContract.address,
-                    });
-                    return [4 /*yield*/, approvalAction.transactionMethods.transact()];
-                case 4:
-                    _c.sent();
-                    // NFT should now be approved
-                    _b = chai_1.expect;
-                    return [4 /*yield*/, testErc721.isApprovedForAll(offerer.address, seaportContract.address)];
-                case 5:
-                    // NFT should now be approved
-                    _b.apply(void 0, [_c.sent()]).to.be.true;
-                    createOrderAction = actions[1];
-                    return [4 /*yield*/, createOrderAction.getMessageToSign()];
-                case 6:
-                    messageToSign = _c.sent();
-                    return [4 /*yield*/, createOrderAction.createOrder()];
-                case 7:
-                    order = _c.sent();
-                    (0, chai_1.expect)(createOrderAction.type).to.equal("create");
-                    return [4 /*yield*/, hardhat_1.ethers.provider.send("eth_signTypedData_v4", [offerer.address, messageToSign])];
-                case 8:
-                    rawSignTypedMessage = _c.sent();
-                    (0, chai_1.expect)(hardhat_1.ethers.utils.splitSignature(rawSignTypedMessage).compact).eq(order.signature);
-                    return [4 /*yield*/, seaportContract
-                            .connect(randomSigner)
-                            .callStatic.validate([
-                            {
-                                parameters: __assign(__assign({}, order.parameters), { totalOriginalConsiderationItems: order.parameters.consideration.length }),
-                                signature: rawSignTypedMessage,
-                            },
-                        ])];
-                case 9:
-                    isValid = _c.sent();
-                    (0, chai_1.expect)(isValid).to.be.true;
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it("should have the same order hash as on the contract", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, _a, offerer, zone, nftId, startTime, endTime, salt, executeAllActions, order, contractOrderHash, localOrderHash;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_b.sent(), 2]), offerer = _a[0], zone = _a[1];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _b.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    salt = (0, order_1.generateRandomSalt)();
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 3:
-                    executeAllActions = (_b.sent()).executeAllActions;
-                    return [4 /*yield*/, executeAllActions()];
-                case 4:
-                    order = _b.sent();
-                    return [4 /*yield*/, seaportContract.getOrderHash(order.parameters)];
-                case 5:
-                    contractOrderHash = _b.sent();
-                    localOrderHash = seaport.getOrderHash(order.parameters);
-                    (0, chai_1.expect)(contractOrderHash).eq(localOrderHash);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it("should create an order with a salt including a hash of the supplied domain", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, _a, offerer, zone, nftId, startTime, endTime, domain, openseaMagicValue, executeAllActions, order, contractOrderHash, localOrderHash;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_b.sent(), 2]), offerer = _a[0], zone = _a[1];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _b.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    domain = "opensea.io";
-                    openseaMagicValue = "0x360c6ebe";
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            domain: domain,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 3:
-                    executeAllActions = (_b.sent()).executeAllActions;
-                    return [4 /*yield*/, executeAllActions()];
-                case 4:
-                    order = _b.sent();
-                    return [4 /*yield*/, seaportContract.getOrderHash(order.parameters)];
-                case 5:
-                    contractOrderHash = _b.sent();
-                    localOrderHash = seaport.getOrderHash(order.parameters);
-                    (0, chai_1.expect)(contractOrderHash).eq(localOrderHash);
-                    (0, chai_1.expect)(order.parameters.salt.slice(0, 10)).eq(openseaMagicValue);
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it("should create an order with a salt with the first four bytes being empty if no domain is given", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, _a, offerer, zone, nftId, startTime, endTime, executeAllActions, order, contractOrderHash, localOrderHash;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_b.sent(), 2]), offerer = _a[0], zone = _a[1];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _b.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 3:
-                    executeAllActions = (_b.sent()).executeAllActions;
-                    return [4 /*yield*/, executeAllActions()];
-                case 4:
-                    order = _b.sent();
-                    return [4 /*yield*/, seaportContract.getOrderHash(order.parameters)];
-                case 5:
-                    contractOrderHash = _b.sent();
-                    localOrderHash = seaport.getOrderHash(order.parameters);
-                    (0, chai_1.expect)(contractOrderHash).eq(localOrderHash);
-                    (0, chai_1.expect)(order.parameters.salt.slice(0, 10)).eq("0x00000000");
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-    it("should create an order with the passed in salt", function () { return __awaiter(void 0, void 0, void 0, function () {
-        var seaportContract, seaport, testErc721, _a, offerer, zone, nftId, startTime, endTime, salt, executeAllActions, order, contractOrderHash, localOrderHash;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    seaportContract = fixture.seaportContract, seaport = fixture.seaport, testErc721 = fixture.testErc721;
-                    return [4 /*yield*/, hardhat_1.ethers.getSigners()];
-                case 1:
-                    _a = __read.apply(void 0, [_b.sent(), 2]), offerer = _a[0], zone = _a[1];
-                    nftId = "1";
-                    return [4 /*yield*/, testErc721.mint(offerer.address, nftId)];
-                case 2:
-                    _b.sent();
-                    startTime = "0";
-                    endTime = constants_1.MAX_INT.toString();
-                    salt = "0xabc";
-                    return [4 /*yield*/, seaport.createOrder({
-                            startTime: startTime,
-                            endTime: endTime,
-                            salt: salt,
-                            offer: [
-                                {
-                                    itemType: constants_1.ItemType.ERC721,
-                                    token: testErc721.address,
-                                    identifier: nftId,
-                                },
-                            ],
-                            consideration: [
-                                {
-                                    amount: hardhat_1.ethers.utils.parseEther("10").toString(),
-                                    recipient: offerer.address,
-                                },
-                            ],
-                            // 2.5% fee
-                            fees: [{ recipient: zone.address, basisPoints: 250 }],
-                        })];
-                case 3:
-                    executeAllActions = (_b.sent()).executeAllActions;
-                    return [4 /*yield*/, executeAllActions()];
-                case 4:
-                    order = _b.sent();
-                    return [4 /*yield*/, seaportContract.getOrderHash(order.parameters)];
-                case 5:
-                    contractOrderHash = _b.sent();
-                    localOrderHash = seaport.getOrderHash(order.parameters);
-                    (0, chai_1.expect)(contractOrderHash).eq(localOrderHash);
-                    (0, chai_1.expect)(order.parameters.salt).eq("0xabc");
-                    return [2 /*return*/];
-            }
-        });
-    }); });
-});
-//# sourceMappingURL=create-order.spec.js.map