@tradelayerprotocol/tradelayer 1.9.1

package/apiEx.js

@@ -0,0 +1,99 @@
+/* @algo
+{
+  "name": "API Ex",
+  "symbol": "TLITE/LTC",
+  "venue": "TradeLayer",
+  "mode": "SPOT",
+  "leverage": 1,
+  "timeframe": "15m",
+  "description": "Simple order placement demo.",
+  "tags": ["mean-reversion","btc","futures"],
+
+  "parameters": {
+    "window":   { "type": "int",    "default": 20, "min": 1,  "max": 500 },
+    "zEntry":   { "type": "number", "default": 1.5, "min": 0, "max": 5, "step": 0.1 },
+    "zExit":    { "type": "number", "default": 0.3, "min": 0, "max": 2, "step": 0.1 },
+    "maxPos":   { "type": "int",    "default": 1,   "min": 1, "max": 10 }
+  },
+
+  "risk": {
+    "stopLossPct": 2.0,
+    "takeProfitPct": 3.5,
+    "maxLeverage": 5
+  },
+
+  "author": "you",
+  "version": "1.0.0"
+}
+@algo */
+ 
+// … actual trading code below …
+
+
+
+const ApiWrapper = require('tradelayer');
+let myInfo = {address:'tltc1q89kkgaslk0lt8l90jkl3cgwg7dkkszn73u4d2t',otherAddrs:[]};
+const api = new ApiWrapper('ws://172.26.37.103', 3001, true,true, myInfo, 'LTCTEST');
+
+// Start listening for order matches and handle swaps
+let orderbookSession = []
+let savedOrderUUIDs = []; // Array to store UUIDs of orders
+
+
+async function performTradeOperations(testAddress) {
+      console.log("awaiting init and address load")
+        await api.delay(2000);
+            myInfo = api.getMyInfo()
+
+
+// Call getTokenBalances with your test address
+console.log('checking we have address loaded before tokenBalances load '+myInfo.keypair.address)
+const tokenBalances = await api.getAllTokenBalancesForAddress(myInfo.keypair.address);
+console.log('tokens '+JSON.stringify(tokenBalances))
+// Example of fetching spot markets
+api.getSpotMarkets()
+    .then(markets => console.log('Spot Markets:', markets))
+    .catch(error => console.error('Error:', error));
+
+api.getFuturesMarkets()
+    .then(markets => console.log('Futures Markets:', markets))
+    .catch(error => console.error('Error:', error));
+
+// Example of sending an order
+const orderDetails = {
+    type: 'SPOT',
+    action: 'BUY',
+    props: { id_for_sale: 5, id_desired:0, price: 0.0003, amount: 0.3, transfer: false },
+    isLimitOrder:true,
+    keypair: {
+    address: 'tltc1qn006lvcx89zjnhuzdmj0rjcwnfuqn7eycw40yf',
+    pubkey: '03670d8f2109ea83ad09142839a55c77a6f044dab8cb8724949931ae8ab1316677'
+    },
+};
+
+await api.delay(3000) 
+api.sendOrder(orderDetails)
+    .then(orderUUID => {
+        console.log('Order sent, UUID:', orderUUID+' '+ JSON.stringify(orderDetails));
+        
+        savedOrderUUIDs.push({id: orderUUID, details: orderDetails}); // Save UUID to the array
+    })
+    console.log('delay and test cancel')
+    
+    console.log(JSON.stringify(savedOrderUUIDs))
+    /*console.log('about to cancel this order '+savedOrderUUIDs[0].id)
+    api.cancelOrder(savedOrderUUIDs[0].id)
+                .then(response => {
+                    savedOrderUUIDs = savedOrderUUIDs.filter(order => order.id !== savedOrderUUIDs[0].id);
+                    console.log(`Order with UUID: ${orderToCancel} canceled successfully!`);
+                })*/
+
+// Example of getting orderbook data
+const filter = { type: 'SPOT', first_token: 0, second_token: 5 };
+api.getOrderbookData(filter)
+    .then(orderbookData => console.log('Orderbook Data:', orderbookData))
+    .catch(error => console.error('Error fetching orderbook data:', error));
+}
+
+// Example usage of the function
+performTradeOperations(myInfo.address);

