@tradelayerprotocol/tradelayer 1.9.1

package/spam_screamer_futures.js

@@ -0,0 +1,222 @@
+// spam_screamer.js
+'use strict';
+
+require('dotenv').config();
+const WebSocket = require('ws');
+
+// prefer local ./tl, fall back to npm 'tradelayer'
+let ApiWrapper;
+try {
+  ApiWrapper = require('./algoAPI.js');
+} catch {
+ // ApiWrapper = require('tradelayer');
+}
+
+
+// ---- helpers ----
+const toBool = (v, d = false) =>
+  v === undefined
+    ? d
+    : ['1', 'true', 'yes', 'on'].includes(String(v).trim().toLowerCase());
+
+const required = (name, def) => {
+  const v = process.env[name] ?? def;
+  if (v === undefined || v === '') {
+    throw new Error(`Missing required env: ${name}`);
+  }
+  return v;
+};
+
+// ---- ENV CONFIG ----
+const HOST    = required('TL_HOST', '172.81.181.19');
+const PORT    = Number(process.env.TL_PORT ?? 3001);
+const TESTNET = toBool(process.env.TL_TEST, true);
+const TL_ON   = toBool(process.env.TL_TLON, true);
+
+const ADDRESS = required(
+  'TL_ADDRESS',
+  'tltc1qn006lvcx89zjnhuzdmj0rjcwnfuqn7eycw40yf'
+);
+const PUBKEY  = required(
+  'TL_PUBKEY',
+  '03670d8f2109ea83ad09142839a55c77a6f044dab8cb8724949931ae8ab1316677'
+);
+const NETWORK = required('TL_NETWORK', 'LTCTEST');
+
+const SIZE          = Number(required('SIZE', 0.1));
+const SPAM_RPS      = Number(process.env.SPAM_RPS ?? 10);
+const MAX_IN_FLIGHT = Number(process.env.MAX_IN_FLIGHT ?? 200);
+
+const CONTRACT  = 3 //Number(process.env.ID_FOR_SALE ?? 0);
+const ID_DESIRED    = Number(process.env.ID_DESIRED ?? 5);
+
+console.log(
+  '[env]',
+  { HOST, PORT, TESTNET, TL_ON, ADDRESS, PUBKEY, NETWORK, SIZE, SPAM_RPS, MAX_IN_FLIGHT }
+);
+
+// ---- INIT API ----
+const api = new ApiWrapper(HOST, PORT, TESTNET, TL_ON, ADDRESS, PUBKEY, NETWORK);
+
+// ---- Binance WebSocket feed (LTC/USDT) ----
+const BINANCE_WS_URL = 'wss://stream.binance.com:9443/ws/ltcusdt@depth20@100ms';
+const LEVEL_OFFSET   = Number(process.env.LEVEL_OFFSET ?? 2);
+
+let lastBook = { bids: [], asks: [] };
+let bookReady = false;
+
+function startBinanceFeed() {
+  const ws = new WebSocket(BINANCE_WS_URL);
+  ws.on('open', () => console.log('[binance] connected'));
+  ws.on('message', msg => {
+    const data = JSON.parse(msg);
+    if (!data.bids || !data.asks) return;
+    lastBook = {
+      bids: data.bids.map(([p, q]) => [Number(p), Number(q)]),
+      asks: data.asks.map(([p, q]) => [Number(p), Number(q)]),
+    };
+    bookReady = true;
+  });
+  ws.on('close', () => {
+    console.warn('[binance] socket closed, retrying...');
+    setTimeout(startBinanceFeed, 2000);
+  });
+  ws.on('error', e => console.error('[binance] error', e.message));
+}
+
+function pickPrice(action) {
+  if (!bookReady) return null;
+  if (action === 'BUY') {
+    const asks = lastBook.asks;
+    const idx = Math.min(LEVEL_OFFSET, asks.length - 1);
+    return asks[idx]?.[0];
+  } else {
+    const bids = lastBook.bids;
+    const idx = Math.min(LEVEL_OFFSET, bids.length - 1);
+    return bids[idx]?.[0];
+  }
+}
+
+// ---- Build TL order ----
+function buildOrder(action, price) {
+  return {
+    type: 'FUTURES',
+    action,
+    // Set as limit order pegged to Binance depth
+    isLimitOrder: true,
+    keypair: {
+      address: ADDRESS,
+      pubkey: PUBKEY,
+    },
+    props: {
+      contract_id: CONTRACT,
+      price,
+      amount: SIZE,
+      transfer: false,
+      network: NETWORK
+    },
+  };
+}
+
+// ---- SPAMMER STATE ----
+let inflight = 0;
+let sent = 0;
+let failed = 0;
+let seq = 0;
+let running = true;
+
+const delay = ms => new Promise(res => setTimeout(res, ms));
+async function fireOne() {
+  if (!running) return;
+  if (inflight >= MAX_IN_FLIGHT) return;
+  if (!bookReady) return;
+
+  inflight++;
+  sent++;
+  const n = seq++;
+  const action = n % 2 === 0 ? 'BUY' : 'SELL';
+  const price = pickPrice(action);
+  if (!price) {
+    inflight--;
+    return;
+  }
+
+  const order = buildOrder(action, price);
+  const requiredLtc = 0.00002 //estimateLtcForOrder(order);
+
+  try {
+    await api.funding.withReservation(
+      {
+        ltc: requiredLtc,
+        contracts: { [order.props.contract_id]: order.props.amount },
+      },
+      async (lockId) => {
+        const t0 = Date.now();
+        const uuid = await api.sendOrder(order);
+        const dt = Date.now() - t0;
+
+        // For now we *release* on order send, and let the real funding step
+        // re-reserve when it actually builds the on-chain tx.
+        // If you want to be stricter, return { commit: true } only after
+        // walletListener confirms a funding tx.
+        return { commit: false };
+      }
+    );
+  } catch (e) {
+    failed++;
+    console.error(`[err] reservation/send failed: ${e?.message || e}`);
+  } finally {
+    inflight--;
+  }
+}
+
+function estimateLtcForOrder(order) {
+  // very rough: notional + fee buffer; refine later
+  const px = Number(order.props.price || 0);
+  const amt = Number(order.props.amount || 0);
+
+  const notional = px * amt;          // if fully margined you can shrink this
+  const feeBuf   = 0.001;             // 0.001 LTC fee buffer, tune properly
+  return notional * 0.1 + feeBuf;    // e.g. 1% margin + fee
+}
+
+
+async function main() {
+  console.log('[cfg] connecting...', { HOST, PORT, TESTNET, TL_ON, NETWORK });
+  startBinanceFeed();
+  await api.delay(1500);
+
+  try {
+    const me = api.getMyInfo?.();
+    if (me?.address) console.log('[me]', me.address);
+  } catch {}
+
+  console.log(`[spam] starting screamer: SPAM_RPS=${SPAM_RPS}, MAX_IN_FLIGHT=${MAX_IN_FLIGHT}, SIZE=${SIZE}`);
+
+  const intervalMs = 1000 / Math.max(SPAM_RPS, 1);
+  const interval = setInterval(() => {
+    if (!running) return;
+    fireOne(); // fire-and-forget
+  }, intervalMs);
+
+  const shutdown = async () => {
+    if (!running) return;
+    running = false;
+    clearInterval(interval);
+    console.log('[shutdown] waiting for inflight orders to finish...');
+    while (inflight > 0) {
+      console.log(`[shutdown] inflight=${inflight} ...`);
+      await delay(500);
+    }
+    console.log(`[stats] sent=${sent}, failed=${failed}, max_inflight=${MAX_IN_FLIGHT}`);
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch(e => {
+  console.error('[fatal]', e);
+  process.exit(1);
+});

package/tradelayer.js/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/tradelayer.js/README.md

@@ -0,0 +1,2 @@
+# tradelayer.js
+ .js rebuild of TradeLayer protocol

package/tradelayer.js/oldTests/activationTest.js

@@ -0,0 +1,6 @@
+var testAdmin = "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8"
+
+// Example usage
+const tokenData = { /* token details */ };
+const tokenCreationMessage = await createAndRegisterToken(tokenData);
+console.log(tokenCreationMessage);

package/tradelayer.js/oldTests/base58.test.js

@@ -0,0 +1,23 @@
+const base58 = require('base-58');
+
+// Function to encode an integer to base58
+function encodeBase58(integer) {
+  return base58.encode(Buffer.from(integer.toString()));
+}
+
+// Function to decode a base58 string to an integer
+function decodeBase58(base58String) {
+  return parseInt(Buffer.from(base58.decode(base58String)).toString());
+}
+
+// Example Usage:
+const amount = 213456789;
+const encodedBase58 = encodeBase58(amount);
+//console.log("Encoded Base58:", encodedBase58);
+
+const decodedAmount = decodeBase58(encodedBase58);
+//console.log("Decoded Amount:", decodedAmount);
+
+test('base58 encoder', () => {
+  expect(amount).toBe(decodedAmount);
+});

package/tradelayer.js/oldTests/base64Decode.test.js

@@ -0,0 +1,16 @@
+function decodeBase64(encodedString) {
+    // Buffer is used in Node.js to handle binary data
+    // 'base64' specifies the current encoding of the string to be decoded
+    const decodedString = Buffer.from(encodedString, 'base64').toString('utf-8');
+    return decodedString;
+}
+
+// Example usage
+const encodedString = "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"
+const decodedString = decodeBase64(encodedString);
+
+//console.log(decodedString);
+
+test('base64', async () => {
+    expect(decodeBase64(encodedString)[2]).toBe('s')
+})

package/tradelayer.js/oldTests/blocksRefactor.js

@@ -0,0 +1,140 @@
+const litecoin = require('litecoin');
+const fs = require('fs');
+const json = require('big-json');
+
+const client = new litecoin.Client({
+    host: '127.0.0.1',
+    port: 8332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+async function decodeOPReturnPayload(hexPayload) {
+    try {
+        const decodedData = Buffer.from(hexPayload, 'hex').toString('utf8');
+        return decodedData;
+    } catch (error) {
+        console.error('Error decoding payload:', error);
+        return null;
+    }
+}
+
+async function extractBlockData(startHeight) {
+    try {
+        const chainTip = await client.getBlockCount();
+        const chainHeight = chainTip;
+
+        const blockData = await getBlockData(startHeight, chainHeight);
+
+        if (blockData) {
+            console.log('Block data extraction completed.');
+            await extractProtocolTx(startHeight, blockData);
+        }
+    } catch (error) {
+        console.error('Error retrieving chain tip:', error);
+    }
+}
+
+async function getBlockData(height, chainHeight) {
+    try {
+        const blockHash = await client.getBlockHash(height);
+        const currentBlock = await client.getBlock(blockHash);
+
+        return currentBlock;
+    } catch (error) {
+        console.error('Error retrieving block data:', error);
+        return null;
+    }
+}
+
+async function makeFile(filename, pojo) {
+    const stringifyStream = json.createStringifyStream({
+        body: pojo
+    });
+
+    stringifyStream.on('data', function (strChunk) {
+        fs.appendFile(filename, strChunk, function (err) {
+            if (err) {
+                console.error('Error writing to file:', err);
+            }
+        });
+    });
+}
+
+async function extractProtocolTx(start, blockData) {
+    if (!blockData) {
+        console.error('Invalid block data. Aborting.');
+        return;
+    }
+
+    const indexPlaceholder = start;
+    const placement = start - startHeight;
+    console.log(placement, start);
+
+    const thisBlock = blockData[placement];
+
+    if (start >= startHeight + 200000) {
+        const obj = JSON.stringify(protocolBlocks);
+        await makeFile('protocolTxIndex.json', protocolBlocks);
+        console.log('ta da!!');
+        return;
+    }
+
+    await loopThroughBlock(thisBlock, 0);
+}
+
+async function loopThroughBlock(block, i) {
+    if (!block) {
+        console.error('Block is undefined. Aborting.');
+        return;
+    }
+
+    console.log(block.height, i, block.tx.length);
+
+    if (i >= block.tx.length) {
+        console.log('Block processing completed.');
+        await extractProtocolTx(block.height + 1, blockData);
+        return;
+    }
+
+    const tx = block.tx[i];
+
+    if (!tx || tx === '') {
+        console.log('Skipping empty transaction.');
+        await loopThroughBlock(block, i + 1);
+        return;
+    }
+
+    try {
+        const rawtx = await client.getRawTransaction(tx, true);
+        let confirmations;
+
+        try {
+            confirmations = rawtx.confirmations;
+        } catch {
+            console.error('Error getting confirmations.');
+            return await loopThroughBlock(block, i + 1);
+        }
+
+        const thisConfirmations = confirmations;
+
+        for (let v = 0; v < rawtx.vout.length; v++) {
+            // ... Rest of your code
+        }
+
+        // Move to the next transaction
+        await loopThroughBlock(block, i + 1);
+    } catch (error) {
+        console.error('Error processing transaction:', error);
+        // Handle the error gracefully if necessary
+        await loopThroughBlock(block, i + 1);
+    }
+}
+
+async function main() {
+    const startHeight = 2098224;
+    await extractBlockData(startHeight);
+}
+
+main();

package/tradelayer.js/oldTests/checkVestBalance.js

@@ -0,0 +1,25 @@
+const TallyMap = require('./tally.js');
+const Logic = require('./logic.js');
+const expressInterface = require('./interfaceExpress.js');
+
+async function testSendTLVEST() {
+    // Initialize components
+    const tallyMap = TallyMap.getInstance();
+
+    // New address generated from the sendTransactionTest script
+    const newAddress = 'LYmNegGLoo1Vf4ZUs9k2yskfUgacRS678j'; // Replace with the actual generated address
+
+    // Wait for a few minutes to allow the transaction to be processed
+    /*console.log('Waiting for transaction to be processed...');
+    await new Promise(resolve => setTimeout(resolve, 3 * 60 * 1000)); // 3 minutes*/
+
+    // Check balances
+    const TLVESTPropertyId = 2; // Assuming TLVEST has property ID 2
+    const newAddressBalance = await expressInterface.getAllBalancesForAddress(newAddress);
+    console.log('New address balance:', newAddressBalance);
+
+    // Assertions (pseudo-code)
+    // assert(newAddressBalance.vesting === 1, 'Vesting balance should be 1 TL');
+}
+
+testSendTLVEST();

package/tradelayer.js/oldTests/consensusHashProto.js

@@ -0,0 +1,151 @@
+const crypto = require('crypto');
+
+// Simulate the data structures and functions used in the C++ code
+const mp_tally_map = new Map(); // Simulate tally map
+const my_offers = new Map(); // Simulate offer map
+const my_accepts = new Map(); // Simulate accept map
+const my_crowds = new Map(); // Simulate crowd map
+const msc_debug_consensus_hash = false; // Simulate debug flag
+
+class CMPTally {
+    constructor() {
+        this.balances = new Map();
+    }
+
+    getMoney(propertyId, type) {
+        const propertyBalances = this.balances.get(propertyId);
+        if (propertyBalances && propertyBalances[type]) {
+            return propertyBalances[type];
+        }
+        return 0;
+    }
+
+    init() {
+        // Simulate initialization
+    }
+
+    next() {
+        // Simulate iterating over property IDs
+        return 0;
+    }
+}
+
+class CMPOffer {
+    constructor() {
+        // Simulate offer properties
+    }
+
+    getHash() {
+        return crypto.createHash('sha256').update('offerdata').digest('hex');
+    }
+
+    // Implement other methods as needed
+}
+
+class CMPAccept {
+    constructor() {
+        // Simulate accept properties
+    }
+
+    getHash() {
+        return crypto.createHash('sha256').update('acceptdata').digest('hex');
+    }
+
+    // Implement other methods as needed
+}
+
+class CMPCrowd {
+    constructor() {
+        // Simulate crowd properties
+    }
+
+    // Implement other methods as needed
+}
+
+class CMPSPInfo {
+    static getArgs() {
+        // Simulate getting command line arguments
+        return [];
+    }
+}
+
+// Helper function to generate a consensus string for hashing
+function generateConsensusString(dataObj, ...args) {
+    // Implement the logic to generate the consensus string
+    return ''; // Return a placeholder for now
+}
+
+// Simulate a lock mechanism
+const cs_tally = {
+    lock() {
+        // Implement locking mechanism
+    },
+};
+
+// Simulate printing to log
+function printToLog(message) {
+    // Implement logging
+    console.log(message);
+}
+
+// Translated C++ function to JavaScript
+function getConsensusHash() {
+    const hasher = crypto.createHash('sha256');
+
+    cs_tally.lock();
+
+    if (msc_debug_consensus_hash) printToLog('Beginning generation of current consensus hash...\n');
+
+    // Balances - Loop through the tally map and update the hash context
+    for (const [address, tally] of mp_tally_map.entries()) {
+        tally.init();
+        let propertyId = 0;
+        while ((propertyId = tally.next()) !== 0) {
+            const dataStr = generateConsensusString(tally, address, propertyId);
+            if (dataStr === '') continue;
+            if (msc_debug_consensus_hash) printToLog(`Adding balance data to consensus hash: ${dataStr}\n`);
+            hasher.update(dataStr);
+        }
+    }
+
+    // Implement the rest of the logic for DEx offers, accepts, crowdsales, and properties
+
+    // Extract the final result and return the hash
+    const consensusHash = hasher.digest('hex');
+    if (msc_debug_consensus_hash) printToLog(`Finished generation of consensus hash. Result: ${consensusHash}\n`);
+
+    return consensusHash;
+}
+
+function getBalancesHash(hashPropertyId) {
+    const hasher = crypto.createHash('sha256');
+
+    cs_tally.lock();
+
+    // Loop through the tally map and update the hash context for a specific property
+    for (const [address, tally] of mp_tally_map.entries()) {
+        tally.init();
+        let propertyId = 0;
+        while ((propertyId = tally.next()) !== 0) {
+            if (propertyId !== hashPropertyId) continue;
+            const dataStr = generateConsensusString(tally, address, propertyId);
+            if (dataStr === '') continue;
+            if (msc_debug_consensus_hash) printToLog(`Adding data to balances hash: ${dataStr}\n`);
+            hasher.update(dataStr);
+        }
+    }
+
+    const balancesHash = hasher.digest('hex');
+
+    return balancesHash;
+}
+
+// The translation is incomplete; you need to implement the missing parts for DEx, crowdsales, and properties.
+
+// Usage
+const consensusHash = getConsensusHash();
+console.log(`Consensus Hash: ${consensusHash}`);
+
+const propertyIdToHash = 1; // Replace with the property ID you want to hash
+const balancesHash = getBalancesHash(propertyIdToHash);
+console.log(`Balances Hash for Property ID ${propertyIdToHash}: ${balancesHash}`);