@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/oldTests/opdecode.js

@@ -0,0 +1,26 @@
+const hexString = "808479860";
+
+function hexToBytes(hex) {
+    let bytes = [];
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes.push(parseInt(hex.substr(i, 2), 16));
+    }
+    return bytes;
+}
+
+function bytesToInteger(bytes) {
+    return bytes.reduce((total, currentByte) => total * 256 + currentByte, 0);
+}
+
+function integerToBase36(integer) {
+    return integer.toString(36);
+}
+
+const bytes = hexToBytes(hexString);
+const integer = bytesToInteger(bytes);
+const base36String = integerToBase36(integer);
+
+console.log("Hex:", hexString);
+console.log("Bytes:", bytes);
+console.log("Integer:", integer);
+console.log("Base36 String:", base36String);

package/tradelayer.js/oldTests/options.js

@@ -0,0 +1,79 @@
+class OptionChain {
+    constructor() {
+        this.optionChains = new Map(); // Stores all option chains
+    }
+
+    createOptionChain(contractSeriesId, strikeInterval, europeanStyle) {
+        const optionChainKey = `optionChain-${contractSeriesId}`;
+        let optionChain = this.optionChains.get(optionChainKey) || [];
+
+        // Assuming we have a method to get the current block height and expiry intervals
+        const currentBlockHeight = this.getCurrentBlockHeight();
+        const expiryIntervals = this.getExpiryIntervals(contractSeriesId);
+
+        expiryIntervals.forEach(expiryBlock => {
+            // Generate Puts and Calls for each strike price
+            const strikePrices = this.calculateStrikePrices(contractSeriesId, strikeInterval);
+            strikePrices.forEach(strikePrice => {
+                ['P', 'C'].forEach(optionType => {
+                    const contractId = `${contractSeriesId}-${expiryBlock}-${optionType}-${strikePrice}`;
+                    optionChain.push({
+                        contractId,
+                        contractSeriesId,
+                        expiryBlock,
+                        optionType,
+                        strikePrice,
+                        europeanStyle
+                    });
+                });
+            });
+        });
+
+        // Update the option chain in the map
+        this.optionChains.set(optionChainKey, optionChain);
+
+        console.log(`Option chain created for contract series ID ${contractSeriesId}`);
+        return optionChain;
+    }
+
+    // Helper method to calculate strike prices based on the interval
+    calculateStrikePrices(contractSeriesId, strikeInterval) {
+        // Placeholder for logic to calculate strike prices
+        // This might involve fetching the current price of the underlying asset and calculating strikes around it
+        return []; // Return an array of strike prices
+    }
+
+    // Placeholder method to get current block height
+    getCurrentBlockHeight() {
+        // Logic to fetch the current block height from the blockchain
+        return 0; // Replace with actual implementation
+    }
+
+    // Placeholder method to get expiry intervals for a contract series
+    getExpiryIntervals(contractSeriesId) {
+        // Logic to fetch expiry intervals for the given contract series
+        return []; // Replace with actual implementation
+    },
+
+    async storeOptionChain(optionChain) {
+        // Placeholder for logic to store the option chain in the blockchain or database
+        // Implement as per your system's requirements
+        // This might involve creating transactions, interacting with a smart contract, or simply storing in a database
+    },
+
+     isValidSeriesId(seriesId) {
+        // Placeholder for series ID validation logic
+        // Implement as per your system's requirements
+        return true; // Replace with actual validation logic
+    }
+}
+
+// Example usage
+const optionChainManager = new OptionChainManager();
+const contractSeriesId = 1; // Example series ID
+const strikeInterval = 5; // Example strike interval
+const europeanStyle = true; // European style option
+const optionChainz = optionChainManager.createOptionChain(contractSeriesId, strikeInterval, europeanStyle);
+console.log(optionChainz);
+
+module.exports = optionChain

package/tradelayer.js/oldTests/optxtest.js

