@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/utils/createwallet.js

@@ -0,0 +1,20 @@
+const Litecoin = require('litecoin');
+const async = require('async')
+const util = require('util');
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 1000
+});
+
+
+const createWalletAsync = util.promisify(client.cmd.bind(client, 'createwallet'))
+async function load(){
+
+const createwallet = await createWalletAsync('wallet.dat')
+}
+
+load()

package/tradelayer.js/utils/crossFuturesTrades.js

@@ -0,0 +1,57 @@
+const TxUtils = require('./TxUtils'); // Import your TxUtils class
+
+async function runTestTokenTrades() {
+    const testAdminAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; // Replace with actual admin address
+    const counterparties = [
+        'tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr',
+        'tltc1qhgfrkv89lwp8vmygyqzt8ljvzn7g5z4sk9krw0',
+        'tltc1qr5ewrtxgj3z54gv9l47xz3cwrp6js9pgfxad2h'
+    ];
+
+    function randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    // Generate random trades
+    function generateRandomTrades(numTrades) {
+        const trades = [];
+        for (let i = 0; i < numTrades; i++) {
+            const random = randomNumber(1, 3);
+            const random2 = randomNumber(1, 10);
+            const counterparty = counterparties[i % counterparties.length];
+            trades.push({
+            contractId: 4,
+            amount: random,
+            price: random2,
+            side: true, // Assuming all trades are 'Buy' orders
+            address: counterparty,
+            insurance:false,
+            fee: false,
+            reduce: false,
+            post: false,
+            stop: false
+            });
+        }
+        return trades;
+    }
+
+    const trades = generateRandomTrades(10); // Generate 10 trades for each side
+
+    // Iterate over each trade and create a transaction
+    for (let trade of trades) {
+        try {
+            console.log(`Creating trade: Offered Property ID ${trade.offeredPropertyId}, Desired Property ID ${trade.desiredPropertyId}, Address: ${trade.address}`);
+            const txId = await TxUtils.createContractOnChainTradeTransaction(
+                trade.address,
+                trade
+            );
+            console.log(`Transaction ID: ${txId}`);
+        } catch (error) {
+            console.error(`Error creating trade for offered property ${trade.offeredPropertyId} and desired property ${trade.desiredPropertyId}:`, error);
+        }
+    }
+}
+
+runTestTokenTrades()
+    .then(() => console.log('Test token trade transactions completed.'))
+    .catch(error => console.error('Error running test token trades:', error));

package/tradelayer.js/utils/crossTokenTrades.js

