Helpdesk
  • Overview
    • Welcome to Finery Markets
    • About Our Products
      • FM Liquidity Match
        • Master Account
        • Sub-Account
      • FM Pulse
      • White Label solution
  • Product Features
    • Onboarding
    • Risk Management
    • Trading
      • Aggregated Order Book
      • Firm Order Book
      • Pending Limit Orders (GTC)
      • RFQ
      • Toxic Flow Protection
      • Markups
      • Authorized trading
      • Non-Deliverable Trading
      • Voice Trading
      • Interdealer Trading
    • Position Management
    • Settlements
      • Automated Settlements
      • Addresses
    • Control Center
      • Multi-Roles
      • Notifications
      • Reporting
      • Bulk Edit
    • Referral program
  • API Reference
    • Quick Start with API
      • For Market Makers
      • For Takers
    • Data Types
    • REST API
      • Client management
        • getSubaccounts
      • RFQ
        • getSettings
        • getSettings (authorized)
        • getUserSettings (authorized)
        • setUserSettings (authorized)
        • getProviders
        • getSessions
      • Trading
        • add
        • add (authorized)
        • Pending limit orders
          • add (pending limit order)
          • add (pending limit order) (authorized)
          • del
          • del (authorized)
          • delAll
          • delAll (authorized)
          • orders
          • orders (authorized)
        • mod
        • del
        • delAll
        • book
        • voiceTrade
        • liquidationTrade
        • dealHistory
        • dealHistory (authorized)
        • instruments
        • positions
        • instrumentMarkups
        • addInstrumentMarkups
        • delInstrumentMarkups
      • Settlements
        • settlementRequests
        • settlementOrders
        • settlementTransactions
        • settlementHistory
        • settlementTransactionHistory
        • addIncomingSettlementRequest
        • delIncomingSettlementRequest
        • delIncomingSettlementCPRequest
        • addOutgoingSettlementTransaction
        • addIncomingSettlementTransaction
        • sendSettlementTransaction
        • commitIncomingSettlementTransaction
        • delSettlementTransaction
      • Risk Management
        • climits
        • setCLimit
        • delCLimit
        • subaccountsLimits
        • setSubaccountLimit
        • delSubaccountLimit
        • enableTrading
        • disableTrading
        • cAssetLimits
        • setCAssetLimit
        • delCAssetLimit
        • cShortSalesBan
        • setShortSalesBan
        • delShortSalesBan
        • enableInstrumentsWhitelist
        • setInstrumentsWhitelist
        • disableInstrumentsWhitelist
        • instrumentsWhitelist
      • Non-deliverable Trading
        • settings/getOvernightRates
        • settings/setOvernightRates
    • Websocket API
      • Feed 'A' - Assets
      • Feed 'P' - Positions
      • Feed 'L' - Counterparty limits
      • Feed 'B' - Global order books
      • Feed 'F' - Tradable order books
      • Feed 'R' - Settlement requests
      • Feed 'N' - Settlement transactions
      • Feed 'K' - Positions
      • Feed 'O' - Orders
      • Feed 'S' - Settlement orders
      • RFQ
    • FIX API
      • Admin messages
      • Market Data
      • Trade
        • Trading for Takers
        • Trading for LPs and Masters
    • Troubleshooting Errors
      • List of Error Codes
      • Error 3
      • Error 6
      • Error 7
      • Error 14
Powered by GitBook
On this page
  1. API Reference
  2. Websocket API

Feed 'B' - Global order books

Global book feed, returns only first 25 book levels

Requests

{"event": "bind", "feed": "B", "feedId": "BTC-EUR"}

Useinstrument name as "feedId" value to subscribe on instrument book

{"event": "unbind", "feed": "B", "feedId": "BTC-USD"}

Feed handling

bookLevel = [
  0: price (Efx::Price)
  1: size (Efx::Size)
]

bookUpdate = [
  0: action ('+', 'M', '-' or '~')
  1: price (Efx::Price)
  2: size (Efx::Size)
]

