feat(orderbook): Add createTraitBid, getTraitBid and listTraitBid functions for orderbook (#2854)

Author: JCSanPedro

packages/orderbook/src/api-client/api-client.ts

@@ -8,8 +8,10 @@ import {
   ListingResult,
   ListListingsResult,
   ListTradeResult,
+  ListTraitBidsResult,
   OrdersService,
   TradeResult,
+  TraitBidResult,
 } from '../openapi/sdk';
 import { FulfillableOrder } from '../openapi/sdk/models/FulfillableOrder';
 import { FulfillmentDataRequest } from '../openapi/sdk/models/FulfillmentDataRequest';
@@ -23,10 +25,13 @@ import {
 } from '../seaport/map-to-immutable-order';
 import {
   CreateBidParams,
+  CreateCollectionBidParams,
   CreateListingParams,
+  CreateTraitBidParams,
   ListBidsParams,
   ListCollectionBidsParams,
   ListListingsParams,
+  ListTraitBidsParams,
   ListTradesParams,
 } from '../types';
 
@@ -72,6 +77,13 @@ export class ImmutableApiClient {
     });
   }
 
+  async getTraitBid(traitBidId: string): Promise<TraitBidResult> {
+    return this.orderbookService.getTraitBid({
+      chainName: this.chainName,
+      traitBidId,
+    });
+  }
+
   async getTrade(tradeId: string): Promise<TradeResult> {
     return this.orderbookService.getTrade({
       chainName: this.chainName,
@@ -106,6 +118,15 @@ export class ImmutableApiClient {
     });
   }
 
+  async listTraitBids(
+    listOrderParams: ListTraitBidsParams,
+  ): Promise<ListTraitBidsResult> {
+    return this.orderbookService.listTraitBids({
+      chainName: this.chainName,
+      ...listOrderParams,
+    });
+  }
+
   async listTrades(
     listTradesParams: ListTradesParams,
   ): Promise<ListTradeResult> {
@@ -243,7 +264,7 @@ export class ImmutableApiClient {
     orderComponents,
     orderSignature,
     makerFees,
-  }: CreateBidParams): Promise<CollectionBidResult> {
+  }: CreateCollectionBidParams): Promise<CollectionBidResult> {
     if (orderComponents.offer.length !== 1) {
       throw new Error('Only one item can be listed for a collection bid');
     }
@@ -293,4 +314,69 @@ export class ImmutableApiClient {
       },
     });
   }
+
+  async createTraitBid({
+    orderHash,
+    orderComponents,
+    orderSignature,
+    makerFees,
+    traitCriteria,
+  }: CreateTraitBidParams): Promise<TraitBidResult> {
+    if (orderComponents.offer.length !== 1) {
+      throw new Error('Only one item can be listed for a trait bid');
+    }
+
+    if (orderComponents.consideration.length !== 1) {
+      throw new Error('Only one item can be used as currency for a trait bid');
+    }
+
+    if (ItemType.ERC20 !== orderComponents.offer[0].itemType) {
+      throw new Error('Only ERC20 tokens can be used as the currency item in a trait bid');
+    }
+
+    if (![ItemType.ERC721_WITH_CRITERIA, ItemType.ERC1155_WITH_CRITERIA]
+      .includes(orderComponents.consideration[0].itemType)
+    ) {
+      throw new Error('Only ERC721 / ERC1155 collection based tokens can be bid against');
+    }
+
+    if (!traitCriteria?.length) {
+      throw new Error('At least one trait criterion is required for a trait bid');
+    }
+
+    return this.orderbookService.createTraitBid({
+      chainName: this.chainName,
+      requestBody: {
+        account_address: orderComponents.offerer,
+        buy: orderComponents.consideration.map(mapSeaportItemToImmutableAssetCollectionItem),
+        fees: makerFees.map((f) => ({
+          type: Fee.type.MAKER_ECOSYSTEM,
+          amount: f.amount,
+          recipient_address: f.recipientAddress,
+        })),
+        end_at: new Date(
+          parseInt(`${orderComponents.endTime.toString()}000`, 10),
+        ).toISOString(),
+        order_hash: orderHash,
+        protocol_data: {
+          order_type:
+            mapSeaportOrderTypeToImmutableProtocolDataOrderType(orderComponents.orderType),
+          zone_address: orderComponents.zone,
+          seaport_address: this.seaportAddress,
+          seaport_version: SEAPORT_CONTRACT_VERSION_V1_5,
+          counter: orderComponents.counter.toString(),
+        },
+        salt: orderComponents.salt,
+        sell: orderComponents.offer.map(mapSeaportItemToImmutableERC20Item),
+        signature: orderSignature,
+        start_at: new Date(
+          parseInt(`${orderComponents.startTime.toString()}000`, 10),
+        ).toISOString(),
+        trait_criteria: traitCriteria.map((c) => ({
+          trait_type: c.traitType,
+          values: c.values,
+        })),
+      },
+    });
+  }
 }

