波纹交换 websocket 等效于波纹数据 apiv2

Question

我正在尝试以涟漪的形式进行交流，我发现 this data API 及其工作。但出于某些原因，我想使用波纹 websocket 工具。此数据 API 是否有任何等效的 websocket？

Answer 1

如果您在套接字中使用“tx_history”命令，我认为有等价但很抱歉告诉您json结果不等于您的特定数据结果。

ajax 正在播放波纹数据 apiv2。在波纹中查看结果 json 格式化程序以进行交换：

  } else if (resp.rows.length) {
    resp.rows[0] = {
      base_currency: resp.rows[0].base_currency,
      base_issuer: resp.rows[0].base_issuer,
      base_amount: resp.rows[0].base_amount,
      counter_amount: resp.rows[0].counter_amount,
      counter_currency: resp.rows[0].counter_currency,
      counter_issuer: resp.rows[0].counter_issuer,
      rate: resp.rows[0].rate,
      executed_time: resp.rows[0].executed_time,
      ledger_index: resp.rows[0].ledger_index,
      buyer: resp.rows[0].buyer,
      seller: resp.rows[0].seller,
      taker: resp.rows[0].taker,
      provider: resp.rows[0].provider,
      autobridged_currency: resp.rows[0].autobridged_currency,
      autobridged_issuer: resp.rows[0].autobridged_issuer,
      offer_sequence: resp.rows[0].offer_sequence,
      tx_type: resp.rows[0].tx_type,
      tx_index: resp.rows[0].tx_index,
      node_index: resp.rows[0].node_index,
      tx_hash: resp.rows[0].tx_hash
    };
  }

  res.csv(resp.rows, filename);
} else {
  res.json({
    result: 'success',
    count: resp.rows.length,
    marker: resp.marker,
    exchanges: resp.rows
  });
}   }

只能通过get url访问：

路由：'/v2/exchanges/{:base}/{:counter}'

在 server.js 中绑定：

app.get('/v2/exchanges/:base/:counter', routes.getExchanges);

最后提示这是他们使用 hbase 进行的数据库查询：

HbaseClient.getExchanges = 函数（选项，回调）{
var base = options.base.currency + '|' + (options.base.issuer || ''); var counter = options.counter.currency + '|' + (options.counter.issuer ||'');变量表； var keyBase; 变量开始行； var endRow;

var 降序；

变量列；

if (counter.toLowerCase() > base.toLowerCase()) { keyBase = 基础 + '|' + 计数器；

} 其他 { keyBase = 计数器 + '|' +基地; options.invert = true; }

如果 (!options.interval) { 表 = '交易所'; 降序=选项。降序？真假; options.unreduced = true;

//only need certain columns
if (options.reduce) {
  columns = [
    'd:base_amount',
    'd:counter_amount',
    'd:rate',
    'f:executed_time',
    'f:buyer',
    'f:seller',
    'f:taker'
  ];
}

} else if (exchangeIntervals.indexOf(options.interval) !== -1) { keyBase = options.interval + '|' + 密钥库； 降序=选项。降序？真假; 表 = 'agg_exchanges';

} 其他 { callback('无效间隔：' + options.interval); 返回; }

startRow = keyBase + '|' + options.start.hbaseFormatStartRow();
endRow = keyBase + '|' + options.end.hbaseFormatStopRow();

如果（options.autobridged）{ options.filterstring = "DependentColumnFilter('f', 'autobridged_currency')"; 如果（列）{ columns.push('f:autobridged_currency'); } }

this.getScanWithMarker(this, { 表：表， 开始行：开始行， 停止行：结束行， 标记：options.marker， 限制：options.limit， 下降：下降， 列：列， filterString: options.filterstring }, function (err, resp) {

if (!resp) {
  resp = {rows: []};
}

if (!resp.rows) {
  resp.rows = [];
}

if (options.reduce && options.unreduced) {
  if (descending) {
    resp.rows.reverse();
  }

  resp.reduced = reduce(resp.rows);
} else if (table === 'exchanges') {
  resp.rows = formatExchanges(resp.rows);
} else {
  resp.rows = formatAggregates(resp.rows);
}

callback(err, resp);   });

/** * 格式交换 */

函数格式交换（行）{ rows.forEach（函数（行）{ var key = row.rowkey.split('|');

  delete row.base_issuer;
  delete row.base_currency;
  delete row.counter_issuer;
  delete row.counter_currency;

  row.base_amount    = parseFloat(row.base_amount);
  row.counter_amount = parseFloat(row.counter_amount);
  row.rate           = parseFloat(row.rate);
  row.offer_sequence = Number(row.offer_sequence || 0);
  row.ledger_index   = Number(row.ledger_index);
  row.tx_index       = Number(key[6]);
  row.node_index     = Number(key[7]);
  row.time           = utils.unformatTime(key[4]).unix();
});

if (options.invert) {
  rows = invertPair(rows);
}

return rows;   }

