@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/tests/256decode.js

@@ -0,0 +1,82 @@
+const path = require('path');
+const Base256 = require(path.join(__dirname, '../src/base256.js'));
+
+// Helpers
+const hexToBuf = h => Buffer.from(h, 'hex');
+const bufToHex = b => Buffer.from(b).toString('hex');
+const pad64 = h => (h.length >= 64 ? h.slice(-64) : '0'.repeat(64 - h.length) + h);
+
+function buildScript(tx1HexBE, tx2HexBE) {
+  // encode to your base-256 "printable" alphabet (multi-byte UTF-8)
+  const s1 = Base256.hexToBase256(tx1HexBE.toLowerCase());
+  const s2 = Base256.hexToBase256(tx2HexBE.toLowerCase());
+
+  const b1 = Buffer.from(s1, 'utf8');
+  const b2 = Buffer.from(s2, 'utf8');
+
+  if (b1.length > 255 || b2.length > 255) {
+    throw new Error(`Base256 UTF-8 is too long for 1-byte length fields: b1=${b1.length}, b2=${b2.length}`);
+  }
+
+  // 'tl' + tag(0x42) + len1 + len2 + data1 + data2
+  const header = Buffer.from([0x74, 0x6c, 0x42, b1.length, b2.length]);
+  const payload = Buffer.concat([header, b1, b2]);
+
+  // Minimal push wrapper
+  const len = payload.length;
+  let script;
+  if (len <= 75) {
+    script = Buffer.concat([Buffer.from([0x6a, len]), payload]);
+  } else if (len <= 0xff) {
+    script = Buffer.concat([Buffer.from([0x6a, 0x4c, len]), payload]); // PUSHDATA1
+  } else if (len <= 0xffff) {
+    script = Buffer.concat([Buffer.from([0x6a, 0x4d, len & 0xff, len >> 8]), payload]); // PUSHDATA2
+  } else {
+    const L = Buffer.allocUnsafe(4); L.writeUInt32LE(len, 0);
+    script = Buffer.concat([Buffer.from([0x6a, 0x4e]), L, payload]); // PUSHDATA4
+  }
+  return bufToHex(script);
+}
+
+function parseScript(scriptHex) {
+  const buf = hexToBuf(scriptHex);
+  if (buf[0] !== 0x6a) throw new Error('Not OP_RETURN');
+
+  const op = buf[1];
+  let len, off;
+  if (op <= 75)       { len = op; off = 2; }
+  else if (op === 0x4c){ len = buf[2]; off = 3; }
+  else if (op === 0x4d){ len = buf[2] | (buf[3] << 8); off = 4; }
+  else if (op === 0x4e){ len = (buf[2] | (buf[3] << 8) | (buf[4] << 16) | (buf[5] << 24)) >>> 0; off = 6; }
+  else throw new Error('Unknown pushdata');
+
+  const data = buf.slice(off, off + len);
+  if (data[0] !== 0x74 || data[1] !== 0x6c) throw new Error('Missing "tl"');
+  if (data[2] !== 0x42) throw new Error('Unexpected tag (expected 0x42)');
+
+  const len1 = data[3], len2 = data[4];
+  if (5 + len1 + len2 !== data.length) throw new Error('Length mismatch');
+
+  const s1 = data.slice(5, 5 + len1).toString('utf8');
+  const s2 = data.slice(5 + len1, 5 + len1 + len2).toString('utf8');
+
+  const h1 = pad64(Base256.base256ToHex(s1).toLowerCase());
+  const h2 = pad64(Base256.base256ToHex(s2).toLowerCase());
+
+  return { txid1: h1, txid2: h2, payloadLen: len, scriptLen: buf.length };
+}
+
+// ---- demo ----
+const TX1 = 'e2b11900c8e99d77bc527807c268bd937a991d975d7a6043725f4174e1fcc6a7';
+const TX2 = 'acb58f122e0ffa34e82b3775289ef55218243d3712fb592f1ac70bdec8984e7c';
+
+const scriptHex = buildScript(TX1, TX2);
+console.log('ScriptPubKey (hex):', scriptHex); // log hex only (no beeps)
+
+const parsed = parseScript(scriptHex);
+console.log('Parsed:', parsed);
+
+if (parsed.txid1 !== TX1 || parsed.txid2 !== TX2) {
+  throw new Error('Round-trip mismatch');
+}
+console.log('Round-trip OK.');

