btc-api-node 1.12.7

package/test/lib/transports/rest-1-integration.js

@@ -0,0 +1,131 @@
+/* eslint-env mocha */
+'use strict'
+
+const PORT = 1337
+
+const assert = require('assert')
+const http = require('http')
+
+const RESTv1 = require('../../../lib/transports/rest')
+
+describe('rest integration test', () => {
+  it('should get the fundingbook asks, zero bids, 100 asks', (done) => {
+    const opts = { limit_bids: 0, limit_asks: 10 }
+    const bhttp = new RESTv1({ url: `http://localhost:${PORT}` })
+
+    const testResBody = `
+{"bids":[],"asks":[
+{"rate":"72.25","amount":"67.5","period":30,"timestamp":"1495565109.0","frr":"No"},
+{"rate":"72.2501","amount":"297.58737203","period":2,"timestamp":"1495565054.0","frr":"No"},
+{"rate":"72.2601","amount":"200.0","period":2,"timestamp":"1495565002.0","frr":"No"},
+{"rate":"72.9535","amount":"211.8299","period":2,"timestamp":"1495565037.0","frr":"No"},
+{"rate":"73.0","amount":"1319.59397488","period":30,"timestamp":"1495564972.0","frr":"No"},
+{"rate":"76.0827","amount":"1511.9115692","period":30,"timestamp":"1495564965.0","frr":"Yes"},
+{"rate":"76.0827","amount":"19849.81630455","period":30,"timestamp":"1495564972.0","frr":"Yes"},
+{"rate":"76.0827","amount":"1052.68464219","period":30,"timestamp":"1495564972.0","frr":"Yes"},
+{"rate":"109.5","amount":"55.33131648","period":3,"timestamp":"1495565103.0","frr":"No"},
+{"rate":"153.1999","amount":"134.86","period":2,"timestamp":"1495565106.0","frr":"No"}]}
+`
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'application/json'
+      })
+      res.end(testResBody)
+    }).listen(PORT, () => {
+      bhttp.fundingbook('USD', opts, (err, data) => {
+        if (err) throw err
+        assert.ok(data)
+        assert.equal(data.bids.length, 0)
+        assert.equal(data.asks.length, 10)
+        server.close()
+        done()
+      })
+    })
+  })
+
+  it('new_order -- post_only: postonly used and true', (done) => {
+    const bhttp = new RESTv1({
+      apiKey: 'dummykey',
+      apiSecret: 'dummysecret',
+      url: `http://localhost:${PORT}`
+    })
+
+    const testResBody = '{}'
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'application/json'
+      })
+      const payload = JSON.parse(
+        Buffer.from(req.headers['x-bfx-payload'], 'base64').toString('ascii')
+      )
+
+      assert.equal(payload['post_only'], true)
+
+      res.end(testResBody)
+    }).listen(PORT, () => {
+      bhttp.new_order('btcusd', '0.1', '0.1', 'bitfinex', 'buy', 'exchange limit', false, true, (err, data) => {
+        if (err) throw err
+        server.close()
+        done()
+      })
+    })
+  })
+
+  it('new_order -- post_only: postonly not used and hidden true', (done) => {
+    const bhttp = new RESTv1({
+      apiKey: 'dummykey',
+      apiSecret: 'dummysecret',
+      url: `http://localhost:${PORT}`
+    })
+
+    const testResBody = '{}'
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'application/json'
+      })
+      const payload = JSON.parse(
+        Buffer.from(req.headers['x-bfx-payload'], 'base64').toString('ascii')
+      )
+
+      assert.equal(payload['is_hidden'], true)
+      assert.equal(payload['post_only'], undefined)
+
+      res.end(testResBody)
+    }).listen(PORT, () => {
+      bhttp.new_order('btcusd', '0.1', '0.1', 'bitfinex', 'buy', 'exchange limit', true, (err, data) => {
+        if (err) throw err
+        server.close()
+        done()
+      })
+    })
+  })
+
+  it('new_order -- post_only: postonly not used and hidden not used', (done) => {
+    const bhttp = new RESTv1({
+      apiKey: 'dummykey',
+      apiSecret: 'dummysecret',
+      url: `http://localhost:${PORT}`
+    })
+
+    const testResBody = '{}'
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'application/json'
+      })
+      const payload = JSON.parse(
+        Buffer.from(req.headers['x-bfx-payload'], 'base64').toString('ascii')
+      )
+
+      assert.equal(payload['is_hidden'], undefined)
+      assert.equal(payload['post_only'], undefined)
+
+      res.end(testResBody)
+    }).listen(PORT, () => {
+      bhttp.new_order('btcusd', '0.1', '0.1', 'bitfinex', 'buy', 'exchange limit', (err, data) => {
+        if (err) throw err
+        server.close()
+        done()
+      })
+    })
+  })
+})

