@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/utils/sendActivation.js

@@ -0,0 +1,21 @@
+//const PropertyManager = require('./property.js');
+//const TallyMap = require('./tally.js');
+//const Logic = require('./logic.js');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('../src/txUtils');
+
+function generateNewAddress() {
+    const privateKey = new litecore.PrivateKey(); // Generate a new private key
+    const address = privateKey.toAddress(); // Generate the address from the private key
+    return {
+        address: address.toString(),
+        privateKey: privateKey.toString()
+    };
+}
+
+    //const { address, privateKey } = generateNewAddress();
+    //console.log('Generated new address:', address);
+
+    TxUtils.activationTransaction('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8',9)
+
+

package/tradelayer.js/utils/sendChannelContractTrade.js

@@ -0,0 +1,34 @@
+const PropertyManager = require('./property.js');
+const TallyMap = require('./tally.js');
+const Logic = require('./logic.js');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('./txUtils');
+const TxIndex = require('./txIndex.js')
+
+async function executeTransaction() {
+    const chainTip = await TxIndex.fetchChainTip();
+
+    let params = {
+        contractId: 1,
+        price: 45000,
+        amount: 1,
+        columnAIsSeller: '1',
+        expiryBlock: chainTip + 10,
+        insurance: '0'
+    };
+
+    // Function to generate a random number within a range
+    function randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    var random = randomNumber(20000, 50000);
+    console.log('creating contract channel trade - params: '+JSON.stringify(params))
+    TxUtils.createChannelContractTradeTransaction('tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk', params, null);
+}
+
+// Call the async function
+executeTransaction();
+
+//tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8
+//tltc1qpgenrwmg9hxgv23mnvd2t7085prjkge2xw7myz

package/tradelayer.js/utils/sendChannelTokenTrade.js

@@ -0,0 +1,34 @@
+const PropertyManager = require('./property.js');
+const TallyMap = require('./tally.js');
+const Logic = require('./logic.js');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('./txUtils');
+const TxIndex = require('./txIndex.js')
+
+async function executeTransaction() {
+    const chainTip = await TxIndex.fetchChainTip();
+
+    let params = {
+		propertyId1: 3,
+	    propertyId2: 4,
+	    amountOffered1: 100,
+	    amountDesired2: 50,
+	    expiryBlock:chainTip+10,
+        columnAIsOfferer: 0
+	}
+    // Function to generate a random number within a range
+    function randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    var random = randomNumber(20000, 50000);
+
+    TxUtils.createChannelTokenTradeTransaction('tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk', params, null);
+}
+
+// Call the async function
+executeTransaction();
+
+
+    //const { address, privateKey } = generateNewAddress();
+    //console.log('Generated new address:', address);

package/tradelayer.js/utils/sendCommit.js

@@ -0,0 +1,24 @@
+const PropertyManager = require('./property.js');
+const TallyMap = require('./tally.js');
+const Logic = require('./logic.js');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('./txUtils');
+
+let params = {
+    propertyId:'s-5-4',
+    amount:1,
+    channelAddress:'tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m'
+}
+    //const { address, privateKey } = generateNewAddress();
+    //console.log('Generated new address:', address);
+
+// Function to generate a random number within a range
+function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+var random = randomNumber(20000,50000)
+
+    TxUtils.createCommitTransaction('tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m',params,4)
+//tltc1qpgenrwmg9hxgv23mnvd2t7085prjkge2xw7myz
+//

package/tradelayer.js/utils/sendDoge.js

