OrderBookApi

npm install @cowprotocol/sdk-order-book
# or
pnpm add @cowprotocol/sdk-order-book
# or
yarn add @cowprotocol/sdk-order-book

new OrderBookApi(context?: PartialApiContext)

import { OrderBookApi, SupportedChainId } from '@cowprotocol/sdk-order-book'

const orderBookApi = new OrderBookApi({
  chainId: SupportedChainId.MAINNET,
  env: 'prod',
})

async getQuote(
  requestBody: OrderQuoteRequest,
  contextOverride?: PartialApiContext
): Promise<OrderQuoteResponse>

const quoteRequest = {
  sellToken: '0xA0b86a33E6417b528874E10EB3a95beb4F25A0E3', // GNO
  buyToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
  from: '0x123...',
  receiver: '0x123...',
  sellAmountBeforeFee: '1000000000000000000', // 1 GNO
  kind: 'sell',
}

const { quote } = await orderBookApi.getQuote(quoteRequest)
console.log('Quote:', quote)

async sendOrder(
  requestBody: OrderCreation,
  contextOverride?: PartialApiContext
): Promise<string>

import { OrderSigningUtils } from '@cowprotocol/sdk-order-signing'

// After getting a quote and signing it
const signingResult = await OrderSigningUtils.signOrder(
  quote,
  chainId,
  signer
)

const orderId = await orderBookApi.sendOrder({
  ...quote,
  ...signingResult,
})

console.log('Order submitted:', orderId)

async getOrder(
  orderUid: string,
  contextOverride?: PartialApiContext
): Promise<EnrichedOrder>

const order = await orderBookApi.getOrder(
  '0xd64389693b6cf89ad6c140a113b10df08073e5ef...'
)

console.log('Order status:', order.status)
console.log('Sell amount:', order.sellAmount)

async getOrders(
  request: GetOrdersRequest,
  contextOverride?: PartialApiContext
): Promise<Array<EnrichedOrder>>

const orders = await orderBookApi.getOrders({
  owner: '0x123...',
  limit: 10,
  offset: 0,
})

console.log(`Found ${orders.length} orders`)
orders.forEach(order => {
  console.log(`Order ${order.uid}: ${order.status}`)
})

async getOrderMultiEnv(
  orderUid: string,
  contextOverride?: PartialApiContext
): Promise<EnrichedOrder>

// Will check prod first, then staging
const order = await orderBookApi.getOrderMultiEnv(
  '0xd64389693b6cf89ad6c140a113b10df08073e5ef...'
)

async sendSignedOrderCancellations(
  requestBody: OrderCancellations,
  contextOverride?: PartialApiContext
): Promise<void>

import { OrderSigningUtils } from '@cowprotocol/sdk-order-signing'

const orderUids = ['0xd64389...', '0xa12345...']

const cancellationSigning = await OrderSigningUtils.signOrderCancellations(
  orderUids,
  chainId,
  signer
)

await orderBookApi.sendSignedOrderCancellations({
  ...cancellationSigning,
  orderUids,
})

console.log('Orders cancelled')

async getTrades(
  request: GetTradesRequest,
  contextOverride?: PartialApiContext
): Promise<Array<Trade>>

// Get all trades for an owner
const trades = await orderBookApi.getTrades({
  owner: '0x123...',
  limit: 20,
})

// Get trades for a specific order
const orderTrades = await orderBookApi.getTrades({
  orderUid: '0xd64389...',
})

console.log(`Found ${trades.length} trades`)

async getTxOrders(
  txHash: string,
  contextOverride?: PartialApiContext
): Promise<Array<EnrichedOrder>>

const orders = await orderBookApi.getTxOrders(
  '0xabc123...'
)

console.log(`Transaction included ${orders.length} orders`)

async getNativePrice(
  tokenAddress: string,
  contextOverride?: PartialApiContext
): Promise<NativePriceResponse>

const price = await orderBookApi.getNativePrice(
  '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48' // USDC
)

console.log('Native price:', price)

async getTotalSurplus(
  address: string,
  contextOverride?: PartialApiContext
): Promise<TotalSurplus>

const surplus = await orderBookApi.getTotalSurplus('0x123...')
console.log('Total surplus:', surplus)

async getAppData(
  appDataHash: string,
  contextOverride?: PartialApiContext
): Promise<AppDataObject>

const appData = await orderBookApi.getAppData(
  '0x0000000000000000000000000000000000000000000000000000000000000000'
)

console.log('App data:', appData)

async uploadAppData(
  appDataHash: string,
  fullAppData: string,
  contextOverride?: PartialApiContext
): Promise<AppDataObject>

const fullAppData = JSON.stringify({
  version: '1.0.0',
  appCode: 'My App',
  metadata: {},
})

const result = await orderBookApi.uploadAppData(
  appDataHash,
  fullAppData
)

async getSolverCompetition(
  auctionIdOrTxHash: number | string,
  contextOverride?: PartialApiContext
): Promise<SolverCompetitionResponse>

// By auction ID
const competition = await orderBookApi.getSolverCompetition(12345)

// By transaction hash
const competition2 = await orderBookApi.getSolverCompetition('0xabc...')

async getOrderCompetitionStatus(
  orderUid: string,
  contextOverride?: PartialApiContext
): Promise<CompetitionOrderStatus>

async getVersion(
  contextOverride?: PartialApiContext
): Promise<string>

getOrderLink(
  orderUid: string,
  contextOverride?: PartialApiContext
): string

const url = orderBookApi.getOrderLink('0xd64389...')
console.log('Order URL:', url)

const orderBookApi = new OrderBookApi({
  chainId: SupportedChainId.MAINNET,
  apiKey: 'your-partner-api-key',
  env: 'prod',
})

import { RateLimiterOpts } from 'limiter'

const limiterOpts: RateLimiterOpts = {
  tokensPerInterval: 5,
  interval: 'second',
}

const orderBookApi = new OrderBookApi({
  chainId: SupportedChainId.MAINNET,
  limiterOpts,
})

import { BackoffOptions } from 'exponential-backoff'

const backoffOpts: BackoffOptions = {
  numOfAttempts: 5,
  maxDelay: Infinity,
  jitter: 'none',
}

const orderBookApi = new OrderBookApi({
  chainId: SupportedChainId.MAINNET,
  backoffOpts,
})

const orderBookApi = new OrderBookApi({
  chainId: SupportedChainId.MAINNET,
  baseUrls: {
    [SupportedChainId.MAINNET]: 'https://your-custom-endpoint.com',
  },
})

import { OrderBookApiError } from '@cowprotocol/sdk-order-book'

try {
  const order = await orderBookApi.getOrder(orderUid)
} catch (error) {
  if (error instanceof OrderBookApiError) {
    console.error('API error:', error.response.status, error.message)
  } else {
    console.error('Unexpected error:', error)
  }
}