@@ -0,0 +1,62 @@
+const TxUtils = require('./TxUtils'); // Import your TxUtils class
+
+async function runTestTokenTrades() {
+    const testAdminAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; // Replace with actual admin address
+    const counterparties = [
+        'tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr',
+        'tltc1qhgfrkv89lwp8vmygyqzt8ljvzn7g5z4sk9krw0',
+        'tltc1qr5ewrtxgj3z54gv9l47xz3cwrp6js9pgfxad2h'
+    ];
+
+    function randomNumber(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    // Generate random trades
+    function generateRandomTrades(numTrades) {
+        const trades = [];
+        for (let i = 0; i < numTrades; i++) {
+            const random = randomNumber(1, 10);
+            const random2 = randomNumber(1, 10);
+            const counterparty = counterparties[i % counterparties.length];
+            trades.push({
+                offeredPropertyId: 4,
+                desiredPropertyId: 5,
+                amountOffered: random,
+                amountExpected: random2,
+                address: testAdminAddress
+            });
+            trades.push({
+                offeredPropertyId: 5,
+                desiredPropertyId: 4,
+                amountOffered: random2,
+                amountExpected: random,
+                address: counterparty
+            });
+        }
+        return trades;
+    }
+
+    const trades = generateRandomTrades(10); // Generate 10 trades for each side
+
+    // Iterate over each trade and create a transaction
+    for (let trade of trades) {
+        try {
+            console.log(`Creating trade: Offered Property ID ${trade.offeredPropertyId}, Desired Property ID ${trade.desiredPropertyId}, Address: ${trade.address}`);
+            const txId = await TxUtils.tokenTradeTransaction(
+                trade.address,
+                trade.offeredPropertyId,
+                trade.desiredPropertyId,
+                trade.amountOffered,
+                trade.amountExpected
+            );
+            console.log(`Transaction ID: ${txId}`);
+        } catch (error) {
+            console.error(`Error creating trade for offered property ${trade.offeredPropertyId} and desired property ${trade.desiredPropertyId}:`, error);
+        }
+    }
+}
+
+runTestTokenTrades()
+    .then(() => console.log('Test token trade transactions completed.'))
+    .catch(error => console.error('Error running test token trades:', error));

package/tradelayer.js/utils/dumpPriv.js

@@ -0,0 +1,29 @@
+
+
+const litecoin = require('litecoin');
+
+// Configure your Litecoin client connection
+const clientConfig = {
+    host: '127.0.0.1',
+    port: 18332, // Testnet port; use 9332 for Mainnet
+    user: 'user',
+    pass: 'pass',
+    timeout: 30000
+};
+
+const client = new litecoin.Client(clientConfig);
+
+// Function to dump the private key
+function dumpPrivKey(address) {
+    client.cmd('dumpprivkey', address, function(err, privateKey, resHeaders) {
+        if (err) {
+            console.error('Error dumping private key:', err);
+            return;
+        }
+        console.log(`Private key for address ${address}: ${privateKey}`);
+    });
+}
+
+// Replace with the address you want to get the private key for
+const address = 'LNmiS6p8z3KuHHx3q6Jf6x6TfcyptE68oP';
+dumpPrivKey(address);

package/tradelayer.js/utils/generateChannel.js

@@ -0,0 +1,34 @@
+const litecore = require('bitcore-lib-ltc');
+const { TradeChannels } = require('./tradeChannels.js');
+
+async function setupTradeChannel(privateKeyA, privateKeyB) {
+    const tradeChannels = new TradeChannels();
+
+    // Extract public keys from the private keys
+    const publicKeyA = new litecore.PrivateKey(privateKeyA).toPublicKey();
+    const publicKeyB = new litecore.PrivateKey(privateKeyB).toPublicKey();
+
+    // Create multisig address from public keys
+    const multisigAddress = new litecore.Address([publicKeyA, publicKeyB], 2).toString();
+
+    // Create a new trade channel with the multisig address as the channel ID
+    const tradeChannel = tradeChannels.createChannel(multisigAddress, 'addressA', 'addressB');
+
+    // Commit transactions to the channel
+    let commitTx1 = await commitTransaction('addressA', 'addressB', propertyId1, amount1, privateKeyA);
+    let commitTx2 = await commitTransaction('addressB', 'addressA', propertyId2, amount2, privateKeyB);
+
+    // Add commitments to the channel
+    tradeChannel.addCommitment(commitTx1);
+    tradeChannel.addCommitment(commitTx2);
+
+    // Return the trade channel for further processing
+    return tradeChannel;
+}
+
+// Example usage with test private keys
+const privateKeyA = '...'; // Replace with private key for address A
+const privateKeyB = '...'; // Replace with private key for address B
+setupTradeChannel(privateKeyA, privateKeyB).then(tradeChannel => {
+    console.log('Trade Channel Setup:', tradeChannel);
+});

package/tradelayer.js/utils/getInfo.js

@@ -0,0 +1,21 @@
+const Litecoin = require('litecoin');
+const async = require('async')
+const util = require('util');
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 1000
+});
+
+
+const getInfoAsync = util.promisify(client.cmd.bind(client, 'getblockchaininfo'))
+async function load(){
+
+const info = await getInfoAsync()
+console.log(JSON.stringify(info))
+}
+
+load()

package/tradelayer.js/utils/hardWipe.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+
+const dbDir = './nedb-data';  // Change to your database directory
+
+// Function to delete all files in the directory
+function wipeDatabase() {
+    fs.readdir(dbDir, (err, files) => {
+        if (err) throw err;
+
+        for (const file of files) {
+            fs.unlink(path.join(dbDir, file), err => {
+                if (err) throw err;
+            });
+        }
+        console.log('Database wiped successfully.');
+    });
+}
+
+wipeDatabase();

package/tradelayer.js/utils/hexTo64.js