@@ -0,0 +1,62 @@
+const dogecore = require("bitcore-lib-doge");
+
+function createTransaction({ senderAddress, privateKeyWIF, recipientAddress, amountToSend, utxos, fee }) {
+  try {
+    // Convert amount to send and fee to satoshis
+    const satoshisToSend = Math.floor(amountToSend * 1e8);
+    const transactionFee = Math.floor(fee * 1e8);
+
+    // Validate UTXOs
+    const totalInputSatoshis = utxos.reduce((acc, utxo) => acc + utxo.satoshis, 0);
+    if (totalInputSatoshis < satoshisToSend + transactionFee) {
+      throw new Error("Insufficient funds for the transaction.");
+    }
+
+    // Create a new transaction
+    const tx = new dogecore.Transaction()
+      .from(utxos) // Add the UTXOs as inputs
+      .to(recipientAddress, satoshisToSend) // Specify the recipient and amount
+      .change(senderAddress) // Specify the change address
+      .fee(transactionFee) // Set the transaction fee
+      .sign(privateKeyWIF); // Sign the transaction with the sender's private key
+
+    // Return the serialized raw transaction hex
+    return tx.toString();
+  } catch (error) {
+    console.error("Error creating transaction:", error.message);
+    return null;
+  }
+}
+
+// Example usage
+const senderAddress = "DLSfu9qvEggkeXAgCAwBBw5BVLvMCtkewz"; // Replace with your Dogecoin address
+const privateKeyWIF = "QW4UD1gNJcYGBPLBGpwTsXKoeVntaT9oNEV1ZU96zTfxc712cwAH"; // Replace with the private key in WIF format
+const recipientAddress = "DNWszyeJFD3qX51cCCDZcBKxnTpbN2N8Sh"; // Replace with recipient's Dogecoin address
+const amountToSend = 6.0; // Amount of Doge to send
+const fee = 1; // Transaction fee in Doge
+
+// Replace this with actual UTXOs from your wallet
+const utxos = [
+  {
+    txId: "fc1835fe96922e6540f614b51b5bcc444db2b860b061ae869ab8aaa41cbbdd6f",
+    outputIndex: 0,
+    address: senderAddress,
+    script: "76a914a7dcce4bf35b50dbe9da38e5dc6758b7ab78ae5a88ac",
+    satoshis: 700000000, // 7 Doge in satoshis
+  },
+];
+
+const rawTx = createTransaction({
+  senderAddress,
+  privateKeyWIF,
+  recipientAddress,
+  amountToSend,
+  utxos,
+  fee,
+});
+
+if (rawTx) {
+  console.log("Raw Transaction Hex:", rawTx);
+} else {
+  console.error("Failed to create transaction.");
+}

package/tradelayer.js/utils/sendDogeMain.js

@@ -0,0 +1,67 @@
+const dogecore = require("bitcore-lib-doge"); // Dogecoin library
+const Encode = require("../src/txEncoder.js");
+
+// Constants
+const STANDARD_FEE = 250000; // 0.01 DOGE in satoshis
+const DUST_THRESHOLD = 1000000; // 0.01 DOGE in satoshis (dust threshold)
+
+// Function to send Dogecoin
+async function sendDogecoin(senderAddress, recipientAddress, amountToSend) {
+  //try {
+    // Define UTXOs for the sender address
+    const utxos = [
+      {
+        txId: "5144f44bc8cec947eb757ce9377f75f3321f2f0f92cd1e2526526df1179ae744",
+        outputIndex: 0,
+        address: senderAddress,
+        script: "76a914226eae66f1d4da7f47015be99d1c4e2484e39b9c88ac", // P2PKH script
+        satoshis: 78750000, // 0.1 DOGE in satoshis
+      },
+    ];
+
+    // Calculate total input balance
+    const totalInput = utxos.reduce((sum, utxo) => sum + utxo.satoshis, 0);
+
+
+    // Calculate change
+    const change = totalInput - amountToSend - STANDARD_FEE;
+    const out = amountToSend-STANDARD_FEE
+    // Prepare OP_RETURN payload
+    const params = {
+      sendAll: 0,
+      propertyId: 1,
+      amount: 20000000,
+      address: "D7NdPZKMnMo9pdmJik15TLDCSN9rXBFNMa", // Example Dogecoin address
+      isColoredOutput: 0,
+    };
+    const opReturnData = Encode.encodeSend(params);
+    const opReturnScript = dogecore.Script.buildDataOut(opReturnData);
+
+    // Create transaction
+    const tx = new dogecore.Transaction()
+      .from(utxos)
+      .to(recipientAddress, out) // Send specified amount
+      .fee(STANDARD_FEE) // Include transaction fee
+      .addOutput(
+        new dogecore.Transaction.Output({
+          script: opReturnScript,
+          satoshis: 0, // OP_RETURN value must be 0
+        })
+      );
+
+
+    // Serialize transaction
+    const serializedTx = tx.toString();
+    console.log(`Transaction hex: ${serializedTx}`);
+  //} catch (error) {
+    //console.error("Error constructing transaction:", error.message);
+  //}
+}
+
+// Replace with actual values
+const senderAddress = "D8HA73pAhxK7eNXSUVhQrWpUkrszUDGs7Z"; // Example sender address
+const recipientAddress = "D8HA73pAhxK7eNXSUVhQrWpUkrszUDGs7Z"; // Example recipient address
+const amountToSend = 78750000; // 0.09 DOGE in satoshis
+
+// Execute the function
+sendDogecoin(senderAddress, recipientAddress, amountToSend);

package/tradelayer.js/utils/sendDogeTx.js