package/tradelayer.js/tests/UTXOracle.js

@@ -0,0 +1,205 @@
+const { execSync } = require('child_process');
+const { DateTime } = require('luxon');
+
+// Configuration options for litecoin-cli
+const config = {
+  datadir: "",
+  rpcuser: "",
+  rpcpassword: "",
+  rpcookiefile: "",
+  rpcconnect: "",
+  rpcport: "",
+  conf: ""
+};
+
+// Add the configuration options to the litecoin-cli call
+const litecoinCliOptions = [];
+if (config.datadir) litecoinCliOptions.push(`-datadir=${config.datadir}`);
+if (config.rpcuser) litecoinCliOptions.push(`-rpcuser=${config.rpcuser}`);
+if (config.rpcpassword) litecoinCliOptions.push(`-rpcpassword=${config.rpcpassword}`);
+if (config.rpcookiefile) litecoinCliOptions.push(`-rpcookiefile=${config.rpcookiefile}`);
+if (config.rpcconnect) litecoinCliOptions.push(`-rpcconnect=${config.rpcconnect}`);
+if (config.rpcport) litecoinCliOptions.push(`-rpcport=${config.rpcport}`);
+if (config.conf) litecoinCliOptions.push(`-conf=${config.conf}`);
+
+// Shortcut function to call the node
+function askNode(command) {
+  const cmd = ['litecoin-cli', ...litecoinCliOptions, ...command].join(' ');
+  try {
+    return execSync(cmd).toString().trim();
+  } catch (error) {
+    console.error("Error connecting to your node. Trouble shooting steps:");
+    console.error("1) Make sure litecoin-cli is working. Try command 'litecoin-cli getblockcount'");
+    console.error("2) Make sure config file litecoin.conf has server=1");
+    console.error("3) Explore the litecoin-cli options in this script");
+    console.error("The command was: " + cmd);
+    console.error("The error from litecoin-cli was:", error);
+    process.exit(1);
+  }
+}
+
+// Get the latest block from the node
+const blockCount = parseInt(askNode(['getblockcount']));
+const blockHash = askNode(['getblockhash', blockCount]);
+const blockHeader = JSON.parse(askNode(['getblockheader', blockHash, 'true']));
+const latestTimeInSeconds = blockHeader.time;
+const latestDateTime = DateTime.fromSeconds(latestTimeInSeconds, { zone: 'utc' });
+const latestPriceDate = latestDateTime.minus({ days: 1 }).toISODate();
+
+console.log(`Connected to local node at block #: ${blockCount}`);
+console.log(`Latest available price date is: ${latestPriceDate}`);
+console.log("Earliest available price date is: 2020-07-26 (full node)");
+
+// Get the desired date to estimate the price
+const readline = require('readline').createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+readline.question("Enter date in YYYY-MM-DD (or 'q' to quit): ", dateEntered => {
+  if (dateEntered.toLowerCase() === 'q') {
+    readline.close();
+    process.exit(0);
+  }
+
+  let datetimeEntered;
+  try {
+    datetimeEntered = DateTime.fromISO(dateEntered, { zone: 'utc' });
+    if (!datetimeEntered.isValid || datetimeEntered >= latestDateTime.startOf('day')) {
+      throw new Error("Invalid date");
+    }
+
+    const minDate = DateTime.fromISO("2020-07-26", { zone: 'utc' });
+    if (datetimeEntered < minDate) {
+      throw new Error("Date is before 2020-07-26");
+    }
+  } catch (error) {
+    console.error("Error interpreting date. Likely not entered in format YYYY-MM-DD");
+    console.error("Please try again");
+    readline.close();
+    process.exit(1);
+  }
+
+  const priceDaySeconds = datetimeEntered.toSeconds();
+  const priceDayDateUtc = datetimeEntered.toLocaleString(DateTime.DATE_FULL);
+  readline.close();
+
+  // Hunt through blocks to find the first block on the target day
+  let secondsSincePriceDay = latestTimeInSeconds - priceDaySeconds;
+  let blocksAgoEstimate = Math.round(144 * secondsSincePriceDay / (60 * 60 * 24));
+  let priceDayBlockEstimate = blockCount - blocksAgoEstimate;
+
+  let blockHashB = askNode(['getblockhash', priceDayBlockEstimate]);
+  let blockHeaderB = JSON.parse(askNode(['getblockheader', blockHashB, 'true']));
+  let timeInSeconds = blockHeaderB.time;
+  let secondsDifference = timeInSeconds - priceDaySeconds;
+  let blockJumpEstimate = Math.round(144 * secondsDifference / (60 * 60 * 24));
+
+  let lastEstimate = 0;
+  let lastLastEstimate = 0;
+  while (blockJumpEstimate > 6 && blockJumpEstimate !== lastLastEstimate) {
+    lastLastEstimate = lastEstimate;
+    lastEstimate = blockJumpEstimate;
+
+    priceDayBlockEstimate -= blockJumpEstimate;
+    blockHashB = askNode(['getblockhash', priceDayBlockEstimate]);
+    blockHeaderB = JSON.parse(askNode(['getblockheader', blockHashB, 'true']));
+    timeInSeconds = blockHeaderB.time;
+    secondsDifference = timeInSeconds - priceDaySeconds;
+    blockJumpEstimate = Math.round(144 * secondsDifference / (60 * 60 * 24));
+  }
+
+  if (timeInSeconds > priceDaySeconds) {
+    while (timeInSeconds > priceDaySeconds) {
+      priceDayBlockEstimate -= 1;
+      blockHashB = askNode(['getblockhash', priceDayBlockEstimate]);
+      blockHeaderB = JSON.parse(askNode(['getblockheader', blockHashB, 'true']));
+      timeInSeconds = blockHeaderB.time;
+    }
+    priceDayBlockEstimate += 1;
+  } else if (timeInSeconds < priceDaySeconds) {
+    while (timeInSeconds < priceDaySeconds) {
+      priceDayBlockEstimate += 1;
+      blockHashB = askNode(['getblockhash', priceDayBlockEstimate]);
+      blockHeaderB = JSON.parse(askNode(['getblockheader', blockHashB, 'true']));
+      timeInSeconds = blockHeaderB.time;
+    }
+  }
+
+  const priceDayBlock = priceDayBlockEstimate;
+
+  // Build the container to hold the output amounts bell curve
+  const firstBinValue = -6;
+  const lastBinValue = 6;
+  const rangeBinValues = lastBinValue - firstBinValue;
+  const outputBellCurveBins = [0.0];
+
+  for (let exponent = -6; exponent < 6; exponent++) {
+    for (let b = 0; b < 200; b++) {
+      const binValue = Math.pow(10, exponent + b / 200);
+      outputBellCurveBins.push(binValue);
+    }
+  }
+
+  const numberOfBins = outputBellCurveBins.length;
+  const outputBellCurveBinCounts = new Array(numberOfBins).fill(0.0);
+
+  // Get all output amounts from all blocks on target day
+  console.log(`\nReading all blocks on ${priceDayDateUtc}...`);
+  console.log("\nThis will take a few minutes (~144 blocks)...");
+  console.log("\nHeight\tTime(utc)\t\tTime(32bit)\t\t  Completion %");
+
+  let blockHeight = priceDayBlock;
+  let blockHashB = askNode(['getblockhash', blockHeight]);
+  let blockB = JSON.parse(askNode(['getblock', blockHashB, '2']));
+  let timeInSeconds = blockB.time;
+  let timeDateTime = DateTime.fromSeconds(timeInSeconds, { zone: 'utc' });
+  let timeUtc = timeDateTime.toFormat('HH:mm:ss');
+  let dayOfMonth = timeDateTime.day;
+  let targetDayOfMonth = dayOfMonth;
+  let time32Bit = (timeInSeconds & 0b11111111111111111111111111111111).toString(2).padStart(32, '0');
+
+  while (targetDayOfMonth === dayOfMonth) {
+    const progressEstimate = 100.0 * (timeDateTime.hour + timeDateTime.minute / 60) / 24.0;
+    console.log(`${blockHeight}\t${timeUtc}\t${time32Bit}\t${progressEstimate.toFixed(2)}%`);
+
+    for (const tx of blockB.tx) {
+      for (const output of tx.vout) {
+        const amount = parseFloat(output.value);
+        if (amount > 1e-6 && amount < 1e6) {
+          const amountLog = Math.log10(amount);
+          const percentInRange = (amountLog - firstBinValue) / rangeBinValues;
+          let binNumberEst = Math.floor(percentInRange * numberOfBins);
+          while (outputBellCurveBins[binNumberEst] <= amount) {
+            binNumberEst += 1;
+          }
+          const binNumber = binNumberEst - 1;
+          outputBellCurveBinCounts[binNumber] += 1.0;
+        }
+      }
+    }
+
+    blockHeight += 1;
+    blockHashB = askNode(['getblockhash', blockHeight]);
+    blockB = JSON.parse(askNode(['getblock', blockHashB, '2']));
+    timeInSeconds = blockB.time;
+    timeDateTime = DateTime.fromSeconds(timeInSeconds, { zone: 'utc' });
+    timeUtc = timeDateTime.toFormat('HH:mm:ss');
+    dayOfMonth = timeDateTime.day;
+    time32Bit = (timeInSeconds & 0b11111111111111111111111111111111).toString(2).padStart(32, '0');
+  }
+
+  console.log("\nNormalizing and displaying histogram...");
+
+  // Normalize and plot the histogram
+  const totalOutputs = outputBellCurveBinCounts.reduce((a, b) => a + b, 0.0);
+  for (let b = 0; b < numberOfBins; b++) {
+    outputBellCurveBinCounts[b] /= totalOutputs;
+  }
+
+  for (let b = 1; b < numberOfBins; b++) {
+    if (outputBellCurveBinCounts[b] > 0.01) {
+      console.log(`Bin ${b}: ${outputBellCurveBins[b].toFixed(8)} LTC - ${outputBellCurveBinCounts[b].toFixed(4)}`);
+    }
+  }
+});