package/test/lib/transports/rest-2-integration.js

@@ -0,0 +1,80 @@
+/* eslint-env mocha */
+'use strict'
+
+const assert = require('assert')
+const RESTv2 = require('../../../lib/transports/rest2')
+const { MockRESTv2Server } = require('bfx-api-mock-srv')
+
+const getTestREST2 = () => {
+  return new RESTv2({
+    apiKey: 'dummy',
+    apiSecret: 'dummy',
+    url: 'http://localhost:9999'
+  })
+}
+
+it('trades: fetches expected data', (done) => {
+  const srv = new MockRESTv2Server({ listen: true })
+  const r = getTestREST2()
+  srv.setResponse('trades.BTCUSD.0.10.50', [42])
+
+  r.trades('BTCUSD', 0, 10, 50, (err, res) => {
+    if (err) return done(err)
+
+    assert.deepEqual(res, [42])
+    srv.close().then(done).catch(done)
+  })
+})
+
+describe('RESTv2 integration (mock server) tests', () => {
+  // [rest2MethodName, finalMockResponseKey, rest2MethodArgs]
+  const methods = [
+    // public
+    ['ticker', 'ticker.BTCUSD', ['BTCUSD']],
+    ['tickers', 'tickers', [['tBTCUSD', 'tETHUSD']]],
+    ['stats', 'stats.key.context', ['key', 'context']],
+    ['candles', 'candles.trade:30m:tBTCUSD.hist', [{ timeframe: '30m', symbol: 'tBTCUSD', section: 'hist' }]],
+
+    // private
+    ['alertList', 'alerts.price', ['price']],
+    ['alertSet', 'alert_set.type.symbol.price', ['type', 'symbol', 'price']],
+    ['alertDelete', 'alert_del.symbol.price', ['symbol', 'price']],
+    ['trades', 'trades.BTCUSD.0.10.50', ['BTCUSD', 0, 10, 50]],
+    ['wallets', 'wallets'],
+    ['activeOrders', 'active_orders'],
+    ['orderHistory', 'orders.sym.start.end.limit', ['sym', 'start', 'end', 'limit']],
+    ['positions'],
+    ['fundingOffers', 'f_offers.sym', ['sym']],
+    ['fundingOfferHistory', 'f_offer_hist.sym.start.end.limit', ['sym', 'start', 'end', 'limit']],
+    ['fundingLoans', 'f_loans.sym', ['sym']],
+    ['fundingLoanHistory', 'f_loan_hist.sym.start.end.limit', ['sym', 'start', 'end', 'limit']],
+    ['fundingCredits', 'f_credits.sym', ['sym']],
+    ['fundingCreditHistory', 'f_credit_hist.sym.start.end.limit', ['sym', 'start', 'end', 'limit']],
+    ['fundingTrades', 'f_trade_hist.sym.start.end.limit', ['sym', 'start', 'end', 'limit']],
+    ['marginInfo', 'margin_info.k', ['k']],
+    ['fundingInfo', 'f_info.k', ['k']],
+    ['performance'],
+    ['calcAvailableBalance', 'calc.sym.dir.rate.type', ['sym', 'dir', 'rate', 'type']]
+  ]
+
+  methods.forEach((m) => {
+    const name = m[0]
+    const dataKey = m[1] || m[0]
+    const args = m[2] || []
+
+    it(`${name}: fetches expected data`, (done) => {
+      const srv = new MockRESTv2Server({ listen: true })
+      const r = getTestREST2()
+      srv.setResponse(dataKey, [42])
+
+      args.push((err, res) => {
+        if (err) return done(err)
+
+        assert.deepEqual(res, [42])
+        srv.close().then(done).catch(done)
+      })
+
+      r[name].apply(r, args)
+    })
+  })
+})