@@ -0,0 +1,16 @@
+const fs = require('fs');
+
+function hexToBase64(hex) {
+    // Convert hex to a buffer, then encode it to base64
+    const buffer = Buffer.from(hex, 'hex');
+    return buffer.toString('base64');
+}
+
+// Example usage
+const hexString = '010000000148a578b5c7aae54b1f33f480d992054371884ba8efe3fb4f9f7f7dd2ffc8a932000000006a47304402206f0318f343860c21ea1ede8b3186b5b5da8448d313da0fa04ad4144388730ee0022062d0466bf1e844db42b448d8a78050e3a86413fa9f8d6209f5a6897c9c9b177c012102b72f530678baac030e896f5f6b1ffaf334dea4b10c8aff3923a335053f43ce93ffffffff020065cd1d000000001976a914be98d27a5fc1fb73d7cb487da7d56d49feacfd3588ac0000000000000000406a3e746c30303b313b323b333b342c33356735726a31343972776d71367835356567703730757867717239396c769c6f3661366433316b7a6163676a3762313900000000';
+
+const base64String = hexToBase64(hexString);
+console.log('Base64:', base64String);
+
+// Optionally, write the base64 string to a file for easy transcription
+fs.writeFileSync('output_base64.txt', base64String);

package/tradelayer.js/utils/importAddress.js

@@ -0,0 +1,28 @@
+const litecoin = require('litecoin');
+
+const clientConfig = {
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user', // Replace with your RPC username
+    pass: 'pass', // Replace with your RPC password
+    timeout: 10000
+};
+
+const client = new litecoin.Client(clientConfig);
+
+// Function to import an address
+function importAddress(address) {
+    client.cmd('importaddress', address, '', false, function(err, response, resHeaders) {
+        if (err) {
+            console.error('Error importing address:', err);
+            return;
+        }
+        console.log('Address imported successfully:', response);
+    });
+}
+
+// Replace with the address you want to import
+const addressToImport = "mj4iTwbHiQX6objWNXHjerF2KQDFcPCdUx";
+
+// Execute the function
+importAddress(addressToImport);

package/tradelayer.js/utils/importpriv.js

@@ -0,0 +1,20 @@
+const Litecoin = require('litecoin');
+const async = require('async')
+const util = require('util');
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 1000
+});
+
+
+const importPrivKeyAsync = util.promisify(client.cmd.bind(client, 'importprivkey'))
+async function load(){
+
+const imported = await importPrivKeyAsync('cNGCJhHBSQM2Kedc8Zc6x9VYe9dQuvanqfS61D3tczZnDD3HwYUW')
+}
+
+load()

package/tradelayer.js/utils/issueOracleContract.js

@@ -0,0 +1,67 @@
+const crypto = require('crypto');
+const TxUtils = require('../src/txUtils.js'); // Assuming TxUtils contains the necessary transaction utility functions
+const client = require('../src/client.js')
+
+// Function to create a random ticker
+function createRandomTicker(length = 5) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+// Function to generate a random number within a range
+function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// Function to create an oracle and then issue a contract
+async function createOracleAndIssueContract() {
+
+    const instance = new client()
+    instance.init()
+    await new Promise(resolve => setTimeout(resolve, 700));
+
+    const adminAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; // Replace with the actual admin address
+    const backupAddress = 'LNmiS6p8z3KuHHx3q6Jf6x6TfcyptE68oP'; // Replace with an actual backup address
+
+    // Create Oracle Parameters
+    const oracleTicker = "BTC/USD";
+    const oracleUrl = "bravenewcoin.com";
+
+    // Create Contract Series Parameters
+    const contractSeriesTicker = "BTC/USD-BLX";
+    const underlyingOracleId = 1; // Placeholder, replace with actual oracle ID after creation
+    const notionalPropertyId = null; // Random property ID for testing
+    const collateralPropertyId = 3; // Random collateral property ID for testing
+    const leverage = 10; // Example leverage
+    const expiryPeriod = 17532; // Example expiry period
+    const series = 5; // Number of contracts in the series
+
+    console.log(`Creating an oracle: ${oracleTicker}`);
+
+    try {
+        // Create Oracle
+        const oracleTxId = await TxUtils.createOracleTransaction(adminAddress, {
+            ticker: oracleTicker,
+            url: oracleUrl,
+            backupAddress: backupAddress,
+            whitelists: [],
+            lag: 1
+        }, 13);
+
+        console.log(`Oracle created successfully. Transaction ID: ${oracleTxId}`);
+
+        // Wait for oracle creation to be confirmed before issuing the contract
+        // This is just a placeholder, you should implement a proper wait/check mechanism
+        console.log('Waiting for oracle confirmation...');
+        await new Promise(resolve => setTimeout(resolve, 30000)); // 30 seconds delay
+    }catch(err){
+        console.log('err '+err)
+    }
+}
+
+// Call the function to create an oracle and issue a contract
+createOracleAndIssueContract();

package/tradelayer.js/utils/issueTokens.js

