@imtbl/orderbook 2.0.0-alpha.0

package/dist/types/openapi/sdk/services/OrdersService.d.ts

@@ -0,0 +1,319 @@
+import type { BidResult } from '../models/BidResult';
+import type { CancelOrdersRequestBody } from '../models/CancelOrdersRequestBody';
+import type { CancelOrdersResult } from '../models/CancelOrdersResult';
+import type { ChainName } from '../models/ChainName';
+import type { CollectionBidResult } from '../models/CollectionBidResult';
+import type { CreateBidRequestBody } from '../models/CreateBidRequestBody';
+import type { CreateCollectionBidRequestBody } from '../models/CreateCollectionBidRequestBody';
+import type { CreateListingRequestBody } from '../models/CreateListingRequestBody';
+import type { FulfillableOrder } from '../models/FulfillableOrder';
+import type { FulfillmentDataRequest } from '../models/FulfillmentDataRequest';
+import type { ListBidsResult } from '../models/ListBidsResult';
+import type { ListCollectionBidsResult } from '../models/ListCollectionBidsResult';
+import type { ListingResult } from '../models/ListingResult';
+import type { ListListingsResult } from '../models/ListListingsResult';
+import type { ListTradeResult } from '../models/ListTradeResult';
+import type { OrderStatusName } from '../models/OrderStatusName';
+import type { PageCursor } from '../models/PageCursor';
+import type { PageSize } from '../models/PageSize';
+import type { TradeResult } from '../models/TradeResult';
+import type { UnfulfillableOrder } from '../models/UnfulfillableOrder';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import type { BaseHttpRequest } from '../core/BaseHttpRequest';
+export declare class OrdersService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Cancel one or more orders
+     * Cancel one or more orders
+     * @returns CancelOrdersResult Orders cancellation response.
+     * @throws ApiError
+     */
+    cancelOrders({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: CancelOrdersRequestBody;
+    }): CancelablePromise<CancelOrdersResult>;
+    /**
+     * List all listings
+     * List all listings
+     * @returns ListListingsResult OK response.
+     * @throws ApiError
+     */
+    listListings({ chainName, status, sellItemContractAddress, buyItemType, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        /**
+         * Order status to filter by
+         */
+        status?: OrderStatusName;
+        /**
+         * Sell item contract address to filter by
+         */
+        sellItemContractAddress?: string;
+        /**
+         * Buy item type to filter by
+         */
+        buyItemType?: 'NATIVE' | 'ERC20';
+        /**
+         * Buy item contract address to filter by
+         */
+        buyItemContractAddress?: string;
+        /**
+         * The account address of the user who created the listing
+         */
+        accountAddress?: string;
+        /**
+         * The metadata_id of the sell item
+         */
+        sellItemMetadataId?: string;
+        /**
+         * Sell item token identifier to filter by
+         */
+        sellItemTokenId?: string;
+        /**
+         * From updated at including given date
+         */
+        fromUpdatedAt?: string;
+        /**
+         * Maximum number of orders to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Order field to sort by. `buy_item_amount` sorts by per token price, for example if 5 ERC-1155s are on sale for 10eth, it’s sorted as 2eth for `buy_item_amount`.
+         */
+        sortBy?: 'created_at' | 'updated_at' | 'buy_item_amount';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListListingsResult>;
+    /**
+     * Create a listing
+     * Create a listing
+     * @returns ListingResult Created response.
+     * @throws ApiError
+     */
+    createListing({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: CreateListingRequestBody;
+    }): CancelablePromise<ListingResult>;
+    /**
+     * List all bids
+     * List all bids
+     * @returns ListBidsResult OK response.
+     * @throws ApiError
+     */
+    listBids({ chainName, status, buyItemContractAddress, sellItemContractAddress, accountAddress, buyItemMetadataId, buyItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        /**
+         * Order status to filter by
+         */
+        status?: OrderStatusName;
+        /**
+         * Buy item contract address to filter by
+         */
+        buyItemContractAddress?: string;
+        /**
+         * Sell item contract address to filter by
+         */
+        sellItemContractAddress?: string;
+        /**
+         * The account address of the user who created the bid
+         */
+        accountAddress?: string;
+        /**
+         * The metadata_id of the buy item
+         */
+        buyItemMetadataId?: string;
+        /**
+         * buy item token identifier to filter by
+         */
+        buyItemTokenId?: string;
+        /**
+         * From updated at including given date
+         */
+        fromUpdatedAt?: string;
+        /**
+         * Maximum number of orders to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Order field to sort by. `sell_item_amount` sorts by per token price, for example if 10eth is offered for 5 ERC1155 items, it’s sorted as 2eth for `sell_item_amount`.
+         */
+        sortBy?: 'created_at' | 'updated_at' | 'sell_item_amount';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListBidsResult>;
+    /**
+     * Create a bid
+     * Create a bid
+     * @returns BidResult Created response.
+     * @throws ApiError
+     */
+    createBid({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: CreateBidRequestBody;
+    }): CancelablePromise<BidResult>;
+    /**
+     * List all collection bids
+     * List all collection bids
+     * @returns ListCollectionBidsResult OK response.
+     * @throws ApiError
+     */
+    listCollectionBids({ chainName, status, buyItemContractAddress, sellItemContractAddress, accountAddress, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        /**
+         * Order status to filter by
+         */
+        status?: OrderStatusName;
+        /**
+         * Buy item contract address to filter by
+         */
+        buyItemContractAddress?: string;
+        /**
+         * Sell item contract address to filter by
+         */
+        sellItemContractAddress?: string;
+        /**
+         * The account address of the user who created the bid
+         */
+        accountAddress?: string;
+        /**
+         * From updated at including given date
+         */
+        fromUpdatedAt?: string;
+        /**
+         * Maximum number of orders to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Order field to sort by. `sell_item_amount` sorts by per token price, for example if 10eth is offered for 5 ERC1155 items, it’s sorted as 2eth for `sell_item_amount`.
+         */
+        sortBy?: 'created_at' | 'updated_at' | 'sell_item_amount';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListCollectionBidsResult>;
+    /**
+     * Create a collection bid
+     * Create a collection bid
+     * @returns CollectionBidResult Created response.
+     * @throws ApiError
+     */
+    createCollectionBid({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: CreateCollectionBidRequestBody;
+    }): CancelablePromise<CollectionBidResult>;
+    /**
+     * Get a single listing by ID
+     * Get a single listing by ID
+     * @returns ListingResult OK response.
+     * @throws ApiError
+     */
+    getListing({ chainName, listingId, }: {
+        chainName: ChainName;
+        /**
+         * Global Order identifier
+         */
+        listingId: string;
+    }): CancelablePromise<ListingResult>;
+    /**
+     * Get a single bid by ID
+     * Get a single bid by ID
+     * @returns BidResult OK response.
+     * @throws ApiError
+     */
+    getBid({ chainName, bidId, }: {
+        chainName: ChainName;
+        /**
+         * Global Bid identifier
+         */
+        bidId: string;
+    }): CancelablePromise<BidResult>;
+    /**
+     * Get a single collection bid by ID
+     * Get a single collection bid by ID
+     * @returns CollectionBidResult OK response.
+     * @throws ApiError
+     */
+    getCollectionBid({ chainName, collectionBidId, }: {
+        chainName: ChainName;
+        /**
+         * Global Collection Bid identifier
+         */
+        collectionBidId: string;
+    }): CancelablePromise<CollectionBidResult>;
+    /**
+     * Retrieve fulfillment data for orders
+     * Retrieve signed fulfillment data based on the list of order IDs and corresponding fees.
+     * @returns any Successful response
+     * @throws ApiError
+     */
+    fulfillmentData({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: Array<FulfillmentDataRequest>;
+    }): CancelablePromise<{
+        result: {
+            fulfillable_orders: Array<FulfillableOrder>;
+            unfulfillable_orders: Array<UnfulfillableOrder>;
+        };
+    }>;
+    /**
+     * List all trades
+     * List all trades
+     * @returns ListTradeResult OK response.
+     * @throws ApiError
+     */
+    listTrades({ chainName, accountAddress, sellItemContractAddress, fromIndexedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        accountAddress?: string;
+        sellItemContractAddress?: string;
+        /**
+         * From indexed at including given date
+         */
+        fromIndexedAt?: string;
+        /**
+         * Maximum number of trades to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Trade field to sort by
+         */
+        sortBy?: 'indexed_at';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListTradeResult>;
+    /**
+     * Get a single trade by ID
+     * Get a single trade by ID
+     * @returns TradeResult OK response.
+     * @throws ApiError
+     */
+    getTrade({ chainName, tradeId, }: {
+        chainName: ChainName;
+        /**
+         * Global Trade identifier
+         */
+        tradeId: string;
+    }): CancelablePromise<TradeResult>;
+}

package/dist/types/orderbook.d.ts

@@ -0,0 +1,193 @@
+import { ModuleConfiguration } from '@imtbl/config';
+import { OrderbookModuleConfiguration, OrderbookOverrides } from './config/config';
+import { CancelOrdersResult } from './openapi/sdk';
+import { BidResult, CancelOrdersOnChainResponse, CollectionBidResult, CreateBidParams, CreateCollectionBidParams, CreateListingParams, FeeValue, FulfillBulkOrdersResponse, FulfillmentListing, FulfillmentOrder, FulfillOrderResponse, ListBidsParams, ListBidsResult, ListCollectionBidsParams, ListCollectionBidsResult, ListingResult, ListListingsParams, ListListingsResult, ListTradesParams, ListTradesResult, PrepareBidParams, PrepareBidResponse, PrepareBulkListingsParams, PrepareBulkListingsResponse, PrepareCancelOrdersResponse, PrepareCollectionBidParams, PrepareCollectionBidResponse, PrepareListingParams, PrepareListingResponse, TradeResult } from './types';
+/**
+ * zkEVM orderbook SDK
+ * @constructor
+ * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
+ */
+export declare class Orderbook {
+    private apiClient;
+    private seaport;
+    private orderbookConfig;
+    constructor(config: ModuleConfiguration<OrderbookOverrides>);
+    static defaultOrderExpiry(): Date;
+    /**
+     * Return the configuration for the orderbook module.
+     * @return {OrderbookModuleConfiguration} The configuration for the orderbook module.
+     */
+    config(): OrderbookModuleConfiguration;
+    /**
+     * Get a listing by ID
+     * @param {string} listingId - The listingId to find.
+     * @return {ListingResult} The returned listing result.
+     */
+    getListing(listingId: string): Promise<ListingResult>;
+    /**
+     * Get a bid by ID
+     * @param {string} bidId - The bidId to find.
+     * @return {BidResult} The returned bid result.
+     */
+    getBid(bidId: string): Promise<BidResult>;
+    /**
+     * Get a collection bid by ID
+     * @param {string} collectionBidId - The collectionBidId to find.
+     * @return {CollectionBidResult} The returned collection bid result.
+     */
+    getCollectionBid(collectionBidId: string): Promise<CollectionBidResult>;
+    /**
+     * Get a trade by ID
+     * @param {string} tradeId - The tradeId to find.
+     * @return {TradeResult} The returned trade result.
+     */
+    getTrade(tradeId: string): Promise<TradeResult>;
+    /**
+     * List listings. This method is used to get a list of listings filtered by conditions specified
+     * in the params object.
+     * @param {ListListingsParams} listOrderParams - Filtering, ordering and page parameters.
+     * @return {ListListingsResult} The paged listings.
+     */
+    listListings(listOrderParams: ListListingsParams): Promise<ListListingsResult>;
+    /**
+     * List bids. This method is used to get a list of bids filtered by conditions specified
+     * in the params object.
+     * @param {ListBidsParams} listOrderParams - Filtering, ordering and page parameters.
+     * @return {ListBidsResult} The paged bids.
+     */
+    listBids(listOrderParams: ListBidsParams): Promise<ListBidsResult>;
+    /**
+     * List collection bids. This method is used to get a list of collection bids filtered
+     * by conditions specified in the params object.
+     * @param {ListCollectionBidsParams} listOrderParams - Filtering, ordering and page parameters.
+     * @return {ListCollectionBidsResult} The paged collection bids.
+     */
+    listCollectionBids(listOrderParams: ListCollectionBidsParams): Promise<ListCollectionBidsResult>;
+    /**
+     * List trades. This method is used to get a list of trades filtered by conditions specified
+     * in the params object
+     * @param {ListTradesParams} listTradesParams - Filtering, ordering and page parameters.
+     * @return {ListTradesResult} The paged trades.
+     */
+    listTrades(listTradesParams: ListTradesParams): Promise<ListTradesResult>;
+    /**
+     * Get required transactions and messages for signing to facilitate creating bulk listings.
+     * Once the transactions are submitted and the message signed, call the
+     * {@linkcode PrepareBulkListingsResponse.completeListings} method provided in the return
+     * type with the signature. This method supports up to 20 listing creations
+     * at a time. It can also be used for individual listings to simplify integration code paths.
+     *
+     * Bulk listings created using an EOA (Metamask) will require a single listing confirmation
+     * signature.
+     * Bulk listings creating using a smart contract wallet will require multiple listing confirmation
+     * signatures (as many as the number of orders).
+     * @param {PrepareBulkListingsParams} prepareBulkListingsParams - Details about the listings
+     * to be created.
+     * @return {PrepareBulkListingsResponse} PrepareBulkListingsResponse includes
+     * any unsigned approval transactions, the typed bulk order message for signing and
+     * the {@linkcode PrepareBulkListingsResponse.completeListings} method that can be called with
+     * the signature(s) to create the listings.
+     */
+    prepareBulkListings({ makerAddress, listingParams, }: PrepareBulkListingsParams): Promise<PrepareBulkListingsResponse>;
+    /**
+     * Get required transactions and messages for signing prior to creating a listing
+     * through the {@linkcode createListing} method
+     * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
+     * @return {PrepareListingResponse} PrepareListingResponse includes
+     * the unsigned approval transaction, the typed order message for signing and
+     * the order components that can be submitted to {@linkcode createListing} with a signature.
+     */
+    prepareListing({ makerAddress, sell, buy, orderStart, orderExpiry, }: PrepareListingParams): Promise<PrepareListingResponse>;
+    /**
+     * Create a listing
+     * @param {CreateListingParams} createListingParams - create a listing with the given params.
+     * @return {ListingResult} The result of the listing created in the Immutable services.
+     */
+    createListing(createListingParams: CreateListingParams): Promise<ListingResult>;
+    /**
+     * Get required transactions and messages for signing prior to creating a bid
+     * through the {@linkcode createBid} method
+     * @param {PrepareBidParams} prepareBidParams - Details about the bid to be created.
+     * @return {PrepareBidResponse} PrepareBidResponse includes
+     * the unsigned approval transaction, the typed order message for signing and
+     * the order components that can be submitted to {@linkcode createBid} with a signature.
+     */
+    prepareBid({ makerAddress, sell, buy, orderStart, orderExpiry, }: PrepareBidParams): Promise<PrepareBidResponse>;
+    /**
+     * Create a bid
+     * @param {CreateBidParams} createBidParams - create a bid with the given params.
+     * @return {BidResult} The result of the bid created in the Immutable services.
+     */
+    createBid(createBidParams: CreateBidParams): Promise<BidResult>;
+    /**
+     * Get required transactions and messages for signing prior to creating a collection bid
+     * through the {@linkcode createCollectionBid} method
+     * @param {PrepareCollectionBidParams} - Details about the collection bid to be created.
+     * @return {PrepareCollectionBidResponse} PrepareCollectionBidResponse includes
+     * the unsigned approval transaction, the typed order message for signing and
+     * the order components that can be submitted to {@linkcode createCollectionBid} with a signature.
+     */
+    prepareCollectionBid({ makerAddress, sell, buy, orderStart, orderExpiry, }: PrepareCollectionBidParams): Promise<PrepareCollectionBidResponse>;
+    /**
+     * Create a collection bid
+     * @param {CreateCollectionBidParams} createCollectionBidParams create a collection bid
+     *                                                              with the given params.
+     * @return {CollectionBidResult} The result of the collection bid created
+     *                               in the Immutable services.
+     */
+    createCollectionBid(createCollectionBidParams: CreateCollectionBidParams): Promise<CollectionBidResult>;
+    /**
+     * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
+     * transaction exists it must be signed and submitted to the chain before the fulfilment
+     * transaction can be submitted or it will be reverted.
+     * @param {string} orderId - The orderId to fulfil.
+     * @param {string} takerAddress - The address of the account fulfilling the order.
+     * @param {FeeValue[]} takerFees - Taker ecosystem fees to be paid.
+     * @param {string} amountToFill - Amount of the order to fill, defaults to sell item amount.
+     *                                Only applies to ERC1155 orders
+     * @return {FulfillOrderResponse} Approval and fulfilment transactions.
+     */
+    fulfillOrder(orderId: string, takerAddress: string, takerFees: FeeValue[], amountToFill?: string, tokenId?: string): Promise<FulfillOrderResponse>;
+    /**
+     * Get unsigned transactions that can be submitted to fulfil multiple open orders. If approval
+     * transactions exist, they must be signed and submitted to the chain before the fulfilment
+     * transaction can be submitted or it will be reverted.
+     * @param {FulfillmentOrder[]} orders - The details of the orders to fulfil, amounts
+     *                                               to fill and taker ecosystem fees to be paid.
+     * @param {string} takerAddress - The address of the account fulfilling the order.
+     * @return {FulfillBulkOrdersResponse} Approval and fulfilment transactions.
+     */
+    fulfillBulkOrders(orders: FulfillmentOrder[] | FulfillmentListing[], takerAddress: string): Promise<FulfillBulkOrdersResponse>;
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * {@linkcode 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
+     * {@linkcode 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.
+     * {@linkcode prepareOrderCancellations} 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} signature - The signature obtained by signing the
+     * message obtained from {@linkcode prepareOrderCancellations}.
+     * @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 {CancelOrdersOnChainResponse} The unsigned cancel order action
+     */
+    cancelOrdersOnChain(orderIds: string[], accountAddress: string): Promise<CancelOrdersOnChainResponse>;
+}

package/dist/types/seaport/components.d.ts

@@ -0,0 +1,8 @@
+import type { OrderComponents } from '@opensea/seaport-js/lib/types';
+export declare function getOrderComponentsFromMessage(orderMessage: string): OrderComponents;
+export declare function getBulkOrderComponentsFromMessage(orderMessage: string): {
+    components: OrderComponents[];
+    types: any;
+    value: any;
+};
+export declare function getBulkSeaportOrderSignatures(signature: string, orderComponents: OrderComponents[]): string[];

package/dist/types/seaport/constants.d.ts

@@ -0,0 +1,43 @@
+export declare const SEAPORT_CONTRACT_NAME = "ImmutableSeaport";
+export declare const SEAPORT_CONTRACT_VERSION_V1_5 = "1.5";
+export declare const EIP_712_ORDER_TYPE: {
+    OrderComponents: {
+        name: string;
+        type: string;
+    }[];
+    OfferItem: {
+        name: string;
+        type: string;
+    }[];
+    ConsiderationItem: {
+        name: string;
+        type: string;
+    }[];
+};
+export declare enum OrderType {
+    FULL_OPEN = 0,// No partial fills, anyone can execute
+    PARTIAL_OPEN = 1,// Partial fills supported, anyone can execute
+    FULL_RESTRICTED = 2,// No partial fills, only offerer or zone can execute
+    PARTIAL_RESTRICTED = 3
+}
+export declare enum ItemType {
+    NATIVE = 0,
+    ERC20 = 1,
+    ERC721 = 2,
+    ERC1155 = 3,
+    ERC721_WITH_CRITERIA = 4,
+    ERC1155_WITH_CRITERIA = 5
+}
+export declare enum Side {
+    OFFER = 0,
+    CONSIDERATION = 1
+}
+export type NftItemType = ItemType.ERC721 | ItemType.ERC1155 | ItemType.ERC721_WITH_CRITERIA | ItemType.ERC1155_WITH_CRITERIA;
+export declare enum BasicOrderRouteType {
+    ETH_TO_ERC721 = 0,
+    ETH_TO_ERC1155 = 1,
+    ERC20_TO_ERC721 = 2,
+    ERC20_TO_ERC1155 = 3,
+    ERC721_TO_ERC20 = 4,
+    ERC1155_TO_ERC20 = 5
+}

package/dist/types/seaport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './seaport';
+export * from './constants';

package/dist/types/seaport/lib/bulk-orders.d.ts

@@ -0,0 +1,6 @@
+import type { OrderComponents } from '@opensea/seaport-js/lib/types';
+import { Eip712MerkleTree } from './merkle';
+export declare function getBulkOrderTreeHeight(length: number): number;
+export declare function getBulkOrderTree(orderComponents: OrderComponents[], startIndex?: number, height?: number): Eip712MerkleTree<OrderComponents>;
+export declare function getBulkOrderTypeHash(height: number): string;
+export declare function getBulkOrderTypeHashes(maxHeight: number): string[];

package/dist/types/seaport/lib/defaults.d.ts

@@ -0,0 +1,14 @@
+import { TypedDataField } from 'ethers';
+export type EIP712TypeDefinitions = Record<string, TypedDataField[]>;
+type DefaultMap<T extends EIP712TypeDefinitions> = {
+    [K in keyof T]: any;
+};
+export declare class DefaultGetter<Types extends EIP712TypeDefinitions> {
+    protected types: Types;
+    defaultValues: DefaultMap<Types>;
+    constructor(types: Types);
+    static from<Types extends EIP712TypeDefinitions>(types: Types): DefaultMap<Types>;
+    static from<Types extends EIP712TypeDefinitions>(types: Types, type: keyof Types): any;
+    getDefaultValue(type: string): any;
+}
+export {};

package/dist/types/seaport/lib/merkle.d.ts

@@ -0,0 +1,33 @@
+import { MerkleTree } from 'merkletreejs';
+import { TypedDataEncoder } from 'ethers';
+import type { EIP712TypeDefinitions } from './defaults';
+type BulkOrderElements<T> = [T, T] | [BulkOrderElements<T>, BulkOrderElements<T>];
+export declare class Eip712MerkleTree<BaseType extends Record<string, any> = any> {
+    types: EIP712TypeDefinitions;
+    rootType: string;
+    leafType: string;
+    elements: BaseType[];
+    depth: number;
+    tree: MerkleTree;
+    private leafHasher;
+    defaultNode: BaseType;
+    defaultLeaf: string;
+    encoder: TypedDataEncoder;
+    get completedSize(): number;
+    /** Returns the array of elements in the tree, padded to the complete size with empty items. */
+    getCompleteElements(): BaseType[];
+    /** Returns the array of leaf nodes in the tree, padded to the complete size with default hashes. */
+    getCompleteLeaves(): string[];
+    get root(): string;
+    getProof(i: number): {
+        leaf: string;
+        proof: string[];
+        root: string;
+    };
+    getEncodedProofAndSignature(i: number, signature: string): string;
+    getDataToSign(): BulkOrderElements<BaseType>;
+    add(element: BaseType): void;
+    getBulkOrderHash(): string;
+    constructor(types: EIP712TypeDefinitions, rootType: string, leafType: string, elements: BaseType[], depth: number);
+}
+export {};

package/dist/types/seaport/lib/utils.d.ts

@@ -0,0 +1,10 @@
+import { BytesLike } from 'ethers';
+export declare const makeArray: <T>(len: number, getValue: (i: number) => T) => T[];
+export declare const chunk: <T>(array: T[], size: number) => T[][];
+export declare const bufferToHex: (buf: Buffer) => string;
+export declare const hexToBuffer: (value: string) => Buffer;
+export declare const bufferKeccak: (value: BytesLike) => Buffer;
+export declare const hashConcat: (arr: BytesLike[]) => Buffer;
+export declare const fillArray: <T>(arr: T[], length: number, value: T) => T[];
+export declare const getRoot: (elements: (Buffer | string)[], hashLeaves?: boolean) => Buffer;
+export declare const getNextLayer: (elements: Buffer[]) => Buffer[];

package/dist/types/seaport/map-to-immutable-order.d.ts

@@ -0,0 +1,7 @@
+import { ConsiderationItem, OfferItem } from '@opensea/seaport-js/lib/types';
+import { AssetCollectionItem, ERC20Item, Item, ProtocolData } from '../openapi/sdk';
+import { OrderType } from './constants';
+export declare function mapSeaportItemToImmutableItem(item: OfferItem | ConsiderationItem): Item;
+export declare function mapSeaportItemToImmutableERC20Item(item: OfferItem | ConsiderationItem): ERC20Item;
+export declare function mapSeaportItemToImmutableAssetCollectionItem(item: OfferItem | ConsiderationItem): AssetCollectionItem;
+export declare function mapSeaportOrderTypeToImmutableProtocolDataOrderType(ot: OrderType): ProtocolData.order_type;

package/dist/types/seaport/map-to-seaport-order.d.ts

@@ -0,0 +1,6 @@
+import { OrderComponents, TipInputItem } from '@opensea/seaport-js/lib/types';
+import { Order } from '../openapi/sdk';
+export declare function mapImmutableOrderToSeaportOrderComponents(order: Order): {
+    orderComponents: OrderComponents;
+    tips: Array<TipInputItem>;
+};

package/dist/types/seaport/seaport-lib-factory.d.ts

@@ -0,0 +1,10 @@
+import { Seaport as SeaportLib } from '@opensea/seaport-js';
+import { JsonRpcProvider } from 'ethers';
+import { SEAPORT_CONTRACT_VERSION_V1_5 } from './constants';
+export type SeaportVersion = typeof SEAPORT_CONTRACT_VERSION_V1_5;
+export declare class SeaportLibFactory {
+    private readonly defaultSeaportContractAddress;
+    private readonly provider;
+    constructor(defaultSeaportContractAddress: string, provider: JsonRpcProvider);
+    create(orderSeaportAddress?: string): SeaportLib;
+}