packages/orderbook/src/openapi/mapper.test.ts

@@ -0,0 +1,88 @@
+import { Fee } from './sdk';
+import { Order as OpenApiOrder } from './sdk/models/Order';
+import { ProtocolData } from './sdk/models/ProtocolData';
+import { mapOrderFromOpenApiOrder, mapTraitBidFromOpenApiOrder } from './mapper';
+
+describe('mapTraitBidFromOpenApiOrder', () => {
+  const baseOrder: OpenApiOrder = {
+    id: '018792c9-4ad7-8ec4-4038-9e05c598534a',
+    type: OpenApiOrder.type.TRAIT_BID,
+    account_address: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
+    chain: { id: 'eip155:11155111', name: 'imtbl-zkevm-testnet' },
+    created_at: '2022-03-07T07:20:50.52Z',
+    updated_at: '2022-03-07T07:20:50.52Z',
+    start_at: '2022-03-09T05:00:50.52Z',
+    end_at: '2022-03-10T05:00:50.52Z',
+    order_hash: '0xabc',
+    salt: '1',
+    signature: '0x',
+    status: { name: 'ACTIVE' },
+    fill_status: { numerator: '0', denominator: '1' },
+    fees: [
+      {
+        type: Fee.type.MAKER_ECOSYSTEM,
+        amount: '1',
+        recipient_address: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+      },
+    ],
+    protocol_data: {
+      order_type: ProtocolData.order_type.PARTIAL_RESTRICTED,
+      counter: '0',
+      zone_address: '0x12',
+      seaport_address: '0x34',
+      seaport_version: '1.5',
+    },
+    sell: [
+      {
+        type: 'ERC20',
+        contract_address: '0x0165878a594ca255338adfa4d48449f69242eb8f',
+        amount: '1000',
+      },
+    ],
+    buy: [
+      {
+        type: 'ERC721_COLLECTION',
+        contract_address: '0x692edad005237c7e737bb2c0f3d8cccc10d3479e',
+        amount: '1',
+      },
+    ],
+  };
+
+  it('maps trait criteria from snake_case API fields', () => {
+    const order: OpenApiOrder = {
+      ...baseOrder,
+      trait_criteria: [
+        { trait_type: 'Background', values: ['Blue', 'Red'] },
+      ],
+    };
+
+    const mapped = mapTraitBidFromOpenApiOrder(order);
+
+    expect(mapped.traitCriteria).toEqual([
+      { traitType: 'Background', values: ['Blue', 'Red'] },
+    ]);
+    expect(mapped.type).toBe('TRAIT_BID');
+    expect(mapped.sell[0]).toEqual({
+      type: 'ERC20',
+      contractAddress: '0x0165878a594ca255338adfa4d48449f69242eb8f',
+      amount: '1000',
+    });
+  });
+
+  it('defaults trait criteria when omitted', () => {
+    const mapped = mapTraitBidFromOpenApiOrder(baseOrder);
+    expect(mapped.traitCriteria).toEqual([]);
+  });
+
+  it('routes TRAIT_BID through mapOrderFromOpenApiOrder', () => {
+    const order: OpenApiOrder = {
+      ...baseOrder,
+      trait_criteria: [{ trait_type: 'Rarity', values: ['Legendary'] }],
+    };
+    const mapped = mapOrderFromOpenApiOrder(order);
+    expect(mapped.type).toBe('TRAIT_BID');
+    if (mapped.type === 'TRAIT_BID') {
+      expect(mapped.traitCriteria).toEqual([{ traitType: 'Rarity', values: ['Legendary'] }]);
+    }
+  });
+});

packages/orderbook/src/openapi/mapper.ts

@@ -12,9 +12,12 @@ import {
   Order,
   Page,
   Trade,
+  TraitBid,
+  TraitFilter,
 } from '../types';
 import { exhaustiveSwitch } from '../utils';
 import { Order as OpenApiOrder } from './sdk/models/Order';
+import type { TraitFilter as OpenApiTraitFilter } from './sdk/models/TraitFilter';
 import { Page as OpenApiPage } from './sdk/models/Page';
 import { Trade as OpenApiTrade } from './sdk/models/Trade';
 
@@ -163,6 +166,18 @@ export function mapBidFromOpenApiOrder(order: OpenApiOrder): Bid {
   };
 }
 
+function mapTraitCriteriaFromOpenApi(
+  criteria: OpenApiTraitFilter[] | undefined,
+): TraitFilter[] {
+  if (!criteria?.length) {
+    return [];
+  }
+  return criteria.map((c) => ({
+    traitType: c.trait_type,
+    values: [...c.values],
+  }));
+}
+
 export function mapCollectionBidFromOpenApiOrder(order: OpenApiOrder): CollectionBid {
   if (order.type !== OpenApiOrder.type.COLLECTION_BID) {
     throw new Error('Order type must be COLLECTION_BID');
@@ -231,6 +246,75 @@ export function mapCollectionBidFromOpenApiOrder(order: OpenApiOrder): Collectio
   };
 }
 