package/tradelayer.js/tests/base94test.js

@@ -0,0 +1,23 @@
+const baseConverter = require('bigint-base-converter');
+
+// Define the Base 94 character set
+const base94Chars = [...Array(94).keys()].map((i) => String.fromCharCode(i + 33));
+
+// Convert a decimal string to base 94
+function toBase94(decimalString) {
+    return baseConverter(decimalString, 10, base94Chars.join(''));
+}
+
+// Convert hexadecimal (base16) string to base94
+function hexToBase94(hex) {
+    // Convert the hexadecimal string to a decimal string
+    const decimalString = BigInt(`0x${hex}`).toString(10);
+
+    // Convert the decimal string to base94
+    return toBase94(decimalString);
+}
+
+// Example usage:
+const hex = '540016785dec88efdc71ebbf13d9c8c690100c9f776c6e275cb1e2a19c27b983';
+const base94Encoded = hexToBase94(hex);
+console.log(`Base 94 Encoded: ${base94Encoded}`);

package/tradelayer.js/tests/cancelTxTest.js

@@ -0,0 +1,62 @@
+const TxUtils = require('./txUtils.js');
+
+async function cancelOrders() {
+    // Admin address
+    const adminAddress = 'tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr'//tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8';
+
+    // Mode 1: Cancel all contract orders
+    const cancelParamsMode1 = {
+        fromAddress: adminAddress,
+        isContract: 0,
+        offeredPropertyId: 5, // Replace with the correct property ID
+        desiredPropertyId: 4, // Replace with the correct property ID
+        cancelAll: true,
+    };
+
+    //await TxUtils.createCancelTransaction(adminAddress, cancelParamsMode1, 6);
+
+    // Mode 2: Cancel a specific contract order by txid
+    const cancelParamsMode2 = {
+        fromAddress: adminAddress,
+        isContract: 1,
+        contractId: 1, // Replace with the correct property ID
+        cancelAll: 0,
+        cancelParams: {
+            txid: '8b146ed06d51a7856e3f27ba1d0d80229b34885cbc63784a2c1051de1ccdc37b', // Replace with the actual txid
+        },
+    };
+
+    //await TxUtils.createCancelTransaction(adminAddress, cancelParamsMode2, 6);
+
+    // Mode 3: Cancel contract buy orders above 0.5
+    const cancelParamsMode3Buy = {
+        fromAddress: adminAddress,
+        isContract: 0,
+        offeredPropertyId: 3, // Replace with the correct property ID
+        desiredPropertyId: 4, // Replace with the correct property ID
+        cancelAll: 0,
+        cancelParams: {
+            price: 0.5,
+            side: 1,
+        },
+    };
+
+    //await TxUtils.createCancelTransaction(adminAddress, cancelParamsMode3Buy, 6);
+
+    // Mode 4: Cancel contract sell orders below 0.48
+    const cancelParamsMode4Sell = {
+        fromAddress: adminAddress,
+        isContract: 1,
+        contractId: 1, // Replace with the correct property ID
+        cancelAll: 1/*,
+        cancelParams: {
+            price: 42500, // Replace with the actual price
+            side: 0,
+        },*/
+    };
+
+    await TxUtils.createCancelTransaction(adminAddress, cancelParamsMode1, 6);
+}
+
+// Call the asynchronous function
+cancelOrders();