@@ -0,0 +1,41 @@
+const crypto = require('crypto');
+const TxUtils = require('./txUtils.js')
+// Function to create a random ticker
+function createRandomTicker(length = 5) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+
+// Function to generate a random number within a range
+function randomNumber(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+// Function to issue a random token
+async function issueRandomToken() {
+    const fromAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; 
+    const initialAmount = randomNumber(1000, 1000000); // Random amount between 1,000 and 1,000,000
+    const ticker = createRandomTicker();
+    const whitelists = []; // Assuming no whitelists for simplicity
+    const managed = false; // Managed flag set to false
+    const backupAddress = 'LNmiS6p8z3KuHHx3q6Jf6x6TfcyptE68oP'; // Replace with an actual backup address
+    const nft = true; // NFT flag set to false
+
+    console.log(`Issuing a new token:
+    - Ticker: ${ticker}
+    - Initial Amount: ${initialAmount}`);
+
+    try {
+        const txid = await TxUtils.issuePropertyTransaction(fromAddress, initialAmount, ticker, whitelists, managed, backupAddress, nft);
+        console.log(`Token issued successfully. Transaction ID: ${txid}`);
+    } catch (error) {
+        console.error('Error issuing token:', error);
+    }
+}
+
+// Call the function to issue a random token
+issueRandomToken();

package/tradelayer.js/utils/listunspent.js

@@ -0,0 +1,66 @@
+const async = require('async');
+const util = require('util');
+const litecore = require('bitcore-lib-ltc');
+const litecoin = require('litecoin');
+
+// Litecoin client configuration (make sure your daemon is running and the RPC parameters are correct)
+const clientConfig = {
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+};
+
+const client = new litecoin.Client(clientConfig);
+
+// Promisify client functions for `listunspent` and `getaddressesbylabel`
+const listUnspentAsync = util.promisify(client.cmd.bind(client, 'listunspent'));
+const getAddressesByLabelAsync = util.promisify(client.cmd.bind(client, 'getaddressesbylabel'));
+const getListReceivedByAddressAsync = util.promisify(client.cmd.bind(client, 'listreceivedbyaddress'))
+const getMempool = util.promisify(client.cmd.bind(client, 'getrawmempool'))
+// Fetch UTXOs for all addresses in the wallet
+async function listUnspentForAllAddresses() {
+
+    const allAddresses = await getListReceivedByAddressAsync(0, true)
+
+        console.log('all addresses '+JSON.stringify(allAddresses))
+
+    try {
+        // Fetch all wallet addresses with a label (e.g., "" means all addresses)
+        const label = "tl-wallet"; // Empty string means fetch all addresses
+        const addressesByLabel = await getAddressesByLabelAsync(label);
+        
+
+        const addresses = Object.keys(addressesByLabel);
+
+        if (addresses.length === 0) {
+            console.log('No addresses found in the wallet.');
+            return;
+        }
+
+        console.log(`Found ${addresses.length} addresses in the wallet.`);
+
+        // Loop over each address and fetch its UTXOs
+        for (let address of addresses) {
+            console.log(`Fetching UTXOs for address: ${address}`);
+            
+            const minConfirmations = 1;
+            const maxConfirmations = 9999999;
+            const utxos = await listUnspentAsync(minConfirmations, maxConfirmations, [address]);
+
+            if (utxos && utxos.length > 0) {
+                console.log(`UTXOs for ${address}:`, utxos);
+            } else {
+                console.log(`No UTXOs available for address: ${address}`);
+            }
+        }
+        const mempool = await getMempool(true)
+        console.log('checking mempool '+JSON.stringify(mempool))
+    } catch (error) {
+        console.error('Error fetching addresses or UTXOs:', error);
+    }
+}
+
+// Execute the function to list unspent outputs for all addresses in the wallet
+listUnspentForAllAddresses();

package/tradelayer.js/utils/litecoinClient.js

@@ -0,0 +1,30 @@
+const litecoin = require('litecoin');
+
+class LitecoinClient {
+    static instance;
+
+    constructor() {
+        if (LitecoinClient.instance) {
+            return LitecoinClient.instance;
+        }
+
+        this.client = new litecoin.Client({
+            host: '127.0.0.1',
+            port: 18332, //for testnet
+            user: 'user',
+            pass: 'pass',
+            timeout: 10000
+        });
+
+        LitecoinClient.instance = this;
+    }
+
+    static getInstance() {
+        if (!LitecoinClient.instance) {
+            new LitecoinClient();
+        }
+        return LitecoinClient.instance.client;
+    }
+}
+
+module.exports = LitecoinClient;

package/tradelayer.js/utils/loadwallet.js

@@ -0,0 +1,20 @@
+const Litecoin = require('litecoin');
+const async = require('async')
+const util = require('util');
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 1000
+});
+
+
+const loadWalletAsync = util.promisify(client.cmd.bind(client, 'loadwallet'))
+async function load(){
+
+const loadwallet = await loadWalletAsync(''/*wallet.dat'*/)
+}
+
+load()