package/bb_hyperscalper.js

@@ -0,0 +1,290 @@
+'use strict';
+
+/**
+ * bb_scalper_binance_tl.js
+ *
+ * 5-second Bollinger Band scalper:
+ *  - Price feed: Binance futures aggTrade stream (e.g. BTCUSDT)
+ *  - Build 5s bars from trades
+ *  - Compute Bollinger Bands on last N closes
+ *  - Flat:
+ *      * close <= lower -> LONG TL market (market order)
+ *      * close >= upper -> SHORT TL market (market order)
+ *  - In position:
+ *      * TP at +TP_BPS
+ *      * SL at -SL_BPS
+ *
+ * Execution: TradeLayer via ApiWrapper (same family as run_bbo_tracker.js).
+ */
+
+const WebSocket = require('ws');
+const { ApiWrapper } = require('./algoAPI'); // adjust path if different
+
+// -------- TL API SETUP --------
+const tlApi = new ApiWrapper(
+  process.env.TL_BASE_URL || 'http://127.0.0.1',
+  Number(process.env.TL_PORT || 3001),
+  process.env.TL_TEST === 'true',
+  process.env.TL_ALREADY_ON === 'true',
+  process.env.TL_ADDRESS,
+  process.env.TL_PUBKEY,
+  process.env.TL_NETWORK || 'LTCTEST'
+);
+
+// -------- CONFIG --------
+const CFG = {
+  // Binance side (price oracle)
+  BINANCE_SYMBOL: (process.env.BINANCE_SYMBOL || 'BTCUSDT').toLowerCase(),
+  // Binance futures aggTrade stream
+  BINANCE_WS_URL_BASE: 'wss://fstream.binance.com/ws',
+
+  // TL side
+  TL_MARKET: process.env.TL_MARKET || 'BTC-PERP', // your TL futures/synth market
+  ORDER_SIZE: Number(process.env.TL_ORDER_SIZE || 1),
+
+  // Bar / indicator settings
+  BAR_MS: 5000,      // 5-second bars
+  BB_PERIOD: 60,     // 60 bars => 5 minutes of history at 5s
+  BB_K: 2,           // standard deviation multiplier
+
+  // Risk
+  TP_BPS: 3,         // take profit at +3 bps
+  SL_BPS: 3,         // stop loss at -3 bps
+
+  LOG_EVERY_BAR: true
+};
+
+// -------- STATE --------
+
+// 5-second bucket
+let bucketStart = null;
+let bucketOpen = null;
+let bucketHigh = null;
+let bucketLow = null;
+let bucketLast = null;
+
+// bar history: { t, o, h, l, c }
+const bars = [];
+
+/**
+ * Position in TL we track locally:
+ *  { side: 'long' | 'short', qty: number, entryPrice: number }
+ */
+let position = null;
+
+// -------- HELPERS --------
+
+function bpsDiff(entry, current, side) {
+  if (side === 'long') {
+    return ((current - entry) / entry) * 10_000;
+  }
+  return ((entry - current) / entry) * 10_000; // short
+}
+
+async function tlMarketOrder(side, qty) {
+  console.log(`[TL] MARKET ${side} ${qty} ${CFG.TL_MARKET}`);
+
+  // Adjust this to your real ApiWrapper method.
+  if (typeof tlApi.placeOrder === 'function') {
+    return tlApi.placeOrder({
+      market: CFG.TL_MARKET,
+      side, // 'buy' | 'sell'
+      type: 'MARKET',
+      size: qty
+    });
+  }
+
+  // Fallback example if you have a different signature:
+  // return tlApi.spotMarketOrder(CFG.TL_MARKET, side, qty);
+}
+
+async function openPosition(side, price) {
+  if (position) return;
+  const qty = CFG.ORDER_SIZE;
+
+  await tlMarketOrder(side === 'long' ? 'buy' : 'sell', qty);
+  position = { side, qty, entryPrice: price };
+
+  console.log(
+    `[ENTRY] ${side.toUpperCase()} qty=${qty} entry=${price.toFixed(8)}`
+  );
+}
+
+async function closePosition(price, reason) {
+  if (!position) return;
+
+  const exitSide = position.side === 'long' ? 'sell' : 'buy';
+  await tlMarketOrder(exitSide, position.qty);
+
+  const pnlBps = bpsDiff(position.entryPrice, price, position.side);
+
+  console.log(
+    `[EXIT] reason=${reason} side=${position.side} qty=${position.qty} entry=${position.entryPrice.toFixed(
+      8
+    )} exit=${price.toFixed(8)} pnl=${pnlBps.toFixed(2)}bps`
+  );
+
+  position = null;
+}
+
+function computeBollinger() {
+  if (bars.length < CFG.BB_PERIOD) return null;
+
+  const lastN = bars.slice(bars.length - CFG.BB_PERIOD);
+  const closes = lastN.map(b => b.c);
+  const n = closes.length;
+
+  const mean =
+    closes.reduce((s, x) => s + x, 0) / n;
+
+  const variance =
+    closes.reduce((s, x) => s + (x - mean) * (x - mean), 0) / n;
+
+  const std = Math.sqrt(variance);
+
+  return {
+    mean,
+    upper: mean + CFG.BB_K * std,
+    lower: mean - CFG.BB_K * std
+  };
+}
+
+async function onNewBar(bar) {
+  bars.push(bar);
+
+  // keep history bounded
+  const maxBars = CFG.BB_PERIOD * 3;
+  if (bars.length > maxBars) {
+    bars.splice(0, bars.length - maxBars);
+  }
+
+  const bb = computeBollinger();
+  if (!bb) return;
+
+  const price = bar.c;
+
+  if (CFG.LOG_EVERY_BAR) {
+    console.log(
+      `[BAR] t=${new Date(bar.t).toISOString()} close=${price.toFixed(
+        2
+      )} mean=${bb.mean.toFixed(2)} upper=${bb.upper.toFixed(
+        2
+      )} lower=${bb.lower.toFixed(2)}`
+    );
+  }
+
+  // 1) Manage existing position TP/SL
+  if (position) {
+    const pnlBps = bpsDiff(position.entryPrice, price, position.side);
+
+    if (pnlBps >= CFG.TP_BPS) {
+      await closePosition(price, 'TP');
+      return;
+    }
+
+    if (pnlBps <= -CFG.SL_BPS) {
+      await closePosition(price, 'SL');
+      return;
+    }
+
+    return; // still in position
+  }
+
+  // 2) Flat: look for entries
+  if (price <= bb.lower) {
+    await openPosition('long', price);
+  } else if (price >= bb.upper) {
+    await openPosition('short', price);
+  }
+}
+
+// 5-second bar builder from trade ticks
+async function onPriceTick(price, ts = Date.now()) {
+  const bucket = Math.floor(ts / CFG.BAR_MS) * CFG.BAR_MS;
+
+  if (bucketStart === null) {
+    bucketStart = bucket;
+    bucketOpen = price;
+    bucketHigh = price;
+    bucketLow = price;
+    bucketLast = price;
+    return;
+  }
+
+  if (bucket !== bucketStart) {
+    // close bar
+    const bar = {
+      t: bucketStart,
+      o: bucketOpen,
+      h: bucketHigh,
+      l: bucketLow,
+      c: bucketLast
+    };
+    await onNewBar(bar);
+
+    // new bucket
+    bucketStart = bucket;
+    bucketOpen = price;
+    bucketHigh = price;
+    bucketLow = price;
+    bucketLast = price;
+  } else {
+    // update current bucket
+    bucketLast = price;
+    if (price > bucketHigh) bucketHigh = price;
+    if (price < bucketLow) bucketLow = price;
+  }
+}
+
+// -------- BINANCE WS WIRING --------
+
+function startBinanceStream() {
+  const streamName = `${CFG.BINANCE_SYMBOL}@aggTrade`; // futures aggregated trades
+  const url = `${CFG.BINANCE_WS_URL_BASE}/${streamName}`;
+
+  console.log(`[WS] connecting to ${url}`);
+
+  const ws = new WebSocket(url);
+
+  ws.on('open', () => {
+    console.log('[WS] connected to Binance aggTrade');
+  });
+
+  ws.on('message', async msg => {
+    try {
+      const data = JSON.parse(msg.toString());
+      // aggTrade payload: { p: "price", T: tradeTime, ... }
+      const price = Number(data.p);
+      if (!price || !isFinite(price)) return;
+
+      const ts = Number(data.T) || Date.now();
+      await onPriceTick(price, ts);
+    } catch (e) {
+      console.log('[WS] message error:', e.message || e);
+    }
+  });
+
+  ws.on('close', () => {
+    console.log('[WS] closed. Reconnecting in 5s...');
+    setTimeout(startBinanceStream, 5000);
+  });
+
+  ws.on('error', err => {
+    console.log('[WS] error:', err.message || err);
+    ws.close();
+  });
+}
+
+// -------- ENTRYPOINT --------
+
+console.log(
+  `BB scalper starting:
+   Binance symbol: ${CFG.BINANCE_SYMBOL.toUpperCase()}
+   TL market:      ${CFG.TL_MARKET}
+   Bar:            ${CFG.BAR_MS / 1000}s
+   BB:             period=${CFG.BB_PERIOD}, k=${CFG.BB_K}
+   TP/SL:          ${CFG.TP_BPS} / ${CFG.SL_BPS} bps
+  `
+);
+
+startBinanceStream();