package/tradelayer.js/tests/contractInterfaceTest.js

@@ -0,0 +1,48 @@
+const adminAddress = "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8";
+
+async function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+const expressInterface = require('../src/walletInterface.js');
+
+async function runTest() {
+    await expressInterface.initMain();
+           await delay(1000)
+
+    /*const address = 'tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk';
+    const contractId = 1; // example contract ID
+
+    const balance2 = await expressInterface.getAllBalancesForAddress('tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk');
+     console.log(`Balance for tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk:`, balance2);
+
+     const balance3 = await expressInterface.getAllBalancesForAddress('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8');
+     console.log(`Balance for tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8:`, balance3);
+    
+    // New calls
+    const contractSeries = await expressInterface.listContractSeries();
+    console.log('Contract Series:', contractSeries);
+
+    const oracles = await expressInterface.listOracles();
+    console.log('Oracles:', oracles);
+
+    // Get contract position for the address
+    const contractPosition = await expressInterface.getContractPositionForAddressAndContractId(address, contractId);
+    console.log(`Contract Position for Address ${address} and Contract ID ${contractId}:`, contractPosition);
+
+    // Get trade history for the contract
+    const contractTradeHistory = await expressInterface.getContractTradeHistory(contractId);
+    console.log(`Trade History for Contract ID ${contractId}:`, contractTradeHistory);
+
+     // Load order books
+    const orderBook1 = await expressInterface.getContractOrderBook(1);
+    console.log('Order Book for Contract ID 1:', orderBook1);
+
+    const trades = await expressInterface.getContractTradeHistory(1)
+    console.log('trade history '+trades)
+    */
+
+
+}
+
+runTest();

