@tradelayerprotocol/tradelayer 1.9.1

package/mmEx.js

@@ -0,0 +1,356 @@
+/**
+ * mmEx_dualLayer.js — fast BBO trackers + slosh (≤5 bps), hedge on fills
+ *
+ * Requirements satisfied:
+ *  - 2 tracking orders per side that closely follow Binance bid/ask (fast)
+ *  - A "slosh" set of deeper passive orders kept within 5 bps; stay put unless trespass/out-of-band
+ *  - Hedge on any detected fill (order disappears without our cancel)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const WebSocket = require('ws');
+const ccxt = require('ccxt');
+const { apiKey, secret } = require('./keys.js');
+const ApiWrapper = require('./algoAPI.js');
+
+// ===== Config =====
+const LOG_PATH = path.join(process.env.HOME || process.env.USERPROFILE || '.', 'Downloads', 'mmEx.dual.log');
+
+const TL_WS_HOST = 'ws://172.26.37.103';
+const TL_WS_PORT = 3001;
+const TL_NETWORK = 'LTCTEST';
+const TL_ADDR = 'tltc1qvlwcnwlhnja7wlj685ptwxej75mms9nyv7vuy8';
+
+const BASE_ID  = 0;  // LTC
+const QUOTE_ID = 5;  // USDTt
+const SYMBOL   = 'LTC/USDT';
+
+// Tracking layer (fast)
+const TRACK_LEVELS_PER_SIDE = 2;
+const TRACK_EDGE_BPS  = 1.0;   // first level distance from BBO
+const TRACK_STEP_BPS  = 1.0;   // gap between tracking levels
+const TRACK_SIZE      = 0.10;
+const TRACK_DEBOUNCE_MS = 150; // per side
+
+// Slosh layer (slow)
+const SLOSH_LEVELS_PER_SIDE = 3;  // number of slosh levels per side
+const SLOSH_MAX_BPS   = 5.0;      // must remain within 5 bps to stay
+const SLOSH_START_BPS = 2.0;      // first slosh level distance from BBO
+const SLOSH_STEP_BPS  = 1.5;      // between levels, not to exceed 5 bps
+const SLOSH_SIZE      = 0.15;
+const SLOSH_DEBOUNCE_MS = 1200;   // slower refresh
+
+// Safety / plumbing
+const CANCEL_TIMEOUT_MS = 1500;
+const PLACE_TIMEOUT_MS  = 1500;
+const EXCH_SPREAD_MIN   = 0.005;  // don't quote if exchange spread too tight
+const EXCH_SPREAD_MAX   = 1.00;   // ignore if absurd
+const HEDGE_SLIPPAGE_F  = 0.25;   // market hedge slippage factor vs last BBO
+
+// ===== Logging =====
+const logStream = fs.createWriteStream(LOG_PATH, { flags: 'a' });
+function log(...a) {
+  const line = `[${new Date().toISOString()}] ${a.map(String).join(' ')}\n`;
+  if (!logStream.destroyed) logStream.write(line);
+  console.log(...a);
+}
+
+// ===== External deps =====
+const binance = new ccxt.binance({ apiKey, secret, enableRateLimit: true });
+const api = new ApiWrapper(
+  TL_WS_HOST, TL_WS_PORT,
+  true,  // debug
+  true,  // autoConnect
+  { address: TL_ADDR, otherAddrs: [] },
+  TL_NETWORK
+);
+
+// ===== State =====
+let bestBid = null, bestAsk = null;
+
+const layer = {
+  TRACK: { BUY: [], SELL: [] }, // items: {uuid, px, sz}
+  SLOSH: { BUY: [], SELL: [] }
+};
+
+const lastTouch = {
+  TRACK: { BUY: 0, SELL: 0 },
+  SLOSH: { BUY: 0, SELL: 0 }
+};
+
+const ours = new Set();     // all open order UUIDs we believe are live
+const oursMeta = new Map(); // uuid -> {side, layer:'TRACK'|'SLOSH', px, sz}
+
+function now() { return Date.now(); }
+function bps(x) { return x / 10000; }
+function tooSoon(kind, side, ms) { return now() - lastTouch[kind][side] < ms; }
+function touch(kind, side) { lastTouch[kind][side] = now(); }
+
+function toTLBuy(price, amount) {
+  return { type: 'SPOT', action: 'BUY',  props: { id_for_sale: QUOTE_ID, id_desired: BASE_ID,  price, amount, transfer: false } };
+}
+function toTLSell(price, amount) {
+  return { type: 'SPOT', action: 'SELL', props: { id_for_sale: BASE_ID,  id_desired: QUOTE_ID, price, amount, transfer: false } };
+}
+
+async function withTimeout(p, ms, tag) {
+  let t; const killer = new Promise((_, rej) => t = setTimeout(() => rej(new Error(`${tag} timeout ${ms}ms`)), ms));
+  try { return await Promise.race([p, killer]); }
+  finally { clearTimeout(t); }
+}
+
+// ===== Binance WS (depth) =====
+const ws = new WebSocket('wss://stream.binance.com:9443/ws');
+ws.on('open', () => {
+  ws.send(JSON.stringify({ method: 'SUBSCRIBE', params: ['ltcusdt@depth'], id: 1 }));
+  log('Subscribed Binance: ltcusdt@depth');
+});
+ws.on('message', (raw) => {
+  try {
+    const d = JSON.parse(raw);
+    const b = Number(d?.b?.[0]?.[0]);
+    const a = Number(d?.a?.[0]?.[0]);
+    if (Number.isFinite(b) && Number.isFinite(a) && a > b) {
+      bestBid = b; bestAsk = a;
+    }
+  } catch {}
+});
+ws.on('error', (e) => log('WS error', e.message || e));
+
+// ===== TL ops =====
+async function place(kind, side, px, sz) {
+  const det = side === 'BUY' ? toTLBuy(px, sz) : toTLSell(px, sz);
+  const uuid = await withTimeout(api.sendOrder(det), PLACE_TIMEOUT_MS, 'place');
+  const id = uuid?.orderUuid || uuid;
+  layer[kind][side].push({ uuid: id, px, sz });
+  ours.add(id);
+  oursMeta.set(id, { side, layer: kind, px, sz });
+  log('PLACED', kind, side, px.toFixed(6), 'uuid=', id);
+}
+
+async function cancel(kind, side, idx, reason) {
+  const item = layer[kind][side][idx];
+  if (!item) return;
+  const id = item.uuid;
+  try {
+    await withTimeout(api.cancelOrder(id), CANCEL_TIMEOUT_MS, 'cancel');
+    log('CANCELED', kind, side, item.px.toFixed(6), 'uuid=', id, 'reason=', reason);
+  } catch (e) {
+    log('CANCEL FAIL', kind, side, id, e.message || e);
+  } finally {
+    layer[kind][side].splice(idx, 1);
+    ours.delete(id);
+    oursMeta.delete(id);
+  }
+}
+
+function genTargets_TRACK(bid, ask) {
+  const bids = [], asks = [];
+  for (let i = 0; i < TRACK_LEVELS_PER_SIDE; i++) {
+    bids.push({ px: bid * (1 - bps(TRACK_EDGE_BPS + i * TRACK_STEP_BPS)), sz: TRACK_SIZE });
+    asks.push({ px: ask * (1 + bps(TRACK_EDGE_BPS + i * TRACK_STEP_BPS)), sz: TRACK_SIZE });
+  }
+  return { bids, asks };
+}
+
+function genTargets_SLOSH(bid, ask) {
+  const bids = [], asks = [];
+  for (let i = 0; i < SLOSH_LEVELS_PER_SIDE; i++) {
+    const dist = Math.min(SLOSH_START_BPS + i * SLOSH_STEP_BPS, SLOSH_MAX_BPS);
+    bids.push({ px: bid * (1 - bps(dist)), sz: SLOSH_SIZE, dist });
+    asks.push({ px: ask * (1 + bps(dist)), sz: SLOSH_SIZE, dist });
+  }
+  return { bids, asks };
+}
+
+// Keep order if: still within SLOSH_MAX_BPS of current BBO and not trespassing
+function sloshStillValid(side, px, bid, ask) {
+  if (side === 'BUY') {
+    const relBps = Math.abs((bid - px) / bid) * 10000;
+    return px <= bid && relBps <= SLOSH_MAX_BPS;
+  } else {
+    const relBps = Math.abs((px - ask) / ask) * 10000;
+    return px >= ask && relBps <= SLOSH_MAX_BPS;
+  }
+}
+
+function pickMissing(existingPx, targets, tolBps) {
+  const out = [];
+  for (const t of targets) {
+    const near = existingPx.some(px => Math.abs(px - t.px) <= (t.px * bps(tolBps)));
+    if (!near) out.push(t);
+  }
+  return out;
+}
+
+// ===== Hedging on fills =====
+// We detect fills by diffs: If a UUID disappears from server-open-orders and we did NOT cancel it, treat as fill
+async function hedgeOnFill(side, px, sz) {
+  try {
+    // simple market hedge opposite to TL side
+    if (!Number.isFinite(bestBid) || !Number.isFinite(bestAsk)) return;
+    const ref = side === 'BUY' ? bestAsk : bestBid;
+    const price = side === 'BUY'
+      ? ref * (1 - bps(HEDGE_SLIPPAGE_F)) // we sold on TL, buy on Binance a bit below ask if allowed
+      : ref * (1 + bps(HEDGE_SLIPPAGE_F)); // we bought on TL, sell on Binance a bit above bid if allowed
+
+    const hedgeSide = side === 'BUY' ? 'buy' : 'sell'; // reverse? we *bought* on TL -> hedge by *sell*; adjust:
+    const takerSide = (side === 'BUY') ? 'sell' : 'buy';
+    await binance.createOrder(SYMBOL, 'market', takerSide, sz, undefined);
+    log('HEDGE', takerSide, sz, SYMBOL, 'ok (fill detected at TL)');
+  } catch (e) {
+    log('HEDGE FAIL', e.message || e);
+  }
+}
+
+// Hook: wire to your ApiWrapper’s stream of account updates / orders list
+// Expect a payload like: { event: 'PLACED_ORDERS', openedOrders: [...uuids...] }
+api.onMessage?.((msg) => {
+  try {
+    if (!msg) return;
+    // normalize possible shapes
+    const ev = msg.event || msg.type || '';
+    if (String(ev).toUpperCase().includes('PLACED') && Array.isArray(msg.openedOrders)) {
+      const openNow = new Set((msg.openedOrders || []).map(o => o.uuid || o.orderUuid || o));
+      for (const id of Array.from(ours)) {
+        if (!openNow.has(id)) {
+          // if it disappeared and we didn't remove it locally => filled (or canceled by match)
+          const meta = oursMeta.get(id);
+          if (meta) {
+            log('FILL-DETECTED', id, meta.side, meta.layer, meta.px);
+            hedgeOnFill(meta.side, meta.px, meta.sz).catch(()=>{});
+            // clean local state if still present in a layer
+            for (const KIND of ['TRACK','SLOSH']) {
+              for (const SIDE of ['BUY','SELL']) {
+                const idx = layer[KIND][SIDE].findIndex(x => x.uuid === id);
+                if (idx >= 0) layer[KIND][SIDE].splice(idx, 1);
+              }
+            }
+            ours.delete(id);
+            oursMeta.delete(id);
+          }
+        }
+      }
+    }
+  } catch {}
+});
+
+// ===== Reconcilers =====
+async function reconcileTRACK(bid, ask) {
+  // debounce per side
+  for (const side of ['BUY','SELL']) {
+    if (tooSoon('TRACK', side, TRACK_DEBOUNCE_MS)) continue;
+    touch('TRACK', side);
+
+    const targets = genTargets_TRACK(bid, ask);
+    const tgt = side === 'BUY' ? targets.bids : targets.asks;
+    const existing = layer.TRACK[side];
+
+    // cancel if too many or trespass BBO (shouldn’t happen, but guard)
+    for (let i = existing.length - 1; i >= 0; i--) {
+      const { px } = existing[i];
+      const trespass = (side === 'BUY') ? (px > bid) : (px < ask);
+      const tooMany = existing.length > TRACK_LEVELS_PER_SIDE;
+      if (trespass || tooMany) {
+        await cancel('TRACK', side, i, trespass ? 'trespass' : 'excess');
+      }
+    }
+
+    // place missing near BBO (tolerance half a step)
+    const miss = pickMissing(existing.map(e => e.px), tgt, TRACK_STEP_BPS * 0.6);
+    for (const m of miss.slice(0, Math.max(0, TRACK_LEVELS_PER_SIDE - existing.length))) {
+      await place('TRACK', side, m.px, m.sz);
+    }
+  }
+}
+
+async function reconcileSLOSH(bid, ask) {
+  for (const side of ['BUY','SELL']) {
+    if (tooSoon('SLOSH', side, SLOSH_DEBOUNCE_MS)) continue;
+    touch('SLOSH', side);
+
+    const targets = genTargets_SLOSH(bid, ask);
+    const tgt = side === 'BUY' ? targets.bids : targets.asks;
+    const existing = layer.SLOSH[side];
+
+    // prune invalid: outside 5 bps window or trespass
+    for (let i = existing.length - 1; i >= 0; i--) {
+      const { px } = existing[i];
+      if (!sloshStillValid(side, px, bid, ask)) {
+        await cancel('SLOSH', side, i, 'out-of-band');
+      }
+    }
+
+    // place up to desired count; tolerance slightly wider than track
+    const miss = pickMissing(existing.map(e => e.px), tgt, Math.min(SLOSH_MAX_BPS, SLOSH_STEP_BPS));
+    for (const m of miss.slice(0, Math.max(0, SLOSH_LEVELS_PER_SIDE - layer.SLOSH[side].length))) {
+      // clamp distances to SLOSH_MAX_BPS
+      const bbo = side === 'BUY' ? bid : ask;
+      const rel = Math.abs((m.px - bbo) / bbo) * 10000;
+      if (rel <= SLOSH_MAX_BPS) await place('SLOSH', side, m.px, m.sz);
+    }
+  }
+}
+
+// ===== Main tick =====
+async function tick() {
+  if (!Number.isFinite(bestBid) || !Number.isFinite(bestAsk)) return;
+  const spread = bestAsk - bestBid;
+  if (spread < EXCH_SPREAD_MIN || spread > EXCH_SPREAD_MAX) return;
+
+  await reconcileTRACK(bestBid, bestAsk);
+  await reconcileSLOSH(bestBid, bestAsk);
+}
+
+// ===== Graceful shutdown =====
+async function shutdown() {
+  log('Shutdown: cancel all…');
+  for (const KIND of ['TRACK','SLOSH']) {
+    for (const SIDE of ['BUY','SELL']) {
+      for (let i = layer[KIND][SIDE].length - 1; i >= 0; i--) {
+        try { await cancel(KIND, SIDE, i, 'shutdown'); } catch {}
+      }
+    }
+  }
+  process.exit(0);
+}
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+
+// ===== Boot =====
+(async () => {
+  log('mmEx_dualLayer starting…');
+  await new Promise(r => setTimeout(r, 1500));
+  setInterval(() => { tick().catch(e => log('tick err', e.message || e)); }, 120);
+
+  // Optional: periodic reconcile of fills if your wrapper has a getter
+  // If ApiWrapper exposes api.getMyOpenOrders(), uncomment this poller:
+  /*
+  setInterval(async () => {
+    try {
+      const list = await api.getMyOpenOrders();
+      const openNow = new Set((list || []).map(o => o.uuid || o.orderUuid || o));
+      for (const id of Array.from(ours)) {
+        if (!openNow.has(id)) {
+          const meta = oursMeta.get(id);
+          if (meta) {
+            log('FILL-DETECTED(POLL)', id, meta.side, meta.layer, meta.px);
+            hedgeOnFill(meta.side, meta.px, meta.sz).catch(()=>{});
+            ours.delete(id);
+            oursMeta.delete(id);
+            for (const KIND of ['TRACK','SLOSH']) {
+              for (const SIDE of ['BUY','SELL']) {
+                const idx = layer[KIND][SIDE].findIndex(x => x.uuid === id);
+                if (idx >= 0) layer[KIND][SIDE].splice(idx, 1);
+              }
+            }
+          }
+        }
+      }
+    } catch {}
+  }, 800);
+  */
+})();

