@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/oldTests/extractBlocksVanillaa.js

@@ -0,0 +1,179 @@
+const litecoin = require('litecoin');
+const fs = require('fs');
+const json = require('big-json');
+const blockData = [];
+var chainHeight = 0
+var protocolBlocks = [{ height: 0, omTx: [], tlTx: [] }]
+var txIndexomni = []
+var indexPlaceholder = 0
+var thisBlockOm = []
+var thisBlockTl = []
+var omniTxCount = 0
+
+const client = new litecoin.Client({
+    host: '127.0.0.1',
+    port: 8332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+function decodeOPReturnPayload(hexPayload) {
+    // Decode the payload and return the decoded data
+    // ...
+
+    // Example code
+    const decodedData = Buffer.from(hexPayload, 'hex').toString('utf8');
+    return decodedData;
+}
+
+function extractBlockData(startHeight) {
+    client.getBlockCount(function (error, chainTip) {
+        if (error) {
+            console.error('Error retrieving chain tip:', error);
+            return;
+        } else { chainHeight = chainTip }
+
+        getBlockData(startHeight);
+    });
+}
+
+function getBlockData(height) {
+    console.log(height)
+    client.getBlockHash(height, function (error, blockHash) {
+        if (error) {
+            console.error('Error retrieving block hash:', error);
+            return;
+        }
+
+        client.getBlock(blockHash, function (error, currentBlock) {
+            if (error) {
+                console.error('Error retrieving block data:', error);
+                return;
+            }
+
+            blockData.push(currentBlock);
+
+            if (currentBlock.height === startHeight + 3) {
+                console.log('Block data extraction completed.');
+                extractProtocolTx(startHeight, false)
+            } else {
+                getBlockData(height + 1);
+            }
+        });
+    });
+}
+
+function makeFile(filename, pojo) {
+
+    const stringifyStream = json.createStringifyStream({
+        body: pojo
+    });
+
+    stringifyStream.on('data', function (strChunk) {
+        fs.appendFile(filename, strChunk, function (err) {
+            if (err) throw err;
+        })
+    });
+
+}
+
+// Example usage
+const startHeight = 2098224;
+extractBlockData(startHeight);
+
+function extractProtocolTx(start, finishBlock) {
+    //console.log(blockData)
+    if (finishBlock == true) {
+        if (protocolBlocks.omTx != [] || tlTx != []) {
+            protocolBlocks.push({ height: start, omTx: thisBlockOm, tlTX: thisBlockTl })
+            thisBlockOm = []
+            thisBlockTl = []
+        }
+    }
+    indexPlaceholder = start
+    var placement = start - startHeight
+    console.log(placement, start)
+    var thisBlock = blockData[placement]
+
+    if (start >= startHeight + 200000) {
+        var obj = JSON.stringify(protocolBlocks)
+        makeFile('protocolTxIndex.json', protocolBlocks)
+        console.log("ta da!!")
+        return true
+    }
+    loopThroughBlock(thisBlock, 0)
+}
+
+function loopThroughBlock(block, i) {
+    if (block != undefined) {
+        console.log(block.height, i, block.tx.length);
+    } else { extractProtocolTx(null, true) }
+
+    if (block === undefined) {
+        console.log("Jim, abort! Block undefined");
+        return extractProtocolTx(indexPlaceholder + 1, true)
+    } else if (i >= block.tx.length) {
+        console.log("Jim, abort! i >= tx.length block done!");
+        return extractProtocolTx(block.height + 1, true)
+    }
+
+    var tx = block.tx[i];
+
+    if (tx === undefined || tx === '') {
+        console.log("Jim, abort!");
+        return loopThroughBlock(block, i + 1);
+    }
+
+    try {
+        client.getRawTransaction(tx, true, function (err, rawtx) {
+
+            if (err && err.code === -5) {
+                // "No such mempool transaction" error, skip this transaction
+                console.error("Skipping transaction:", tx, "Error:", err.message);
+                return loopThroughBlock(block, i + 1);
+            } else if (err) {
+                // Handle other errors as needed
+                console.error("Error processing transaction:", err);
+                return loopThroughBlock(block, i + 1);
+            }
+
+            // Process the transaction as normal
+
+            let confirmations;
+            try {
+                confirmations = rawtx.confirmations;
+            } catch {
+                return loopThroughBlock(block, i + 1);
+            }
+
+            var thisConfirmations = confirmations;
+
+            for (let v = 0; v < rawtx.vout.length; v++) {
+                // ... Rest of your code
+            }
+
+            // Move to the next transaction
+            loopThroughBlock(block, i + 1);
+        });
+    } catch (error) {
+        console.error("Error processing transaction:", error);
+        // Handle the error gracefully if necessary
+        loopThroughBlock(block, i + 1);
+    }
+}
+
+function decodeOmniPayload(hexPayload) {
+    const marker = hexPayload.slice(0, 4);
+
+    if (marker === '6f6d') {
+        // Decode 'om' marker
+        return "omni"
+    } else if (marker === '746c') {
+        // Decode 'tl' marker
+        return "tl"
+    } else {
+        // Unknown marker
+        return { error: 'Unknown marker' };
+    }
+}

package/tradelayer.js/oldTests/extractPubkeyTest.js

@@ -0,0 +1,60 @@
+const Litecoin = require('litecoin');
+const util = require('util');
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+// Promisify the necessary RPC commands
+const getrawtransactionAsync = util.promisify(client.cmd.bind(client, 'getrawtransaction'));
+const decoderawtransactionAsync = util.promisify(client.cmd.bind(client, 'decoderawtransaction'));
+
+async function getScriptPubKeyFromRawTx(rawTx, address) {
+    try {
+        // Decode the raw transaction
+        const decodedTx = await decoderawtransactionAsync('decoderawtransaction', rawTx);
+
+        // Find the output with the matching address
+        const matchingOutput = decodedTx.vout.find(output => 
+            output.scriptPubKey.addresses && output.scriptPubKey.addresses.includes(address));
+
+        if (matchingOutput) {
+            console.log(`ScriptPubKey for address ${address}:`, matchingOutput.scriptPubKey.hex);
+            return matchingOutput.scriptPubKey.hex;
+        } else {
+            throw new Error(`Address not found in transaction outputs`);
+        }
+    } catch (error) {
+        console.error(`Error retrieving scriptPubKey:`, error);
+        throw error;
+    }
+}
+
+async function getAndDecodeRawTransaction(txid) {
+    try {
+        // Retrieve the raw transaction hex string using the transaction ID
+        const rawTx = await getrawtransactionAsync(txid);
+        console.log(`Raw Transaction Hex: ${rawTx}`);
+
+        // Decode the raw transaction
+        const decodedTx = await decoderawtransactionAsync('decoderawtransaction', rawTx);
+        console.log('Decoded Transaction:', decodedTx);
+
+        // Get the scriptPubKey for a specific address
+        await getScriptPubKeyFromRawTx(rawTx, 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8');
+
+        return decodedTx;
+    } catch (error) {
+        console.error(`Error retrieving and decoding raw transaction:`, error);
+        throw error;
+    }
+}
+
+// Example usage
+const txid = '57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5';
+getAndDecodeRawTransaction(txid)
+    .then(decodedTx => console.log(`Decoded Transaction:`, decodedTx))
+    .catch(error => console.error(`Error: ${error.message}`));

package/tradelayer.js/oldTests/fillInputCacheProto.js

@@ -0,0 +1,111 @@
+const nCacheSize = 500000; // Define the cache size (you can adjust this value)
+
+async function fillTxInputCache(tx, removedCoins) {
+    // Simulate clearing the cache when it exceeds the cache size
+    if (viewCacheSize > nCacheSize) {
+        console.log(`${fillTxInputCache.name}: clearing cache before insertion [size=${viewCacheSize}]`);
+        await flushView();
+    }
+
+    for (const txIn of tx.vin) {
+        const prevout = txIn.prevout;
+        const coin = await accessCoin(prevout);
+
+        if (!coin.isSpent) {
+            nCacheHits++;
+        } else {
+            nCacheMiss++;
+        }
+
+        let txPrev, hashBlock;
+        let newcoin = new Coin(); // Create a new coin
+
+        if (removedCoins && removedCoins[prevout.toString()]) {
+            newcoin = removedCoins[prevout.toString()];
+        } else if (await getTransaction(prevout.hash, txPrev, Params().getConsensus(), hashBlock)) {
+            const nOut = prevout.n;
+            newcoin.out.scriptPubKey = txPrev.vout[nOut].scriptPubKey;
+            newcoin.out.nValue = txPrev.vout[nOut].nValue;
+
+            const blockIndex = mapBlockIndex[hashBlock];
+            newcoin.nHeight = blockIndex ? blockIndex.nHeight : 1;
+        } else {
+            return false;
+        }
+
+        await addCoin(prevout, newcoin, true);
+    }
+
+    return true;
+}
+
+// Simulated view cache size and related functions
+let viewCacheSize = 0;
+const viewCache = {}; // Simulated coin view cache
+
+async function accessCoin(prevout) {
+    const key = prevout.toString();
+    if (viewCache[key]) {
+        return viewCache[key];
+    }
+    // Simulate coin retrieval logic here if not in cache
+    return new Coin();
+}
+
+async function addCoin(prevout, coin, isSpent) {
+    viewCache[prevout.toString()] = coin;
+    viewCacheSize++;
+    // Simulate adding the coin to the cache
+}
+
+async function flushView() {
+    viewCacheSize = 0;
+    viewCache = {};
+    // Simulate clearing the cache
+}
+
+// Simulated Coin and related functions
+class Coin {
+    constructor() {
+        this.isSpent = true; // Simulated spent state
+        this.out = {
+            scriptPubKey: '',
+            nValue: 0,
+        };
+        this.nHeight = 0;
+    }
+}
+
+// Simulated getTransaction function
+async function getTransaction(hash, txPrev, consensus, hashBlock) {
+    // Simulate transaction retrieval logic here
+    return false;
+}
+
+// Simulated Params class and related functions
+class Params {
+    getConsensus() {
+        // Simulate getting consensus parameters
+        return {};
+    }
+}
+
+// Simulated nCacheHits and nCacheMiss
+let nCacheHits = 0;
+let nCacheMiss = 0;
+
+// Example usage:
+const removedCoins = {}; // Simulated removedCoins map
+const tx = {}; // Simulated transaction
+
+fillTxInputCache(tx, removedCoins)
+    .then((result) => {
+        if (result) {
+            console.log('Successfully filled the transaction input cache.');
+        } else {
+            console.error('Failed to fill the transaction input cache.');
+        }
+    })
+    .catch((error) => {
+        console.error('An error occurred:', error);
+    });

package/tradelayer.js/oldTests/getRawTxTest.js

@@ -0,0 +1,22 @@
+const litecoin = require('litecoin');
+
+const client = new litecoin.Client({
+    host: '127.0.0.1',
+    port: 8332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+const tx = "85f459ae3422aff3e01c2ba240605f997befd2a639d87b3b72b5456a8aeaf610";
+
+console.log("Fetching raw transaction...");
+
+client.getRawTransaction(tx, true, function(err, rawtx) {
+  if (err) {
+    console.error(err);
+    return;
+  }
+
+  console.log(rawtx);
+});

package/tradelayer.js/oldTests/indexTest.js

@@ -0,0 +1,26 @@
+const TxIndex = require('./txIndex.js');
+
+async function runUnitTest() {
+    const genesisBlock = 3082500;
+    try {
+        console.log(`Initializing index from genesis block: ${genesisBlock}`);
+        await TxIndex.initializeIndex(genesisBlock,true);
+    
+        console.log(`Extracting block data starting from block: ${genesisBlock}`);
+        await TxIndex.extractBlockData(genesisBlock);
+
+        if (txIndex.transparentIndex.includes('00')) {
+            console.log("Payload 'tl00' found in the index.");
+        } else {
+            console.log("Payload 'tl00' not found in the index.");
+        }
+
+        const loadedIndex = await TxIndex.loadIndex(); // Corrected to call static method
+        console.log('Loaded index:', loadedIndex);
+
+    } catch (error) {
+        console.error('Error during unit test:', error);
+    }
+}
+
+runUnitTest();

package/tradelayer.js/oldTests/initTokensTest.js

@@ -0,0 +1,32 @@
+const TxIndex = require('./txIndex.js')
+const Main = require('./main.js'); // Replace with the correct path
+const TallyMap = require('./tally.js'); // Replace with the correct path
+
+// Define the admin address
+const adminAddress = "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8";
+
+async function runIntegrationTest() {
+    console.log("Starting integration test...");
+
+    // Access the singleton instance of Main
+    //await TxIndex.clearTxIndex()
+    //await TxIndex.resetIndexFlag();
+    const mainProcessor = Main.getInstance(test=true);
+    await mainProcessor.initialize(); // Assuming init() initializes the entire flow
+
+    // Monitor the progress
+    console.log("Transaction Index Completed");
+    console.log("Consensus Completed");
+
+    // Trigger activation transaction (tx type "0")
+    //await mainProcessor.triggerActivationTransaction(adminAddress, 0);
+    console.log("Activation Transaction Processed");
+
+    // Check the balance in the tally map for the admin address
+    const balance = await TallyMap.getAddressBalances(adminAddress);
+    console.log(`Balance for admin address ${adminAddress}:`, balance);
+
+    console.log("Integration test completed.");
+}
+
+runIntegrationTest().catch(console.error);

package/tradelayer.js/oldTests/interfaceChild.js

@@ -0,0 +1,129 @@
+const { fork } = require('child_process');
+
+class InterfaceChild {
+    constructor() {
+        // Forking the main process
+        this.mainProcess = fork('./main.js');
+
+        this.mainProcess.on('message', (message) => {
+            console.log('Message from main process:', message);
+        });
+
+        this.mainProcess.on('error', (error) => {
+            console.error('Error in main process:', error);
+        });
+
+        this.mainProcess.on('exit', (code) => {
+            console.log(`Main process exited with code ${code}`);
+        });
+    }
+
+    async sendCommandToMainProcess(command, args) {
+        return new Promise((resolve, reject) => {
+            this.mainProcess.send({ command, args });
+            this.mainProcess.once('message', (response) => {
+                if (response.error) {
+                    reject(response.error);
+                } else {
+                    resolve(response.data);
+                }
+            });
+        });
+    }
+
+    async initMain() {
+        return await this.sendCommandToMainProcess('initMain');
+    }
+
+    // Example method: Get balances for an address
+    async getAllBalancesForAddress(address) {
+        return await this.sendCommandToMainProcess('getAllBalancesForAddress', { address });
+    }
+
+    // Method: Get transaction details
+    async getTransaction(txid) {
+        return await this.sendCommandToMainProcess('getTransaction', { txid });
+    }
+
+    // Method: Get property details
+    async getProperty(propertyId) {
+        return await this.sendCommandToMainProcess('getProperty', { propertyId });
+    }
+
+    // ... Integrate all other methods from Interface.js ...
+
+    // For example, a method to list all properties
+    async listProperties() {
+        return await this.sendCommandToMainProcess('listProperties');
+    }
+
+    // Method to list all activations
+    async listActivations() {
+        return await this.sendCommandToMainProcess('listActivations');
+    }
+
+
+    async getConsensusHashForBlock(blockHeight) {
+        return await this.sendCommandToMainProcess('getConsensusHashForBlock', { blockHeight });
+    }
+
+    async getFeatureActivationStatus(featureId) {
+        return await this.sendCommandToMainProcess('getFeatureActivationStatus', { featureId });
+    }
+
+    async getAllBalancesForAddress(address) {
+        return await this.sendCommandToMainProcess('getAllBalancesForAddress', { address });
+    }
+
+    async getTotalTokens(propertyId) {
+        return await this.sendCommandToMainProcess('getTotalTokens', { propertyId });
+    }
+
+    async getBalancesAcrossAllWallets() {
+        return await this.sendCommandToMainProcess('getBalancesAcrossAllWallets');
+    }
+
+    async isTransactionTypeActive(txType) {
+        return await this.sendCommandToMainProcess('isTransactionTypeActive', { txType });
+    }
+
+    async getAllActiveTransactionTypes() {
+        return await this.sendCommandToMainProcess('getAllActiveTransactionTypes');
+    }
+
+    async getAddressesWithBalanceForProperty(propertyId) {
+        return await this.sendCommandToMainProcess('getAddressesWithBalanceForProperty', { propertyId });
+    }
+
+    async getTransaction(txid) {
+        return await this.sendCommandToMainProcess('getTransaction', { txid });
+    }
+
+    async getProperty(propertyId) {
+        return await this.sendCommandToMainProcess('getProperty', { propertyId });
+    }
+
+    async listProperties() {
+        return await this.sendCommandToMainProcess('listProperties');
+    }
+
+    async getGrants(propertyId) {
+        return await this.sendCommandToMainProcess('getGrants', { propertyId });
+    }
+
+    async getPayToToken(propertyId) {
+        return await this.sendCommandToMainProcess('getPayToToken', { propertyId });
+    }
+
+    async listBlockTransactions(blockIndex) {
+        return await this.sendCommandToMainProcess('listBlockTransactions', { blockIndex });
+    }
+
+    async listPendingTransactions(addressFilter) {
+        return await this.sendCommandToMainProcess('listPendingTransactions', { addressFilter });
+    }
+
+    // ... Continue adding all methods from Interface.js ...
+}
+
+module.exports = InterfaceChild;

package/tradelayer.js/oldTests/listenerChild.js

@@ -0,0 +1,112 @@
+const TallyMap = require('./tally');
+const TxIndex = require('./TxIndex');
+const PropertyManager = require('./property');
+const Interface = require('./Interface');
+const interfaceInstance = new Interface();
+const Main = require('./main.js')
+
+// ... Import other necessary modules ...
+
+async function listen() {
+     process.on('message', async (message) => {
+        console.log('Child process received message:', message);
+        try {
+            const { command, args } = message;
+            switch (command) {
+
+                case 'initMain':
+                    console.log('initializing')
+                     const mainProcessor = Main.getInstance(test = true); // Assuming 'test' is a parameter for testing
+                     mainProcessor.initialize();
+                    
+                    // Send a response back to the child process to indicate successful initialization
+                    process.send({ data: 'Main process initialized successfully' });
+                    break;
+
+                case 'getAllBalancesForAddress':
+                    const balances = await TallyMap.getAddressBalances(args.address);
+                    process.send({ data: balances });
+                    break;
+
+                case 'getTransaction':
+                    const transaction = await TxIndex.getTransactionDetails(args.txid);
+                    process.send({ data: transaction });
+                    break;
+
+
+                case 'getConsensusHashForBlock':
+                    result = await interfaceInstance.getConsensusHashForBlock(args.blockHeight);
+                    break;
+
+                case 'getFeatureActivationStatus':
+                    result = await interfaceInstance.getFeatureActivationStatus(args.featureId);
+                    break;
+
+                case 'getAllBalancesForAddress':
+                    result = await interfaceInstance.getAllBalancesForAddress(args.address);
+                    break;
+
+                case 'getTotalTokens':
+                    result = await interfaceInstance.getTotalTokens(args.propertyId);
+                    break;
+
+                case 'getBalancesAcrossAllWallets':
+                    result = await interfaceInstance.getBalancesAcrossAllWallets();
+                    break;
+
+                case 'isTransactionTypeActive':
+                    result = await interfaceInstance.isTransactionTypeActive(args.txType);
+                    break;
+
+                case 'getAllActiveTransactionTypes':
+                    result = await interfaceInstance.getAllActiveTransactionTypes();
+                    break;
+
+                case 'getAddressesWithBalanceForProperty':
+                    result = await interfaceInstance.getAddressesWithBalanceForProperty(args.propertyId);
+                    break;
+
+                case 'getTransaction':
+                    result = await interfaceInstance.getTransaction(args.txid);
+                    break;
+
+                case 'getProperty':
+                    result = await interfaceInstance.getProperty(args.propertyId);
+                    break;
+
+                case 'listProperties':
+                    result = await interfaceInstance.listProperties();
+                    break;
+
+                case 'getGrants':
+                    result = await interfaceInstance.getGrants(args.propertyId);
+                    break;
+
+                case 'getPayToToken':
+                    result = await interfaceInstance.getPayToToken(args.propertyId);
+                    break;
+
+                case 'listBlockTransactions':
+                    result = await interfaceInstance.listBlockTransactions(args.blockIndex);
+                    break;
+
+                case 'listBlocksTransactions':
+                    result = await interfaceInstance.listBlocksTransactions(args.firstBlock, args.lastBlock);
+                    break;
+
+                case 'listPendingTransactions':
+                    result = await interfaceInstance.listPendingTransactions(args.addressFilter);
+                    break;
+
+                // ... Add other cases for each method in Interface.js ...
+
+                default:
+                    process.send({ error: 'Unknown command' });
+            }
+        } catch (error) {
+            process.send({ error: error.message });
+        }
+    });
+}
+
+module.exports = listen;