+export function mapTraitBidFromOpenApiOrder(order: OpenApiOrder): TraitBid {
+  if (order.type !== OpenApiOrder.type.TRAIT_BID) {
+    throw new Error('Order type must be TRAIT_BID');
+  }
+
+  const sellItems: ERC20Item[] = order.sell.map((item) => {
+    if (item.type === 'ERC20') {
+      return {
+        type: 'ERC20',
+        contractAddress: item.contract_address,
+        amount: item.amount,
+      };
+    }
+
+    throw new Error('Trait bid sell items must be ERC20');
+  });
+
+  const buyItems: (ERC721CollectionItem | ERC1155CollectionItem)[] = order.buy.map((item) => {
+    if (item.type === 'ERC721_COLLECTION') {
+      return {
+        type: 'ERC721_COLLECTION',
+        contractAddress: item.contract_address,
+        amount: item.amount,
+      };
+    }
+
+    if (item.type === 'ERC1155_COLLECTION') {
+      return {
+        type: 'ERC1155_COLLECTION',
+        contractAddress: item.contract_address,
+        amount: item.amount,
+      };
+    }
+
+    throw new Error('Trait bid buy items must either ERC721_COLLECTION or ERC1155_COLLECTION');
+  });
+
+  return {
+    id: order.id,
+    type: order.type,
+    chain: order.chain,
+    accountAddress: order.account_address,
+    sell: sellItems,
+    buy: buyItems,
+    fees: order.fees.map((fee) => ({
+      amount: fee.amount,
+      recipientAddress: fee.recipient_address,
+      type: fee.type as unknown as FeeType,
+    })),
+    status: order.status,
+    fillStatus: order.fill_status,
+    startAt: order.start_at,
+    endAt: order.end_at,
+    salt: order.salt,
+    signature: order.signature,
+    orderHash: order.order_hash,
+    protocolData: {
+      orderType: order.protocol_data.order_type,
+      counter: order.protocol_data.counter,
+      seaportAddress: order.protocol_data.seaport_address,
+      seaportVersion: order.protocol_data.seaport_version,
+      zoneAddress: order.protocol_data.zone_address,
+    },
+    createdAt: order.created_at,
+    updatedAt: order.updated_at,
+    traitCriteria: mapTraitCriteriaFromOpenApi(order.trait_criteria),
+  };
+}
+
 export function mapOrderFromOpenApiOrder(order: OpenApiOrder): Order {
   switch (order.type) {
     case OpenApiOrder.type.LISTING:
@@ -239,6 +323,8 @@ export function mapOrderFromOpenApiOrder(order: OpenApiOrder): Order {
       return mapBidFromOpenApiOrder(order);
     case OpenApiOrder.type.COLLECTION_BID:
       return mapCollectionBidFromOpenApiOrder(order);
+    case OpenApiOrder.type.TRAIT_BID:
+      return mapTraitBidFromOpenApiOrder(order);
     default:
       return exhaustiveSwitch(order.type);
   }

packages/orderbook/src/openapi/sdk/index.ts

@@ -21,6 +21,7 @@ export type { ChainName } from './models/ChainName';
 export type { CollectionBidResult } from './models/CollectionBidResult';
 export type { CreateBidRequestBody } from './models/CreateBidRequestBody';
 export type { CreateCollectionBidRequestBody } from './models/CreateCollectionBidRequestBody';
+export type { CreateTraitBidRequestBody } from './models/CreateTraitBidRequestBody';
 export type { CreateListingRequestBody } from './models/CreateListingRequestBody';
 export type { ERC1155CollectionItem } from './models/ERC1155CollectionItem';
 export type { ERC1155Item } from './models/ERC1155Item';
@@ -39,6 +40,7 @@ export type { InactiveOrderStatus } from './models/InactiveOrderStatus';
 export type { Item } from './models/Item';
 export type { ListBidsResult } from './models/ListBidsResult';
 export type { ListCollectionBidsResult } from './models/ListCollectionBidsResult';
+export type { ListTraitBidsResult } from './models/ListTraitBidsResult';
 export type { ListingResult } from './models/ListingResult';
 export type { ListListingsResult } from './models/ListListingsResult';
 export type { ListTradeResult } from './models/ListTradeResult';
@@ -54,6 +56,8 @@ export { ProtocolData } from './models/ProtocolData';
 export type { Trade } from './models/Trade';
 export type { TradeBlockchainMetadata } from './models/TradeBlockchainMetadata';
 export type { TradeResult } from './models/TradeResult';
+export type { TraitBidResult } from './models/TraitBidResult';
+export type { TraitFilter } from './models/TraitFilter';
 export type { UnfulfillableOrder } from './models/UnfulfillableOrder';
 
 export { OrdersService } from './services/OrdersService';