@opensea/seaport-js 1.0.5 → 1.0.7

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

@@ -0,0 +1,1043 @@
+"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