opensea-js 3.0.4 → 4.0.0-beta.2

package/README.md

@@ -20,11 +20,9 @@ Published on [GitHub](https://github.com/ProjectOpenSea/opensea-js) and [npm](ht
   - [Fetching Assets](#fetching-assets)
     - [Checking Balances and Ownerships](#checking-balances-and-ownerships)
   - [Making Offers](#making-offers)
-    - [Bidding on Multiple Assets](#bidding-on-multiple-assets)
     - [Bidding on ENS Short Name Auctions](#bidding-on-ens-short-name-auctions)
     - [Offer Limits](#offer-limits)
   - [Making Listings / Selling Items](#making-listings--selling-items)
-    - [Creating English Auctions](#creating-english-auctions)
   - [Running Crowdsales](#running-crowdsales)
   - [Fetching Orders](#fetching-orders)
   - [Buying Items](#buying-items)
@@ -34,7 +32,6 @@ Published on [GitHub](https://github.com/ProjectOpenSea/opensea-js) and [npm](ht
   - [Scheduling Future Listings](#scheduling-future-listings)
   - [Purchasing Items for Other Users](#purchasing-items-for-other-users)
   - [Bulk Transfers](#bulk-transfers)
-  - [Creating Bundles](#creating-bundles)
   - [Using ERC-20 Tokens Instead of Ether](#using-erc-20-tokens-instead-of-ether)
   - [Private Auctions](#private-auctions)
   - [Sharing Sale Fees with OpenSea](#sharing-sale-fees-with-opensea)
@@ -50,9 +47,9 @@ Published on [GitHub](https://github.com/ProjectOpenSea/opensea-js) and [npm](ht
 
 This is the JavaScript SDK for [OpenSea](https://opensea.io), the largest marketplace for NFTs.
 
-It allows developers to access the official orderbook, filter it, create buy orders (**offers**), create sell orders (**auctions**), create collections of assets to sell at once (**bundles**), and complete trades programmatically.
+It allows developers to access the official orderbook, filter it, create buy orders (**offers**), create sell orders (**auctions**), and complete trades programmatically.
 
-You get started by [requesting an API key](https://docs.opensea.io/reference) and instantiating your own seaport. Then you can create orders off-chain or fulfill orders on-chain, and listen to events (like `ApproveAllAssets` or `WrapEth`) in the process.
+Get started by [requesting an API key](https://docs.opensea.io/reference) and instantiating your own OpenSea SDK instance. Then you can create orders off-chain or fulfill orders on-chain, and listen to events (like `ApproveAllAssets` or `WrapEth`) in the process.
 
 Happy seafaring! ⛵️
 
@@ -63,7 +60,7 @@ We recommend switching to Node.js version 16 to make sure common crypto dependen
 Then, in your project, run:
 
 ```bash
-npm install --save opensea-js
+npm install --save opensea-js@beta
 ```
 
 Install [web3](https://github.com/ethereum/web3.js) too if you haven't already.
@@ -80,16 +77,16 @@ sudo npm explore npm -g -- npm install node-gyp@latest # (Optional) update node-
 
 To get started, first request an API key [here](https://docs.opensea.io/reference). Note the terms of use for using API data.
 
-Then, create a new OpenSeaJS client, called an OpenSeaPort 🚢, using your Web3 provider:
+Then, create a new OpenSeaJS client, called an OpenSeaSDK 🚢, using your Web3 provider:
 
 ```JavaScript
 import * as Web3 from 'web3'
-import { OpenSeaPort, Network } from 'opensea-js'
+import { OpenSeaSDK, Network } from 'opensea-js'
 
 // This example provider won't let you make transactions, only read-only calls:
 const provider = new Web3.providers.HttpProvider('https://mainnet.infura.io')
 
-const seaport = new OpenSeaPort(provider, {
+const openseaSDK = new OpenSeaSDK(provider, {
   networkName: Network.Main,
   apiKey: YOUR_API_KEY
 })
@@ -128,7 +125,7 @@ The `Asset` type is the minimal type you need for most marketplace actions. `Wyv
 You can fetch an asset using the `OpenSeaAPI`, which will return an `OpenSeaAsset` for you (`OpenSeaAsset` extends `Asset`):
 
 ```TypeScript
-const asset: OpenSeaAsset = await seaport.api.getAsset({
+const asset: OpenSeaAsset = await openseaSDK.api.getAsset({
   tokenAddress, // string
   tokenId, // string | number | null
 })
@@ -149,7 +146,7 @@ const asset = {
   tokenId: "1", // Token ID
 }
 
-const balance = await seaport.getAssetBalance({
+const balance = await openseaSDK.getAssetBalance({
   accountAddress, // string
   asset, // Asset
 })
@@ -160,7 +157,7 @@ const ownsKitty = balance.greaterThan(0)
 You can use this same method for fungible ERC-20 tokens like wrapped ETH (WETH). As a convenience, you can use this fungible wrapper for checking fungible balances:
 
 ```JavaScript
-const balanceOfWETH = await seaport.getTokenBalance({
+const balanceOfWETH = await openseaSDK.getTokenBalance({
   accountAddress, // string
   tokenAddress: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
 })
@@ -176,7 +173,7 @@ const { tokenId, tokenAddress } = YOUR_ASSET
 // The offerer's wallet address:
 const accountAddress = "0x1234..."
 
-const offer = await seaport.createBuyOrder({
+const offer = await openseaSDK.createBuyOrder({
   asset: {
     tokenId,
     tokenAddress,
@@ -190,23 +187,6 @@ const offer = await seaport.createBuyOrder({
 
 When you make an offer on an item owned by an OpenSea user, **that user will automatically get an email notifying them with the offer amount**, if it's above their desired threshold.
 
-#### Bidding on Multiple Assets
-
-You can also make an offer on a bundle of assets. This could also be used for creating a bounty for whoever can acquire a list of items. Here's how you do it:
-
-```JavaScript
-const assets = YOUR_ASSETS
-const offer = await seaport.createBundleBuyOrder({
-  assets,
-  accountAddress,
-  startAmount: 2.4,
-  // Optional expiration time for the order, in Unix time (seconds):
-  expirationTime: Math.round(Date.now() / 1000 + 60 * 60 * 24) // One day from now
-})
-```
-
-When you bid on multiple assets, an email will be sent to the owner if a bundle exists on OpenSea that contains the assets. In the future, OpenSea will send emails to multiple owners if the assets aren't all owned by the same wallet.
-
 #### Bidding on ENS Short Name Auctions
 
 The Ethereum Name Service (ENS) is auctioning short (3-6 character) names that can be used for labeling wallet addresses and more. Learn more on the [ENS FAQ](https://opensea.io/ens).
@@ -220,9 +200,9 @@ const {
   tokenAddress,
   // Name must have `.eth` at the end and correspond with the tokenId
   name
-} = ENS_ASSET // You can get an ENS asset from `seaport.api.getAsset(...)`
+} = ENS_ASSET // You can get an ENS asset from `openseaSDK.api.getAsset(...)`
 
-const offer = await seaport.createBuyOrder({
+const offer = await openseaSDK.createBuyOrder({
   asset: {
     tokenId,
     tokenAddress,
@@ -251,7 +231,7 @@ To sell an asset, call `createSellOrder`. You can do a fixed-price listing, wher
 // Note that we convert from the JavaScript timestamp (milliseconds):
 const expirationTime = Math.round(Date.now() / 1000 + 60 * 60 * 24)
 
-const listing = await seaport.createSellOrder({
+const listing = await openseaSDK.createSellOrder({
   asset: {
     tokenId,
     tokenAddress,
@@ -281,7 +261,7 @@ const paymentTokenAddress = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
 
 const startAmount = 0 // The minimum amount to sell for, in normal units (e.g. ETH)
 
-const auction = await seaport.createSellOrder({
+const auction = await openseaSDK.createSellOrder({
   asset: {
     tokenId,
     tokenAddress,
@@ -308,7 +288,7 @@ Then call `createFactorySellOrders` with your factory contract address and asset
 // Expire these auctions one day from now
 const expirationTime = Math.round(Date.now() / 1000 + 60 * 60 * 24)
 
-const sellOrders = await seaport.createFactorySellOrders({
+const sellOrders = await openseaSDK.createFactorySellOrders({
   assetId: ASSET_OPTION_ID,
   factoryAddress: FACTORY_CONTRACT_ADDRESS,
   accountAddress,
@@ -322,7 +302,7 @@ const sellOrders = await seaport.createFactorySellOrders({
 
 Here's an [example script](https://github.com/ProjectOpenSea/opensea-creatures/blob/master/scripts/sell.js) you can use to mint items.
 
-**NOTE:** If `numberOfOrders` is greater than 5, we will automatically batch them in groups of 5 so you can post orders in parallel. Requires an `apiKey` to be set during seaport initialization in order to not be throttled by the API.
+**NOTE:** If `numberOfOrders` is greater than 5, we will automatically batch them in groups of 5 so you can post orders in parallel. Requires an `apiKey` to be set during SDK initialization in order to not be throttled by the API.
 
 Games using this method include [Coins & Steel](https://opensea.io/assets/coins&steelfounderssale) and a couple in stealth :) If you have questions or want support, contact us at contact@opensea.io (or in [Discord](https://discord.gg/ga8EJbv)).
 
@@ -334,14 +314,14 @@ To retrieve a list of offers and auction on an asset, you can use an instance of
 import { OrderSide } from 'opensea-js/lib/types'
 
 // Get offers (bids), a.k.a. orders where `side == 0`
-const { orders, count } = await seaport.api.getOrders({
+const { orders, count } = await openseaSDK.api.getOrders({
   asset_contract_address: tokenAddress,
   token_id: token_id,
   side: OrderSide.Buy
 })
 
 // Get page 2 of all auctions, a.k.a. orders where `side == 1`
-const { orders, count } = await seaport.api.getOrders({
+const { orders, count } = await openseaSDK.api.getOrders({
   asset_contract_address: tokenAddress,
   token_id: token_id,
   side: OrderSide.Sell
@@ -380,9 +360,9 @@ The available API filters for the orders endpoint is documented in the `OrderJSO
 To buy an item , you need to **fulfill a sell order**. To do that, it's just one call:
 
 ```JavaScript
-const order = await seaport.api.getOrder({ side: OrderSide.Sell, ... })
+const order = await openseaSDK.api.getOrder({ side: OrderSide.Sell, ... })
 const accountAddress = "0x..." // The buyer's wallet address, also the taker
-const transactionHash = await this.props.seaport.fulfillOrder({ order, accountAddress })
+const transactionHash = await this.props.openseaSDK.fulfillOrder({ order, accountAddress })
 ```
 
 Note that the `fulfillOrder` promise resolves when the transaction has been confirmed and mined to the blockchain. To get the transaction hash before this happens, add an event listener (see [Listening to Events](#listening-to-events)) for the `TransactionCreated` event.
@@ -394,9 +374,9 @@ If the order is a sell order (`order.side === OrderSide.Sell`), the taker is the
 Similar to fulfilling sell orders above, you need to fulfill a buy order on an item you own to receive the tokens in the offer.
 
 ```JavaScript
-const order = await seaport.api.getOrder({ side: OrderSide.Buy, ... })
+const order = await openseaSDK.api.getOrder({ side: OrderSide.Buy, ... })
 const accountAddress = "0x..." // The owner's wallet address, also the taker
-await this.props.seaport.fulfillOrder({ order, accountAddress })
+await this.props.openseaSDK.fulfillOrder({ order, accountAddress })
 ```
 
 If the order is a buy order (`order.side === OrderSide.Buy`), then the taker is the _owner_ and this will prompt the owner to exchange their item(s) for whatever is being offered in return. See [Listening to Events](#listening-to-events) below to respond to the setup transactions that occur the first time a user accepts a bid.
@@ -409,7 +389,7 @@ To transfer an ERC-721 asset or an ERC-1155 asset, it's just one call:
 
 ```JavaScript
 
-const transactionHash = await seaport.transfer({
+const transactionHash = await openseaSDK.transfer({
   asset: { tokenId, tokenAddress },
   fromAddress, // Must own the asset
   toAddress
@@ -420,7 +400,7 @@ For fungible ERC-1155 assets, you can set `schemaName` to "ERC1155" and pass a `
 
 ```JavaScript
 
-const transactionHash = await seaport.transfer({
+const transactionHash = await openseaSDK.transfer({
   asset: {
     tokenId,
     tokenAddress,
@@ -437,9 +417,9 @@ To transfer fungible assets without token IDs, like ERC20 tokens, you can pass i
 Example for transfering 2 DAI ($2) to another address:
 
 ```JavaScript
-const paymentToken = (await seaport.api.getPaymentTokens({ symbol: 'DAI'})).tokens[0]
+const paymentToken = (await openseaSDK.api.getPaymentTokens({ symbol: 'DAI'})).tokens[0]
 const quantity = new BigNumber(Math.pow(10, paymentToken.decimals)).times(2)
-const transactionHash = await seaport.transfer({
+const transactionHash = await openseaSDK.transfer({
   asset: {
     tokenId: null,
     tokenAddress: paymentToken.address,
@@ -455,14 +435,14 @@ For more information, check out the documentation for WyvernSchemas on https://p
 
 ## Advanced
 
-Interested in purchasing for users server-side or with a bot, making bundling items together, scheduling future orders, or making bids in different ERC-20 tokens? OpenSea.js can help with that.
+Interested in purchasing for users server-side or with a bot, scheduling future orders, or making bids in different ERC-20 tokens? OpenSea.js can help with that.
 
 ### Scheduling Future Listings
 
-You can create sell orders that aren't fulfillable until a future date. Just pass in a `listingTime` (a UTC timestamp in seconds) to your seaport instance:
+You can create sell orders that aren't fulfillable until a future date. Just pass in a `listingTime` (a UTC timestamp in seconds) to your SDK instance:
 
 ```JavaScript
-const auction = await seaport.createSellOrder({
+const auction = await openseaSDK.createSellOrder({
   tokenAddress,
   tokenId,
   accountAddress,
@@ -476,8 +456,8 @@ const auction = await seaport.createSellOrder({
 You can buy and transfer an item to someone else in one step! Just pass the `recipientAddress` parameter:
 
 ```JavaScript
-const order = await seaport.api.getOrder({ side: OrderSide.Sell, ... })
-await this.props.seaport.fulfillOrder({
+const order = await openseaSDK.api.getOrder({ side: OrderSide.Sell, ... })
+await this.props.openseaSDK.fulfillOrder({
   order,
   accountAddress, // The address of your wallet, which will sign the transaction
   recipientAddress // The address of the recipient, i.e. the wallet you're purchasing on behalf of
@@ -495,7 +475,7 @@ To make a bulk transfer, it's just one call:
 ```JavaScript
 const assets: Array<{tokenId: string; tokenAddress: string}> = [...]
 
-const transactionHash = await seaport.transferAll({
+const transactionHash = await openseaSDK.transferAll({
   assets,
   fromAddress, // Must own all the assets
   toAddress
@@ -504,28 +484,6 @@ const transactionHash = await seaport.transferAll({
 
 This will automatically approve the assets for trading and confirm the transaction for sending them.
 
-### Creating Bundles
-
-You can also create bundles of assets to sell at the same time! If the owner has approved all the assets in the bundle already, only a signature is needed to create it.
-
-To make a bundle, it's just one call:
-
-```JavaScript
-const assets: Array<{tokenId: string; tokenAddress: string}> = [...]
-
-const bundle = await seaport.createBundleSellOrder({
-  bundleName, bundleDescription, bundleExternalLink,
-  assets, accountAddress, startAmount, endAmount,
-  expirationTime, paymentTokenAddress
-})
-```
-
-The parameters `bundleDescription`, `bundleExternalLink`, and `expirationTime` are optional, and `endAmount` can equal `startAmount`, similar to the normal `createSellOrder` functionality.
-
-The parameter `paymentTokenAddress` is the address of the ERC-20 token to accept in return. If it's `undefined` or `null`, the amount is assumed to be in Ether.
-
-Wait what, you can use other currencies than ETH?
-
 ### Using ERC-20 Tokens Instead of Ether
 
 Here's an example of listing the Genesis CryptoKitty for $100! No more needing to worry about the exchange rate:
@@ -535,7 +493,7 @@ Here's an example of listing the Genesis CryptoKitty for $100! No more needing t
 const paymentTokenAddress = "0x89d24a6b4ccb1b6faa2625fe562bdd9a23260359"
 
 // The units for `startAmount` and `endAmount` are now in DAI, so $100 USD
-const auction = await seaport.createSellOrder({
+const auction = await openseaSDK.createSellOrder({
   tokenAddress: "0x06012c8cf97bead5deae237070f9587f8e7a266d", // CryptoKitties
   tokenId: "1", // Token ID
   accountAddress: OWNERS_WALLET_ADDRESS,
@@ -547,9 +505,9 @@ const auction = await seaport.createSellOrder({
 You can use `getPaymentTokens` to search for tokens by symbol name. And you can even list all orders for a specific ERC-20 token by querying the API:
 
 ```JavaScript
-const token = (await seaport.api.getPaymentTokens({ symbol: 'MANA'})).tokens[0]
+const token = (await openseaSDK.api.getPaymentTokens({ symbol: 'MANA'})).tokens[0]
 
-const order = await seaport.api.getOrders({
+const order = await openseaSDK.api.getOrders({
   side: OrderSide.Sell,
   payment_token_address: token.address
 })
@@ -571,7 +529,7 @@ Here's an example of listing a Decentraland parcel for 10 ETH with a specific bu
 // Address allowed to buy from you
 const buyerAddress = "0x123..."
 
-const listing = await seaport.createSellOrder({
+const listing = await openseaSDK.createSellOrder({
   tokenAddress: "0xf87e31492faf9a91b02ee0deaad50d51d56d5d4d", // Decentraland
   tokenId: "115792089237316195423570985008687907832853042650384256231655107562007036952461", // Token ID
   accountAddress: OWNERS_WALLET_ADDRESS,
@@ -597,68 +555,68 @@ Our recommendation is that you "forward" OpenSea events to your own store or sta
 ```JavaScript
 import { EventType } from 'opensea-js'
 import * as ActionTypes from './index'
-import { openSeaPort } from '../globalSingletons'
+import { openSeaSDK } from '../globalSingletons'
 
 // ...
 
-handleSeaportEvents() {
+handleSDKEvents() {
   return async function(dispatch, getState) {
-    openSeaPort.addListener(EventType.TransactionCreated, ({ transactionHash, event }) => {
+    openSeaSDK.addListener(EventType.TransactionCreated, ({ transactionHash, event }) => {
       console.info({ transactionHash, event })
       dispatch({ type: ActionTypes.SET_PENDING_TRANSACTION_HASH, hash: transactionHash })
     })
-    openSeaPort.addListener(EventType.TransactionConfirmed, ({ transactionHash, event }) => {
+    openSeaSDK.addListener(EventType.TransactionConfirmed, ({ transactionHash, event }) => {
       console.info({ transactionHash, event })
       // Only reset your exchange UI if we're finishing an order fulfillment or cancellation
       if (event == EventType.MatchOrders || event == EventType.CancelOrder) {
         dispatch({ type: ActionTypes.RESET_EXCHANGE })
       }
     })
-    openSeaPort.addListener(EventType.TransactionDenied, ({ transactionHash, event }) => {
+    openSeaSDK.addListener(EventType.TransactionDenied, ({ transactionHash, event }) => {
       console.info({ transactionHash, event })
       dispatch({ type: ActionTypes.RESET_EXCHANGE })
     })
-    openSeaPort.addListener(EventType.TransactionFailed, ({ transactionHash, event }) => {
+    openSeaSDK.addListener(EventType.TransactionFailed, ({ transactionHash, event }) => {
       console.info({ transactionHash, event })
       dispatch({ type: ActionTypes.RESET_EXCHANGE })
     })
-    openSeaPort.addListener(EventType.InitializeAccount, ({ accountAddress }) => {
+    openSeaSDK.addListener(EventType.InitializeAccount, ({ accountAddress }) => {
       console.info({ accountAddress })
       dispatch({ type: ActionTypes.INITIALIZE_PROXY })
     })
-    openSeaPort.addListener(EventType.WrapEth, ({ accountAddress, amount }) => {
+    openSeaSDK.addListener(EventType.WrapEth, ({ accountAddress, amount }) => {
       console.info({ accountAddress, amount })
       dispatch({ type: ActionTypes.WRAP_ETH })
     })
-    openSeaPort.addListener(EventType.UnwrapWeth, ({ accountAddress, amount }) => {
+    openSeaSDK.addListener(EventType.UnwrapWeth, ({ accountAddress, amount }) => {
       console.info({ accountAddress, amount })
       dispatch({ type: ActionTypes.UNWRAP_WETH })
     })
-    openSeaPort.addListener(EventType.ApproveCurrency, ({ accountAddress, tokenAddress }) => {
+    openSeaSDK.addListener(EventType.ApproveCurrency, ({ accountAddress, tokenAddress }) => {
       console.info({ accountAddress, tokenAddress })
       dispatch({ type: ActionTypes.APPROVE_WETH })
     })
-    openSeaPort.addListener(EventType.ApproveAllAssets, ({ accountAddress, proxyAddress, tokenAddress }) => {
+    openSeaSDK.addListener(EventType.ApproveAllAssets, ({ accountAddress, proxyAddress, tokenAddress }) => {
       console.info({ accountAddress, proxyAddress, tokenAddress })
       dispatch({ type: ActionTypes.APPROVE_ALL_ASSETS })
     })
-    openSeaPort.addListener(EventType.ApproveAsset, ({ accountAddress, proxyAddress, tokenAddress, tokenId }) => {
+    openSeaSDK.addListener(EventType.ApproveAsset, ({ accountAddress, proxyAddress, tokenAddress, tokenId }) => {
       console.info({ accountAddress, proxyAddress, tokenAddress, tokenId })
       dispatch({ type: ActionTypes.APPROVE_ASSET })
     })
-    openSeaPort.addListener(EventType.CreateOrder, ({ order, accountAddress }) => {
+    openSeaSDK.addListener(EventType.CreateOrder, ({ order, accountAddress }) => {
       console.info({ order, accountAddress })
       dispatch({ type: ActionTypes.CREATE_ORDER })
     })
-    openSeaPort.addListener(EventType.OrderDenied, ({ order, accountAddress }) => {
+    openSeaSDK.addListener(EventType.OrderDenied, ({ order, accountAddress }) => {
       console.info({ order, accountAddress })
       dispatch({ type: ActionTypes.RESET_EXCHANGE })
     })
-    openSeaPort.addListener(EventType.MatchOrders, ({ buy, sell, accountAddress }) => {
+    openSeaSDK.addListener(EventType.MatchOrders, ({ buy, sell, accountAddress }) => {
       console.info({ buy, sell, accountAddress })
       dispatch({ type: ActionTypes.FULFILL_ORDER })
     })
-    openSeaPort.addListener(EventType.CancelOrder, ({ order, accountAddress }) => {
+    openSeaSDK.addListener(EventType.CancelOrder, ({ order, accountAddress }) => {
       console.info({ order, accountAddress })
       dispatch({ type: ActionTypes.CANCEL_ORDER })
     })
@@ -666,7 +624,7 @@ handleSeaportEvents() {
 }
 ```
 
-To remove all listeners and start over, just call `seaport.removeAllListeners()`.
+To remove all listeners and start over, just call `openseaSDK.removeAllListeners()`.
 
 ## Learning More
 

package/lib/api.d.ts

@@ -1,4 +1,5 @@
 import "isomorphic-unfetch";
+import { OrderAPIOptions, OrdersQueryOptions, OrderV2, ProtocolData, QueryCursors } from "./orders/types";
 import { OpenSeaAPIConfig, OpenSeaAsset, OpenSeaAssetBundle, OpenSeaAssetBundleQuery, OpenSeaAssetQuery, OpenSeaFungibleToken, OpenSeaFungibleTokenQuery, Order, OrderJSON, OrderQuery } from "./types";
 export declare class OpenSeaAPI {
     /**
@@ -18,12 +19,31 @@ export declare class OpenSeaAPI {
      */
     logger: (arg: string) => void;
     private apiKey;
+    private networkName;
+    private retryDelay;
     /**
      * Create an instance of the OpenSea API
      * @param config OpenSeaAPIConfig for setting up the API, including an optional API key, network name, and base URL
      * @param logger Optional function for logging debug strings before and after requests are made
      */
     constructor(config: OpenSeaAPIConfig, logger?: (arg: string) => void);
+    /**
+     * Gets an order from API based on query options. Throws when no order is found.
+     */
+    getOrder({ protocol, side, orderDirection, orderBy, ...restOptions }: Omit<OrdersQueryOptions, "limit">): Promise<OrderV2>;
+    /**
+     * Gets a list of orders from API based on query options and returns orders
+     * with next and previous cursors.
+     */
+    getOrders({ protocol, side, orderDirection, orderBy, ...restOptions }: Omit<OrdersQueryOptions, "limit">): Promise<QueryCursors & {
+        orders: OrderV2[];
+    }>;
+    /**
+     * Send an order to be posted. Throws when the order is invalid.
+     */
+    postOrder(order: ProtocolData, apiOptions: OrderAPIOptions, { retries }?: {
+        retries?: number;
+    }): Promise<OrderV2>;
     /**
      * Send an order to the orderbook.
      * Throws when the order is invalid.
@@ -31,7 +51,7 @@ export declare class OpenSeaAPI {
      * @param order Order JSON to post to the orderbook
      * @param retries Number of times to retry if the service is unavailable for any reason
      */
-    postOrder(order: OrderJSON, retries?: number): Promise<Order>;
+    postOrderLegacyWyvern(order: OrderJSON, retries?: number): Promise<Order>;
     /**
      * Create a whitelist entry for an asset to prevent others from buying.
      * Buyers will have to have verified at least one of the emails
@@ -48,11 +68,11 @@ export declare class OpenSeaAPI {
      */
     getOrderCreateWyvernExchangeAddress(): Promise<string | null>;
     /**
-     * Get an order from the orderbook, throwing if none is found.
+     * Get an order from the orderbook using the legacy wyvern API, throwing if none is found.
      * @param query Query to use for getting orders. A subset of parameters
      *  on the `OrderJSON` type is supported
      */
-    getOrder(query: OrderQuery): Promise<Order>;
+    getOrderLegacyWyvern(query: OrderQuery): Promise<Order>;
     /**
      * Get a list of orders from the orderbook, returning the page of orders
      *  and the count of total orders found.
@@ -61,7 +81,7 @@ export declare class OpenSeaAPI {
      * @param page Page number, defaults to 1. Can be overridden by
      * `limit` and `offset` attributes from OrderQuery
      */
-    getOrders(query?: OrderQuery, page?: number): Promise<{
+    getOrdersLegacyWyvern(query?: OrderQuery, page?: number): Promise<{
         orders: Order[];
         count: number;
     }>;