@@ -0,0 +1,116 @@
+const Litecoin = require('litecoin'); // Replace with actual library import
+const util = require('util');
+const bitcore = require('bitcore-lib-ltc');
+
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+const STANDARD_FEE = 10000; // Standard fee in LTC
+const DUST_THRESHOLD = 54600; // Dust threshold in LTC
+
+const decoderawtransactionAsync = util.promisify(client.cmd.bind(client, 'decoderawtransaction'));
+const getrawtransactionAsync = util.promisify(client.cmd.bind(client, 'getrawtransaction'));
+const dumpprivkeyAsync = util.promisify(client.cmd.bind(client, 'dumpprivkey'));
+const sendrawtransactionAsync = util.promisify(client.cmd.bind(client, 'sendrawtransaction'));
+const listUnspentAsync = util.promisify(client.cmd.bind(client, 'listunspent'))
+
+const scriptPubKey= "0014ebecd536259ef21bc6ecc18e45b35412f0472290"
+
+async function main() {
+
+        // Dump private key
+        const privateKey = await dumpprivkeyAsync('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8');
+        console.log(privateKey);
+
+        // Get raw transaction
+        const rawTx = await getrawtransactionAsync('57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5');
+        console.log(rawTx);
+
+        // Extract scriptPubKey
+        const scriptPubKey = await getScriptPubKeyFromRawTx(rawTx, 'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8', 1);
+        console.log(scriptPubKey);
+
+        // Create UTXO object
+        var utxo = {
+            "txId": "57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5",
+            "outputIndex": 1,
+            "address": "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8",
+            "script": scriptPubKey,
+            "satoshis": 50000 // This should be the actual amount in satoshis
+        };
+
+        // Get the UTXO from the blockchain (I assume you have the txid and vout)
+        const utxoTxId = '57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5';
+        const utxoVout = 1; // or the appropriate vout index
+
+        const blockchainUtxo = await getrawtransactionAsync(utxoTxId, true);
+        const blockchainScriptPubKey = blockchainUtxo.vout[utxoVout].scriptPubKey.hex;
+
+        // Compare with the script you have in your UTXO object
+        if (utxo.script !== blockchainScriptPubKey) {
+            console.error("Script mismatch: UTXO script does not match blockchain data.");
+        }
+
+        // Check if the UTXO is unspent
+        const utxos = await listUnspentAsync(0, 9999999, ["tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8"]);
+
+        let utxoFound = false;
+        utxos.forEach(utxo => {
+            if (utxo.txid === utxoTxId && utxo.vout === utxoVout) {
+                utxoFound = true;
+                // Validate the satoshis (amount in satoshis) as well
+                if (utxo.satoshis !== 50000) { // Replace 50000 with the correct amount
+                    console.error("Incorrect UTXO amount.");
+                }
+            }
+        });
+
+        if (!utxoFound) {
+            console.error("UTXO not found or already spent.");
+        }
+
+        try {
+            // Create and sign transaction
+            var transaction = new bitcore.Transaction()
+                .from(utxo) // Make sure this UTXO is unspent
+                .addData('litecore rocks') // OP_RETURN data
+                .change('tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8') // Change address
+                .sign(privateKey);
+
+            // Check if transaction is valid before serialization
+            if (transaction.getSerializationError()) {
+                const error = transaction.getSerializationError().message;
+                throw new Error(`Transaction serialization failed: ${error}`);
+            }
+
+            const serializedTx = transaction.serialize();
+            console.log(`Serialized Transaction: ${serializedTx}`);
+
+            // Broadcast the transaction
+            const txid = await sendrawtransactionAsync(serializedTx);
+            console.log(`Transaction ID: ${txid}`);
+        } catch (error) {
+            console.error(`Error:`, error);
+        }
+}
+
+// Execute the main function
+main();
+
+async function getScriptPubKeyFromRawTx(rawTx, address, vout) {
+    try {
+        // Decode the raw transaction
+        const decodedTx = await decoderawtransactionAsync(rawTx);
+
+        // Find the output with the matching address
+        return decodedTx.vout[vout].scriptPubKey.hex;
+    } catch (error) {
+        console.error(`Error retrieving scriptPubKey:`, error);
+        throw error;
+    }
+}