@@ -0,0 +1,46 @@
+const axios = require('axios');
+
+/**
+ * Broadcasts a Dogecoin transaction using the Tatum API.
+ * 
+ * @param {string} txHex - The raw transaction hex string (signed).
+ * @param {string} apiKey - Your Tatum API key.
+ */
+async function broadcastDogecoinTransaction(txHex, apiKey) {
+    const apiUrl = 'https://api.tatum.io/v3/dogecoin/broadcast';
+
+    try {
+        // Prepare the payload
+        const payload = {
+            txData: txHex
+        };
+
+        // Send the POST request to the Tatum API
+        const response = await axios.post(apiUrl, payload, {
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey // Set your API key in the headers
+            }
+        });
+
+        // Check if the broadcast was successful
+        if (response.status === 200) {
+            console.log("Transaction broadcasted successfully!");
+            console.log("Response:", response.data);
+        } else {
+            console.error(`Failed to broadcast transaction. Status Code: ${response.status}`);
+            console.error("Response:", response.data);
+        }
+    } catch (error) {
+        if (error.response) {
+            console.error("API Response Error:", error.response.data);
+        } else {
+            console.error("Error:", error.message);
+        }
+    }
+}
+
+// Example Usage
+const txHex = "010000000144e79a17f16d5226251ecd920f2f1f32f3757f37e97c75eb47c9cec84bf44451000000006b483045022100a6ea0b1cd9b404030a53fcee8b445a8026bc8337b67d254c77cd7ef4a0193ad30220045f771a506a0b3ddb0dea03379754bf0e2a166ed3a02793c7ef7e7f062eeceb0121034480f60d0010d92fb3e35516e4ddef458c0f7405010afce931488ed1c0570ba6ffffffff02a0d0ad04000000001976a914226eae66f1d4da7f47015be99d1c4e2484e39b9c88ac0000000000000000336a31746c32303b44374e64505a4b4d6e4d6f3970646d4a696b3135544c4443534e39725842464e4d613b313b62776f336b3b3000000000"; // Replace with your signed transaction hex
+const apiKey = "t-6796b068758217afa9cf49ca-93175dba4b9545f3be960d83"; // Replace with your Tatum API key
+broadcastDogecoinTransaction(txHex, apiKey);

package/tradelayer.js/utils/sendLTC.js

@@ -0,0 +1,63 @@
+const async = require('async');
+const util = require('util');
+const litecore = require('bitcore-lib-ltc');
+const Encode = require('../src/txEncoder.js');
+const litecoin = require('litecoin');
+
+const clientConfig = /*test ?*/ {
+            host: '127.0.0.1',
+            port: 18332,
+            user: 'user',
+            pass: 'pass',
+            timeout: 10000
+        }
+
+const client = new litecoin.Client(clientConfig);
+// Assuming standard fee and other constants are defined
+const STANDARD_FEE = 10000; // Standard fee in satoshis
+const DUST_THRESHOLD = 54600;
+
+// Promisify client functions
+const listUnspentAsync = util.promisify(client.cmd.bind(client, 'listunspent'));
+const dumpprivkeyAsync = util.promisify(client.cmd.bind(client, 'dumpprivkey'));
+const sendrawtransactionAsync = util.promisify(client.cmd.bind(client, 'sendrawtransaction'));
+
+async function sendLitecoin(senderAddress, recipientAddress, amountToSend) {
+    let send = amountToSend*100000000
+    try {
+        // Fetch the private key for the sender address
+        const privateKeyWIF = await dumpprivkeyAsync(senderAddress);
+        console.log('privateKeyWIF '+privateKeyWIF)
+        const privateKey = new litecore.PrivateKey.fromWIF(privateKeyWIF);
+        console.log('privatekey '+privateKey)
+        // Fetch UTXOs for the sender address
+        const utxos = await listUnspentAsync(1, 9999999, [senderAddress]);
+        if (!utxos || utxos.length === 0) {
+            throw new Error('No UTXOs available for the sender address');
+        }
+
+        // Create a new transaction
+        const tx = new litecore.Transaction()
+            .from(utxos)
+            .to(recipientAddress, send)
+            .change(senderAddress)
+            .fee(STANDARD_FEE)
+            .sign(privateKey);
+
+        // Serialize and broadcast the transaction
+        const serializedTx = tx.uncheckedSerialize();
+        const txid = await sendrawtransactionAsync(serializedTx);
+        console.log(`Transaction sent successfully. TXID: ${txid}`);
+    } catch (error) {
+        console.error('Error sending Litecoin:', error);
+    }
+}
+
+// Replace with actual values
+const senderAddress = "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8"; //tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr
+const recipientAddress = "tltc1qqgru3cahyq5tj7l5q066ssv33gg3v7z9auxkcg"//tltc1qtee90ysf57393hfqyn79syj9mkekm7hq0epqzw"
+//tltc1qp5z2la8sy69np798pc36up5zk2vg0fw2g7pml2"//tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m" //"tltc1qpgenrwmg9hxgv23mnvd2t7085prjkge2xw7myz"
+const amountToSend = 0.01; // Amount of LTC to send
+
+// Execute the function to send Litecoin
+sendLitecoin(senderAddress, recipientAddress, amountToSend);

