@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/oldTests/contractOrderbook.js

@@ -0,0 +1,243 @@
+const BigNumber = require('bignumber.js');
+const level = require('level');
+
+class TokenOrderbook {
+  constructor(dbPath, tickSize = new BigNumber('0.000000001')) {
+    this.tickSize = tickSize;
+    this.db = level(dbPath);
+    this.orderBooks = {}; // This will be populated from LevelDB
+    this.loadOrderBooks(); // Load existing order books from LevelDB
+  }
+
+  async loadOrderBooks() {
+    // Load order books from LevelDB
+    for await (const [key, value] of this.db.iterator({ gt: 'book-', lt: 'book-\xFF' })) {
+      this.orderBooks[key.split('-')[1]] = JSON.parse(value);
+    }
+  }
+
+  async saveOrderBook(pair) {
+    // Save order book to LevelDB
+    await this.db.put(`book-${pair}`, JSON.stringify(this.orderBooks[pair]));
+  }
+
+  // Adds a token order to the order book
+  addTokenOrder({ propertyIdNumber, propertyIdNumberDesired, amountOffered, amountExpected, time }) {
+    const price = this.calculatePrice(amountOffered, amountExpected);
+    const order = { propertyIdNumber, propertyIdNumberDesired, amountOffered, amountExpected, price, time };
+
+    const orderBookKey = `${propertyIdNumber}-${propertyIdNumberDesired}`;
+    this.insertOrder(order, orderBookKey);
+    this.matchOrders(orderBookKey);
+  }
+
+  addContractOrder({ contractId, amount, price, time, sell }) {
+  // Create a contract order object with the sell parameter
+    const contractOrder = { contractId, amount, price, time, sell };
+
+    // The orderBookKey is based on the contractId since it's a derivative contract
+    const orderBookKey = `contract-${contractId}`;
+
+    // Insert the contract order into the order book
+    this.insertOrder(contractOrder, orderBookKey, true);
+
+    // Match orders in the derivative contract order book
+    this.matchOrders(orderBookKey);
+  }
+
+  insertOrder(order, orderBookKey, isContractOrder = false) {
+    // If order book does not exist, create it
+    if (!this.orderBooks[orderBookKey]) {
+      this.orderBooks[orderBookKey] = { buy: [], sell: [] };
+    }
+
+    // Determine if it's a buy or sell order based on the property IDs
+    if(isContractOrder==false){
+        const side = order.propertyIdNumber < order.propertyIdNumberDesired ? 'buy' : 'sell';
+    }else if(isContractOrder==true&&sell==true){
+      const side = 'sell';
+    }else if(isContractOrder==true&&sell==false){
+      const side = 'buy'
+    }
+    // Insert the order into the correct side of the book
+    const bookSide = this.orderBooks[orderBookKey][side];
+    const index = bookSide.findIndex((o) => o.time > order.time);
+    if (index === -1) {
+      bookSide.push(order);
+    } else {
+      bookSide.splice(index, 0, order);
+    }
+
+    // Save the updated order book
+    this.saveOrderBook(orderBookKey);
+  }
+
+  calculatePrice(amountOffered, amountExpected) {
+    const priceRatio = new BigNumber(amountOffered).dividedBy(amountExpected);
+    return priceRatio.decimalPlaces(8, BigNumber.ROUND_HALF_UP);
+  }
+
+  matchOrders(orderBookKey, isContract = false) {
+    const orderBook = this.orderBooks[orderBookKey];
+    if (!orderBook || orderBook.buy.length === 0 || orderBook.sell.length === 0) {
+      return; // Nothing to match
+    }
+
+    const matches = [];
+
+    // Sort buy orders from highest to lowest price and sell orders from lowest to highest price
+    orderBook.buy.sort((a, b) => b.price.comparedTo(a.price) || a.time - b.time); // Highest price and oldest first
+    orderBook.sell.sort((a, b) => a.price.comparedTo(b.price) || a.time - b.time); // Lowest price and oldest first
+
+    // While there is still potential for matches
+    while (orderBook.sell.length > 0 && orderBook.buy.length > 0 &&
+           orderBook.sell[0].price.lte(orderBook.buy[0].price)) {
+      
+      // Match the top of the buy and sell orders
+      let sellOrder = orderBook.sell[0];
+      let buyOrder = orderBook.buy[0];
+
+      // Determine the amount to trade which is the minimum of the two orders
+      const amountToTrade = BigNumber.minimum(sellOrder.amountOffered, buyOrder.amountExpected);
+
+      // Update orders
+      sellOrder.amountOffered = sellOrder.amountOffered.minus(amountToTrade);
+      buyOrder.amountExpected = buyOrder.amountExpected.minus(amountToTrade);
+
+      // Deduct taker fee from buyer and give maker rebate to seller
+      if(isContract==false){
+          const takerFee = amountToTrade.times(0.0002);
+          const makerRebate = takerFee.div(2);
+      }
+
+      if(isContract==true){
+          const takerFee = amountToTrade.times(0.0001);
+          const makerRebate = takerFee.div(2);
+      }
+      buyOrder.amountExpected = buyOrder.amountExpected.minus(takerFee);
+      sellOrder.amountOffered = sellOrder.amountOffered.plus(makerRebate);
+
+      // If an order is completely filled, remove it from the order book
+      if (sellOrder.amountOffered.isZero()) {
+        orderBook.sell.shift(); // Remove the sell order
+      }
+      if (buyOrder.amountExpected.isZero()) {
+        orderBook.buy.shift(); // Remove the buy order
+      }
+
+      const matchedOrderDetails = {
+              sellOrderId: sellOrder.id, // Assuming we have unique IDs for orders 
+              buyOrderId: buyOrder.id,
+              amountToTrade: amountToTrade.toString(),
+              price: sellOrder.price.toString(),
+              takerFee: takerFee.toString(),
+              makerRebate: makerRebate.toString()
+            };
+  
+      matches.push(matchedOrderDetails);
+
+      // Partial matches: remaining amounts stay in the order book
+      // (They are already updated in the order objects)
+    }// Process the matches differently based on whether they're token or contract matches
+
+        const matchResults = {
+            orderBook: this.orderBooks[orderBookKey],
+            matches
+        };
+ 
+       if (isContract) {
+        this.processContractMatches(matchResults.matches);
+        } else {
+        this.processTokenMatches(matchResults.matches);
+      }
+
+      this.saveOrderBook(orderBookKey);
+
+     // Return the updated order book and the matches
+    return {
+      orderBook: this.orderBooks[orderBookKey],
+      matches
+    };
+  }
+
+
+  processTokenMatches(matches) {
+    matches.forEach(match => {
+      const sellOrder = this.getAddressBalances(match.sellOrderId);
+      const buyOrder = this.getAddressBalances(match.buyOrderId);
+
+      // Debit the reserve balances from the seller and buyer
+      sellOrder.reserveAmount = sellOrder.reserveAmount.minus(match.amountToTrade);
+      buyOrder.reserveAmount = buyOrder.reserveAmount.minus(match.amountToTrade);
+
+      // Credit the available balances to the buyer and seller
+      sellOrder.available = sellOrder.available.plus(match.amountToTrade);
+      buyOrder.available = buyOrder.available.plus(match.amountToTrade);
+
+      // Apply fees and rebates
+      buyOrder.available = buyOrder.available.minus(match.takerFee);
+      sellOrder.available = sellOrder.available.plus(match.makerRebate);
+
+      // Save the updated balances back to the TallyMap
+      this.updateBalance(match.sellOrderId, sellOrder);
+      this.updateBalance(match.buyOrderId, buyOrder);
+    });
+  }
+
+  processContractMatches(matches) {
+      matches.forEach(match => {
+        // Logic for identifying and updating the marginMap for contracts
+        // You can go to negative balances for contracts, so the logic here
+        // will need to be different than for tokens.
+
+        // Example logic (you'll need to replace this with your actual logic):
+        const contract = this.marginMap.get(match.contractId);
+        if (match.sell) {
+          // Update seller's margin balance
+          contract.sellerMargin = contract.sellerMargin.minus(match.amountToTrade);
+          // Update buyer's balance (can go negative)
+          contract.buyerMargin = contract.buyerMargin.plus(match.amountToTrade.minus(match.takerFee));
+        } else {
+          // Update buyer's margin balance
+          contract.buyerMargin = contract.buyerMargin.minus(match.amountToTrade);
+          // Update seller's balance (can go negative)
+          contract.sellerMargin = contract.sellerMargin.plus(match.amountToTrade.plus(match.makerRebate));
+        }
+
+        // Save the updated contract margins back to the marginMap
+        this.marginMap.set(match.contractId, contract);
+      });
+    }
+
+    async processContractMatches(matches, currentBlockHeight) {
+      for (const match of matches) {
+        try {
+          // Load the margin map for the given series ID and block height
+          const marginMap = await MarginMap.loadMarginMap(match.contractSeriesId, currentBlockHeight);
+
+          // Update contract balances for the buyer and seller
+          marginMap.updateContractBalances(match.buyerAddress, match.amount, match.price, true);
+          marginMap.updateContractBalances(match.sellerAddress, match.amount, match.price, false);
+          marginMap.updateMargin(match.buyerAddress, match.amount, match.price);
+          marginMap.updateMargin(match.sellerAddress, -match.amount, match.price);
+
+          // Realize PnL for the buyer and seller
+          const buyerPnl = marginMap.realizePnl(match.buyerAddress, match.amount, match.price, match.buyerAvgPrice);
+          const sellerPnl = marginMap.realizePnl(match.sellerAddress, -match.amount, match.price, match.sellerAvgPrice);
+
+          // Save the updated margin map
+          await marginMap.saveMarginMap(currentBlockHeight);
+
+          // Optionally handle the PnL if needed, e.g., logging or further processing
+          // ...
+
+        } catch (error) {
+          console.error(`Error processing contract match ${match.id}:`, error);
+          // Handle error, potentially rolling back any partial updates or retrying
+        }
+      }
+    }
+}
+
+
+module.exports = TokenOrderbook;