package/networks.js

@@ -0,0 +1,51 @@
+const BTC = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: 'bc',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x00,
+    scriptHash: 0x05,
+    wif: 0x80,
+};
+
+const BTCTEST = {
+    messagePrefix: '\x18Bitcoin Testnet Signed Message:\n',
+    bech32: 'tb',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+};
+
+const LTC = {
+    messagePrefix: '\x19Litecoin Signed Message:\n',
+    bech32: 'ltc',
+    bip32: {
+      public: 0x019da462,
+      private: 0x019d9cfe,
+    },
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    wif: 0xb0,
+};
+
+const LTCTEST = {
+    messagePrefix: '\x19Litecoin Testnet Signed Message:\n',
+    bech32: 'tltc',
+    bip32: {
+      public: 0x0436f6e1,
+      private: 0x0436ef7d,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0x3a,
+    wif: 0xef,
+};
+
+const networks = { BTC, LTC, LTCTEST, BTCTEST };
+
+module.exports = networks

package/orderbook.js

@@ -0,0 +1,200 @@
+const SellSwapper = require('./seller.js')
+const BuySwapper = require('./buyer.js')
+const BigNumber = require('bignumber.js')
+
+class OrderbookSession {
+    constructor(socket, myInfo, client,test) {
+        console.log('initializing orderbook '+JSON.stringify(myInfo))
+        this.socket = socket;
+        this.myInfo = myInfo;
+        this.client = client;
+        this.test = test
+        
+        // Start the session and listen for various events
+        this.startSession();
+    }
+
+    setInfo(myInfo){
+        this.myInfo=myInfo
+    }
+
+    // Start the session and manage connection lifecycle
+    startSession() {
+        this.socket.on('connection', () => {
+            console.log('Connected to the orderbook server.');
+            this.subscribeToOrderbook();
+        });
+
+        this.socket.on('disconnect', () => {
+            console.log('Disconnected from the orderbook server.');
+            // Reconnection logic could be added here if necessary
+        });
+
+        this.handleOrderMatches();
+        this.handleNewOrders();
+        this.handleOrderUpdates();
+        this.handleClosedOrders();
+    }
+
+    // Subscribe to orderbook updates after connection
+    subscribeToOrderbook() {
+        // Subscribe to specific assets or full orderbook
+        this.socket.emit('subscribe', { event: 'update-orderbook', assets: ['LTC', 'BTC'] });
+        console.log('Subscribed to orderbook data for assets: LTC, BTC.');
+
+        // Listening for general orderbook updates
+        this.socket.on('update-orderbook', (data) => {
+            console.log('Orderbook Updated:', data);
+            // You can update your local orderbook or UI here
+        });
+    }
+
+    // Handle new orders
+    handleNewOrders() {
+        this.socket.on('new-order', (newOrderData) => {
+            console.log('socket in new order '+JSON.stringify(this.socket)+' '+this.socket)
+            console.log('New Order:', newOrderData);
+            // You can update the UI or alert the user about new orders
+        });
+
+        this.socket.on('many-orders', (bulkOrdersData) => {
+            console.log('Many Orders Received:', bulkOrdersData);
+            // Handle bulk order updates (e.g., refreshing the full orderbook)
+        });
+    }
+
+    // Handle updates to existing orders in the orderbook
+    handleOrderUpdates() {
+        this.socket.on('update-orderbook', (updateData) => {
+            console.log('Orderbook Update:', updateData);
+            // Handle any updates to the orderbook here
+        });
+    }
+
+    // Handle order closing or cancellations
+    handleClosedOrders() {
+        this.socket.on('close-order', (orderUUID) => {
+            console.log(`Order ${orderUUID} closed or canceled.`);
+            // Remove the order from the UI or local state
+        });
+    }
+
+   // Handle matched orders and initiate trade swaps
+        handleOrderMatches() {
+            this.socket.on('new-channel', async (swapConfig) => {
+                const tradeInfo = swapConfig?.tradeInfo;
+                console.log('inside handleOrderMatches on algo '+JSON.stringify(swapConfig))
+                if (!tradeInfo?.buyer || !tradeInfo?.seller) {
+                  return;
+                }
+
+                //console.log('swap config '+JSON.stringify(swapConfig))
+                if(!swapConfig.tradeInfo.buyer||!swapConfig.tradeInfo.seller){return}
+                try {
+                    const { tradeInfo, isBuyer } = swapConfig; // Extract the relevant trade info and buyer/seller flag
+                    const { buyer, seller, props, type } = tradeInfo; // Get buyer/seller info and trade properties
+                    
+                    console.log('new channel match '+JSON.stringify(swapConfig)+' trade info'+JSON.stringify(tradeInfo))
+                    // Make sure the buyer/seller addresses are properly matched
+                    console.log('my address'+this.myInfo.keypair.address, +' buyer.address '+buyer.keypair.address+' seller.address '+seller.keypair.address)
+                    if(!this.myInfo.keypair.address){
+                       const address =  await this.getUTXOBalances()
+                       if(!address||!this.myInfo.keypair.address){console.log('houston we have a problem')}
+                    }
+                    if (this.myInfo.keypair.address === buyer.keypair.address){
+                        console.log('Initiating Buy Swap...');
+                        await this.initiateBuySwap(type, tradeInfo, buyer, seller);
+                    } else if (this.myInfo.keypair.address === seller.keypair.address){
+                        console.log('Initiating Sell Swap...');
+                        await this.initiateSellSwap(type, tradeInfo, buyer, seller);
+                    } else {
+                        console.log('Address mismatch, cannot proceed with swap.');
+                    }
+                } catch (error) {
+                    console.error('Error handling matched order:', error);
+                }
+            });
+        }
+
+        // Initialize buy swap
+        async initiateBuySwap(typeTrade, tradeInfo, buyerInfo, sellerInfo) {
+            const key = [tradeInfo.buyer?.uuid, tradeInfo.seller?.uuid].join('-');
+            try {
+                const buySwapper = new BuySwapper(typeTrade, tradeInfo, buyerInfo, sellerInfo, this.client, this.socket,this.test,key);
+                const res = await buySwapper.onReady();
+                if (res.error) {
+                    console.error(`Buy Swap Failed: ${res.error}`);
+                } else {
+                    console.log(`Buy Swap Complete: ${res.data}`);
+                }
+            } catch (error) {
+                console.error('Error initiating Buy Swap:', error);
+            }
+        }
+
+        // Initialize sell swap
+        async initiateSellSwap(typeTrade, tradeInfo, buyerInfo, sellerInfo) {
+            const key = [tradeInfo.buyer?.uuid, tradeInfo.seller?.uuid].join('-');
+          
+            try {
+                const sellSwapper = new SellSwapper(typeTrade, tradeInfo, sellerInfo, buyerInfo, this.client, this.socket,this.test,key);
+                const res = await sellSwapper.onReady();
+                if (res.error) {
+                    console.error(`Sell Swap Failed: ${res.error}`);
+                } else {
+                    console.log(`Sell Swap Complete: ${res.data}`);
+                }
+            } catch (error) {
+                console.error('Error initiating Sell Swap:', error);
+            }
+        }
+
+        async getUTXOBalances(address) {
+            try {
+                const utxos = await this.listUnspent(); // Fetch sunspent transactions
+                console.log('utxos returned 2nd pass in orderbook '+JSON.stringify(utxos))
+                let totalBalance = new BigNumber(0);
+
+                for (const utxo of utxos) {
+                    console.log('scanning utxos '+utxo.address+' '+utxo.amount)
+                    if (utxo.address === address){
+                        totalBalance += utxo.amount; // Sum balances for the specific address
+                    } else if (!this.myInfo.keypair.address){
+                        this.myInfo.keypair.address = utxo.address;
+                        this.myInfo.keypair.pubkey = await this.getPubKeyFromAddress(utxo.address); // Get pubkey for the new address
+                        console.log('logging pubkey ' +this.myInfo.keypair.pubkey+' '+this.myInfo.keypair.address)
+                        totalBalance += utxo.amount;
+                    } else if (address === '' && this.myInfo.keypair.address){
+                        const pubkey = await this.getPubKeyFromAddress(utxo.address);
+                        this.myInfo.otherAddrs.push({ address: utxo.address, pubkey: pubkey });
+                        totalBalance += utxo.amount;
+                    }
+                }
+
+                console.log(`Total UTXO balance for address ${this.myInfo.keypair.address}:`, totalBalance);
+                  
+                return this.myInfo.keypair.address
+            } catch (error) {
+                console.error('Error fetching UTXO balances:', error);
+            }
+        }
+
+        listUnspent(...params) {
+            return util.promisify(this.client.cmd.bind(this.client, 'listunspent'))(...params);
+        }
+
+        async getPubKeyFromAddress(address) {
+        try {
+            const addressInfo = await this.getAddressInfo(address);
+            if (addressInfo && addressInfo.pubkey) {
+                return addressInfo.pubkey;
+            } else {
+                throw new Error('Public key not found for address');
+            }
+        } catch (error) {
+            console.error('Error fetching pubkey:', error);
+        }
+    }
+}
+
+module.exports = OrderbookSession

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@tradelayerprotocol/tradelayer",
+  "version": "1.9.1",
+  "description": "NPM package for interacting with TradeLayer orderbook and building Litecoin/Token/Futures transactions.",
+  "main": "index.js",
+  "dependencies": {
+    "axios": "^1.7.7",
+    "bigint-base-converter": "^0.1.3",
+    "bignumber.js": "^9.1.2",
+    "bip32": "^5.0.0",
+    "bip39": "^3.1.0",
+    "bitcoin": "^3.0.3",
+    "bitcoinjs-lib": "^6.1.6",
+    "bitcore-lib-ltc": "^10.0.21",
+    "ccxt": "^4.4.77",
+    "dotenv": "^16.4.5",
+    "ecpair": "^3.0.0",
+    "isomorphic-ws": "^5.0.0",
+    "litecoin": "^2.0.5",
+    "socket.io-client": "^4.7.5",
+    "tiny-secp256k1": "^2.2.4",
+    "tradelayer": "^1.5.2",
+    "ws": "^8.18.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/patrickdugan/tlnpm"
+  },
+  "scripts": {
+    "start": "node algoAPI.js"
+  },
+  "author": "Your Name",
+  "license": "MIT"
+}

package/perTradeQueue.js

@@ -0,0 +1,36 @@
+// perTradeQueue.js
+'use strict';
+
+/**
+ * Run async functions sequentially *per key*.
+ * Calls for different keys can run in parallel.
+ */
+const pending = new Map();
+
+/**
+ * @param {string} key         e.g. `${buyerUuid}-${sellerUuid}`
+ * @param {() => Promise<any>} fn  async work to run
+ */
+function runForKey(key, fn) {
+  if (!key) {
+    // no key → just run without queuing
+    return Promise.resolve().then(fn);
+  }
+
+  const prev = pending.get(key) || Promise.resolve();
+
+  const next = prev
+    .catch(() => {}) // swallow errors from previous tasks
+    .then(() => fn())
+    .finally(() => {
+      // clear if this is still the tail
+      if (pending.get(key) === next) pending.delete(key);
+    });
+
+  pending.set(key, next);
+  return next;
+}
+
+module.exports = {
+  runForKey,
+};