"+" action: book level added
"M" action: book level size modified
"-" action: book level removed
"~" action: top of book removed till specified price, 
            price and size of a new top level are returned 
            (both zeros if book side became empty)

If you receive the following update [~, 12300000000, 100000000], then you must delete levels from the existing order book starting from the top of the book and ending with the order at a price of 123 and size of 1. Therefore, price 123 and size 1 is the new top of the book.

If you receive the following update [~, 0, 0], the described side of the book is empty.

For detailed book description

// snapshot
['B', feed_id, 'S', [
  array of bid bookLevel,
  array of ask boolLevel
]]

// book levels modified
['B', feed_id, 'M', [
  array of bid bookUpdate,
  array of ask bookUpdate,
]]

// book levels added
['B', feed_id, 'M', [[['+', 300000000000, 10000000]], []]]

// book level size modified
['B', feed_id, 'M', [[['M', 300000000000, 10000000]], []]]

// book levels removed
['B', feed_id, 'M', [[['-', 300000000000, 10000000]], []]]

// till specified price, price and size of a new top level are returned
// (both zeros if book side became empty)
['B', feed_id, 'M', [[['~', 300000000000, 10000000]], []]]

// failed to subscribe
['B', feed_id, 'Z', 2]

// unsubscribed
['B', feed_id, 'U', 0]
applyToSnapshot(prevSnapshot, feed, action, data) {
    switch (feed) {
        case 'B': {
            switch (action) {
                case 'S' : {
                    return [[...data[0]], [...data[1]]]
                }
                case 'M' : {
                    data[0].forEach(item => {
                        var side = prevSnapshot[0]
                        switch (item[0]) {
                            case '+': {
                                var found = false
                                for (var i in side) {
                                    if (side[i][0] < item[1]) {
                                        side.splice(i, 0, [item[1], item[2]])
                                        found = true
                                        break
                                    }
                                }
                                if (!found) {
                                    side.push([item[1], item[2]])
                                }
                                break
                            }
                            case 'M': {
                                for (var i in side) {
                                    if (side[i][0] == item[1]) {
                                        side[i][1] = item[2]
                                        break
                                    }
                                }
                                break
                            }
                            case '-': {
                                for (var i in side) {
                                    if (side[i][0] == item[1]) {
                                        side.splice(i, 1)
                                        break
                                    }
                                }
                                break
                            }
                            case '~': {
                                if (item[1]) {
                                    for (var i in side) {
                                        if (side[i][0] == item[1]) {
                                            side[i][1] = item[2]
                                            if (i > 0) {
                                                side.splice(0, i)
                                            }
                                            break
                                        }
                                    }
                                } else {
                                    side.length = 0
                                }
                                break
                            }
                        }
                    })
                    data[1].forEach(item => {
                        var side = prevSnapshot[1]
                        switch (item[0]) {
                            case '+': {
                                var found = false
                                for (var i in side) {
                                    if (side[i][0] > item[1]) {
                                        side.splice(i, 0, [item[1], item[2]])
                                        found = true
                                        break
                                    }
                                }
                                if (!found) {
                                    side.push([item[1], item[2]])
                                }
                                break
                            }
                            case 'M': {
                                for (var i in side) {
                                    if (side[i][0] == item[1]) {
                                        side[i][1] = item[2]
                                        break
                                    }
                                }
                                break
                            }
                            case '-': {
                                for (var i in side) {
                                    if (side[i][0] == item[1]) {
                                        side.splice(i, 1)
                                        break
                                    }
                                }
                                break
                            }
                            case '~': {
                                if (item[1]) {
                                    for (var i in side) {
                                        if (side[i][0] == item[1]) {
                                            side[i][1] = item[2]
                                            if (i > 0) {
                                                side.splice(0, i)
                                            }
                                            break
                                        }
                                    }
                                } else {
                                    side.length = 0
                                }
                                break
                            }
                        }
                    })
                    break
                }
            }
            break
        }
    }
    return prevSnapshot
}
PreviousFeed 'L' - Counterparty limitsNextFeed 'F' - Tradable order books

Last updated 3 months ago

book