package/test/lib/transports/rest-2-issue-80-argument-length.js

@@ -0,0 +1,61 @@
+/* eslint-env mocha */
+'use strict'
+
+const PORT = 1337
+
+const assert = require('assert')
+const http = require('http')
+
+const REST2 = require('../../../lib/transports/rest2')
+
+const bhttp = new REST2({
+  apiKey: 'dummy',
+  apiSecret: 'dummy',
+  url: `http://localhost:${PORT}`
+})
+
+const testResBody = `["ente", "gans", "scholle"]`
+
+describe('rest2 api client: issue 80 - argumment length auth request', () => {
+  it('errors if no payload defined', (done) => {
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'text/plain'
+      })
+      res.end(testResBody)
+    })
+
+    server.listen(PORT, () => {
+      bhttp.genericCallback = (err) => {
+        assert.ok(err)
+
+        server.close()
+        done()
+      }
+
+      bhttp._makeAuthRequest('/auth/r/orders', () => {})
+    })
+  })
+
+  it('succeeds with the right argument length', (done) => {
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'text/plain'
+      })
+      res.end(testResBody)
+    })
+
+    server.listen(PORT, () => {
+      bhttp._makeAuthRequest('/auth/r/orders', {}, (err, res) => {
+        assert.equal(err, null)
+        assert.deepEqual(
+          res,
+          [ 'ente', 'gans', 'scholle' ]
+        )
+
+        server.close()
+        done()
+      })
+    })
+  })
+})

package/test/lib/transports/rest-2-smoke-test.js

@@ -0,0 +1,49 @@
+/* eslint-env mocha */
+'use strict'
+
+const PORT = 1337
+
+const assert = require('assert')
+const http = require('http')
+const REST2 = require('../../../lib/transports/rest2')
+
+const bhttp = new REST2({
+  apiKey: 'dummy',
+  apiSecret: 'dummy',
+  url: `http://localhost:${PORT}`
+})
+
+const testResBody = `[1765.3,
+  0.56800816,
+  1767.6,
+  1.3874,
+  -62.2,
+  -0.034,
+  1765.3,
+  14063.54589155,
+  1834.2,
+  1726.3 ]`
+
+describe('rest2 api client', () => {
+  it('gets a response as JSON', (done) => {
+    const server = http.createServer((req, res) => {
+      res.writeHead(200, {
+        'Content-Type': 'text/plain'
+      })
+      res.end(testResBody)
+    })
+
+    server.listen(PORT, () => {
+      bhttp.ticker('tBTCUSD', (err, res) => {
+        assert.equal(err, null)
+        assert.deepEqual(
+          res,
+          JSON.parse(testResBody)
+        )
+
+        server.close()
+        done()
+      })
+    })
+  })
+})

package/test/lib/transports/rest-2-unit.js

@@ -0,0 +1,26 @@
+/* eslint-env mocha */
+'use strict'
+
+// const assert = require('assert')
+// const RESTv2 = require('../../../lib/transports/rest2')
+
+describe.skip('RESTv2 unit tests', () => {
+  it('constructor: applies options')
+  it('constructor: provides defaults')
+  it('_generateNonce: increments internal nonce')
+
+  it('_makeAuthRequest: calls cb w/ error on missing arguments')
+  it('_makeAuthRequest: POSTs to the specified path')
+  it('_makeAuthRequest: includes necessary headers')
+  it('_makeAuthRequest: calls cb with an error, or response')
+  it('_makeAuthRequest: transforms data if needed')
+
+  it('_makePublicRequest: GETs the specified path')
+  it('_makePublicRequest: calls cb with an error, or response')
+  it('_makePublicRequest: transforms data if needed')
+
+  it('_doTransform: returns empty array for no data')
+  it('_doTransform: returns data if unable to transform')
+  it('_doTransform: returns array of models for snapshots')
+  it('_doTransform: returns single model')
+})

package/test/lib/transports/rest1.js

