@imtbl/sdk 0.28.3-alpha.1 → 0.28.4

package/dist/orderbook.d.ts

@@ -5,10 +5,14 @@ declare enum Environment {
 }
 declare class ImmutableConfiguration {
     readonly environment: Environment;
+    readonly rateLimitingKey?: string;
     readonly apiKey?: string;
+    readonly clientAppId?: string;
     constructor(options: {
         environment: Environment;
+        rateLimitingKey?: string;
         apiKey?: string;
+        clientAppId?: string;
     });
 }
 interface ModuleConfiguration<T> {
@@ -595,53 +599,6 @@ interface OrderbookModuleConfiguration {
     provider: JsonRpcProvider | Web3Provider;
 }
 
-declare enum OrderType {
-    FULL_OPEN = 0,
-    PARTIAL_OPEN = 1,
-    FULL_RESTRICTED = 2,
-    PARTIAL_RESTRICTED = 3
-}
-declare enum ItemType {
-    NATIVE = 0,
-    ERC20 = 1,
-    ERC721 = 2,
-    ERC1155 = 3,
-    ERC721_WITH_CRITERIA = 4,
-    ERC1155_WITH_CRITERIA = 5
-}
-
-type OfferItem = {
-    itemType: ItemType;
-    token: string;
-    identifierOrCriteria: string;
-    startAmount: string;
-    endAmount: string;
-};
-type ConsiderationItem = {
-    itemType: ItemType;
-    token: string;
-    identifierOrCriteria: string;
-    startAmount: string;
-    endAmount: string;
-    recipient: string;
-};
-type OrderParameters = {
-    offerer: string;
-    zone: string;
-    orderType: OrderType;
-    startTime: BigNumberish;
-    endTime: BigNumberish;
-    zoneHash: string;
-    salt: string;
-    offer: OfferItem[];
-    consideration: ConsiderationItem[];
-    totalOriginalConsiderationItems: BigNumberish;
-    conduitKey: string;
-};
-type OrderComponents = OrderParameters & {
-    counter: BigNumberish;
-};
-
 type ApiRequestOptions = {
     readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
     readonly url: string;
@@ -729,7 +686,7 @@ declare namespace FailedOrderCancellation {
      * Reason code indicating why the order failed to be cancelled
      */
     enum reason_code {
-        ALREADY_FILLED = "ALREADY_FILLED"
+        FILLED = "FILLED"
     }
 }
 
@@ -907,20 +864,20 @@ type Chain = {
 
 type ActiveOrderStatus = {
     /**
-     * The order status
+     * The order status that indicates an order can be fulfilled.
      */
     name: 'ACTIVE';
 };
 
 type CancelledOrderStatus = {
     /**
-     * The order status
+     * The order status indicating a order is has been cancelled or about to be cancelled.
      */
     name: 'CANCELLED';
     /**
      * Whether the cancellation of the order is pending
      */
-    is_pending: boolean;
+    pending: boolean;
     /**
      * Whether the cancellation was done on-chain or off-chain
      */
@@ -938,30 +895,46 @@ declare namespace CancelledOrderStatus {
 
 type ExpiredOrderStatus = {
     /**
-     * The order status
+     * A terminal order status indicating that an order cannot be fulfilled due to expiry.
      */
     name: 'EXPIRED';
 };
 
 type FilledOrderStatus = {
     /**
-     * The order status
+     * A terminal order status indicating that an order has been fulfilled.
      */
     name: 'FILLED';
 };
 
 type InactiveOrderStatus = {
     /**
-     * The order status
+     * The order status that indicates an order cannot be fulfilled.
      */
     name: 'INACTIVE';
+    /**
+     * Whether the order offerer has sufficient approvals
+     */
+    sufficient_approvals: boolean;
+    /**
+     * Whether the order offerer still has sufficient balance to complete the order
+     */
+    sufficient_balances: boolean;
 };
 
 type PendingOrderStatus = {
     /**
-     * The order status
+     * The order status that indicates the order is yet to be active due to various reasons.
      */
     name: 'PENDING';
+    /**
+     * Whether the order has been evaluated after its creation
+     */
+    evaluated: boolean;
+    /**
+     * Whether the order has reached its specified start time
+     */
+    started: boolean;
 };
 
 /**
@@ -1266,6 +1239,53 @@ declare class OrdersService {
     }): CancelablePromise<TradeResult$1>;
 }
 
+declare enum OrderType {
+    FULL_OPEN = 0,
+    PARTIAL_OPEN = 1,
+    FULL_RESTRICTED = 2,
+    PARTIAL_RESTRICTED = 3
+}
+declare enum ItemType {
+    NATIVE = 0,
+    ERC20 = 1,
+    ERC721 = 2,
+    ERC1155 = 3,
+    ERC721_WITH_CRITERIA = 4,
+    ERC1155_WITH_CRITERIA = 5
+}
+
+type OfferItem = {
+    itemType: ItemType;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+};
+type ConsiderationItem = {
+    itemType: ItemType;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+    recipient: string;
+};
+type OrderParameters = {
+    offerer: string;
+    zone: string;
+    orderType: OrderType;
+    startTime: BigNumberish;
+    endTime: BigNumberish;
+    zoneHash: string;
+    salt: string;
+    offer: OfferItem[];
+    consideration: ConsiderationItem[];
+    totalOriginalConsiderationItems: BigNumberish;
+    conduitKey: string;
+};
+type OrderComponents = OrderParameters & {
+    counter: BigNumberish;
+};
+
 interface ERC721Item {
     type: 'ERC721';
     contractAddress: string;
@@ -1295,6 +1315,9 @@ interface PrepareListingResponse {
     orderComponents: OrderComponents;
     orderHash: string;
 }
+interface PrepareCancelOrdersResponse {
+    signableAction: SignableAction;
+}
 interface CreateListingParams {
     orderComponents: OrderComponents;
     orderHash: string;
@@ -1318,10 +1341,12 @@ interface Fee extends FeeValue {
 }
 declare enum TransactionPurpose {
     APPROVAL = "APPROVAL",
-    FULFILL_ORDER = "FULFILL_ORDER"
+    FULFILL_ORDER = "FULFILL_ORDER",
+    CANCEL = "CANCEL"
 }
 declare enum SignablePurpose {
-    CREATE_LISTING = "CREATE_LISTING"
+    CREATE_LISTING = "CREATE_LISTING",
+    OFF_CHAIN_CANCELLATION = "OFF_CHAIN_CANCELLATION"
 }
 declare enum ActionType {
     TRANSACTION = "TRANSACTION",
@@ -1373,8 +1398,8 @@ interface FulfillOrderResponse {
     expiration: string;
     order: Order;
 }
-interface CancelOrderResponse {
-    unsignedCancelOrderTransaction: PopulatedTransaction;
+interface CancelOrdersOnChainResponse {
+    cancellationAction: TransactionAction;
 }
 interface Order {
     id: string;
@@ -1536,17 +1561,40 @@ declare class Orderbook {
     fulfillOrder(listingId: string, takerAddress: string, takerFees: FeeValue[]): Promise<FulfillOrderResponse>;
     fulfillBulkOrders(listings: Array<FulfillmentListing>, takerAddress: string): Promise<FulfillBulkOrdersResponse>;
     /**
-     * Get an unsigned cancel order transaction. Orders can only be cancelled by
-     * the account that created them.
-     * @param {string} listingId - The listingId to cancel.
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. For the orderbook to authenticate the cancellation, the creator
+     * of the orders must sign an EIP712 message containing the orderIds
+     * @param {string} orderIds - The orderIds to attempt to cancel.
+     * @return {PrepareCancelOrdersResponse} The signable action to cancel the orders.
+     */
+    prepareOrderCancellations(orderIds: string[]): Promise<PrepareCancelOrdersResponse>;
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. Orders cancelled this way cannot be fulfilled and will be removed
+     * from the orderbook. If there is pending fulfillment data outstanding for the order, its
+     * cancellation will be pending until the fulfillment window has passed.
+     * `prepareOffchainOrderCancellations` can be used to get the signable action that is signed
+     * to get the signature required for this call.
+     * @param {string[]} orderIds - The orderIds to attempt to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @return {CancelOrdersResult} The result of the off-chain cancellation request
+     */
+    cancelOrders(orderIds: string[], accountAddress: string, signature: string): Promise<CancelOrdersResult>;
+    /**
+     * Get an unsigned order cancellation transaction. Orders can only be cancelled by
+     * the account that created them. All of the orders must be from the same seaport contract.
+     * If trying to cancel orders from multiple seaport contracts, group the orderIds by seaport
+     * contract and call this method for each group.
+     * @param {string[]} orderIds - The orderIds to cancel.
      * @param {string} accountAddress - The address of the account cancelling the order.
-     * @return {CancelOrderResponse} The unsigned cancel order transaction
+     * @return {CancelOrdersOnChainResponse} The unsigned cancel order action
      */
-    cancelOrder(listingId: string, accountAddress: string): Promise<CancelOrderResponse>;
+    cancelOrdersOnChain(orderIds: string[], accountAddress: string): Promise<CancelOrdersOnChainResponse>;
 }
 
 declare const constants: {
     estimatedFulfillmentGasGwei: number;
 };
 
-export { Action, ActionType, CancelOrderResponse, CreateListingParams, ERC20Item, ERC721Item, Fee, FeeType, FeeValue, FulfillBulkOrdersInsufficientBalanceResponse, FulfillBulkOrdersResponse, FulfillBulkOrdersSufficientBalanceResponse, FulfillOrderResponse, FulfillmentListing, ListListingsParams, ListListingsResult, ListTradesParams, ListTradesResult, ListingResult, NativeItem, Order, OrderStatusName, Orderbook, Page, PrepareListingParams, PrepareListingResponse, RoyaltyInfo, SignableAction, SignablePurpose, Trade, TradeResult, TransactionAction, TransactionBuilder, TransactionPurpose, UnfulfillableOrder, constants };
+export { Action, ActionType, CancelOrdersOnChainResponse, CreateListingParams, ERC20Item, ERC721Item, Fee, FeeType, FeeValue, FulfillBulkOrdersInsufficientBalanceResponse, FulfillBulkOrdersResponse, FulfillBulkOrdersSufficientBalanceResponse, FulfillOrderResponse, FulfillmentListing, ListListingsParams, ListListingsResult, ListTradesParams, ListTradesResult, ListingResult, NativeItem, Order, OrderStatusName, Orderbook, Page, PrepareCancelOrdersResponse, PrepareListingParams, PrepareListingResponse, RoyaltyInfo, SignableAction, SignablePurpose, Trade, TradeResult, TransactionAction, TransactionBuilder, TransactionPurpose, UnfulfillableOrder, constants };

package/dist/orderbook.js

@@ -606,7 +606,7 @@ var CancelledOrderStatus;
 var FailedOrderCancellation;
 (function (FailedOrderCancellation) {
     (function (reason_code) {
-        reason_code["ALREADY_FILLED"] = "ALREADY_FILLED";
+        reason_code["FILLED"] = "FILLED";
     })(FailedOrderCancellation.reason_code || (FailedOrderCancellation.reason_code = {}));
 })(FailedOrderCancellation || (FailedOrderCancellation = {}));
 
@@ -660,10 +660,12 @@ var TransactionPurpose;
 (function (TransactionPurpose) {
     TransactionPurpose["APPROVAL"] = "APPROVAL";
     TransactionPurpose["FULFILL_ORDER"] = "FULFILL_ORDER";
+    TransactionPurpose["CANCEL"] = "CANCEL";
 })(TransactionPurpose || (TransactionPurpose = {}));
 var SignablePurpose;
 (function (SignablePurpose) {
     SignablePurpose["CREATE_LISTING"] = "CREATE_LISTING";
+    SignablePurpose["OFF_CHAIN_CANCELLATION"] = "OFF_CHAIN_CANCELLATION";
 })(SignablePurpose || (SignablePurpose = {}));
 var ActionType;
 (function (ActionType) {
@@ -1060,11 +1062,15 @@ class Seaport {
                 .reduce((p, c) => (new Date(p) < new Date(c) ? p : c)),
         };
     }
-    async cancelOrder(order, account) {
-        const { orderComponents } = this.mapImmutableOrderToSeaportOrderComponents(order);
-        const seaportLib = this.getSeaportLib(order);
-        const cancellationTransaction = await seaportLib.cancelOrders([orderComponents], account);
-        return prepareTransaction(cancellationTransaction)();
+    async cancelOrders(orders, account) {
+        const orderComponents = orders.map((order) => this.mapImmutableOrderToSeaportOrderComponents(order).orderComponents);
+        const seaportLib = this.getSeaportLib(orders[0]);
+        const cancellationTransaction = await seaportLib.cancelOrders(orderComponents, account);
+        return {
+            type: ActionType.TRANSACTION,
+            buildTransaction: prepareTransaction(cancellationTransaction),
+            purpose: TransactionPurpose.CANCEL,
+        };
     }
     mapImmutableOrderToSeaportOrderComponents(order) {
         const orderCounter = order.protocol_data.counter;
@@ -1166,6 +1172,16 @@ class ImmutableApiClient {
             ...listTradesParams,
         });
     }
+    async cancelOrders(orderIds, accountAddress, signature) {
+        return this.orderbookService.cancelOrders({
+            chainName: this.chainName,
+            requestBody: {
+                account_address: accountAddress,
+                orders: orderIds,
+                signature,
+            },
+        });
+    }
     async createListing({ orderHash, orderComponents, orderSignature, makerFees, }) {
         if (orderComponents.offer.length !== 1) {
             throw new Error('Only one item can be listed at a time');
@@ -1467,24 +1483,89 @@ class Orderbook {
         }
     }
     /**
-     * Get an unsigned cancel order transaction. Orders can only be cancelled by
-     * the account that created them.
-     * @param {string} listingId - The listingId to cancel.
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. For the orderbook to authenticate the cancellation, the creator
+     * of the orders must sign an EIP712 message containing the orderIds
+     * @param {string} orderIds - The orderIds to attempt to cancel.
+     * @return {PrepareCancelOrdersResponse} The signable action to cancel the orders.
+     */
+    async prepareOrderCancellations(orderIds) {
+        const network = await this.orderbookConfig.provider.getNetwork();
+        const domain = {
+            name: 'imtbl-order-book',
+            chainId: network.chainId,
+            verifyingContract: this.orderbookConfig.seaportContractAddress,
+        };
+        const types = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            CancelPayload: [
+                { name: 'orders', type: 'Order[]' },
+            ],
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            Order: [
+                { name: 'id', type: 'string' },
+            ],
+        };
+        const cancelMessage = {
+            orders: orderIds.map((id) => ({ id })),
+        };
+        return {
+            signableAction: {
+                purpose: SignablePurpose.OFF_CHAIN_CANCELLATION,
+                type: ActionType.SIGNABLE,
+                message: {
+                    domain,
+                    types,
+                    value: cancelMessage,
+                },
+            },
+        };
+    }
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. Orders cancelled this way cannot be fulfilled and will be removed
+     * from the orderbook. If there is pending fulfillment data outstanding for the order, its
+     * cancellation will be pending until the fulfillment window has passed.
+     * `prepareOffchainOrderCancellations` can be used to get the signable action that is signed
+     * to get the signature required for this call.
+     * @param {string[]} orderIds - The orderIds to attempt to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @return {CancelOrdersResult} The result of the off-chain cancellation request
+     */
+    async cancelOrders(orderIds, accountAddress, signature) {
+        return this.apiClient.cancelOrders(orderIds, accountAddress, signature);
+    }
+    /**
+     * Get an unsigned order cancellation transaction. Orders can only be cancelled by
+     * the account that created them. All of the orders must be from the same seaport contract.
+     * If trying to cancel orders from multiple seaport contracts, group the orderIds by seaport
+     * contract and call this method for each group.
+     * @param {string[]} orderIds - The orderIds to cancel.
      * @param {string} accountAddress - The address of the account cancelling the order.
-     * @return {CancelOrderResponse} The unsigned cancel order transaction
+     * @return {CancelOrdersOnChainResponse} The unsigned cancel order action
      */
-    async cancelOrder(listingId, accountAddress) {
-        const orderResult = await this.apiClient.getListing(listingId);
-        if (orderResult.result.status.name !== OrderStatusName.ACTIVE
-            && orderResult.result.status.name !== OrderStatusName.INACTIVE
-            && orderResult.result.status.name !== OrderStatusName.PENDING) {
-            throw new Error(`Cannot cancel order with status ${orderResult.result.status}`);
+    async cancelOrdersOnChain(orderIds, accountAddress) {
+        const orderResults = await Promise.all(orderIds.map((id) => this.apiClient.getListing(id)));
+        // eslint-disable-next-line no-restricted-syntax
+        for (const orderResult of orderResults) {
+            if (orderResult.result.status.name !== OrderStatusName.ACTIVE
+                && orderResult.result.status.name !== OrderStatusName.INACTIVE
+                && orderResult.result.status.name !== OrderStatusName.PENDING) {
+                throw new Error(`Cannot cancel order with status ${orderResult.result.status}`);
+            }
+            if (orderResult.result.account_address !== accountAddress.toLowerCase()) {
+                throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${orderResult.result.id}`);
+            }
         }
-        if (orderResult.result.account_address !== accountAddress.toLowerCase()) {
-            throw new Error(`Only account ${orderResult.result.account_address} can cancel order ${listingId}`);
+        const orders = orderResults.map((orderResult) => orderResult.result);
+        const seaportAddresses = orders.map((o) => o.protocol_data.seaport_address);
+        const distinctSeaportAddresses = new Set(...[seaportAddresses]);
+        if (distinctSeaportAddresses.size !== 1) {
+            throw new Error('Cannot cancel multiple orders from different seaport contracts. Please group your orderIds accordingly');
         }
-        const cancelOrderTransaction = await this.seaport.cancelOrder(orderResult.result, accountAddress);
-        return { unsignedCancelOrderTransaction: cancelOrderTransaction };
+        const cancellationAction = await this.seaport.cancelOrders(orders, accountAddress);
+        return { cancellationAction };
     }
 }