package/tradelayer.js/oldTests/optxtest1.js

@@ -0,0 +1,64 @@
+const Litecoin = require('litecoin'); // Replace with actual library import
+const async = require('async')
+const util = require('util');
+const bitcore = require('bitcore-lib-ltc');
+
+const STANDARD_FEE = 0.0001; // Standard fee in LTC
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+
+var privateKey ='' 
+
+client.cmd('dumpprivkey','tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8',function(err,data){
+	if(err){console.log(err)}
+	privateKey = data
+	console.log(privateKey)
+});
+
+
+
+const decoderawtransactionAsync = util.promisify(client.cmd.bind(client, 'decoderawtransaction'));
+const getrawtransactionAsync = util.promisify(client.cmd.bind(client, 'getrawtransaction'));
+
+const rawTx = await getrawtransactionAsync('57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5')
+
+console.log(rawTx)
+
+async function getScriptPubKeyFromRawTx(rawTx, address, vout) {
+    try {
+        // Decode the raw transaction
+        const decodedTx = await decoderawtransactionAsync('decoderawtransaction', rawTx);
+
+        // Find the output with the matching address
+        return decodedTx.vout[vout].scriptPubKey.hex;
+
+    } catch (error) {
+        console.error(`Error retrieving scriptPubKey:`, error);
+        throw error;
+    }
+}
+
+const scriptPubKey = getScriptPubKeyFromRawTx()
+
+console.log(scriptPubKey)
+
+var utxo = {
+  "txId" : "57dbb47d8db6249b720421d78052e6f168664f3c062f1fbe187270ff5edd4dc5",
+  "outputIndex" : `1`,
+  "address" : "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8",
+  "script" : "0014ebecd536259ef21bc6ecc18e45b35412f0472290",
+  "satoshis" : 50000
+};
+
+var transaction = new bitcore.Transaction()
+    .from(utxo)
+    .addData('litecore rocks') // Add OP_RETURN data
+    .sign(privateKey);
+
+console.log(transaction)

package/tradelayer.js/oldTests/oracle.test.js

@@ -0,0 +1,32 @@
+const OR = require('../oracle')
+
+describe('=== ORACLE TESTs ===', () => {
+    path = './dbOR'
+    or = null
+
+    beforeAll(async () => {
+        //console.log('--beforeAll');
+    })
+
+    beforeEach(async () => {
+        //console.log('--beforeEach');
+        or = new OR(path)
+        await or.load()
+    });
+
+    test('PUT', async () => {
+    })
+
+    test('GET', async () => {
+    })
+
+    afterEach(async () => {
+        //console.log('--afterEach');
+        //await or.save()
+        await or.close()
+    })
+
+    afterAll(async () => {
+        //console.log('--afterAll');
+    })
+})

package/tradelayer.js/oldTests/orderbook.test.js

@@ -0,0 +1,36 @@
+const OB = require('../orderbook')
+
+describe('=== OB TESTS ===', () => {
+    path = './dbOB'
+    ob = null
+
+    beforeAll(async () => {
+        //console.log('--beforeAll');
+    })
+
+    beforeEach(async () => {
+        //console.log('--beforeEach');
+        ob = new OB(path)
+        await ob.load()
+    });
+
+    test('PUT', async () => {
+        ob.addTokenOrder({ propertyIdNumber : 1, propertyIdNumberDesired : 1, amountOffered : 100, amountExpected : 100, time : 123456789 })
+    })
+
+    test('GET', async () => {
+    })
+
+    afterEach(async () => {
+        //console.log('--afterEach');
+        //await ob.save(null)
+        await ob.close()
+    })
+
+    afterAll(async () => {
+        //console.log('--afterAll');
+        ob = new OB(path)
+        await ob.clear()
+        await ob.close()
+    })
+})