@@ -0,0 +1,152 @@
+'use strict'
+/* eslint-env mocha */
+/* eslint camelcase: "off" */
+/* eslint-disable no-unused-expressions */
+
+const assert = require('assert')
+const { expect } = require('chai')
+const DNS = require('dns')
+const RESTv1 = require('../../../lib/transports/rest')
+const _ = require('lodash')
+
+describe('REST v1', () => {
+  let skipPublic = process.env.SKIP_PUBLIC_REST
+
+  if (!skipPublic) {
+    before((done) => {
+      DNS.resolve('api.bitfinex.com', (err) => {
+        if (err) skipPublic = true
+        done()
+      })
+    })
+  }
+
+  describe('errors', function () {
+    const bfx_rest = new RESTv1()
+    this.timeout(5000)
+    it('should error out if a bad endpoint is given', () => {
+      expect(bfx_rest.make_public_request).to.throw(Error)
+    })
+    it('should fail on authenticated requests if no api_key and api_secret', () => {
+      expect(bfx_rest.account_infos).to.throw(Error)
+    })
+  })
+
+  describe('public endpoints', function () {
+    const bfx_rest = new RESTv1()
+    this.timeout(10000) // bumped from 5k for moments of platform lag
+    it('should get a ticker', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.ticker('BTCUSD', (error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        expect(_.has(data, ['mid',
+          'bid',
+          'ask',
+          'last_price',
+          'low',
+          'high',
+          'volume',
+          'timestamp']))
+        done()
+      })
+    })
+    it('should get the today endpoint', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.today('BTCUSD', (error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        done()
+      })
+    })
+    it('should get the stats', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.stats('BTCUSD', (error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        expect(_.has(data[0], ['period', 'volume']))
+        expect(_.has(data[1], ['period', 'volume']))
+        expect(_.has(data[2], ['period', 'volume']))
+        done()
+      })
+    })
+    it('should get the fundingbook', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.fundingbook('USD', (error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        expect(_.has(data, ['bids', 'asks']))
+        expect(_.keys(data.bids[0])).is.eql(['rate', 'amount', 'period', 'timestamp', 'frr'])
+        expect(_.keys(data.asks[0])).is.eql(['rate', 'amount', 'period', 'timestamp', 'frr'])
+        expect(_.every([data.asks[0] + data.bids[0]]), !NaN).ok
+        done()
+      })
+    })
+
+    it('should get the orderbook', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.orderbook('BTCUSD', (error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        expect(_.keys(data)).is.eql(['bids', 'asks'])
+        expect(_.keys(data.bids[0])).is.eql(['price', 'amount', 'timestamp'])
+        expect(_.keys(data.asks[0])).is.eql(['price', 'amount', 'timestamp'])
+        expect(_.every([data.asks[0] + data.bids[0]]), !NaN).ok
+        done()
+      })
+    })
+    it('should get recent trades', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.trades('BTCUSD', (error, data) => {
+        assert(!error)
+        expect(data).is.an.array
+        expect(data.length).to.eql(100)
+        expect(_.keys(data[0])).to.eql(['timestamp', 'tid', 'price', 'amount', 'exchange', 'type'])
+        expect(
+          _.map(_.values(data[0]), (v) => typeof (v))
+        ).is.eql(['number', 'number', 'string', 'string', 'string', 'string'])
+        done()
+      })
+    })
+    it('should get recent lends', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.lends('USD', (error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        expect(data).is.an.array
+        expect(data.length).to.eql(50)
+        expect(_.keys(data[0])).to.eql(['rate', 'amount_lent', 'amount_used', 'timestamp'])
+        expect(
+          _.map(_.values(data[0]), (v) => typeof (v))
+        ).is.eql(['string', 'string', 'string', 'number'])
+        done()
+      })
+    })
+    it('should get symbols', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.get_symbols((error, data) => {
+        assert(!error)
+        expect(data[0]).to.eql('btcusd')
+        done()
+      })
+    })
+    it('should get symbol details', (done) => {
+      if (skipPublic) return done()
+
+      bfx_rest.symbols_details((error, data) => {
+        assert(!error)
+        expect(data).to.exist
+        expect(data[0].pair).to.eql('btcusd')
+        done()
+      })
+    })
+  })
+})

package/test/lib/transports/ws-1-handle-channel.js