package/tradelayer.js/oldTests/createTestnetAddr.js

@@ -0,0 +1,43 @@
+const litecoin = require('litecoin');
+const fs = require('fs');
+const path = require('path');
+
+const client = new litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+/*client.cmd('createwallet','', function(err, walletInfo) {
+    if (err) {
+        console.error('Error creating new wallet:', err);
+        return;
+    }
+    console.log('New Wallet Info:', walletInfo);
+});
+
+client.getBalance('*', 1, function(err, balance) {
+    if (err) {
+        console.error('Error fetching balance:', err);
+        return;
+    }
+    console.log('Total Wallet Balance:', balance, 'LTC');
+});
+
+client.listUnspent(1, 9999999, function(err, unspent) {
+    if (err) {
+        console.error('Error listing unspent transactions:', err);
+        return;
+    }
+    console.log('Unspent Transactions:', unspent);
+});*/
+
+client.getNewAddress(function(err, address) {
+    if (err) {
+        console.error('Error fetching new address:', err);
+        return;
+    }
+    console.log('New Address:', address);
+});

package/tradelayer.js/oldTests/decode.js

@@ -0,0 +1,205 @@
+function decodeOmniPayload(hexPayload) {
+    // Remove the "OP_RETURN" prefix (4 bytes) and convert the hex payload to a Buffer
+    const payloadBuffer = Buffer.from(hexPayload.slice(8), 'hex');
+
+    // Extract the markers (each marker is 4 bytes)
+    const markers = [];
+    for (let i = 0; i < payloadBuffer.length; i += 4) {
+        const markerBuffer = payloadBuffer.slice(i, i + 4);
+        const marker = markerBuffer.toString('ascii');
+        markers.push(marker);
+    }
+
+    // Extract the payload data as a Buffer (skip markers)
+    const dataBuffer = payloadBuffer.slice(markers.length * 4);
+
+    // Check if there is enough data to read a 32-bit integer
+    let numericValue = null;
+    if (dataBuffer.length >= 4) {
+        numericValue = dataBuffer.readInt32LE(0);
+    }
+
+    // Convert markers to plain text
+    const markersText = markers.join(' ');
+
+    // Convert payload data to plain text
+    const dataText = dataBuffer.toString('utf8');
+
+    return {
+        markers: markersText,
+        data: dataText,
+        numericValue
+    };
+}
+
+// Example usage:
+const hexPayload = "6f6d6e6900000032010002000000000000537175697272656c20636f696e00004e55545300001dd7c1681d0000";
+const decodedPayload = decodeOmniPayload(hexPayload);
+console.log(decodedPayload.markers); // "omni coin NUTS"
+console.log(decodedPayload.data); // "Squirrel coin"
+console.log(decodedPayload.numericValue); // 84000000
+
+
+
+/*function decodeOmniPayload(hexPayload) {
+    // Remove the "OP_RETURN" prefix (4 bytes) and convert the hex payload to a Buffer
+    const payloadBuffer = Buffer.from(hexPayload.slice(8), 'hex');
+
+    // Extract the Omni marker (4 bytes) as an ASCII string
+    const marker = payloadBuffer.slice(0, 4).toString('ascii');
+
+    // Decode the payload data to a string while handling non-printable characters
+    let decodedData = '';
+    for (let i = 4; i < payloadBuffer.length; i++) {
+        const charCode = payloadBuffer.readUInt8(i);
+        if (charCode >= 32 && charCode <= 126) {
+            // Printable ASCII characters
+            decodedData += String.fromCharCode(charCode);
+        } else {
+            // Non-printable characters, represent as \xHH
+            decodedData += `\\x${charCode.toString(16).padStart(2, '0').toUpperCase()}`;
+        }
+    }
+
+    return {
+        marker,
+        data: decodedData
+    };
+}
+
+// Example usage:
+const hexPayload = "6f6d6e6900000032010002000000000000537175697272656c20636f696e00004e55545300001dd7c1681d0000";
+const decodedPayload = decodeOmniPayload(hexPayload);
+console.log(decodedPayload.marker); // "omni"
+console.log(decodedPayload.data); // "Squirrel coinNUTS\x1D\xD7\xC1\x68\x1D"
+
+
+/*function decodeOmniPayload(hexPayload) {
+    // Remove the "OP_RETURN" prefix (4 bytes) and convert the hex payload to a Buffer
+    const payloadBuffer = Buffer.from(hexPayload.slice(8), 'hex');
+
+    // Extract the Omni marker (4 bytes) as a hexadecimal string
+    const markerHex = payloadBuffer.slice(0, 4).toString('hex');
+
+    // Define a mapping for known Omni markers
+    const markerMap = {
+        '6f6d6e69': 'omni',
+        // Add more markers as needed
+    };
+
+    // Decode the payload data to a string while handling non-printable characters
+    let decodedData = '';
+    for (let i = 4; i < payloadBuffer.length; i++) {
+        const charCode = payloadBuffer.readUInt8(i);
+        if (charCode >= 32 && charCode <= 126) {
+            // Printable ASCII characters
+            decodedData += String.fromCharCode(charCode);
+        } else {
+            // Non-printable characters, represent as \xHH
+            decodedData += `\\x${charCode.toString(16).padStart(2, '0').toUpperCase()}`;
+        }
+    }
+
+    // Determine the marker name based on the hexadecimal value
+    const markerName = markerMap[markerHex] || 'Unknown';
+
+    return {
+        marker: markerName,
+        data: decodedData
+    };
+}
+
+// Example usage:
+const hexPayload = "6f6d6e6900000032010002000000000000537175697272656c20636f696e00004e55545300001dd7c1681d0000";
+const decodedPayload = decodeOmniPayload(hexPayload);
+console.log(decodedPayload.marker); // "omni"
+console.log(decodedPayload.data); // "Squirrel coinNUTS\x1D\xD7\xC1\x68\x1D"*/
+
+
+/*function decodeOmniPayload(hexPayload) {
+    // Remove the "OP_RETURN" prefix (4 bytes) and convert the hex payload to a Buffer
+    const payloadBuffer = Buffer.from(hexPayload.slice(8), 'hex');
+
+    // Extract the Omni marker (4 bytes)
+    const marker = payloadBuffer.slice(0, 4).toString('hex');
+
+    // Extract the payload data (after the marker)
+    const payloadData = payloadBuffer.slice(4);
+
+    // Decode the payload data to a string while handling non-printable characters
+    let decodedData = '';
+    for (let i = 0; i < payloadData.length; i++) {
+        const charCode = payloadData.readUInt8(i);
+        if (charCode >= 32 && charCode <= 126) {
+            // Printable ASCII characters
+            decodedData += String.fromCharCode(charCode);
+        } else {
+            // Non-printable characters, represent as \xHH
+            decodedData += `\\x${charCode.toString(16).padStart(2, '0').toUpperCase()}`;
+        }
+    }
+
+    return {
+        marker: marker,
+        data: decodedData
+    };
+}*/
+
+// Example usage:
+/*const hexPayload = "6f6d6e6900000032010002000000000000537175697272656c20636f696e00004e55545300001dd7c1681d0000";
+const decodedPayload = decodeOmniPayload(hexPayload);
+console.log(decodedPayload.marker); // "omni"
+console.log(decodedPayload.data); // "Squirrel coinNUTS\x1D\xD7\xC1\x68\x1D*/
+
+/*function decodeOmniPayload(hexPayload) {
+    // Remove the "OP_RETURN" prefix (4 bytes) and convert the hex payload to a Buffer
+    const payloadBuffer = Buffer.from(hexPayload.slice(8), 'hex');
+
+    // Extract the Omni marker (4 bytes)
+    const marker = payloadBuffer.slice(0, 4).toString('hex');
+
+    // Extract the payload data (after the marker)
+    const payloadData = payloadBuffer.slice(4);
+
+    // Decode the payload data to a string
+    let decodedData = '';
+    for (let i = 0; i < payloadData.length; i++) {
+        decodedData += String.fromCharCode(payloadData[i]);
+    }
+
+    return {
+        marker: marker,
+        data: decodedData
+    };
+}
+
+// Example usage:
+const hexPayload = "6f6d6e6900000032010002000000000000537175697272656c20636f696e00004e55545300001dd7c1681d0000";
+const decodedPayload = decodeOmniPayload(hexPayload);
+console.log(decodedPayload.marker); // "omni"
+console.log(decodedPayload.data); // "Squirrel coinNUTSh"
+*/
+
+/*
+function decodeOmniPayload(hexPayload) {
+    // Remove the "OP_RETURN" prefix (4 bytes) and convert the hex payload to a Buffer
+    const payloadBuffer = Buffer.from(hexPayload.slice(8), 'hex');
+
+    // Extract the Omni marker (4 bytes)
+    const marker = payloadBuffer.slice(0, 4).toString('hex');
+
+    // Extract the payload data (after the marker)
+    const payloadData = payloadBuffer.slice(4).toString('utf8');
+
+    return {
+        marker: marker,
+        data: payloadData
+    };
+}
+
+// Example usage:
+const hexPayload = "6f6d6e6900000032010002000000000000537175697272656c20636f696e00004e55545300001dd7c1681d0000";
+const decodedPayload = decodeOmniPayload(hexPayload);
+console.log(decodedPayload.marker); // "omni"
+console.log(decodedPayload.data); // "Squirrel coinNUTSh"
+*/

