Feed 'F' - Firm Market Data

Returns Tradable Order book or may return incremental updates of both Tradable Market Data or View-Only Market Data. Returns only the first 25 levels of the book

Requests

For takers:

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

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

For masters, the clientId parameter is used to subscribe on behalf of a sub-taker:

{"event": "bind", "feed": "F", "feedId": {"instrument": "BTC-EUR", "clientId": 5}}

Use instrument and clientId as "feedId" value to subscribe on client's instrument book

Feed handling

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

Feed 'F' provides incremental updates

For a detailed book description

book

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

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

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

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

// book levels removed
['F', 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)
['F', feed_id, 'M', [[['~', 300000000000, 10000000]], []]]

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

// unsubscribed
['F', feed_id, 'U', 0]

applyToSnapshot(prevSnapshot, feed, action, data) {
    switch (feed) {
        case 'F': {
            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 'B' - Global order book NextFeed 'MD' - View-only Firm Market data

Last updated 3 months ago

applyToSnapshot(prevSnapshot, feed, action, data) {
    switch (feed) {
        case 'F': {
            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
}