@@ -0,0 +1,83 @@
+/* eslint-env mocha */
+'use strict'
+
+const assert = require('assert')
+const BfxWs = require('../../../lib/transports/ws.js')
+
+const bfxWs = new BfxWs({
+  apiKey: 'dummy',
+  apiSecret: 'dummy'
+})
+
+describe('ws1 channel msg handling', () => {
+  it('ws1 transforms & normalizes well - R0 update', (done) => {
+    bfxWs._channelMap = {
+      32755: { channel: 'book', prec: 'R0', symbol: 'tBTCUSD' }
+    }
+
+    bfxWs.once('orderbook', (symbol, data) => {
+      assert.deepEqual(data, { price: 2477.1, orderId: 2919111002, amount: 0.0125 })
+      done()
+    })
+
+    bfxWs._handleChannel([ 32755, 2919111002, 2477.1, 0.0125 ])
+  })
+
+  it('ws1 transforms & normalizes well - P1 update', (done) => {
+    bfxWs._channelMap = {
+      182: { channel: 'book', prec: 'P1', symbol: 'tBTCUSD' }
+    }
+
+    bfxWs.once('orderbook', (symbol, data) => {
+      assert.deepEqual(data, { price: 2494, count: 2, amount: 5.9895 })
+      done()
+    })
+
+    bfxWs._handleChannel([ 182, 2494, 2, 5.9895 ])
+  })
+
+  it('ws1 transforms & normalizes well - P1 snap', (done) => {
+    bfxWs._channelMap = {
+      39: { channel: 'book', prec: 'P1', symbol: 'tBTCUSD' }
+    }
+
+    bfxWs.once('orderbook', (symbol, data) => {
+      assert.deepEqual(data[1], { price: 2494, count: 3, amount: 0.14606853 })
+      done()
+    })
+
+    const snap = [ 39, [
+      [ 2495, 2, 0.8744 ],
+      [ 2494, 3, 0.14606853 ],
+      [ 2492, 1, 0.4 ]
+    ]]
+
+    bfxWs._handleChannel(snap)
+  })
+
+  it('ws1 transforms & normalizes well - R0 snap', (done) => {
+    bfxWs._channelMap = {
+      34513: { channel: 'book', prec: 'R0', symbol: 'tBTCUSD' }
+    }
+
+    bfxWs.once('orderbook', (symbol, data) => {
+      assert.deepEqual(
+        data[1],
+        { price: 2494.5, orderId: 2919279471, amount: 0.07288 }
+      )
+      done()
+    })
+
+    const snap = [ 34513, [
+      [ 2919278474, 2494.5, 0.07901704 ],
+      [ 2919279471, 2494.5, 0.07288 ],
+      [ 2919280093, 2494.5, 0.03644 ]
+    ]]
+
+    bfxWs._handleChannel(snap)
+  })
+
+  it('ws1 _handleChannel ignores heartbeats')
+  it('ws1 _processUserEvent emits data, breaks up snapshots')
+  it('ws1 _processTradeEvent emits a single trade for te & tu messages')
+})

package/test/lib/transports/ws-1-parsing.js

@@ -0,0 +1,40 @@
+/* eslint-env mocha */
+'use strict'
+
+const PORT = 1337
+
+const assert = require('assert')
+const WebSocket = require('ws')
+const WSv1 = require('../../../lib/transports/ws')
+
+describe('websocket1 parsing non json', () => {
+  it('should not crash the client', (done) => {
+    const bws = new WSv1({
+      apiKey: 'dummy',
+      apiSecret: 'dummy',
+      url: `ws://localhost:${PORT}`
+    })
+
+    bws.open()
+
+    const wss = new WebSocket.Server({
+      perMessageDeflate: false,
+      port: PORT
+    })
+
+    wss.on('connection', function connection (ws) {
+      ws.on('message', function incoming (msg) {
+        msg = JSON.parse(msg)
+        assert.equal(msg.len, '25')
+        wss.close()
+        done()
+      })
+
+      ws.send("HTTP Code 408 - I'm a Tea Pot")
+    })
+
+    bws.on('open', () => {
+      bws.subscribeOrderBook('BTCUSD', 'R0')
+    })
+  })
+})