package/tradelayer.js/tests/decimalTest.js

@@ -0,0 +1,65 @@
+const BigNumber = require('bignumber.js');
+
+// Function to encode using BigNumber and base-36
+function encodeTradeTokenForUTXO(params) {
+    console.log('--- Encoding ---');
+    console.log('Input Amount:', params.amountOffered);
+
+    // Use BigNumber for precision and convert to base-36
+    const amount = new BigNumber(params.amountOffered).toString(36);
+    console.log('Amount in base-36:', amount);
+
+    const payload = [
+        params.propertyId.toString(36),
+        amount,
+        params.columnA ? '1' : '0',
+        params.satsExpected.toString(36),
+        params.tokenOutput.toString(36),
+        params.payToAddress.toString(36)
+    ];
+
+    console.log('Encoded Payload:', payload.join(','));
+    return payload.join(',');
+}
+
+// Function to decode back to original value
+function decodeTradeTokenForUTXO(payload) {
+    console.log('--- Decoding ---');
+    console.log('Payload:', payload);
+
+    const parts = payload.split(',');
+
+    // Decode the amount using BigNumber and base-36
+    const amount = new BigNumber(parts[1], 36).toNumber();
+    console.log('Decoded Amount:', amount);
+
+    return {
+        propertyId: parseInt(parts[0], 36),
+        amount: amount, // This should now return the correct value
+        columnA: parts[2] === '1',
+        satsExpected: parseInt(parts[3], 36),
+        tokenOutput: parseInt(parts[4], 36),
+        payToAddress: parseInt(parts[5], 36)
+    };
+}
+
+// Test with the 0.1 that is causing issues in the larger codebase
+const testInput = {
+    propertyId: 1,
+    amountOffered: 0.1,
+    columnA: true,
+    satsExpected: 1000,
+    tokenOutput: 2,
+    payToAddress: 3
+};
+
+// Encode the test input
+console.log('Encoding test input...');
+const encoded = encodeTradeTokenForUTXO(testInput);
+
+// Decode it back to see if we get the original values
+console.log('Decoding test input...');
+const decoded = decodeTradeTokenForUTXO(encoded);
+
+console.log('--- Final Decoded Object ---');
+console.log(decoded);

