@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/oldTests/testNewEncoding2.js

@@ -0,0 +1,113 @@
+// Encode the transaction to base 256
+function encodeOmniTransaction(type, params) {
+  const payload = [type];
+
+  switch (type) {
+    case 1:
+      payload.push(params.initialAmount.toString(16)); // Convert integer to hex
+      payload.push(params.ticker);
+      payload.push(params.whitelists || 0);
+      break;
+    case 2:
+      payload.push(params.propertyId.toString(16)); // Convert integer to hex
+      payload.push(params.amount.toString(16)); // Convert integer to hex
+      break;
+    case 3:
+      payload.push(params.propertyId.toString(16)); // Convert integer to hex
+      payload.push(params.amount.toString(16)); // Convert integer to hex
+      payload.push(params.satsExpected.toString(16)); // Convert integer to hex
+      break;
+    case 4:
+      payload.push(params.propertyId.toString(16)); // Convert integer to hex
+      payload.push(params.amount.toString(16)); // Convert integer to hex
+      break;
+    case 5:
+      payload.push(params.propertyId.toString(16)); // Convert integer to hex
+      payload.push(params.propertyIdDesired.toString(16)); // Convert integer to hex
+      payload.push(params.amountOffered.toString(16)); // Convert integer to hex
+      payload.push(params.amountExpected.toString(16)); // Convert integer to hex
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  // Join all the elements of the payload into a single string, separated by commas
+  const encodedPayload = payload.join(',');
+
+  return encodedPayload;
+}
+
+// Decode the base 256 payload to a transaction object
+function decodeOmniTransaction(encodedPayload) {
+  if (encodedPayload.startsWith("tl")) {
+    encodedPayload = encodedPayload.substr(2); // Remove the "tl" marker
+  }
+
+  const parts = encodedPayload.split(',');
+
+  const type = parseInt(parts[0], 10); // Parse the type as a regular integer
+  const params = {};
+
+  let index = 1;
+
+  switch (type) {
+    case 1:
+      params.initialAmount = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.ticker = parts[index];
+      index++;
+      params.whitelists = parts.slice(index).map(value => parseInt(value, 10));
+      break;
+    case 2:
+      params.propertyId = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.amount = parseInt(parts[index], 16); // Convert hex to integer
+      break;
+    case 3:
+      params.propertyId = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.amount = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.satsExpected = parseInt(parts[index], 16); // Convert hex to integer
+      break;
+    case 4:
+      params.propertyId = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.amount = parseInt(parts[index], 16); // Convert hex to integer
+      break;
+    case 5:
+      params.propertyId = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.propertyIdDesired = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.amountOffered = parseInt(parts[index], 16); // Convert hex to integer
+      index++;
+      params.amountExpected = parseInt(parts[index], 16); // Convert hex to integer
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  return { type, params };
+}
+
+// Logic test: Check if the encoded payload is <= 40 bytes
+function isPayloadSizeValid(encodedPayload) {
+  return encodedPayload.length <= 40;
+}
+
+// Example Usage:
+const tx = encodeOmniTransaction(1, {
+  propertyId: 12342,
+  initialAmount: 10000557964,
+  ticker: "TOKEN",
+  whitelists: [122, 234, 612, 1212312]
+});
+
+const encodedPayloadWithMarker = `tl${tx}`; // Prepend "tl" marker
+
+console.log("Encoded Payload with Marker:", encodedPayloadWithMarker);
+console.log("Is Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker));
+
+const decodedTx = decodeOmniTransaction(encodedPayloadWithMarker.substr(2)); // Remove the "tl" marker when decoding
+console.log("Decoded Transaction:", decodedTx);

package/tradelayer.js/oldTests/testNewEncoding3

@@ -0,0 +1,112 @@
+const bs58 = require('bs58');
+
+// Encode the transaction to base 256
+function encodeOmniTransaction(type, params) {
+  const payload = [type];
+
+  switch (type) {
+    case 1:
+      payload.push(bs58.encode(Buffer.from(params.initialAmount.toString(), 'hex')));
+      payload.push(params.ticker.length); // Include the length of the ticker
+      payload.push(bs58.encode(Buffer.from(params.ticker, 'utf8'))); // Convert ticker to base 58
+      payload.push(params.whitelists || 0);
+      break;
+    case 2:
+      payload.push(bs58.encode(Buffer.from(params.propertyId.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.amount.toString(), 'hex')));
+      break;
+    case 3:
+      payload.push(bs58.encode(Buffer.from(params.propertyId.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.amount.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.satsExpected.toString(), 'hex')));
+      break;
+    case 4:
+      payload.push(bs58.encode(Buffer.from(params.propertyId.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.amount.toString(), 'hex')));
+      break;
+    case 5:
+      payload.push(bs58.encode(Buffer.from(params.propertyId.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.propertyIdDesired.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.amountOffered.toString(), 'hex')));
+      payload.push(bs58.encode(Buffer.from(params.amountExpected.toString(), 'hex')));
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  // Join all the elements of the payload into a single string, separated by commas
+  const encodedPayload = payload.map(item => item.toString()).join(',');
+
+  return encodedPayload;
+}
+
+// Decode the base 256 payload to a transaction object
+function decodeOmniTransaction(encodedPayload) {
+  if (encodedPayload.startsWith("tl")) {
+    encodedPayload = encodedPayload.substr(2); // Remove the "tl" marker
+  }
+
+  const parts = encodedPayload.split(',');
+
+  const type = parseInt(parts[0], 10); // Parse the type as a regular integer
+  const params = {};
+
+  let index = 1;
+
+  switch (type) {
+    case 1:
+      params.initialAmount = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      const tickerLength = parseInt(parts[index], 10);
+      index++;
+      params.ticker = bs58.decode(parts[index]).toString('utf8');
+      index++;
+      params.whitelists = parseInt(parts[index], 10);
+      break;
+    case 2:
+      params.propertyId = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.amount = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      break;
+    case 3:
+      params.propertyId = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.amount = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.satsExpected = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      break;
+    case 4:
+      params.propertyId = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.amount = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      break;
+    case 5:
+      params.propertyId = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.propertyIdDesired = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.amountOffered = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      index++;
+      params.amountExpected = parseInt(bs58.decode(parts[index]).toString('hex'), 16);
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  return { type, params };
+}
+
+// Example Usage:
+const tx = encodeOmniTransaction(1, {
+  initialAmount: 557964,
+  ticker: "TOKEN",
+  whitelists: [2, 4, 6, 12],
+});
+
+const encodedPayloadWithMarker = `tl${tx}`; // Prepend "tl" marker
+
+console.log("Encoded Payload with Marker:", encodedPayloadWithMarker);
+console.log("Is Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker));
+
+const decodedTx = decodeOmniTransaction(encodedPayloadWithMarker.substr(2)); // Remove the "tl" marker when decoding
+console.log("Decoded Transaction:", decodedTx);

package/tradelayer.js/oldTests/testNewEncoding3.js

@@ -0,0 +1,168 @@
+f// Encode the transaction to base 256
+function encodeOmniTransaction(type, params) {
+  const payload = [type];
+
+  switch (type) {
+    case 1:
+      payload.push(params.initialAmount.toString(36)); // Convert integer to hex
+      payload.push(params.ticker);
+      payload.push(params.whitelists.map(val => val.toString(36)).join(',')); // Convert integers to hex and join with commas
+      break;
+    case 2:
+      payload.push(params.propertyId.toString(36)); // Convert integer to hex
+      payload.push(params.amount.toString(36)); // Convert integer to hex
+      break;
+    case 3:
+      payload.push(params.propertyId.toString(36)); // Convert integer to hex
+      payload.push(params.amount.toString(36)); // Convert integer to hex
+      payload.push(params.satsExpected.toString(36)); // Convert integer to hex
+      break;
+    case 4:
+      payload.push(params.propertyId.toString(36)); // Convert integer to hex
+      payload.push(params.amount.toString(36)); // Convert integer to hex
+      break;
+    case 5:
+      payload.push(params.propertyId.toString(36)); // Convert integer to hex
+      payload.push(params.propertyIdDesired.toString(36)); // Convert integer to hex
+      payload.push(params.amountOffered.toString(36)); // Convert integer to hex
+      payload.push(params.amountExpected.toString(36)); // Convert integer to hex
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  // Join all the elements of the payload into a single string, separated by commas
+  const encodedPayload = payload.join(',');
+
+  return encodedPayload;
+}
+
+// Decode the base 256 payload to a transaction object
+function decodeOmniTransaction(encodedPayload) {
+  if (encodedPayload.startsWith("tl")) {
+    encodedPayload = encodedPayload.substr(2); // Remove the "tl" marker
+  }
+
+  const parts = encodedPayload.split(',');
+
+  const type = parseInt(parts[0], 16); // Parse the type as a hex integer
+  const params = {};
+
+  let index = 1;
+
+  switch (type) {
+    case 1:
+      params.initialAmount = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.ticker = parts[index];
+      index++;
+      params.whitelists = [];
+      while (index < parts.length) {
+        params.whitelists.push(parseInt(parts[index], 36)); // Convert hex to integer
+        index++;
+      }
+      break;
+    case 2:
+      params.propertyId = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.amount = parseInt(parts[index], 36); // Convert hex to integer
+      break;
+    case 3:
+      params.propertyId = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.amount = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.satsExpected = parseInt(parts[index], 36); // Convert hex to integer
+      break;
+    case 4:
+      params.propertyId = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.amount = parseInt(parts[index], 36); // Convert hex to integer
+      break;
+    case 5:
+      params.propertyId = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.propertyIdDesired = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.amountOffered = parseInt(parts[index], 36); // Convert hex to integer
+      index++;
+      params.amountExpected = parseInt(parts[index], 36); // Convert hex to integer
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  return { type, params };
+}
+
+// Logic test: Check if the encoded payload is <= 40 bytes
+function isPayloadSizeValid(encodedPayload) {
+  return encodedPayload.length <= 40;
+}
+
+// Function to prepend "tl" marker to encoded payload
+function prependTlMarker(encodedPayload) {
+  return `tl${encodedPayload}`;
+}
+
+// Test Cases
+const tx1 = encodeOmniTransaction(1, {
+  propertyId: 12342,
+  initialAmount: 10000.557964,
+  ticker: "TOKEN",
+  whitelists: [122, 234, 612, 1212312]
+});
+
+const encodedPayloadWithMarker1 = prependTlMarker(tx1);
+
+const tx2 = encodeOmniTransaction(2, {
+  propertyId: 54321,
+  amount: 87654321.00000000,
+});
+
+const encodedPayloadWithMarker2 = prependTlMarker(tx2);
+
+const tx3 = encodeOmniTransaction(3, {
+  propertyId: 98765,
+  amount: 12345678.00000000,
+  satsExpected: 8765432,
+});
+
+const encodedPayloadWithMarker3 = prependTlMarker(tx3);
+
+const tx4 = encodeOmniTransaction(4, {
+  propertyId: 13579,
+  amount: 246813579.00000000,
+});
+
+const encodedPayloadWithMarker4 = prependTlMarker(tx4);
+
+const tx5 = encodeOmniTransaction(5, {
+  propertyId: 11111,
+  propertyIdDesired: 99999,
+  amountOffered: 123456789.00000000,
+  amountExpected: 87654322334.00000000,
+});
+
+const encodedPayloadWithMarker5 = prependTlMarker(tx5);
+
+// Display Test Results
+console.log("Encoded Transaction 1:", encodedPayloadWithMarker1);
+console.log("Is Transaction 1 Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker1));
+console.log("Decoded Transaction 1:", decodeOmniTransaction(encodedPayloadWithMarker1).params);
+
+console.log("Encoded Transaction 2:", encodedPayloadWithMarker2);
+console.log("Is Transaction 2 Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker2));
+console.log("Decoded Transaction 2:", decodeOmniTransaction(encodedPayloadWithMarker2).params);
+
+console.log("Encoded Transaction 3:", encodedPayloadWithMarker3);
+console.log("Is Transaction 3 Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker3));
+console.log("Decoded Transaction 3:", decodeOmniTransaction(encodedPayloadWithMarker3).params);
+
+console.log("Encoded Transaction 4:", encodedPayloadWithMarker4);
+console.log("Is Transaction 4 Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker4));
+console.log("Decoded Transaction 4:", decodeOmniTransaction(encodedPayloadWithMarker4).params);
+
+console.log("Encoded Transaction 5:", encodedPayloadWithMarker5);
+console.log("Is Transaction 5 Payload Size Valid:", isPayloadSizeValid(encodedPayloadWithMarker5));
+console.log("Decoded Transaction 5:", decodeOmniTransaction(encodedPayloadWithMarker5).params);

package/tradelayer.js/oldTests/testOPReturn.js

@@ -0,0 +1,102 @@
+const litecoin = require('litecoin');
+
+const client = new litecoin.Client({
+    host: '127.0.0.1',
+    port: 8332, // Litecoin RPC port (default is 9332)
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+var hasOPReturn= true;
+var payload =""
+var payload2= ""
+var senderVout =0
+
+const tx = "70d0cc07326bd1c55dbada54217d211933f1eef59fefd869aa12dfeb9fd6347d";
+
+console.log("Fetching raw transaction...");
+
+/*client.cmd('createwallet',function(err,wallet){
+	console.log(wallet)
+})*/
+
+client.getRawTransaction(tx, true, function (err, rawtx) {
+    if (err) {
+        console.error("Error:", err);
+    } else {
+    	console.log(rawtx)
+    	var confirmations=confirmations
+         for (let v = 0; v < rawtx.vout.length; v++) {
+          console.log(v)
+          var vout = rawtx.vout[v];
+          var ASMstring = vout.scriptPubKey.asm.slice(0,9);
+          payload2=JSON.stringify(rawtx.vout[2].scriptPubKey.asm)
+          console.log(ASMstring)
+          if (ASMstring === "OP_RETURN" && confirmations >= 1) {
+          	hasOPReturn=true
+            var payload = vout.scriptPubKey.asm.slice(11,vout.scriptPubKey.asm.length);
+            console.log(payload)           
+            var marker =decode(payload.slice(0,1))
+
+            var txObj = { tx: tx, payload: payload, marker: marker };
+            console.log(decodedPayload,marker,txObj)
+            if (marker === "om") {
+              marker = payload.slice(0,3)
+              txObj.marker=marker
+              payload=payload.slice(4,payload.length)
+              txObj.payload=payload
+              omniTxCount+=1
+              console.log("Omni tx "+omniTxCount)
+              thisBlockOm.push(txObj);
+            }
+            if (marker === "tl") {
+              payload=payload.slice(2,payload.length)
+              txObj.payload=payload
+              thisBlockTl.push(txObj);
+            }
+          } else if (ASMstring === "OP_RETURN" && confirmations === 0) {
+          	hasOPReturn=true
+            var payload = vout.scriptPubKey.asm.split(' ');
+            var decodedPayload = decodeOPReturnPayload(payload);
+            var marker = decodedPayload.slice(0, 1);
+            var txObj = { tx: tx, payload: payload, decode: decode, marker: marker };
+            if (marker === "om" || marker === "tl") {
+              memPool.push(tx);
+            }
+          }
+        }
+        // Parse the sender (first input)
+        const sender = rawtx.vin[0].txid
+        const senderVout = rawtx.vin[0].vout
+
+        // Parse the reference address (second output)
+        const referenceAddress = rawtx.vout[1].scriptPubKey.addresses[0]
+        const referenceValue = rawtx.vout[1].value;
+
+        const changeAddress=rawtx.vout[0].scriptPubKey.addresses[0]
+        const changeValue = rawtx.vout[0].value;
+
+
+        console.log('Sender:', sender);
+        console.log('Reference Address:', referenceAddress);
+        console.log('Reference Value (Satoshi):', referenceValue);
+        console.log('Change Address:', changeAddress);
+        console.log('Change Value (Satoshi):', changeValue);
+
+        if (hasOPReturn) {
+            console.log('OP_Return Output Data:', payload2.slice(10,payload2.length-1) );
+            const stringBuffer = Buffer.from(payload2.slice(10,payload2.length-1), 'hex');
+            console.log(stringBuffer)
+			const text = stringBuffer.toString('utf8');
+			console.log("decoded hex: "+text);
+        } else {
+            console.log('No OP_Return Output found in the transaction.');
+        }
+
+        client.getRawTransaction(sender, true, function(err,rawtx){
+        	var senderAddress=rawtx.vout[senderVout].scriptPubKey.addresses[0]
+        	console.log("Sender Address "+senderAddress)
+        })
+    }
+});

package/tradelayer.js/oldTests/testPayload.js

@@ -0,0 +1,23 @@
+function testPayloadSeparation(hexPayload) {
+    // Decode from hex to plaintext
+    const asmBuffer = new Buffer(hexPayload, "hex");
+    const message =  asmBuffer.toString();
+    console.log(message);
+    // Assuming the payload format is 'tlXX' where XX are digits
+    if (!plaintextPayload.startsWith('tl')) {
+        throw new Error('Invalid payload');
+    }
+
+    const marker = plaintextPayload.substring(0, 2); // 'tl'
+    const restOfPayload = plaintextPayload.substring(2); // '00' in this case
+
+    const transactionId = restOfPayload.charAt(0); // First '0'
+    const otherData = restOfPayload.substring(1); // Second '0'
+
+    console.log(`Marker: ${marker}`);
+    console.log(`Transaction ID: ${transactionId}`);
+    console.log(`Other Data: ${otherData}`);
+}
+
+// Example usage
+testPayloadSeparation('808479860');

package/tradelayer.js/oldTests/testRaw.js

@@ -0,0 +1,50 @@
+const Litecoin = require('litecoin'); // Replace with actual library import
+const async = require('async')
+const STANDARD_FEE = 0.0001; // Standard fee in LTC
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+const util = require('util');
+// ... rest of your setup ...
+
+// Promisify the createRawTransaction function
+client.createRawTransaction = util.promisify(client.createRawTransaction);
+
+async function createRawTransaction() {
+    try {
+        const inputs = [{
+            "txid": "57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5",
+            "vout": 1
+        }];
+
+        // Specify the output with the address and amount (example amount here is 0.01 LTC)
+        const outputs = {
+            "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8": 0.01
+        };
+
+        const rawTx = await client.createRawTransaction(inputs, outputs);
+        if (rawTx) {
+            console.log('Raw Transaction:', rawTx);
+        } else {
+            console.log('Raw Transaction is undefined. Check if litecoind is running and accepting RPC commands.');
+        }
+        return rawTx;
+    } catch (error) {
+        console.error('Error creating raw transaction:', error);
+    }
+}
+
+createRawTransaction();
+
+
+/*client.createRawTransaction([{txid:"57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5",vout:1}],[{
+            "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8": 0.01
+        }],function(err,data){
+    if(err){console.log(err)}
+    console.log(data)
+})*/

package/tradelayer.js/oldTests/testSendTooMuch.js

@@ -0,0 +1,20 @@
+const Logic = require('./Logic'); // Assuming Logic is the module with your business logic
+const TxUtils = require('./TxUtils'); // Assuming TxUtils contains your utility functions
+
+async function testSendLargeAmount() {
+    // Initialize components
+    const adminAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; // Replace with actual admin address
+    const TLVESTPropertyId = 2; // Assuming TLVEST has property ID 2
+    const largeAmount = 2000000;
+    // Send a large amount of TLVEST from admin address
+    try {
+        const sendTxId = await TxUtils.sendTransaction(adminAddress, 'LNmiS6p8z3KuHHx3q6Jf6x6TfcyptE68oP', TLVESTPropertyId, largeAmount, false);
+        console.log('Send Transaction ID:', sendTxId);
+    } catch (error) {
+        console.log('Expected error:', error.message);
+        // Assertions (pseudo-code)
+        // assert(error.message.includes('Insufficient balance'), 'Transaction should be invalid due to insufficient balance');
+    }
+}
+
+testSendLargeAmount();

package/tradelayer.js/oldTests/testTxBuild

@@ -0,0 +1,28 @@
+const Litecoin = require('litecoin'); // Replace with actual library import
+const util = require('util');
+const bitcore = require('bitcore-lib-ltc');
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+
+var privateKey = new litecore.PrivateKey('L1uyy5qTuGrVXrmrsvHWHgVzW9kKdrp27wBC7Vs6nZDTF2BRUVwy');
+var utxo = {
+  "txId" : "115e8f72f39fad874cfab0deed11a80f24f967a84079fb56ddf53ea02e308986",
+  "outputIndex" : 0,
+  "address" : "17XBj6iFEsf8kzDMGQk5ghZipxX49VXuaV",
+  "script" : "76a91447862fe165e6121af80d5dde1ecb478ed170565b88ac",
+  "satoshis" : 50000
+};
+
+var transaction = new litecore.Transaction()
+  .from(utxo)
+  .to('tltc1qq95gckx4lg8c9pvcajh5kgg5ahdk5t6mjyyynl', 15000)
+  .sign(privateKey);
+
+

package/tradelayer.js/oldTests/testTxBuild.js

@@ -0,0 +1,42 @@
+const Litecoin = require('litecoin'); // Replace with actual library import
+const util = require('util');
+const litecore = require('bitcore-lib-ltc');
+const txUtils = require('C:/projects/tradelayer.js/txUtilsA.js')
+const fee = 1000
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+const sendrawtransactionAsync = util.promisify(client.cmd.bind(client, 'sendrawtransaction'));
+
+
+//var privateKey = new litecore.PrivateKey('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8');
+
+
+async function main(){
+	 // Define the minimum amount in satoshis
+    const minAmountSatoshis = 15000; // Adjust this value as needed
+
+    // Find a suitable UTXO
+    var utxo = await txUtils.findSuitableUTXO('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8', minAmountSatoshis);
+	console.log(utxo)
+	var transaction = new litecore.Transaction()
+		  .from(utxo)
+		  .to('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8', 14000)
+		  .addData('litecore rocks')
+		  .change('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8')
+		  .fee(fee)
+		  .sign('cNGCJhHBSQM2Kedc8Zc6x9VYe9dQuvanqfS61D3tczZnDD3HwYUW');
+	const serializedTx = transaction.serialize();
+	const txid = await sendrawtransactionAsync(serializedTx);
+	console.log(txid)
+
+}
+
+
+main()