@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/tests/tallyTest.js

@@ -0,0 +1,40 @@
+const assert = require('assert');
+const TallyMap = require('./tallyMap.js');
+
+describe('TallyMap', function() {
+    let tallyMap;
+
+    before(function() {
+        tallyMap = new TallyMap();
+    });
+
+    it('should update and retrieve balances', function() {
+        const testAddress = 'address1';
+        const propertyId = 1;
+        tallyMap.updateBalance(testAddress, propertyId, 100, 80, 20);
+
+        const balances = tallyMap.getAddressBalances(testAddress);
+        assert.strictEqual(balances.length, 1);
+        assert.strictEqual(balances[0].propertyId, propertyId.toString());
+        assert.strictEqual(balances[0].amount, 100);
+        assert.strictEqual(balances[0].available, 80);
+        assert.strictEqual(balances[0].reserved, 20);
+    });
+
+    it('should not allow negative balances', function() {
+        const testAddress = 'address2';
+        const propertyId = 2;
+
+        assert.throws(() => {
+            tallyMap.updateBalance(testAddress, propertyId, -100, -50, -50);
+        }, /Balance cannot go negative/);
+    });
+
+    it('should calculate total tokens correctly', function() {
+        const propertyId = 1;
+        const total = tallyMap.totalTokens(propertyId);
+        assert.strictEqual(total, 100); // Total from previous test
+    });
+
+    // Additional tests for save, load, getTally, etc.
+});

package/tradelayer.js/tests/testBuybacks.js