package/tradelayer.js/oldTests/decodeTest.js

@@ -0,0 +1,50 @@
+const Litecoin = require('litecoin'); // Replace with actual library import
+const util = require('util');
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+const decoderawtransactionAsync = util.promisify(client.cmd.bind(client,'decoderawtransaction'));
+const getTransactionAsync = util.promisify(client.cmd.bind(client, 'gettransaction'))
+
+async function testDecodeRawTransaction(rawTx) {
+    try {
+        const decodedTx = await decoderawtransactionAsync('decoderawtransaction', rawTx);
+        console.log('Decoded Transaction:', decodedTx);
+
+        const opReturnOutput = decodedTx.vout.find(output => output.scriptPubKey.type === 'nulldata');
+
+        if (opReturnOutput) {
+            const opReturnData = opReturnOutput.scriptPubKey.hex;
+            console.log('OP_RETURN Data:', opReturnData);
+
+            // Extract and log the "tl" marker
+            const markerHex = opReturnData.substring(4, 8); // '746c' for 'tl'
+            const marker = Buffer.from(markerHex, 'hex').toString();
+            console.log('Marker:', marker);
+
+            // Extract and log the actual payload
+            const payloadHex = opReturnData.substring(8);
+            const payload = Buffer.from(payloadHex, 'hex').toString();
+            console.log('Decoded Payload:', payload);
+
+
+            return { marker, payload };
+        } else {
+            console.log('No OP_RETURN output found.');
+            return null;
+        }
+    } catch (error) {
+        console.error('Error decoding raw transaction:', error);
+    }
+}
+
+const rawTx = '02000000000101be64c98a4c17b5861b45b2602873212cb0ada374539c7b61593b2d3e47b8e5cd0100000000ffffffff020000000000000000066a04746c303080b9ff0600000000160014ebecd536259ef21bc6ecc18e45b35412f04722900247304402201ac4b0e373e7555d502e80b5424683dd1da2ca8052793bd2c62d64b2e9370367022014e72b32507262b3c78848b81558acfb2c9f9cb2a8c7968b65615888e7f04d0b012103d6521aea309f7a2768a1cabcb917664966cabc28bc23874b12f73c1989972c5f00000000';
+client.cmd('gettransaction','0513576fa72ffdd721176dfc5a971af50958102070f55fce6d50aa604c6d0cb0',function(err,data){
+    console.log(data.hex)
+    testDecodeRawTransaction(data.hex);
+})

package/tradelayer.js/oldTests/displayTallyMap.js

@@ -0,0 +1,19 @@
+const TallyMap = require('./tally.js'); // Adjust the path to your TallyMap class file
+
+async function displayTallyMap() {
+    try {
+        console.log('Loading TallyMap from Database...');
+
+        // Assuming the block height is not relevant for just loading and displaying
+        const tallyMapInstance = await TallyMap.getInstance(); 
+        tallyMapInstance.loadFromDB()
+        // Convert the Map to an Object for easier JSON stringification
+        const tallyMapObject = Object.fromEntries(tallyMapInstance.addresses);
+        console.log('tallyMap: '+JSON.stringify(tallyMapInstance.addresses))
+        console.log('TallyMap:', JSON.stringify(tallyMapObject, null, 2));
+    } catch (error) {
+        console.error('Error loading and displaying TallyMap:', error);
+    }
+}
+
+displayTallyMap();