package/tradelayer.js/oldTests/parsing.js

@@ -0,0 +1,93 @@
+const { CSHA256 } = require('sha2');
+
+function isBigEndian() {
+    const bint = { i: 0x01020304 };
+    const byteArray = new Uint8Array(new Uint32Array([bint.i]).buffer);
+    return byteArray[0] === 1;
+}
+
+function swapByteOrder16(us) {
+    if (isBigEndian()) return us;
+    return ((us >> 8) & 0x00ff) | ((us << 8) & 0xff00);
+}
+
+function swapByteOrder32(ui) {
+    if (isBigEndian()) return ui;
+    return (
+        ((ui >> 24) & 0x000000ff) |
+        ((ui << 8) & 0x00ff0000) |
+        ((ui >> 8) & 0x0000ff00) |
+        ((ui << 24) & 0xff000000)
+    );
+}
+function swapByteOrder64(ull) {
+    if (isBigEndian()) return;
+    ull = (
+        ((ull >> BigInt(56)) & BigInt(0x00000000000000ff)) |
+        ((ull << BigInt(40)) & BigInt(0x00ff000000000000)) |
+        ((ull << BigInt(24)) & BigInt(0x0000ff0000000000)) |
+        ((ull << BigInt(8)) & BigInt(0x000000ff00000000)) |
+        ((ull >> BigInt(8)) & BigInt(0x00000000ff000000)) |
+        ((ull >> BigInt(24)) & BigInt(0x0000000000ff0000)) |
+        ((ull >> BigInt(40)) & BigInt(0x000000000000ff00)) |
+        ((ull << BigInt(56)) & BigInt(0xff00000000000000))
+    );
+
+    // Note: The result `ull` will be a BigInt type.
+}
+
+function hashToAddress(version, hash) {
+    const Base58 = require('base-58');
+    const { CKeyID, CScriptID, Params } = require('bitcoinjs-lib');
+
+    const base58PrefixPubKeyAddress = Params().base58Prefixes.pubkeyhash;
+    const base58PrefixScriptAddress = Params().base58Prefixes.scripthash;
+
+    if (version === base58PrefixPubKeyAddress[0]) {
+        const keyId = new CKeyID(hash);
+        return Base58.encode(keyId);
+    } else if (version === base58PrefixScriptAddress[0]) {
+        const scriptId = new CScriptID(hash);
+        return Base58.encode(scriptId);
+    }
+
+    return '';
+}
+
+function prepareObfuscatedHashes(strSeed, hashCount) {
+    const MAX_SHA256_OBFUSCATION_TIMES = 255;
+    const sha_input = Buffer.alloc(128);
+    const sha_result = Buffer.alloc(32);
+    const vstrHashes = [];
+
+    if (strSeed.length >= sha_input.length) {
+        throw new Error('Seed length exceeds the maximum allowed size');
+    }
+
+    sha_input.write(strSeed);
+
+    if (hashCount > MAX_SHA256_OBFUSCATION_TIMES) {
+        hashCount = MAX_SHA256_OBFUSCATION_TIMES;
+    }
+
+    for (let j = 1; j <= hashCount; ++j) {
+        const sha256 = new CSHA256();
+        sha256.update(sha_input);
+        sha256.finalize(sha_result);
+        const hexStr = sha_result.toString('hex').toUpperCase();
+        vstrHashes[j] = hexStr;
+
+        sha_input.fill(0);
+        sha_input.write(hexStr);
+    }
+
+    return vstrHashes;
+}
+
+module.exports = {
+    swapByteOrder16,
+    swapByteOrder32,
+    swapByteOrder64,
+    hashToAddress,
+    prepareObfuscatedHashes,
+};