@@ -0,0 +1,46 @@
+const assert = require('assert'); // Assertion library
+const sinon = require('sinon'); // Mocking library (if needed)
+const TradeLayerManager = require('./path/to/TradeLayerManager'); // The module under test
+
+describe('TradeLayerManager', function() {
+    let tradeLayerManager;
+    let mockDependencies; // Mock any dependencies
+
+    beforeEach(function() {
+        // Set up for each test
+        tradeLayerManager = new TradeLayerManager();
+        mockDependencies = sinon.stub(/* ... */);
+    });
+
+    afterEach(function() {
+        // Clean up after each test
+        sinon.restore();
+    });
+
+    describe('performBuyback', function() {
+        it('should calculate buyback amount correctly based on order book', function() {
+            // Simulate fee cache and order book data
+            const feeCache = /* mock fee cache data */;
+            const orderBook = /* mock order book data */;
+
+            // Perform buyback
+            tradeLayerManager.performBuyback([feeCache]);
+
+            // Assert the buyback amount is calculated correctly
+            const expectedBuybackAmount = /* calculate expected buyback amount */;
+            assert.equal(tradeLayerManager.getBuybackAmount(), expectedBuybackAmount);
+        });
+
+        it('should execute buyback transactions correctly', function() {
+            // Simulate fee cache and order book data
+            const feeCache = /* mock fee cache data */;
+            const orderBook = /* mock order book data */;
+
+            // Perform buyback
+            tradeLayerManager.performBuyback([feeCache]);
+
+            // Assert buyback transactions are executed as expected
+            // This may include checking the change in order book, token balances, etc.
+        });
+    });
+}

package/tradelayer.js/tests/testCodeHash.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+// Define file names
+const jsFiles = [
+    'activation', 'amm', 'channels', 'clearing', 'clearlist', 'consensus', 'contractRegistry',
+    'insurance', 'logic', 'main', 'marginMap', 'options', 'oracle', 'orderbook',
+    'persistence', 'property', 'reOrg', 'tally', 'txDecoder', 'txIndex', 'types',
+    'validity', 'vaults', 'vesting', 'volumeIndex'
+];
+
+// Function to hash files in the specified folder
+async function hashFiles(basePath) {
+    try {
+        let combinedContent = ''; // Initialize empty string to hold combined file content
+
+        // Loop through each file, read its content, and append to combinedContent
+        for (const file of jsFiles) {
+            const filePath = path.join(basePath, `../src/${file}.js`);
+
+            if (fs.existsSync(filePath)) {
+                const fileContent = fs.readFileSync(filePath, 'utf8');
+                combinedContent += fileContent; // Append file content
+            } else {
+                console.warn(`File not found: ${filePath}`); // Warn if the file is missing
+            }
+        }
+
+        // Stringify the combined content
+        const combinedContentString = JSON.stringify(combinedContent);
+
+        // Generate a SHA-256 hash of the combined content
+        const hash = crypto.createHash('sha256');
+        hash.update(combinedContentString);
+        const finalHash = hash.digest('hex');
+
+        console.log('Final SHA-256 Hash:', finalHash);
+        return finalHash;
+    } catch (err) {
+        console.error('Error reading or hashing files:', err);
+    }
+}
+
+// Test the function
+(async () => {
+    const projectPath = path.resolve(__dirname);  // Specify path to the tradelayer project
+    await hashFiles(projectPath);
+})();

package/tradelayer.js/tests/testConsensusHash.js

@@ -0,0 +1,91 @@
+const crypto = require('crypto');
+const db = require('../src/db.js'); // Assuming db.js is correctly set up
+const client = require('../src/client.js').getInstance()
+
+class ConsensusDatabase {
+    // Function to generate SHA-256 hash
+    static generateHash(input) {
+        const hash = crypto.createHash('sha256');
+        hash.update(input);
+        return hash.digest('hex');
+    }
+
+    // Function to get the latest instance of a DB
+    static async getLatestInstance(dbName) {
+        const base = await db.getDatabase(dbName)
+        const data = await base.findAsync({});
+        return data.length > 0 ? data[data.length - 1] : null; // Get the latest entry
+    }
+
+    // Function to get all instances from a DB
+    static async getAllInstances(dbName) {
+        const base = await db.getDatabase(dbName)
+        const data = await base.findAsync({});
+        return data; // Return all entries
+    }
+
+    // Function to generate stateConsensusHash based on various DBs
+    static async stateConsensusHash() {
+        try {
+            // Retrieve latest instance from tally.db and activations.db
+            const latestTally = await this.getLatestInstance('tallyMap');
+            const latestActivation = await this.getLatestInstance('activations');
+
+            // Retrieve everything from other specified DBs
+            const channels = await this.getAllInstances('channels');
+            const clearlists = await this.getAllInstances('clearlists');
+            const contractList = await this.getAllInstances('contractList');
+            const feeCache = await this.getAllInstances('feeCache');
+            const insurance = await this.getAllInstances('insurance');
+            const marginMaps = await this.getAllInstances('marginMaps');
+            const oracleData = await this.getAllInstances('oracleData');
+            const oracleList = await this.getAllInstances('oracleList');
+            const orderBooks = await this.getAllInstances('orderBooks');
+            const propertyList = await this.getAllInstances('propertyList');
+            const syntheticTokens = await this.getAllInstances('syntheticTokens');
+            const vaults = await this.getAllInstances('vaults');
+            const volumeIndex = await this.getAllInstances('volumeIndex');
+            const withdrawQueue = await this.getAllInstances('withdrawQueue');
+
+            // Combine all the retrieved data into a single structure
+            const combinedState = {
+                latestTally,
+                latestActivation,
+                channels,
+                clearlists,
+                contractList,
+                feeCache,
+                insurance,
+                marginMaps,
+                oracleData,
+                oracleList,
+                orderBooks,
+                propertyList,
+                syntheticTokens,
+                vaults,
+                volumeIndex,
+                withdrawQueue
+            };
+
+            // Convert combined data to string
+            const combinedStateString = JSON.stringify(combinedState);
+
+            // Generate and return the SHA-256 hash of the combined state
+            const hash = this.generateHash(combinedStateString);
+            console.log('stateConsensusHash:', hash);
+            return hash;
+
+        } catch (err) {
+            console.error('Error generating stateConsensus hash:', err);
+        }
+    }
+}
+
+// Test the stateConsensusHash function
+(async () => {
+    
+    await db.init('ltc')
+    console.log('Generating stateConsensusHash...');
+    const stateHash = await ConsensusDatabase.stateConsensusHash();
+    console.log('Generated stateConsensusHash:', stateHash);
+})();

package/tradelayer.js/tests/testDecode.js

@@ -0,0 +1,30 @@
+function testDecode(opReturnData){
+	
+            // Check if the hex contains the marker "746c" (which corresponds to "tl")
+            let markerHex = "746c"; // Hex for "tl"
+            let payloadStart = 8;
+            let markerPosition = opReturnData.indexOf(markerHex); // Check if the marker is anywhere in the string
+            if (markerPosition === -1 || markerPosition > 6) {
+                console.log('Marker "tl" not found or in an invalid position.');
+                return null;
+            } else if (markerHex === opReturnData.substring(4, 8)) {
+                payloadStart = 8;
+            } else if (markerHex === opReturnData.substring(5, 9)) {
+                payloadStart = 9;
+            } else if (markerHex === opReturnData.substring(6, 10)) {
+                payloadStart = 10;
+            }
+
+            // Extract and log the actual payload
+            const payloadHex = opReturnData.substring(payloadStart);
+            const payload = Buffer.from(payloadHex, 'hex').toString();
+            console.log(`Marker: ${markerHex}, Payload: ${payload}`);
+
+            if (markerHex === '746c') {
+                console.log('Pre-decoded and Decoded Payload:', opReturnData + ' ' + payload);
+            }
+
+            return { marker: 'tl', payload, decodedTx };
+}
+
+payload= ''

package/tradelayer.js/tests/testEncodingLengths.js

@@ -0,0 +1,129 @@
+const axios = require('axios');
+const baseConverter = require('bigint-base-converter');
+let txCount = 0
+
+// Litecoin Core RPC Config
+const rpcConfig = {
+    url: 'http://127.0.0.1:18332',
+    auth: {
+        username: 'user', // Replace with your Litecoin Core RPC username
+        password: 'pass'  // Replace with your Litecoin Core RPC password
+    }
+};
+
+// Base 94 and Base 128 Character Sets
+const base94Chars = [...Array(94).keys()].map(i => String.fromCharCode(i + 33));
+const base128Chars = Array.from({ length: 128 }, (_, i) => String.fromCharCode(i + 128));
+
+// Define Custom Character Set, Filtering Out Problematic Characters
+const allCharacters = [...Array(65536).keys()].map(i => String.fromCharCode(i));
+const customBase256Chars = allCharacters.filter(
+    char => !/[\s\u0000-\u001F\u007F-\u00A0\u00AD\u2028\u2029]/.test(char)
+).slice(0, 256);
+
+// Check if the character set meets the base requirements
+if (customBase256Chars.length !== 256) {
+    console.warn(`Character set only contains ${customBase256Chars.length} characters, switching to smaller base.`);
+}
+
+// Encoding Functions
+function hexToBase94(hex) {
+    const decimalString = BigInt(`0x${hex}`).toString(10);
+    return baseConverter(decimalString, 10, base94Chars.join(''));
+}
+
+function hexToBase128(hex) {
+    const decimalString = BigInt(`0x${hex}`).toString(10);
+    return baseConverter(decimalString, 10, base128Chars.join(''));
+}
+
+function hexToCustomBase256(hex) {
+    const decimalString = BigInt(`0x${hex}`).toString(10);
+    return baseConverter(decimalString, 10, customBase256Chars.join(''));
+}
+
+function fromCustomBase256(base256String) {
+    const result = baseConverter(base256String, customBase256Chars.join(''), 10);
+    return Array.isArray(result) ? result.join('') : result;
+}
+
+// Helper to Detect Problematic Characters
+function hasWhitespaceOrNonPrintable(str) {
+    return /[\s\u0000-\u001F\u007F-\u00A0\u00AD\u2028\u2029]/.test(str);  // Common problematic characters
+}
+
+// Main Function to Test Encodings
+async function testTxidEncodings(startBlock, endBlock) {
+    const results = {
+        base94: { lengths: [], problematicCount: 0 },
+        base128: { lengths: [], problematicCount: 0 },
+        customBase256: { lengths: [], problematicCount: 0 }
+    };
+
+    for (let block = startBlock; block <= endBlock; block++) {
+        if(block%1000==1){console.log(block)}
+        try {
+            // Fetch Block Hash and Block Data
+            const { data: blockHashRes } = await axios.post(rpcConfig.url, {
+                jsonrpc: '1.0',
+                id: 'curltext',
+                method: 'getblockhash',
+                params: [block]
+            }, { auth: rpcConfig.auth });
+            const blockHash = blockHashRes.result;
+
+            const { data: blockRes } = await axios.post(rpcConfig.url, {
+                jsonrpc: '1.0',
+                id: 'curltext',
+                method: 'getblock',
+                params: [blockHash, 2]
+            }, { auth: rpcConfig.auth });
+
+            const transactions = blockRes.result.tx;
+            transactions.forEach(tx => {
+                const txid = tx.txid;
+                txCount++
+                // Base 94 Encoding
+                const base94Encoded = hexToBase94(txid);
+                results.base94.lengths.push(base94Encoded.length);
+                if (hasWhitespaceOrNonPrintable(base94Encoded)) {
+                    results.base94.problematicCount++;
+                }
+                
+                // Base 128 Encoding
+                const base128Encoded = hexToBase128(txid);
+                results.base128.lengths.push(base128Encoded.length);
+                if (hasWhitespaceOrNonPrintable(base128Encoded)) {
+                    results.base128.problematicCount++;
+                }
+                
+                // Custom Base 256 Encoding
+                const customBase256Encoded = hexToCustomBase256(txid);
+                results.customBase256.lengths.push(customBase256Encoded.length);
+                if (hasWhitespaceOrNonPrintable(customBase256Encoded)) {
+                    results.customBase256.problematicCount++;
+                }
+            });
+        } catch (error) {
+            console.error(`Error processing block ${block}:`, error.message);
+        }
+    }
+
+    // Output Statistical Results
+    const avgLength = arr => arr.reduce((a, b) => a + b, 0) / arr.length;
+    console.log('--- Base 94 Results ---');
+    console.log(`Average Length: ${avgLength(results.base94.lengths)}`);
+    console.log(`Problematic Character Count: ${results.base94.problematicCount}`);
+
+    console.log('--- Base 128 Results ---');
+    console.log(`Average Length: ${avgLength(results.base128.lengths)}`);
+    console.log(`Problematic Character Count: ${results.base128.problematicCount}`);
+
+    console.log('--- Custom Base 256 Results ---');
+    console.log(`Average Length: ${avgLength(results.customBase256.lengths)}`);
+    console.log(`Problematic Character Count: ${results.customBase256.problematicCount}`);
+    console.log('Total transactions '+txCount)
+}
+
+// Run Test on Blocks 100000 to 100010 (sample range)
+testTxidEncodings(3100000, 3150010);

package/tradelayer.js/tests/testGetTx

@@ -0,0 +1,32 @@
+// testGetRawTransaction.js
+const Litecoin = require('litecoin');
+const util = require('util');
+
+// Configuration for Litecoin RPC
+const config = {
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user', // replace with actual RPC username
+    pass: 'pass', // replace with actual RPC password
+    timeout: 10000,
+};
+
+// Create Litecoin client instance
+const client = new Litecoin.Client(config);
+
+// Promisify getrawtransaction
+const getRawTransaction = (txId, verbose = true) => {
+    return util.promisify(client.cmd.bind(client, 'getrawtransaction'))(txId, verbose);
+};
+
+// Test transaction ID (replace with a valid txId)
+const testTxId = '763db4ffd18c7c0839b8e7532907db2b48e10da5c08b28874c249aa870a505aa';
+
+(async () => {
+    try {
+        const transactionData = await getRawTransaction(testTxId, true);
+        console.log('Transaction Data:', transactionData);
+    } catch (error) {
+        console.error('Error retrieving transaction:', error);
+    }
+})();

package/tradelayer.js/tests/testGetTx.js

@@ -0,0 +1,32 @@
+// testGetRawTransaction.js
+const Litecoin = require('litecoin');
+const util = require('util');
+
+// Configuration for Litecoin RPC
+const config = {
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user', // replace with actual RPC username
+    pass: 'pass', // replace with actual RPC password
+    timeout: 10000,
+};
+
+// Create Litecoin client instance
+const client = new Litecoin.Client(config);
+
+// Promisify getrawtransaction
+const getRawTransaction = (txId, verbose = true) => {
+    return util.promisify(client.cmd.bind(client, 'getrawtransaction'))(txId, verbose);
+};
+
+// Test transaction ID (replace with a valid txId)
+const testTxId = '763db4ffd18c7c0839b8e7532907db2b48e10da5c08b28874c249aa870a505aa';
+
+(async () => {
+    try {
+        const transactionData = await getRawTransaction(testTxId, true);
+        console.log('Transaction Data:', transactionData);
+    } catch (error) {
+        console.error('Error retrieving transaction:', error);
+    }
+})();

package/tradelayer.js/tests/testHexHash.js

@@ -0,0 +1,32 @@
+function hexToBase36(hex) {
+    try {
+        const bigIntValue = BigInt('0x' + hex);
+        return bigIntValue.toString(36);
+    } catch (err) {
+        console.error('Error converting Hex to Base36:', err.message);
+        return null;
+    }
+}
+
+// Test Function
+function testHexToBase36Consistency() {
+    const testHex = '9dbe78a08985827d8ba2459466a770c831155cf5d3d03abf5e5e2cb2351103e6';
+    const expectedBase36 = '3xjcq2nduqyz7bey9tq9uqihxgyt15lomgapljtojujlj3tckm';
+
+    console.log('Original Hex:', testHex);
+
+    // Convert Hex to Base36
+    const base36Result = hexToBase36(testHex);
+    console.log('Base36 Result:', base36Result);
+
+    // Check Consistency
+    if (base36Result === expectedBase36) {
+        console.log('✅ Consistent Base36 conversion!');
+    } else {
+        console.error('❌ Base36 conversion mismatch!');
+    }
+}
+
+// Run the Test
+console.log("=== Hex to Base36 Consistency Test ===");
+testHexToBase36Consistency();

package/tradelayer.js/tests/testIndexHash.js

@@ -0,0 +1,35 @@
+// test-txIndexHash.js
+
+const crypto = require('crypto');
+const db = require('./db.js');  // Import the actual db.js file
+
+// ConsensusDatabase class
+class ConsensusDatabase {
+    // Function to generate SHA-256 hash
+    static generateHash(input) {
+        const hash = crypto.createHash('sha256');
+        hash.update(input);
+        return hash.digest('hex');
+    }
+
+    // 1. txIndexHash: Hash the filtered txIndex
+    static async txIndexHash() {
+        try {
+            const txIndex = await db.getDatabase('txIndex').findAsync({});
+            const filteredTxIndex = txIndex.filter(tx => tx._id.startsWith('tx'));
+            const filteredTxIndexString = JSON.stringify(filteredTxIndex);
+            const hash = this.generateHash(filteredTxIndexString);
+            console.log('txIndexHash:', hash);
+            return hash;
+        } catch (err) {
+            console.error('Error generating txIndex hash:', err);
+        }
+    }
+}
+
+// Run the test
+(async () => {
+    console.log('Running txIndexHash test...');
+    const result = await ConsensusDatabase.txIndexHash();
+    console.log('Test result:', result);
+})();

package/tradelayer.js/tests/testInitContracts.js

@@ -0,0 +1,38 @@
+const assert = require('assert'); // Assertion library
+const sinon = require('sinon'); // Mocking library (if needed)
+const TradeLayerManager = require('./path/to/TradeLayerManager'); // The module under test
+
+describe('TradeLayerManager', function() {
+    let tradeLayerManager;
+    let mockDependencies; // Mock any dependencies
+
+    beforeEach(function() {
+        // Set up for each test
+        tradeLayerManager = new TradeLayerManager();
+        mockDependencies = sinon.stub(/* ... */);
+    });
+
+    afterEach(function() {
+        // Clean up after each test
+        sinon.restore();
+    });
+
+    // Assuming activation logic is in place to activate contract series
+    describe('initializeContractSeries', function() {
+        it('should create contract series correctly after activation', async function() {
+            // Simulate activation logic for contract series
+            await tradeLayerManager.activateContractSeries();
+
+            // Assert that the contract series are created with correct properties
+            const contractSeries = tradeLayerManager.getContractSeries();
+            assert.ok(contractSeries);
+            assert.equal(contractSeries.marginRequirement, expectedMarginRequirement);
+            assert.equal(contractSeries.expiry, expectedExpiry);
+            assert.equal(contractSeries.index, expectedIndex);
+            // Other assertions for contract properties
+        });
+    });
+    // Other tests...
+});
+
+

package/tradelayer.js/tests/testMaxConsensus.js

@@ -0,0 +1,12 @@
+const expressInterface = require('./walletInterface.js')
+
+async function someAsyncFunction() {
+    try {
+        const maxProcessedHeight = await expressInterface.getMaxProcessedHeight();
+        console.log("Max processed height:", maxProcessedHeight);
+    } catch (error) {
+        console.error("Error:", error);
+    }
+}
+
+someAsyncFunction()

package/tradelayer.js/tests/testMaxSynth.js

@@ -0,0 +1,44 @@
+// queryMaxSynth.js
+// Usage: node queryMaxSynth.js
+const http = require('http');
+const querystring = require('querystring');
+
+const HOST = process.env.HOST || 'localhost';
+const PORT = Number(process.env.PORT || 3000);
+
+// target params
+const address = 'tltc1q89kkgaslk0lt8l90jkl3cgwg7dkkszn73u4d2t';
+const propertyId = '1';
+
+const qs = querystring.stringify({ address, propertyId });
+
+const options = {
+  hostname: HOST,
+  port: PORT,
+  path: `/tl_getMaxSynth?${qs}`,
+  method: 'GET',
+  headers: { 'Accept': 'application/json' },
+};
+
+const req = http.request(options, (res) => {
+  let body = '';
+  res.setEncoding('utf8');
+  res.on('data', (chunk) => (body += chunk));
+  res.on('end', () => {
+    try {
+      const json = JSON.parse(body);
+      console.log('Status:', res.statusCode);
+      console.dir(json, { depth: null });
+    } catch (e) {
+      console.error('Non-JSON response:', body);
+      process.exitCode = 1;
+    }
+  });
+});
+
+req.on('error', (err) => {
+  console.error('Request error:', err.message);
+  process.exitCode = 1;
+});
+
+req.end();

package/tradelayer.js/tests/testMint.js

@@ -0,0 +1,21 @@
+const txUtils = require('./txUtils'); // Make sure this path matches where txUtils.js is located
+
+async function createMintTransaction() {
+    const thisAddress = 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8'; // Replace with your address
+    const params = {
+        propertyIdUsed: 5,      // Replace with the actual property ID
+        contractIdUsed: 4,      // Replace with the actual contract ID
+        amount: 3,               // Replace with the amount to mint
+    };
+
+    try {
+        const mintTransaction = await txUtils.createMintTransaction(thisAddress, params);
+        console.log('Mint Transaction Created:', mintTransaction);
+        // Here you would send the transaction using a web3 library or your preferred method
+    } catch (error) {
+        console.error('Error creating mint transaction:', error);
+    }
+}
+
+// Call the function to create the transaction
+createMintTransaction();

package/tradelayer.js/tests/testNetwork.js

@@ -0,0 +1,33 @@
+const litecoin = require('litecoin');
+const util = require('util');
+
+// Litecoin client configuration
+const clientConfig = {
+    host: '127.0.0.1', // Change to your Litecoin node IP if needed
+    port: 18332,        // Default Litecoin RPC port
+    user: 'user', // Set your RPC username
+    pass: 'pass', // Set your RPC password
+    timeout: 10000
+};
+
+// Create a Litecoin client
+const client = new litecoin.Client(clientConfig);
+
+// Promisify the RPC call for getnetworkinfo
+const getNetworkInfoAsync = util.promisify(client.cmd.bind(client, 'getnetworkinfo'));
+
+async function testNetworkInfo() {
+    try {
+        const result = await getNetworkInfoAsync();
+        console.log('Network Info:', result); // Log the network info if successful
+    } catch (error) {
+        if (error.code === -32601) {
+            console.error('Error: Method not found. Ensure that your Litecoin node supports the getnetworkinfo method.');
+        } else {
+            console.error('An unexpected error occurred:', error);
+        }
+    }
+}
+
+// Call the test function
+testNetworkInfo();