package/tradelayer.js/tests/decoderTest.js

@@ -0,0 +1,100 @@
+const Litecoin = require('litecoin'); // Import the litecoin npm package
+const util = require('util')
+
+// Litecoin client configuration
+const client = new Litecoin.Client({
+    host: 'localhost',  // Replace with your Litecoin node's host if different
+    port: 18332,        // The port to connect to (RPC port for Litecoin)
+    user: 'user', // Replace with your Litecoin RPC username
+    pass: 'pass', // Replace with your Litecoin RPC password
+    timeout: 30000       // Optional: adjust as needed
+});
+
+const block = 3496378
+
+function getBlockHash(height) {
+    return util.promisify(client.cmd.bind(client, 'getblockhash'))(height);
+  }
+
+function  getrawtransaction(...params) {
+    return util.promisify(client.cmd.bind(client, 'getrawtransaction'))(...params);
+  }
+// Replace with actual method to get raw transaction from txid
+async function fetchTransactionData(txId, verbose, block) {
+        console.log(block)
+        const blockHash = await getBlockHash(block)
+       
+            const transaction = await getrawtransaction(txId, verbose, blockHash );
+            const decodedTx = await DecodeRawTransaction(transaction,true)
+    }
+
+
+    async function DecodeRawTransaction(thisTx,flag) {
+        try {
+            //const decodedTx = await this.client.decoderawtransaction(rawTx);
+            
+
+            const opReturnOutput = thisTx.vout.find(output => output.scriptPubKey.type === 'nulldata');
+
+            console.log(thisTx.vout)
+
+
+            if (opReturnOutput) {
+                console.log('op return ' +opReturnOutput)
+                const opReturnData = opReturnOutput.scriptPubKey.hex;
+                if(flag){console.log('OP_RETURN Data:', opReturnData)};
+                // Extract and log the "tl" marker
+
+                 // Check if the hex contains the marker "746c" (which corresponds to "tl")
+                let markerHex = "746c"; // Hex for "tl"
+                let payloadStart =8
+                let markerPosition = opReturnData.indexOf(markerHex); // Check if the marker is anywhere in the string
+                if(flag){console.log('marker position '+markerPosition)}
+                if (markerPosition === -1||markerPosition>6) {
+                    //console.error('Marker "tl" not found in OP_RETURN data');
+                    return null;
+                }else if(markerHex = opReturnData.substring(4, 8)){
+                    payloadStart= 8
+                }else if(markerHex==opReturnData.substring(5, 9)){
+                    payloadStart= 9
+                }else if(markerHex==opReturnData.substring(6,10)){
+                    payloadStart=10
+                }; // '746c' for 'tl'
+                let marker = Buffer.from(markerHex, 'hex').toString();
+                if(flag){console.log('checking marker '+marker+ ' payload start '+payloadStart)}
+                // Extract and log the actual payload
+                const payloadHex = opReturnData.substring(payloadStart);
+                const payload = Buffer.from(payloadHex, 'hex').toString();
+                console.log('market data ' +markerHex+' '+marker+' '+payload)
+                if(marker=='tl'){console.log('Pre-decoded and Decoded Payload:', opReturnData + ' ' + payload+ ' decoding the whole thing '+Buffer.from(opReturnData, 'hex').toString())};
+                return { marker, payload , decodedTx};
+            } else {
+                //console.log('No OP_RETURN output found.');
+                return null;
+            }
+            // Process decoded transaction logic here...
+            return decodedTx;
+        } catch (error) {
+            //console.error('Error decoding raw transaction:', error);
+        }
+    }
+
+
+// Main function to test the txId
+async function testTxId(txId) {
+    // Fetch the raw transaction data
+    const rawTxHex = await fetchTransactionData(txId, true, block);
+
+    if (!rawTxHex) {
+        console.log('No raw transaction data found for txId:', txId);
+        return;
+    }
+
+    // Decode the raw transaction and check for the OP_RETURN marker
+    console.log(`Testing txId: ${txId}`);
+    await decodeTransaction(rawTxHex);
+}
+
+// Test the transaction by its txId
+const txId = 'bc395db7a7a11b42e9711e192a860da2fffe64955cae6dd673e267532f328b3d'; // Replace with your txId
+testTxId(txId);