package/bbo_demo.js

@@ -0,0 +1,111 @@
+const WebSocket = require('ws');
+const ccxt = require('ccxt');
+
+//
+// CONFIG
+//
+const OB_URL = 'ws://172.81.181.19:3001/ws';
+const CONTRACT_ID = 2;
+const NETWORK = 'BTC';
+
+// dummy keypair (server does NOT verify sigs for demo)
+const KEYP = {
+    address: 'btc_demo_bot',
+    pubkey: '02aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
+};
+
+// quoting values (adjust for visuals)
+const SIZE = 1;              // 1 contract
+const SPREAD = 3;            // dollars above/below mark
+const COLLATERAL = 50;       // fake
+const MARGIN = 0.1;          // 10%
+
+//
+// Connect to Orderbook Server
+//
+console.log("[MM] Connecting to OB server:", OB_URL);
+const ws = new WebSocket(OB_URL);
+
+ws.on('open', () => {
+    console.log("[OB] Connected");
+
+    // join market (important!)
+    ws.send(JSON.stringify({
+        event: "orderbook:join",
+        data: {
+            marketKey: `FUTURES:${CONTRACT_ID}`,
+            network: NETWORK
+        }
+    }));
+
+    startLoop();
+});
+
+ws.on('message', (msg) => {
+    console.log("[OB] >>", msg.toString());
+});
+
+ws.on('close', () => console.log("[OB] Closed"));
+ws.on('error', (e) => console.log("[OB] Error:", e.message));
+
+
+//
+// Binance spot ticker loop (fetchTicker, not WS, simple & stable)
+//
+const binance = new ccxt.binance();
+
+async function getMarkPrice() {
+    try {
+        const t = await binance.fetchTicker('BTC/USDT');
+        return t.last; // mid or last is fine for demo
+    } catch (err) {
+        console.log("[WARN] Binance error:", err.message);
+        return null;
+    }
+}
+
+//
+// Send an order in TL FUTURES shape
+//
+function sendFuturesOrder(side, price) {
+    const msg = {
+        event: "new-order",
+        keypair: KEYP,
+        action: side,
+        type: "FUTURES",
+        props: {
+            contract_id: CONTRACT_ID,
+            amount: SIZE,
+            price: price,
+            collateral: COLLATERAL,
+            margin: MARGIN,
+            transfer: false
+        },
+        isLimitOrder: true,
+        marketName: `FUTURES:${CONTRACT_ID}`,
+        network: NETWORK
+    };
+
+    console.log("[SEND]", side, "@", price);
+    ws.send(JSON.stringify(msg));
+}
+
+//
+// Main quoting loop
+//
+async function startLoop() {
+    console.log("[MM] Starting futures MM loop on contract", CONTRACT_ID);
+
+    setInterval(async () => {
+        const mark = await getMarkPrice();
+        if (!mark) return;
+
+        // create BUY and SELL around mark
+        const buy = mark - SPREAD;
+        const sell = mark + SPREAD;
+
+        sendFuturesOrder("BUY", buy);
+        sendFuturesOrder("SELL", sell);
+
+    }, 1500);
+}