package/tradelayer.js/utils/publishOracle.js

@@ -0,0 +1,113 @@
+const litecoin = require('litecoin');
+const axios = require('axios');
+const util = require('util');
+const litecore = require('bitcore-lib-ltc');
+const encoder = require('../src/txEncoder.js');
+
+const clientConfig = {
+    host: '127.0.0.1',
+    port: 18332, // Testnet RPC port
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+};
+
+const client = new litecoin.Client(clientConfig);
+
+// Promisify necessary RPC commands
+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'));
+
+const LTC_PRICE_API_URL = 'https://api.coingecko.com/api/v3/simple/price?ids=litecoin&vs_currencies=usd';
+
+//'https://api.coingecko.com/api/v3/simple/price?ids=litecoin&vs_currencies=usd';
+
+// Fetch the BTC price
+async function fetchBTCPrice() {
+    try {
+        const response = await axios.get(LTC_PRICE_API_URL);
+        const price = response.data.litecoin.usd;
+        console.log('Fetched BTC Price:', price);
+        return price;
+    } catch (error) {
+        console.error('Error fetching BTC price:', error.message);
+        throw error;
+    }
+}
+
+// Build, sign, and send the transaction
+async function buildSignAndSendTransaction(fromAddress, btcPrice) {
+    try {
+        console.log('Preparing transaction with BTC Price:', btcPrice);
+
+        // Dump private key and get UTXOs
+        const privateKeyWIF = await dumpPrivKeyAsync(fromAddress);
+        const privateKey = litecore.PrivateKey.fromWIF(privateKeyWIF);
+        const unspentOutputs = await listUnspentAsync(0, 9999999, [fromAddress]);
+        console.log('unspent '+JSON.stringify(unspentOutputs))
+        if (!unspentOutputs.length) throw new Error('No unspent outputs available.');
+
+        // Select the largest UTXO
+        const largestUTXO = unspentOutputs.reduce((prev, curr) => prev.amount > curr.amount ? prev : curr);
+        console.log('Using UTXO:', largestUTXO);
+        if(largestUTXO.spendable==true){
+             const utxo = {
+                txId: largestUTXO.txid,
+                outputIndex: largestUTXO.vout,
+                script: largestUTXO.scriptPubKey,
+                satoshis: Math.floor(largestUTXO.amount * 1e8)
+            };
+        }else{
+            const utxo = unspentOutputs
+        }
+       
+
+        // Create the payload
+        const params = {
+            oracleid: 2,
+            price: 142,//btcPrice,
+            targetAddress: fromAddress
+        };
+
+        const payload = encoder.encodePublishOracleData(params);
+
+        // Create and sign the transaction
+        const transaction = new litecore.Transaction()
+            .from(largestUTXO) // Add UTXO as input
+            .addOutput(new litecore.Transaction.Output({
+                satoshis: 0, // OP_RETURN fee
+                script: litecore.Script.buildDataOut(payload) // Embed payload in OP_RETURN
+            }))
+            .change(fromAddress) // Send change back to sender
+            .sign(privateKey); // Sign transaction
+
+        console.log('Raw Transaction Hex:', transaction.toString());
+
+        // Broadcast the transaction
+        const txid = await sendrawtransactionAsync(transaction.serialize());
+        console.log(`Transaction broadcasted successfully. TXID: ${txid}`);
+    } catch (error) {
+        console.error('Error building/signing transaction:', error.message);
+        throw error;
+    }
+}
+
+// Main function to fetch BTC price and send the attestation
+async function publishBTCPrice() {
+    try {
+        const fromAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; // Admin address
+        const btcPrice = await fetchBTCPrice();
+        await buildSignAndSendTransaction(fromAddress, btcPrice);
+    } catch (error) {
+        console.error('Failed to publish BTC price:', error.message);
+    }
+}
+
+publishBTCPrice()
+
+// Run the attestation script every 150 seconds
+setInterval(() => {
+    console.log('Starting BTC price publish cycle...');
+    publishBTCPrice();
+}, 150 * 1000); // 150 seconds in milliseconds