package/tradelayer.js/oldTests/payload.js

@@ -0,0 +1,13 @@
+const tokenIdentifier = 2;
+const amount = "0.1";
+
+// Convert the token identifier to a 4-byte hexadecimal string
+const tokenIdentifierHex = tokenIdentifier.toString(16).padStart(8, "0");
+
+// Convert the amount to a 8-byte hexadecimal string (assuming 8 bytes for the amount)
+const amountHex = (Math.floor(parseFloat(amount) * 1e8)).toString(16).padStart(16, "0");
+
+// Combine the token identifier and amount as a payload
+const payload = tokenIdentifierHex + amountHex;
+
+console.log(payload);

package/tradelayer.js/oldTests/persistenceUnitTest.js

@@ -0,0 +1,23 @@
+const BlockchainPersistence = require('./BlockchainPersistence');
+
+describe('BlockchainPersistence', () => {
+    let blockchainPersistence;
+
+    beforeEach(() => {
+        blockchainPersistence = new BlockchainPersistence();
+        // Setup for test database connection
+    });
+
+    afterEach(() => {
+        // Clean up database or mock after each test
+    });
+
+    test('should update last known block hash', async () => {
+        const testBlockHash = '000000testhash';
+        await blockchainPersistence.updateLastKnownBlock(testBlockHash);
+        const storedHash = await blockchainPersistence.getLastKnownBlock();
+        expect(storedHash).toBe(testBlockHash);
+    });
+
+    // Add more tests for other methods
+});

package/tradelayer.js/oldTests/property.test.js

@@ -0,0 +1,53 @@
+const PM = require('../property')
+
+describe('=== PM TEST ===', () => {
+    path = './dbPM'
+    pm = null
+
+    beforeAll(async () => {
+        //console.log('--beforeAll');
+    })
+
+    beforeEach(async () => {
+        //console.log('--beforeEach');
+        pm = new PM(path)
+        await pm.load()
+    });
+
+    test('PUT1', async () => {
+        pm.addProperty(1, 'PROP1', 1000000, 'Fixed')
+    })
+
+    test('ID1', async () => {
+        let p = pm.getPropertyData(1)
+        expect(p != null).toBe(true)
+        expect(p.ticker).toBe('PROP1')
+        expect(p.type).toBe(1)
+        expect(p.totalInCirculation).toBe(1000000)
+    })
+
+    test('PUT2', async () => {
+        pm.addProperty(2, 'PROP2', 500000, 'Managed')
+    })
+
+    test('ID2', async () => {
+        let p = pm.getPropertyData(2)
+        expect(p != null).toBe(true)
+        expect(p.ticker).toBe('PROP2')
+        expect(p.type).toBe(2)
+        expect(p.totalInCirculation).toBe(500000)
+    })
+
+    afterEach(async () => {
+        //console.log('--afterEach');
+        await pm.save()
+        await pm.close()
+    })
+
+    afterAll(async () => {
+        //console.log('--afterAll');
+        pm = new PM(path)
+        await pm.save()
+        await pm.close()
+    })
+})

package/tradelayer.js/oldTests/propertyLevel.js

