getOrderByHash handle os2 order response

Author: tpetrychyn

src/api/api.ts

@@ -34,6 +34,7 @@ import {
   GetBestListingResponse,
   GetOffersResponse,
   GetListingsResponse,
+  GetOrderByHashResponse,
   CollectionOffer,
   CollectionOrderByOption,
   CancelOrderResponse,
@@ -126,14 +127,14 @@ export class OpenSeaAPI {
    * @param orderHash The hash of the order to fetch
    * @param protocolAddress The address of the seaport contract
    * @param chain The chain where the order is located. Defaults to the chain set in the constructor.
-   * @returns The {@link OrderV2} returned by the API
+   * @returns The {@link GetOrderByHashResponse} returned by the API (can be Offer or Listing)
    * @throws An error if the order is not found
    */
   public async getOrderByHash(
     orderHash: string,
     protocolAddress: string,
     chain: Chain = this.chain,
-  ): Promise<OrderV2> {
+  ): Promise<GetOrderByHashResponse> {
     return this.ordersAPI.getOrderByHash(orderHash, protocolAddress, chain);
   }
 

src/api/orders.ts

@@ -3,7 +3,11 @@ import {
   getOrderByHashPath,
   getCancelOrderPath,
 } from "./apiPaths";
-import { GetOrdersResponse, CancelOrderResponse } from "./types";
+import {
+  GetOrdersResponse,
+  CancelOrderResponse,
+  GetOrderByHashResponse,
+} from "./types";
 import {
   FulfillmentDataResponse,
   OrderAPIOptions,
@@ -72,16 +76,17 @@ export class OrdersAPI {
 
   /**
    * Gets a single order by its order hash.
+   * Returns the raw API response which can be either an Offer or Listing.
    */
   async getOrderByHash(
     orderHash: string,
     protocolAddress: string,
     chain: Chain = this.chain,
-  ): Promise<OrderV2> {
+  ): Promise<GetOrderByHashResponse> {
     const response = await this.fetcher.get<{
-      order: OrdersQueryResponse["orders"][0];
+      order: GetOrderByHashResponse;
     }>(getOrderByHashPath(chain, protocolAddress, orderHash));
-    return deserializeOrder(response.order);
+    return response.order;
   }
 
   /**

src/api/types.ts

@@ -243,6 +243,13 @@ export type GetBestOfferResponse = Offer | CollectionOffer;
  */
 export type GetBestListingResponse = Listing;
 
+/**
+ * Response from OpenSea API for fetching an order by hash.
+ * Can be either an Offer or a Listing.
+ * @category API Response Types
+ */
+export type GetOrderByHashResponse = Offer | Listing;
+
 /**
  * Response from OpenSea API for offchain canceling an order.
  * @category API Response Types

src/sdk/cancellation.ts

@@ -1,5 +1,6 @@
 import { OrderComponents } from "@opensea/seaport-js/lib/types";
 import { Overrides, Signer } from "ethers";
+import { GetOrderByHashResponse } from "../api/types";
 import { OrderV2 } from "../orders/types";
 import { DEFAULT_SEAPORT_CONTRACT_ADDRESS } from "../orders/utils";
 import { Chain, EventType } from "../types";
@@ -55,37 +56,41 @@ export class CancellationManager {
     // Check account availability after parameter validation
     await this.context.requireAccountIsAvailable(accountAddress);
 
-    let orderToCancel: OrderV2;
+    let orderComponents: OrderComponents;
+    let effectiveProtocolAddress: string;
 
     if (order) {
       // Using OrderV2 object directly
       requireValidProtocol(order.protocolAddress);
-      orderToCancel = order;
+      effectiveProtocolAddress = order.protocolAddress;
+      orderComponents = order.protocolData.parameters;
+
+      this.context.dispatch(EventType.CancelOrder, {
+        orderV2: order,
+        accountAddress,
+      });
     } else if (orderHash) {
       // Fetch order from API using order hash
       requireValidProtocol(protocolAddress);
-      orderToCancel = await this.context.api.getOrderByHash(
+      const fetchedOrder = await this.context.api.getOrderByHash(
         orderHash,
         protocolAddress,
         this.context.chain,
       );
-      requireValidProtocol(orderToCancel.protocolAddress);
+      requireValidProtocol(fetchedOrder.protocol_address);
+      effectiveProtocolAddress = fetchedOrder.protocol_address;
+      orderComponents = fetchedOrder.protocol_data.parameters;
     } else {
       // Should never reach here due to earlier validation
       throw new Error("Invalid input");
     }
 
-    this.context.dispatch(EventType.CancelOrder, {
-      orderV2: orderToCancel,
-      accountAddress,
-    });
-
     // Transact and get the transaction hash
     const transactionHash = await this.cancelSeaportOrders({
-      orders: [orderToCancel.protocolData.parameters],
+      orders: [orderComponents],
       accountAddress,
       domain,
-      protocolAddress: orderToCancel.protocolAddress,
+      protocolAddress: effectiveProtocolAddress,
     });
 
     // Await transaction confirmation
@@ -176,9 +181,17 @@ export class CancellationManager {
           return order as OrderComponents;
         }
       });
+
+      // Dispatch event for the first order if available (for backwards compatibility with cancelOrder)
+      if (firstOrderV2) {
+        this.context.dispatch(EventType.CancelOrder, {
+          orderV2: firstOrderV2,
+          accountAddress,
+        });
+      }
     } else if (orderHashes) {
       // Fetch orders from the API using order hashes
-      const fetchedOrders: OrderV2[] = [];
+      const fetchedOrders: GetOrderByHashResponse[] = [];
       for (const orderHash of orderHashes) {
         const order = await this.context.api.getOrderByHash(
           orderHash,
@@ -190,26 +203,15 @@ export class CancellationManager {
 
       // Extract OrderComponents from the fetched orders
       orderComponents = fetchedOrders.map((order) => {
-        requireValidProtocol(order.protocolAddress);
-        effectiveProtocolAddress = order.protocolAddress;
-        return order.protocolData.parameters;
+        requireValidProtocol(order.protocol_address);
+        effectiveProtocolAddress = order.protocol_address;
+        return order.protocol_data.parameters;
       });
-
-      // Save the first order for event dispatching
-      firstOrderV2 = fetchedOrders[0];
     } else {
       // Should never reach here due to earlier validation
       throw new Error("Invalid input");
     }
 
-    // Dispatch event for the first order if available (for backwards compatibility with cancelOrder)
-    if (firstOrderV2) {
-      this.context.dispatch(EventType.CancelOrder, {
-        orderV2: firstOrderV2,
-        accountAddress,
-      });
-    }
-
     // Transact and get the transaction hash
     const transactionHash = await this.cancelSeaportOrders({
       orders: orderComponents,