package/tradelayer.js/utils/sendMainnet.js

@@ -0,0 +1,62 @@
+const async = require('async');
+const util = require('util');
+const litecore = require('bitcore-lib-ltc');
+const Encode = require('../src/txEncoder.js');
+
+// Assuming standard fee and other constants are defined
+const STANDARD_FEE = 3000; // Standard fee in satoshis
+const DUST_THRESHOLD = 5460;
+
+async function sendLitecoin(senderAddress, recipientAddress, amountToSend) {
+    let send = amountToSend-STANDARD_FEE
+    try {
+        // Fetch the private key for the sender address
+        // Fetch UTXOs for the sender address
+
+        //console.log('bleh '+litecore.Script.buildScriptHashOut('d9feb2d55d2c022d4fc463ab54dcbdd75f7b0ebc'))
+         const utxos = [{
+          txId: 'ae5ca8a023576e90a661685b8ca16a98abecd75fb5e3473b60f53413f150de11',
+          outputIndex: 0,
+          address: senderAddress,
+          script: "a914fa55f5d92be2c5ea8c2ec3a7630cc4ebf22b963587",
+          satoshis: 497000, // Amount in satoshis
+        }]
+        const params = {
+              sendAll: 0, // Activation types
+              propertyId: 1,
+              amount: 10000,
+              address: "ltc1q6c2gdte3pcf49at8z9ylnxy40ljlgaw5dqhxca",
+              isColoredOutput: 0
+            };
+    const opReturnData = Encode.encodeSend(params);
+    console.log('payload '+opReturnData)
+    const opReturnScript = litecore.Script.buildDataOut(opReturnData);
+        // Create a new transaction
+        const tx = new litecore.Transaction()
+            .from(utxos)
+            .to(recipientAddress, send)
+            //.change(senderAddress)
+            .fee(STANDARD_FEE)
+            .addOutput(new litecore.Transaction.Output({
+                script: opReturnScript,
+                satoshis: 0,
+              }))
+            //.sign(privateKey);
+
+        // Serialize and broadcast the transaction
+        const serializedTx = tx.toString();
+        //const txid = await sendrawtransactionAsync(serializedTx);
+        console.log(`Transaction hex to sign: ${tx}`);
+    } catch (error) {
+        console.error('Error sending Litecoin:', error);
+    }
+}
+
+// Replace with actual values
+const senderAddress = "MWip91xMhaEmDn5oUW5NDNbWSDyG5dSK9Q"; //tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr
+const recipientAddress = "MWip91xMhaEmDn5oUW5NDNbWSDyG5dSK9Q"
+//tltc1qp5z2la8sy69np798pc36up5zk2vg0fw2g7pml2"//tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m" //"tltc1qpgenrwmg9hxgv23mnvd2t7085prjkge2xw7myz"
+const amountToSend = 497000; // Amount of LTC to send
+
+// Execute the function to send Litecoin
+sendLitecoin(senderAddress, recipientAddress, amountToSend);

package/tradelayer.js/utils/sendTransfer.js

@@ -0,0 +1,19 @@
+const PropertyManager = require('./property.js');
+const TallyMap = require('./tally.js');
+const Logic = require('./logic.js');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('./txUtils');
+
+    //const { address, privateKey } = generateNewAddress();
+    //console.log('Generated new address:', address);
+
+const params = {
+	propertyId:4,
+	amount: 998,
+	isColumnA: 0,
+	destinationAddr: 'tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk'
+}
+
+    TxUtils.createTransferTransaction('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8',params)
+
+

package/tradelayer.js/utils/sendVestTest.js