@@ -0,0 +1,75 @@
+// PropertyManager
+
+const level = require('level');
+const db = level('properties');
+
+// ...existing code
+
+loadPropertyIndexFromDb() {
+  return new Promise((resolve, reject) => {
+    db.get('propertyIndex', (err, value) => {
+      if (err) return reject(err);
+      if (!value) return resolve();
+      
+      this.propertyIndex = new Map(Object.entries(JSON.parse(value)));
+      resolve();
+    });
+  });
+}
+
+savePropertyIndexToDb() {
+  const indexJson = JSON.stringify(Object.fromEntries(this.propertyIndex));
+  
+  return new Promise((resolve, reject) => {
+    db.put('propertyIndex', indexJson, err => {
+      if (err) return reject(err);
+      resolve();
+    }); 
+  });
+}
+
+// TallyMap
+
+const db = level('balances');
+
+// ...existing code 
+
+loadBalancesFromDb() {
+  return new Promise((resolve, reject) => {
+    db.createReadStream()
+      .on('data', ({key, value}) => {
+        const { address, propertyId } = JSON.parse(key);
+        const balance = JSON.parse(value);
+        
+        this.updateBalance(
+          address, 
+          propertyId,
+          balance.amount,
+          balance.available,
+          balance.reserved
+        );
+      })
+      .on('error', reject)
+      .on('end', resolve);
+  });
+}
+
+saveBalancesToDb() {
+  const batch = [];
+  
+  for (let [address, balances] of this.addresses) {
+    for (let [propertyId, balance] of Object.entries(balances)) {
+      const key = JSON.stringify({ address, propertyId });
+      const value = JSON.stringify(balance);
+      
+      batch.push({ type: 'put', key, value });
+    }
+  }
+  
+  return new Promise((resolve, reject) => {
+    db.batch(batch, err => {
+      if (err) return reject(err);
+      resolve();
+    });
+  });
+}

package/tradelayer.js/oldTests/propertyTest.js

@@ -0,0 +1,32 @@
+const PropertyManager = require('./property.js'); // Adjust the path to the PropertyManager class file
+
+async function addRandomTokensAndDisplay(count) {
+    const propertyManager = PropertyManager.getInstance();
+    const propertyTypes = ['Fixed', 'Managed', 'Native', 'Vesting', 'Synthetic', 'Non-Fungible'];
+    
+
+    for (let i = 0; i < count; i++) {
+        const ticker = 'TK' + Math.random().toString(36).substring(2, 7).toUpperCase();
+        const type = propertyTypes[Math.floor(Math.random() * propertyTypes.length)];
+        const totalInCirculation = Math.floor(Math.random() * 1000000);
+        
+        try {
+            const propertyId = await propertyManager.createToken(ticker, totalInCirculation, type);
+            console.log(`Added token with ID: ${propertyId}, Ticker: ${ticker}, Type: ${type}`);
+        } catch (error) {
+            console.error('Error adding token:', error);
+        }
+    }
+
+    try {
+        propertyManager.inspectPropertyIndex()
+
+        const properties = await PropertyManager.getPropertyIndex();
+        console.log('Current Properties:', properties);
+    } catch (error) {
+        console.error('Error retrieving properties:', error);
+    }
+}
+
+// Call the function to add 5 random tokens and display the list
+addRandomTokensAndDisplay(5);

package/tradelayer.js/oldTests/queryAddressTest.js

@@ -0,0 +1,17 @@
+const TallyMap = require('./tally.js'); // Adjust the path
+
+async function queryAddressBalances(address) {
+    try {
+        console.log(`Querying balances for address: ${address}`);
+        //const tallyMapInstance = await TallyMap.getInstance();
+        //await tallyMapInstance.loadFromDB();
+
+        const balances = await TallyMap.getAddressBalances(address);
+        console.log(`Balances for address ${address}:`, balances);
+    } catch (error) {
+        console.error('Error querying address balances:', error);
+    }
+}
+
+const addressToQuery = 'test-address' //'tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8';
+queryAddressBalances(addressToQuery);

package/tradelayer.js/oldTests/salter.js

@@ -0,0 +1,14 @@
+const bcrypt = require('bcrypt');
+
+const saltRounds = 10; // Number of salt rounds (adjust as needed)
+const password = 'pass'; // Replace with your actual password
+
+bcrypt.genSalt(saltRounds, function(err, salt) {
+    bcrypt.hash(password, salt, function(err, hash) {
+        if (!err) {
+            console.log(`Salted Hash Password: ${hash}`);
+        } else {
+            console.error('Error generating salted hash:', err);
+        }
+    });
+});