@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/utils/activateMainnet.js

@@ -0,0 +1,59 @@
+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 = 54600;
+
+async function sendLitecoin(senderAddress, recipientAddress, amountToSend) {
+    let send = (amountToSend*100000000)-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: 'a750adc0f1801f4848e529d3d0c8478c20b384d0688486b318c9dc3ef11be60b',
+          outputIndex: 0,
+          address: senderAddress,
+          script: "a914d9feb2d55d2c022d4fc463ab54dcbdd75f7b0ebc87",
+          satoshis: 0.00044 * 1e8, // Amount in satoshis
+        }]
+        const params = {
+              txTypeToActivate: 9, // Activation types
+              codeHash: '11b89e7aa5bd3f2b42b25003a76efbc2c191c80ab06526f303f05443d2881fcf'
+            };
+    const opReturnData = Encode.encodeActivateTradeLayer(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 = "MTmoypkhRQoJ172ZqxcsVumPZfJ8KCrQCB"; //tltc1qfffvwpftp8w3kv6gg6273ejtsfnu2dara5x4tr
+const recipientAddress = "MTmoypkhRQoJ172ZqxcsVumPZfJ8KCrQCB"
+//tltc1qp5z2la8sy69np798pc36up5zk2vg0fw2g7pml2"//tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m" //"tltc1qpgenrwmg9hxgv23mnvd2t7085prjkge2xw7myz"
+const amountToSend = 0.00044; // Amount of LTC to send
+
+// Execute the function to send Litecoin
+sendLitecoin(senderAddress, recipientAddress, amountToSend);

package/tradelayer.js/utils/activateMainnetDoge.js

@@ -0,0 +1,63 @@
+const async = require('async');
+const litecore = require('bitcore-lib-doge'); // Use Dogecoin version
+const Encode = require('../src/txEncoder.js'); // Assuming TradeLayer encoding logic
+
+// Constants
+const STANDARD_FEE = 100000000; // Standard fee in satoshis (e.g., 1 DOGE)
+const DUST_THRESHOLD = 100000000; // Dogecoin dust threshold (e.g., 1 DOGE)
+
+async function sendDogecoin(senderAddress, recipientAddress, amountToSend) {
+    let send = Math.floor(amountToSend * 1e8) - STANDARD_FEE; // Convert to satoshis and subtract fee
+
+    try {
+        // Mock UTXO for demonstration (replace with real UTXO fetching logic)
+        const utxos = [{
+            txId: '502ce433a589184cc04c6ee8ac5260a34acc679ec071c6727c1ebbdcf51cc7a6',
+            outputIndex: 0,
+            address: senderAddress,
+            script: "76a914a7dcce4bf35b50dbe9da38e5dc6758b7ab78ae5a88ac",
+            satoshis: 5 * 1e8, // Amount in satoshis
+        }];
+
+        // Activation parameters for TradeLayer
+        const params = {
+            txTypeToActivate: 9, // Activation type
+            codeHash: '873af1d08d3603c8296afe6de040d228b76872fa0dc570f7b236dd4900b26f0d',
+        };
+
+        // Encode OP_RETURN data for TradeLayer activation
+        const opReturnData = Encode.encodeActivateTradeLayer(params);
+        console.log('Payload:', opReturnData);
+
+        // Create OP_RETURN script
+        const opReturnScript = litecore.Script.buildDataOut(opReturnData);
+
+        // Create a new Dogecoin transaction
+        const tx = new litecore.Transaction()
+            .from(utxos) // Add UTXOs as inputs
+            .to(recipientAddress, send) // Send to recipient
+            .fee(STANDARD_FEE) // Set the transaction fee
+            .addOutput(new litecore.Transaction.Output({
+                script: opReturnScript, // Add OP_RETURN data as output
+                satoshis: 0, // OP_RETURN outputs always have 0 value
+            }));
+
+        // Serialize the transaction
+        const serializedTx = tx.toString();
+        console.log(`Transaction hex to sign: ${serializedTx}`);
+
+        // Mock broadcasting (replace with actual broadcast logic)
+        // const txid = await sendrawtransactionAsync(serializedTx);
+        // console.log(`Transaction broadcasted with txid: ${txid}`);
+    } catch (error) {
+        console.error('Error sending Dogecoin:', error);
+    }
+}
+
+// Replace with actual values
+const senderAddress = "DLSfu9qvEggkeXAgCAwBBw5BVLvMCtkewz"; // Replace with a valid Dogecoin address
+const recipientAddress = "DLSfu9qvEggkeXAgCAwBBw5BVLvMCtkewz"; // Replace with recipient Dogecoin address
+const amountToSend = 5; // Amount of DOGE to send
+
+// Execute the function to send Dogecoin
+sendDogecoin(senderAddress, recipientAddress, amountToSend);

package/tradelayer.js/utils/autocompactdb.js

@@ -0,0 +1,23 @@
+const dbInstance = require('./path/to/your/dbInstance'); // Import your database instance
+const COMPACT_INTERVAL_MS = 60000; // Set this to your desired compaction interval in milliseconds
+const COMPACT_MODULO = 10; // Perform compaction every 10th interval
+
+let intervalCount = 0;
+
+setInterval(() => {
+    intervalCount++;
+    if (intervalCount % COMPACT_MODULO === 0) {
+        console.log('Compacting database...');
+        compactDatabase();
+    }
+}, COMPACT_INTERVAL_MS);
+
+function compactDatabase() {
+    // Assuming you have multiple databases to compact, loop through them
+    const databases = ['tallyMap', 'propertyList', 'anotherDatabase']; // List your databases here
+    databases.forEach(dbName => {
+        const db = dbInstance.getDatabase(dbName);
+        db.persistence.compactDatafile();
+        console.log(`Compacted ${dbName} database.`);
+    });
+}

package/tradelayer.js/utils/base64toHex.js

@@ -0,0 +1,32 @@
+// Base64 to Hex Decoder
+const base64ToHex = (base64String) => {
+    try {
+        // Decode base64 to a buffer
+        const buffer = Buffer.from(base64String, 'base64');
+        // Convert buffer to hex
+        const hexString = buffer.toString('hex');
+        return hexString;
+    } catch (error) {
+        console.error('Error decoding base64 to hex:', error);
+        return null;
+    }
+};
+
+// Example usage
+const readline = require('readline');
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+rl.question('Enter the Base64 string: ', (base64String) => {
+    const hexResult = base64ToHex(base64String.trim());
+    if (hexResult) {
+        console.log('Hexadecimal Output:');
+        console.log(hexResult);
+    } else {
+        console.log('Failed to convert the input to hex.');
+    }
+    rl.close();
+});

package/tradelayer.js/utils/broadcastDoge.js

@@ -0,0 +1,38 @@
+const axios = require('axios');
+
+/**
+ * Broadcasts a signed Dogecoin transaction to the Dogecoin network.
+ * 
+ * @param {string} txHex - The raw transaction hex string (signed).
+ * @param {string} apiUrl - The API endpoint for broadcasting the transaction.
+ */
+async function broadcastDogecoinTransaction(txHex, apiUrl = 'https://sochain.com/api/v2/send_tx/DOGE') {
+    try {
+        // Prepare the payload
+        const payload = {
+            tx_hex: txHex
+        };
+
+        // Make the POST request to the API
+        const response = await axios.post(apiUrl, payload, {
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+
+        // 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) {
+        console.error("An error occurred while broadcasting the transaction:", error.message);
+    }
+}
+
+// Example Usage
+const txHex = "01000000014ceac2bf9640e751498dded188c6b9bb494ddbbbcc8f4fc30b620a583c49867a0000000000ffffffff02c071b504000000001976a914226eae66f1d4da7f47015be99d1c4e2484e39b9c88ac0000000000000000336a31746c32303b44366e4e6e5069384743477a536178375148644246576b48397454477a68746642383b313b68763035633b3000000000"; // Replace with your signed transaction hex
+broadcastDogecoinTransaction(txHex);

package/tradelayer.js/utils/calcRedeem.js

@@ -0,0 +1,19 @@
+const crypto = require('crypto');
+
+// Public key
+const publicKey = Buffer.from('03860babecfccca06dc6a91e4071e91323464d885547662d4c0aba4660bef7', 'hex');
+
+// Step 1: SHA-256
+const sha256Hash = crypto.createHash('sha256').update(publicKey).digest();
+
+// Step 2: RIPEMD-160
+const ripemd160Hash = crypto.createHash('ripemd160').update(sha256Hash).digest();
+
+// Construct the redeem script
+const redeemScript = Buffer.concat([
+  Buffer.from([0x76, 0xa9, 0x14]), // OP_DUP OP_HASH160 (0x14 is length of hash)
+  ripemd160Hash,                   // Public key hash
+  Buffer.from([0x88, 0xac])         // OP_EQUALVERIFY OP_CHECKSIG
+]);
+
+console.log('Redeem Script:', redeemScript.toString('hex'));

package/tradelayer.js/utils/checkNetwork.js

@@ -0,0 +1,27 @@
+// checkChain.js
+const client = require('../src/client'); // Import the client wrapper directly
+
+async function checkNetworkInfo() {
+  if (!client) {
+    console.error('Failed to initialize client.');
+    return;
+  }
+
+  try {
+    const networkInfo = await client.getNetworkInfo();
+    console.log('Connected chain info:', networkInfo);
+    
+    // Display specific details if available
+    console.log('Subversion:', networkInfo.subversion);
+    console.log('Connections:', networkInfo.connections);
+  } catch (error) {
+    console.error('Error fetching network info:', error);
+  }
+
+   const blockchainInfo = await client.getBlockchainInfo();
+  const isTestnet = blockchainInfo.chain === 'test';
+  console.log(isTestnet ? 'Running on Testnet' : 'Running on Mainnet');
+}
+
+// Run the check
+checkNetworkInfo();

package/tradelayer.js/utils/createAddress.js

@@ -0,0 +1,48 @@
+const litecoin = require('litecoin');
+
+const client = new litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332, // Use 9332 for mainnet
+    user: 'user', // Replace with actual RPC username
+    pass: 'pass', // Replace with actual RPC password
+    timeout: 30000
+});
+
+async function createAndImportAddress() {
+    try {
+        // Create a new address
+        const newAddress = await new Promise((resolve, reject) => {
+            client.getNewAddress('', (error, address) => {
+                if (error) reject(error);
+                else resolve(address);
+            });
+        });
+
+        console.log(`New address created: ${newAddress}`);
+
+        // Dump the private key for the new address
+        const privateKey = await new Promise((resolve, reject) => {
+            client.dumpPrivKey(newAddress, (error, key) => {
+                if (error) reject(error);
+                else resolve(key);
+            });
+        });
+
+        console.log(`Private key for new address: ${privateKey}`);
+
+        // Import the private key back into the wallet (optional, as it should already be in the wallet)
+        await new Promise((resolve, reject) => {
+            client.importPrivKey(privateKey, '', false, (error, result) => {
+                if (error) reject(error);
+                else resolve(result);
+            });
+        });
+
+        console.log('Private key imported successfully into the wallet.');
+
+    } catch (error) {
+        console.error('Error during address creation and import:', error);
+    }
+}
+
+createAndImportAddress();

package/tradelayer.js/utils/createAttestation.js

@@ -0,0 +1,133 @@
+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 interface = require('../src/walletInterface.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'));
+
+// Admin Address
+const adminAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8';
+
+
+// Function to fetch balances for a specific address
+async function getTokenBalancesForAddress(address) {
+    try {
+        const response = await axios.post('http://localhost:3000/tl_getAllBalancesForAddress', {
+            params: address
+        });
+        console.log(data)
+        return response.data;
+    } catch (error) {
+        console.error(`Error fetching balances for ${address}:`, error.message);
+        throw error;
+    }
+}
+
+// Function to find the first address with $TL balance
+async function findAddressWithTLBalance() {
+    try {
+        console.log('Fetching all UTXOs to find wallet addresses...');
+        const unspentOutputs = await listUnspentAsync(0, 9999999);
+
+        // Extract unique addresses from UTXOs
+        const uniqueAddresses = [...new Set(unspentOutputs.map(utxo => utxo.address))];
+        console.log(JSON.stringify(uniqueAddresses))
+        console.log(`Found ${uniqueAddresses.length} addresses. Checking for TL balance...`);
+
+        // Loop through each address and fetch balances
+        for (const address of uniqueAddresses) {
+            if (address === adminAddress) continue; // Skip admin address
+
+            const balances = await getTokenBalancesForAddress(address);
+
+            // Check if property ID 1 (TL) has a balance > 0
+            if (balances['1'] && balances['1'].amount > 0) {
+                console.log(`Address with TL Balance found: ${address}`);
+                return address;
+            }
+        }
+
+        throw new Error('No address with TL balance found.');
+    } catch (error) {
+        console.error('Error finding address with TL balance:', error.message);
+        throw error;
+    }
+}
+
+// Build, sign, and broadcast transaction
+async function buildSignAndSendTransaction(fromAddress, metadata) {
+    try {
+        console.log('Preparing transaction...');
+
+        // Step 1: Dump private key and get UTXOs
+        const privateKeyWIF = await dumpPrivKeyAsync(fromAddress);
+        const privateKey = litecore.PrivateKey.fromWIF(privateKeyWIF);
+        const unspentOutputs = await listUnspentAsync(0, 9999999, [fromAddress]);
+
+        if (!unspentOutputs.length) throw new Error('No unspent outputs available.');
+
+        // Step 2: Select the largest UTXO
+        const largestUTXO = unspentOutputs.reduce((prev, curr) => prev.amount > curr.amount ? prev : curr);
+
+        console.log('Using UTXO:', largestUTXO);
+
+        // Step 3: Create and sign transaction
+        const utxo = {
+            txId: largestUTXO.txid,
+            outputIndex: largestUTXO.vout,
+            script: largestUTXO.scriptPubKey,
+            satoshis: Math.floor(largestUTXO.amount * 1e8)
+        };
+
+        const params = {revoke:0, id:0, targetAddress:fromAddress,metaData:metadata}
+
+        const payload = encoder.encodeIssueOrRevokeAttestation(params)
+
+        const transaction = new litecore.Transaction()
+            .from(utxo) // UTXO input
+            .addOutput(new litecore.Transaction.Output({
+                satoshis: 1000, // small OP_RETURN fee
+                script: litecore.Script.buildDataOut(payload) // Embed metadata in OP_RETURN
+            }))
+            .change(fromAddress) // Change back to sender
+            .sign(privateKey); // Sign transaction
+
+        console.log('Raw Transaction Hex:', transaction.toString());
+
+        // Step 4: Broadcast 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 issue attestation
+async function issueAttestation(metadata) {
+    try {
+        const fromAddress = await findAddressWithTLBalance();
+        console.log(`Sending attestation from ${fromAddress} with metadata: ${metadata}`);
+        await buildSignAndSendTransaction(fromAddress, metadata);
+    } catch (error) {
+        console.error('Failed to issue attestation:', error.message);
+    }
+}
+
+// Run the attestation script
+buildSignAndSendTransaction('tltc1qn3src8lgu50gxhndn5hnd6zrc9yv2364wu858m','CL');

package/tradelayer.js/utils/createContract.js

@@ -0,0 +1,118 @@
+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: 19332, // 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 BTC_PRICE_API_URL = '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(BTC_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.');
+
+        const underlyingOracleId = 2; // Replace with your underlying oracle ID
+const collateralPropertyId = 5; // Replace with your collateral property ID
+const leverage = 10; // Example leverage
+const expiryPeriod = 4032; // Example expiry period
+const series = 5; 
+        // 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 = {
+            native: false,
+            underlyingOracleId: 2,
+            onChainData: '',
+            notionalPropertyId: 0,
+            notionalValue: 1,
+            collateralPropertyId: 's1-1',
+            leverage: leverage,
+            expiryPeriod: expiryPeriod,
+            series: series,
+            inverse: true,
+            fee: false
+        }
+
+        const payload = encoder.encodeCreateFutureContractSeries(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 createContract() {
+    //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);
+    //}
+}
+
+createContract()

package/tradelayer.js/utils/createOracle.js

@@ -0,0 +1,94 @@
+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 interface = require('../src/walletInterface.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'));
+
+// Admin Address
+const adminAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8';
+
+// Build, sign, and broadcast transaction
+async function buildSignAndSendTransaction(fromAddress) {
+    try {
+        console.log('Preparing transaction...');
+
+        // Step 1: Dump private key and get UTXOs
+        const privateKeyWIF = await dumpPrivKeyAsync(fromAddress);
+        console.log('priv key '+privateKeyWIF)
+        const privateKey = litecore.PrivateKey.fromWIF(privateKeyWIF);
+        const unspentOutputs = await listUnspentAsync(0, 9999999, [fromAddress]);
+
+        if (!unspentOutputs.length) throw new Error('No unspent outputs available.');
+
+        // Step 2: Select the largest UTXO
+        const largestUTXO = unspentOutputs.reduce((prev, curr) => prev.amount > curr.amount ? prev : curr);
+
+        console.log('Using UTXO:', largestUTXO);
+
+        // Step 3: Create and sign transaction
+        const utxo = {
+            txId: largestUTXO.txid,
+            outputIndex: largestUTXO.vout,
+            script: largestUTXO.scriptPubKey,
+            satoshis: Math.floor(largestUTXO.amount * 1e8)
+        };
+
+        const params = {ticker:"LTC/USD", url:'', backupAddress:'', whitelists:[],lag:3}
+
+        const payload = encoder.encodeCreateOracle(params)
+
+        if (payload.length > 80) {
+            throw new Error('Payload exceeds OP_RETURN data size limit.');
+        }
+
+
+        const transaction = new litecore.Transaction()
+            .from(utxo) // UTXO input
+            .addOutput(new litecore.Transaction.Output({
+                satoshis: 0, // small OP_RETURN fee
+                script: litecore.Script.buildDataOut(payload) // Embed metadata in OP_RETURN
+            }))
+            .change(fromAddress) // Change back to sender
+            .sign(privateKey); // Sign transaction
+
+        console.log('Raw Transaction Hex:', transaction.toString());
+
+        // Step 4: Broadcast transaction
+        const txid = await sendrawtransactionAsync(transaction.uncheckedSerialize());
+        console.log(`Transaction broadcasted successfully. TXID: ${txid}`);
+    } catch (error) {
+        console.error('Error building/signing transaction:', error.message);
+        throw error;
+    }
+}
+
+// Main function to issue attestation
+async function issueAttestation(address, metadata) {
+    try {
+        const fromAddress = await findAddressWithTLBalance();
+        console.log(`Sending attestation from ${fromAddress} with metadata: ${metadata}`);
+        await buildSignAndSendTransaction(fromAddress, metadata);
+    } catch (error) {
+        console.error('Failed to issue attestation:', error.message);
+    }
+}
+
+// Run the attestation script
+buildSignAndSendTransaction('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8');
+