/** * 格式聚合 */

函数格式聚合（行）{ rows.forEach（函数（行）{ var key = row.rowkey.split('|'); row.base_volume = parseFloat(row.base_volume), row.counter_volume = parseFloat(row.counter_volume), row.buy_volume = parseFloat(row.buy_volume), row.count = Number(row.count); row.open = parseFloat(row.open); row.high = parseFloat(row.high); row.low = parseFloat(row.low); row.close = parseFloat(row.close); row.vwap = parseFloat(row.vwap); row.close_time = Number(row.close_time); row.open_time = Number(row.open_time); });

if (options.invert) {
  rows = invertPair(rows);
}

return rows;   }

/** * 如果基础/计数器键被反转，我们需要交换 * 结果中的一些值 */

函数反转对（行）{ 变量交换； 变量 i;

if (options.unreduced) {

  for (i=0; i<rows.length; i++) {
    rows[i].rate = 1/rows[i].rate;

    //swap base and counter vol
    swap = rows[i].base_amount;
    rows[i].base_amount    = rows[i].counter_amount;
    rows[i].counter_amount = swap;

    //swap buyer and seller
    swap = rows[i].buyer;
    rows[i].buyer  = rows[i].seller;
    rows[i].seller = swap;
  }

} else {

  for (i=0; i<rows.length; i++) {

    //swap base and counter vol
    swap = rows[i].base_volume;
    rows[i].base_volume    = rows[i].counter_volume;
    rows[i].counter_volume = swap;

    //swap high and low
    swap = 1/rows[i].high;
    rows[i].high = 1/rows[i].low;
    rows[i].low  = swap;

    //invert open, close, vwap
    rows[i].open  = 1/rows[i].open;
    rows[i].close = 1/rows[i].close;
    rows[i].vwap  = 1/rows[i].vwap;

    //invert buy_volume
    rows[i].buy_volume /= rows[i].vwap;
  }
}

return rows;   }

/** * 减少 * 减少所有行 */

函数减少（行）{

var buyVolume = 0;
var reduced = {
  open: 0,
  high: 0,
  low: Infinity,
  close: 0,
  base_volume: 0,
  counter_volume: 0,
  buy_volume: 0,
  count: 0,
  open_time: 0,
  close_time: 0
};

rows = formatExchanges(rows);

// filter out small XRP amounts

rows = rows.filter(function(row) { 如果（options.base.currency === 'XRP' && row.base_amount

if (rows.length) {
  reduced.open_time  = moment.unix(rows[0].time).utc().format();
  reduced.close_time = moment.unix(rows[rows.length-1].time).utc().format();

  reduced.open  = rows[0].rate;
  reduced.close = rows[rows.length -1].rate;
  reduced.count = rows.length;

} else {
  reduced.low = 0;
  return reduced;
}

rows.forEach(function(row) {
  reduced.base_volume    += row.base_amount;
  reduced.counter_volume += row.counter_amount;

  if (row.rate < reduced.low)  reduced.low  = row.rate;
  if (row.rate > reduced.high) reduced.high = row.rate;

  if (row.buyer === row.taker) {
    reduced.buy_volume += row.base_amount;
  }
});


reduced.vwap = reduced.counter_volume / reduced.base_volume;
return reduced;   } };

Answer 2

也许您应该制作一个自定义 websocket，让您的 RPC 调用升级到 1.1 http 协议 (ws)。

在nodejs 你可以简单地

// for http
var http = require('http');

// for websocket
var ws = require("nodejs-websocket")

var options = {
  host: 'URL-RPC-HERE',
  port: '80',
  method: 'POST',
  headers: {
   'Content-Type': 'application/x-www-form-urlencoded',
   'Content-Length': post_data.length
  }
};

var req = http.request(options, function(res) {
  // after getting the response wich is the <res>
  // we can upgrade it to ws
  upToWebsocket(res);
});

//Upgrade to websocket
var upToWebsocket = function(json) {
  var server = ws.createServer(function (conn) {
    conn.on("json", function (str) {
      conn.sendText(str.toUpperCase()+"!!!")
  })

    conn.on("close", function (code, reason) {
      console.log("Connection closed")
    })
  }).listen(8001)
}

如果您在服务器上运行 Rippled，这也无济于事，因为没有支持交换 API 的 RPC 或 WS。