package/tradelayer.js/tests/deltaCount.js

@@ -0,0 +1,47 @@
+const dbInstance = require('./db');
+
+// Load tallyMapDelta database
+const tallyMapDeltaDB = dbInstance.getDatabase('tallyMapDelta');
+
+// Function to tally amounts and calculate balance for each type
+async function calculateBalanceForAddress(address) {
+    try {
+        // Find all delta records for the given address
+        const deltaRecords = await tallyMapDeltaDB.findAsync({ 'data.address': address });
+
+        // Create a map to store counts for each type
+        const typeCounts = {};
+
+        // Iterate through delta records and tally counts for each type
+        deltaRecords.forEach(delta => {
+            const { type } = delta.data;
+
+            // Update type count
+            typeCounts[type] = (typeCounts[type] || 0) + 1;
+        });
+
+        // Sort type counts by type
+        const sortedTypeCounts = Object.entries(typeCounts).sort((a, b) => {
+            const typeA = a[0].toUpperCase(); // ignore case
+            const typeB = b[0].toUpperCase();
+            return typeA.localeCompare(typeB);
+        });
+
+        // Display sorted type counts
+        console.log(`Type counts for address ${address}:`);
+        sortedTypeCounts.forEach(([type, count]) => {
+            console.log(`${type}: ${count}`);
+        });
+
+        return sortedTypeCounts;
+    } catch (error) {
+        console.error('Error calculating balance:', error);
+        throw error;
+    }
+}
+
+// Example: Replace 'your_address_here' with the actual address you want to calculate the balance for
+const addressToCalculate = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8';
+
+// Call the function to calculate and display the type counts
+calculateBalanceForAddress(addressToCalculate);