@imtbl/sdk 0.1.8-alpha → 0.1.8-alpha.1

package/dist/immutablex_client.js

@@ -16,7 +16,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-0.1.8-alpha',
+    sdkVersion: 'ts-immutable-sdk-0.1.8-alpha.1',
 });
 /**
  * Sets `sdkVersion` at the time of build

package/dist/index.cjs

@@ -8,7 +8,6 @@ var magicSdk = require('magic-sdk');
 var oidc = require('@magic-ext/oidc');
 var BN = require('bn.js');
 var encUtils = require('enc-utils');
-var constants = require('@opensea/seaport-js/lib/constants');
 var FormData = require('form-data');
 var seaportJs = require('@opensea/seaport-js');
 var units = require('@ethersproject/units');
@@ -3282,6 +3281,265 @@ var SellItem;
     })(SellItem.item_type || (SellItem.item_type = {}));
 })(SellItem || (SellItem = {}));
 
+/* eslint-disable */
+// TODO: Resolve these from seaport-js.
+// There is some bundling issue that is preventing this from working
+const SEAPORT_CONTRACT_NAME = 'Seaport';
+const SEAPORT_CONTRACT_VERSION_V1_4 = '1.4';
+const EIP_712_ORDER_TYPE = {
+    OrderComponents: [
+        { name: 'offerer', type: 'address' },
+        { name: 'zone', type: 'address' },
+        { name: 'offer', type: 'OfferItem[]' },
+        { name: 'consideration', type: 'ConsiderationItem[]' },
+        { name: 'orderType', type: 'uint8' },
+        { name: 'startTime', type: 'uint256' },
+        { name: 'endTime', type: 'uint256' },
+        { name: 'zoneHash', type: 'bytes32' },
+        { name: 'salt', type: 'uint256' },
+        { name: 'conduitKey', type: 'bytes32' },
+        { name: 'counter', type: 'uint256' },
+    ],
+    OfferItem: [
+        { name: 'itemType', type: 'uint8' },
+        { name: 'token', type: 'address' },
+        { name: 'identifierOrCriteria', type: 'uint256' },
+        { name: 'startAmount', type: 'uint256' },
+        { name: 'endAmount', type: 'uint256' },
+    ],
+    ConsiderationItem: [
+        { name: 'itemType', type: 'uint8' },
+        { name: 'token', type: 'address' },
+        { name: 'identifierOrCriteria', type: 'uint256' },
+        { name: 'startAmount', type: 'uint256' },
+        { name: 'endAmount', type: 'uint256' },
+        { name: 'recipient', type: 'address' },
+    ],
+};
+var OrderType;
+(function (OrderType) {
+    OrderType[OrderType["FULL_OPEN"] = 0] = "FULL_OPEN";
+    OrderType[OrderType["PARTIAL_OPEN"] = 1] = "PARTIAL_OPEN";
+    OrderType[OrderType["FULL_RESTRICTED"] = 2] = "FULL_RESTRICTED";
+    OrderType[OrderType["PARTIAL_RESTRICTED"] = 3] = "PARTIAL_RESTRICTED";
+})(OrderType || (OrderType = {}));
+var ItemType;
+(function (ItemType) {
+    ItemType[ItemType["NATIVE"] = 0] = "NATIVE";
+    ItemType[ItemType["ERC20"] = 1] = "ERC20";
+    ItemType[ItemType["ERC721"] = 2] = "ERC721";
+    ItemType[ItemType["ERC1155"] = 3] = "ERC1155";
+    ItemType[ItemType["ERC721_WITH_CRITERIA"] = 4] = "ERC721_WITH_CRITERIA";
+    ItemType[ItemType["ERC1155_WITH_CRITERIA"] = 5] = "ERC1155_WITH_CRITERIA";
+})(ItemType || (ItemType = {}));
+var Side;
+(function (Side) {
+    Side[Side["OFFER"] = 0] = "OFFER";
+    Side[Side["CONSIDERATION"] = 1] = "CONSIDERATION";
+})(Side || (Side = {}));
+var BasicOrderRouteType;
+(function (BasicOrderRouteType) {
+    BasicOrderRouteType[BasicOrderRouteType["ETH_TO_ERC721"] = 0] = "ETH_TO_ERC721";
+    BasicOrderRouteType[BasicOrderRouteType["ETH_TO_ERC1155"] = 1] = "ETH_TO_ERC1155";
+    BasicOrderRouteType[BasicOrderRouteType["ERC20_TO_ERC721"] = 2] = "ERC20_TO_ERC721";
+    BasicOrderRouteType[BasicOrderRouteType["ERC20_TO_ERC1155"] = 3] = "ERC20_TO_ERC1155";
+    BasicOrderRouteType[BasicOrderRouteType["ERC721_TO_ERC20"] = 4] = "ERC721_TO_ERC20";
+    BasicOrderRouteType[BasicOrderRouteType["ERC1155_TO_ERC20"] = 5] = "ERC1155_TO_ERC20";
+})(BasicOrderRouteType || (BasicOrderRouteType = {}));
+
+function getOrderComponentsFromMessage(orderMessage) {
+    const data = JSON.parse(orderMessage);
+    const orderComponents = data.message;
+    orderComponents.salt = ethers.BigNumber.from(orderComponents.salt).toHexString();
+    return orderComponents;
+}
+
+// Add 20% more gas than estimate to prevent out of gas errors
+// This can always be overwritten by the user signing the transaction
+async function prepareTransaction(transactionMethods) {
+    const transaction = await transactionMethods.buildTransaction();
+    transaction.gasLimit = await transactionMethods.estimateGas();
+    transaction.gasLimit = transaction.gasLimit
+        .add(transaction.gasLimit.div(5));
+    return transaction;
+}
+
+function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
+    const considerationItems = order.buy.map((buyItem) => ({
+        startAmount: buyItem.start_amount,
+        endAmount: buyItem.start_amount,
+        itemType: buyItem.item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
+        recipient: order.account_address,
+        token: buyItem.contract_address || ethers.constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    const fees = order.buy_fees.map((fee) => ({
+        startAmount: fee.amount,
+        endAmount: fee.amount,
+        itemType: order.buy[0].item_type === 'ERC20' ? ItemType.ERC20 : ItemType.NATIVE,
+        recipient: fee.recipient,
+        token: order.buy[0].contract_address || ethers.constants.AddressZero,
+        identifierOrCriteria: '0',
+    }));
+    return {
+        conduitKey: ethers.constants.HashZero,
+        consideration: [...considerationItems, ...fees],
+        offer: order.sell.map((sellItem) => ({
+            startAmount: '1',
+            endAmount: '1',
+            itemType: ItemType.ERC721,
+            token: sellItem.contract_address,
+            identifierOrCriteria: sellItem.token_id,
+        })),
+        counter,
+        endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
+        startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
+        salt: order.salt,
+        offerer: order.account_address,
+        zone: zoneAddress,
+        totalOriginalConsiderationItems: 2,
+        orderType: OrderType.FULL_RESTRICTED,
+        zoneHash: ethers.constants.HashZero,
+    };
+}
+
+class Seaport {
+    seaport;
+    provider;
+    seaportContractAddress;
+    zoneContractAddress;
+    constructor(seaport, provider, seaportContractAddress, zoneContractAddress) {
+        this.seaport = seaport;
+        this.provider = provider;
+        this.seaportContractAddress = seaportContractAddress;
+        this.zoneContractAddress = zoneContractAddress;
+    }
+    async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
+        const { actions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
+        let approvalTransaction;
+        const approvalAction = actions
+            .find((action) => action.type === 'approval');
+        if (approvalAction) {
+            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
+        }
+        const createAction = actions
+            .find((action) => action.type === 'create');
+        if (!createAction) {
+            throw new Error('No create order action found');
+        }
+        const orderMessageToSign = await createAction.getMessageToSign();
+        const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
+        return {
+            unsignedApprovalTransaction: approvalTransaction,
+            typedOrderMessageForSigning: await this.getTypedDataFromOrderComponents(orderComponents),
+            orderComponents,
+            orderHash: await this.seaport.getOrderHash(orderComponents),
+        };
+    }
+    async fulfilOrder(order, account) {
+        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
+        const { actions } = await this.seaport.fulfillOrders({
+            accountAddress: account,
+            fulfillOrderDetails: [{
+                    order: {
+                        parameters: orderComponents,
+                        signature: order.signature,
+                    },
+                    extraData: order.protocol_data.operator_signature,
+                }],
+        });
+        let approvalTransaction;
+        const approvalAction = actions
+            .find((action) => action.type === 'approval');
+        if (approvalAction) {
+            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
+        }
+        const fulfillmentAction = actions
+            .find((action) => action.type === 'exchange');
+        if (!fulfillmentAction) {
+            throw new Error('No exchange action found');
+        }
+        const fulfillmentTransaction = await prepareTransaction(fulfillmentAction.transactionMethods);
+        return {
+            unsignedApprovalTransaction: approvalTransaction,
+            unsignedFulfillmentTransaction: fulfillmentTransaction,
+        };
+    }
+    async cancelOrder(order, account) {
+        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
+        const cancellationTransaction = await this.seaport.cancelOrders([orderComponents], account);
+        return prepareTransaction(cancellationTransaction);
+    }
+    async mapImmutableOrderToSeaportOrderComponents(order) {
+        const counterForOfferer = await this.seaport.getCounter(order.account_address);
+        return mapImmutableOrderToSeaportOrderComponents(order, counterForOfferer.toString(), this.zoneContractAddress);
+    }
+    createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
+        return this.seaport.createOrder({
+            allowPartialFills: false,
+            offer: [
+                {
+                    itemType: ItemType.ERC721,
+                    token: listingItem.contractAddress,
+                    identifier: listingItem.tokenId,
+                },
+            ],
+            consideration: [
+                {
+                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
+                    amount: considerationItem.amount,
+                    recipient: offerer,
+                },
+                {
+                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
+                    amount: royaltyInfo.amountRequired,
+                    recipient: royaltyInfo.recipient,
+                },
+            ],
+            startTime: (orderStart.getTime() / 1000).toFixed(0),
+            endTime: (orderExpiry.getTime() / 1000).toFixed(0),
+            zone: this.zoneContractAddress,
+            restrictedByZone: true,
+        }, offerer);
+    }
+    async getTypedDataFromOrderComponents(orderComponents) {
+        const { chainId } = await this.provider.getNetwork();
+        const domainData = {
+            name: SEAPORT_CONTRACT_NAME,
+            version: SEAPORT_CONTRACT_VERSION_V1_4,
+            chainId,
+            verifyingContract: this.seaportContractAddress,
+        };
+        return {
+            domain: domainData,
+            types: EIP_712_ORDER_TYPE,
+            value: orderComponents,
+        };
+    }
+}
+
+class SeaportFactory {
+    seaportContractAddress;
+    zoneContractAddress;
+    provider;
+    seaport;
+    constructor(seaportContractAddress, zoneContractAddress, provider) {
+        this.seaportContractAddress = seaportContractAddress;
+        this.zoneContractAddress = zoneContractAddress;
+        this.provider = provider;
+        this.seaport = new seaportJs.Seaport(provider, {
+            seaportVersion: '1.4',
+            balanceAndApprovalChecksOnOrderCreation: true,
+            overrides: {
+                contractAddress: seaportContractAddress,
+            },
+        });
+    }
+    create() {
+        return new Seaport(this.seaport, this.provider, this.seaportContractAddress, this.zoneContractAddress);
+    }
+}
+
 class ImmutableApiClient {
     orderbookService;
     chainId;
@@ -3302,7 +3560,7 @@ class ImmutableApiClient {
         if (orderComponents.offer.length !== 1) {
             throw new Error('Only one item can be listed at a time');
         }
-        if (Number(orderComponents.offer[0].itemType) !== constants.ItemType.ERC721) {
+        if (Number(orderComponents.offer[0].itemType) !== ItemType.ERC721) {
             throw new Error('Only ERC721 tokens can be listed');
         }
         const considerationItemTypeTheSame = new Set([...orderComponents.consideration.map((c) => c.itemType)]).size === 1;
@@ -3316,7 +3574,7 @@ class ImmutableApiClient {
                 account_address: offerer,
                 buy: [
                     {
-                        item_type: Number(orderComponents.consideration[0].itemType) === constants.ItemType.NATIVE
+                        item_type: Number(orderComponents.consideration[0].itemType) === ItemType.NATIVE
                             ? BuyItem.item_type.NATIVE
                             : BuyItem.item_type.ERC20,
                         start_amount: orderComponents.consideration[0].startAmount,
@@ -4286,199 +4544,6 @@ class ERC721Factory {
     }
 }
 
-function getOrderComponentsFromMessage(orderMessage) {
-    const data = JSON.parse(orderMessage);
-    const orderComponents = data.message;
-    orderComponents.salt = ethers.BigNumber.from(orderComponents.salt).toHexString();
-    return orderComponents;
-}
-
-// Add 20% more gas than estimate to prevent out of gas errors
-// This can always be overwritten by the user signing the transaction
-async function prepareTransaction(transactionMethods) {
-    const transaction = await transactionMethods.buildTransaction();
-    transaction.gasLimit = await transactionMethods.estimateGas();
-    transaction.gasLimit = transaction.gasLimit
-        .add(transaction.gasLimit.div(5));
-    return transaction;
-}
-
-function mapImmutableOrderToSeaportOrderComponents(order, counter, zoneAddress) {
-    const considerationItems = order.buy.map((buyItem) => ({
-        startAmount: buyItem.start_amount,
-        endAmount: buyItem.start_amount,
-        itemType: buyItem.item_type === 'ERC20' ? constants.ItemType.ERC20 : constants.ItemType.NATIVE,
-        recipient: order.account_address,
-        token: buyItem.contract_address || ethers.constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
-    const fees = order.buy_fees.map((fee) => ({
-        startAmount: fee.amount,
-        endAmount: fee.amount,
-        itemType: order.buy[0].item_type === 'ERC20' ? constants.ItemType.ERC20 : constants.ItemType.NATIVE,
-        recipient: fee.recipient,
-        token: order.buy[0].contract_address || ethers.constants.AddressZero,
-        identifierOrCriteria: '0',
-    }));
-    return {
-        conduitKey: ethers.constants.HashZero,
-        consideration: [...considerationItems, ...fees],
-        offer: order.sell.map((sellItem) => ({
-            startAmount: '1',
-            endAmount: '1',
-            itemType: constants.ItemType.ERC721,
-            token: sellItem.contract_address,
-            identifierOrCriteria: sellItem.token_id,
-        })),
-        counter,
-        endTime: Math.round(new Date(order.end_time).getTime() / 1000).toString(),
-        startTime: Math.round(new Date(order.start_time).getTime() / 1000).toString(),
-        salt: order.salt,
-        offerer: order.account_address,
-        zone: zoneAddress,
-        totalOriginalConsiderationItems: 2,
-        orderType: constants.OrderType.FULL_RESTRICTED,
-        zoneHash: ethers.constants.HashZero,
-    };
-}
-
-class Seaport {
-    seaport;
-    provider;
-    seaportContractAddress;
-    zoneContractAddress;
-    constructor(seaport, provider, seaportContractAddress, zoneContractAddress) {
-        this.seaport = seaport;
-        this.provider = provider;
-        this.seaportContractAddress = seaportContractAddress;
-        this.zoneContractAddress = zoneContractAddress;
-    }
-    async prepareSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        const { actions } = await this.createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry);
-        let approvalTransaction;
-        const approvalAction = actions
-            .find((action) => action.type === 'approval');
-        if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
-        }
-        const createAction = actions
-            .find((action) => action.type === 'create');
-        if (!createAction) {
-            throw new Error('No create order action found');
-        }
-        const orderMessageToSign = await createAction.getMessageToSign();
-        const orderComponents = getOrderComponentsFromMessage(orderMessageToSign);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            typedOrderMessageForSigning: await this.getTypedDataFromOrderComponents(orderComponents),
-            orderComponents,
-            orderHash: await this.seaport.getOrderHash(orderComponents),
-        };
-    }
-    async fulfilOrder(order, account) {
-        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
-        const { actions } = await this.seaport.fulfillOrders({
-            accountAddress: account,
-            fulfillOrderDetails: [{
-                    order: {
-                        parameters: orderComponents,
-                        signature: order.signature,
-                    },
-                    extraData: order.protocol_data.operator_signature,
-                }],
-        });
-        let approvalTransaction;
-        const approvalAction = actions
-            .find((action) => action.type === 'approval');
-        if (approvalAction) {
-            approvalTransaction = await prepareTransaction(approvalAction.transactionMethods);
-        }
-        const fulfillmentAction = actions
-            .find((action) => action.type === 'exchange');
-        if (!fulfillmentAction) {
-            throw new Error('No exchange action found');
-        }
-        const fulfillmentTransaction = await prepareTransaction(fulfillmentAction.transactionMethods);
-        return {
-            unsignedApprovalTransaction: approvalTransaction,
-            unsignedFulfillmentTransaction: fulfillmentTransaction,
-        };
-    }
-    async cancelOrder(order, account) {
-        const orderComponents = await this.mapImmutableOrderToSeaportOrderComponents(order);
-        const cancellationTransaction = await this.seaport.cancelOrders([orderComponents], account);
-        return prepareTransaction(cancellationTransaction);
-    }
-    async mapImmutableOrderToSeaportOrderComponents(order) {
-        const counterForOfferer = await this.seaport.getCounter(order.account_address);
-        return mapImmutableOrderToSeaportOrderComponents(order, counterForOfferer.toString(), this.zoneContractAddress);
-    }
-    createSeaportOrder(offerer, listingItem, considerationItem, royaltyInfo, orderStart, orderExpiry) {
-        return this.seaport.createOrder({
-            allowPartialFills: false,
-            offer: [
-                {
-                    itemType: constants.ItemType.ERC721,
-                    token: listingItem.contractAddress,
-                    identifier: listingItem.tokenId,
-                },
-            ],
-            consideration: [
-                {
-                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
-                    amount: considerationItem.amount,
-                    recipient: offerer,
-                },
-                {
-                    token: considerationItem.type === 'ERC20' ? considerationItem.contractAddress : undefined,
-                    amount: royaltyInfo.amountRequired,
-                    recipient: royaltyInfo.recipient,
-                },
-            ],
-            startTime: (orderStart.getTime() / 1000).toFixed(0),
-            endTime: (orderExpiry.getTime() / 1000).toFixed(0),
-            zone: this.zoneContractAddress,
-            restrictedByZone: true,
-        }, offerer);
-    }
-    async getTypedDataFromOrderComponents(orderComponents) {
-        const { chainId } = await this.provider.getNetwork();
-        const domainData = {
-            name: constants.SEAPORT_CONTRACT_NAME,
-            version: constants.SEAPORT_CONTRACT_VERSION_V1_4,
-            chainId,
-            verifyingContract: this.seaportContractAddress,
-        };
-        return {
-            domain: domainData,
-            types: constants.EIP_712_ORDER_TYPE,
-            value: orderComponents,
-        };
-    }
-}
-
-class SeaportFactory {
-    seaportContractAddress;
-    zoneContractAddress;
-    provider;
-    seaport;
-    constructor(seaportContractAddress, zoneContractAddress, provider) {
-        this.seaportContractAddress = seaportContractAddress;
-        this.zoneContractAddress = zoneContractAddress;
-        this.provider = provider;
-        this.seaport = new seaportJs.Seaport(provider, {
-            seaportVersion: '1.4',
-            balanceAndApprovalChecksOnOrderCreation: true,
-            overrides: {
-                contractAddress: seaportContractAddress,
-            },
-        });
-    }
-    create() {
-        return new Seaport(this.seaport, this.provider, this.seaportContractAddress, this.zoneContractAddress);
-    }
-}
-
 /**
  * zkEVM orderbook SDK
  * @constructor