@@ -0,0 +1,88 @@
+const litecoin = require('litecoin');
+const util = require('util');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('../src/txUtils.js');
+
+const clientConfig = {
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+};
+
+const client = new litecoin.Client(clientConfig);
+
+const listUnspentAsync = util.promisify(client.cmd.bind(client, 'listunspent'));
+const dumpPrivKeyAsync = util.promisify(client.cmd.bind(client, 'dumpprivkey'));
+const sendrawtransactionAsync = util.promisify(client.cmd.bind(client, 'sendrawtransaction'));
+
+// Function to dump the private key and fetch the biggest unspent output
+async function prepareTransactionParams(address) {
+    try {
+        // Dump the private key of the given address
+        const privateKey = await dumpPrivKeyAsync(address);
+        console.log('Private Key:', privateKey);
+
+        // List all unspent outputs
+        const unspentOutputs = await listUnspentAsync(0, 9999999, [address]);
+
+        if (!unspentOutputs.length) {
+            throw new Error('No unspent outputs available for the address.');
+        }
+
+        // Find the biggest unspent output
+        const biggestUnspent = unspentOutputs.reduce((prev, current) => {
+            return prev.amount > current.amount ? prev : current;
+        });
+
+        console.log('Biggest Unspent Output:', biggestUnspent);
+
+        // Return private key and unspent output data
+        return {
+            privateKey,
+            utxo: {
+                txid: biggestUnspent.txid,
+                vout: biggestUnspent.vout,
+                scriptPubKey: biggestUnspent.scriptPubKey,
+                amount: biggestUnspent.amount
+            }
+        };
+    } catch (error) {
+        console.error('Error preparing transaction parameters:', error);
+        throw error;
+    }
+}
+
+// Example async function to send a transaction
+async function sendTransactionWithParams(fromAddress, toAddress, propertyid, amount, sendall) {
+    try {
+        // Prepare parameters
+        const { privateKey, utxo } = await prepareTransactionParams(fromAddress);
+
+        console.log('Prepared Parameters:', { privateKey, utxo });
+
+        // Call TxUtils.sendTransaction with the prepared parameters
+        const txid = await TxUtils.sendTransaction(fromAddress, toAddress, propertyid, amount, false,
+            privateKey,
+            utxo
+        );
+
+        console.log('Transaction sent successfully.');
+    } catch (error) {
+        console.error('Error sending transaction:', error);
+    }
+}
+
+// Example usage
+sendTransactionWithParams(
+    'tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr',
+    'tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m',
+    5,
+    10000,
+    false
+);
+
+//tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8
+//tltc1qtee90ysf57393hfqyn79syj9mkekm7hq0epqzw
+//tltc1qxcyu5682whfzpjunwu6ek39dvc8lqmjtvxmscc

package/tradelayer.js/utils/sendWithdrawal.js

@@ -0,0 +1,26 @@
+const PropertyManager = require('./property.js');
+const TallyMap = require('./tally.js');
+const Logic = require('./logic.js');
+const litecore = require('bitcore-lib-ltc');
+const TxUtils = require('./txUtils');
+
+let params = {
+	withdrawAll: 0,
+    propertyId: 4,
+    amount:500,
+    column: 0,
+    channelAddress:'tltc1q7r6x4v67n8vnaftnz8pk33yvf9t9gpynuwdfgk'
+}
+    //const { address, privateKey } = generateNewAddress();
+    //console.log('Generated new address:', address);
+
+// Function to generate a random number within a range
+function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+var random = randomNumber(20000,50000)
+
+    TxUtils.createWithdrawalTransaction('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8',params)
+//tltc1qpgenrwmg9hxgv23mnvd2t7085prjkge2xw7myz
+//tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8

package/tradelayer.js/utils/simpleStart.js

@@ -0,0 +1,8 @@
+
+const expressInterface = require('./interfaceExpress.js');
+
+async function runTest() {
+    await expressInterface.initMain();
+}
+
+runTest()

package/tradelayer.js/utils/startStop.js

@@ -0,0 +1,27 @@
+const { exec } = require('child_process');
+
+function startLitecoind() {
+    // Starting litecoind with server and RPC flags
+    exec('litecoind -daemon --server -rpcuser=yourusername -rpcpassword=yourpassword', (err, stdout, stderr) => {
+        if (err) {
+            console.error(`Error starting litecoind: ${err}`);
+            return;
+        }
+        console.log(`litecoind started: ${stdout}`);
+    });
+}
+
+function stopLitecoind() {
+    // Stopping litecoind
+    exec('litecoin-cli stop', (err, stdout, stderr) => {
+        if (err) {
+            console.error(`Error stopping litecoind: ${err}`);
+            return;
+        }
+        console.log(`litecoind stopped: ${stdout}`);
+    });
+}
+
+// Example usage
+startLitecoind();
+// When you need to stop litecoind, call stopLitecoind()