@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/oldTests/tally.js

@@ -0,0 +1,81 @@
+class TallyMap {
+  constructor() {
+    this.addresses = new Map();
+    const level = require('level');
+  }
+
+  updateBalance(address, propertyId, amount, available, reserved) {
+    if (!this.addresses.has(address)) {
+      this.addresses.set(address, {});
+    }
+    const addressObj = this.addresses.get(address);
+
+    if (!addressObj[propertyId]) {
+      addressObj[propertyId] = { amount: 0, available: 0, reserved: 0 };
+    }
+
+    addressObj[propertyId].amount += amount;
+    addressObj[propertyId].available += available;
+    addressObj[propertyId].reserved += reserved;
+  }
+
+  getAddressBalances(address) {
+    if (!this.addresses.has(address)) {
+      return [];
+    }
+
+    const addressObj = this.addresses.get(address);
+    const balances = [];
+
+    for (const propertyId in addressObj) {
+      if (Object.hasOwnProperty.call(addressObj, propertyId)) {
+        const balanceObj = addressObj[propertyId];
+        balances.push({
+          propertyId: propertyId,
+          amount: balanceObj.amount,
+          available: balanceObj.available,
+          reserved: balanceObj.reserved,
+        });
+      }
+    }
+  }
+    return balances;
+
+    totalTokens(propertyId) {
+        let total = 0;
+        for (const addressObj of this.addresses.values()) {
+          // Check if the addressObj has the propertyId
+          if (addressObj[propertyId]) {
+            total +=
+              addressObj[propertyId].available +
+              addressObj[propertyId].reserved; // Assuming these are the properties we want to sum
+          }
+        }
+        return total;
+    }
+
+     async save(blockHeight) {
+    const serializedData = JSON.stringify([...this.addresses]);
+    await this.db.put(`block-${blockHeight}`, serializedData);
+  }
+
+  async load(blockHeight) {
+    try {
+      const serializedData = await this.db.get(`block-${blockHeight}`);
+      const addressesArray = JSON.parse(serializedData);
+      this.addresses = new Map(addressesArray);
+    } catch (error) {
+      console.error('Error loading data:', error);
+    }
+  }
+}
+
+// Example usage
+const tallyMap = new TallyMap('./path_to_db');
+
+tallyMap.updateBalance('address1', 1, 100, 80, 20);
+tallyMap.updateBalance('address1', 2, 200, 150, 50);
+tallyMap.updateBalance('address2', 1, 50, 40, 10);
+
+console.log('Address 1 Balances:', tallyMap.getAddressBalances('address1'));
+console.log('Address 2 Balances:', tallyMap.getAddressBalances('address2'));

package/tradelayer.js/oldTests/tally.test.js

@@ -0,0 +1,48 @@
+const Tally = require('../tally')
+
+describe('=== TALLY TESTS ===', () => {
+    path = './dbTL'
+    tally = null
+
+    // beforeAll(async () => {
+    //     //console.log('--beforeAll');
+    // })
+
+    beforeEach(async () => {
+        //console.log('--beforeEach');
+        tally = new Tally(path)
+        await tally.load()
+    });
+
+    test('PUT', () => {
+        tally.updateBalance('a1', 1, 100, 10, 0);
+        tally.updateBalance('a1', 2, 200, 20, 0);
+    })
+
+    test('BAL', () => {
+        let b1 = tally.getAddressBalances('a1').map(b => b.balance.amount).reduce((a, b) => a + b, 0)
+        expect(b1).toBe(300)
+        let b2 = tally.getAddressesWithBalanceForProperty(1).map(b => b.amount).reduce((a, b) => a + b, 0)
+        expect(b2).toBe(100)
+    })
+
+    test('SUM', () => {
+        let sum2 = tally.totalTokens(2)
+        expect(sum2).toBe(20)
+        let sum1 = tally.totalTokens(1)
+        expect(sum1).toBe(10)
+    })
+
+    afterEach(async () => {
+        //console.log('--afterEach');
+        await tally.save()
+        await tally.close()
+    })
+
+    afterAll(async () => {
+        //console.log('--afterAll');
+        tally = new Tally(path)
+        await tally.save()
+        await tally.close()
+    })
+})

package/tradelayer.js/oldTests/tally2.js

@@ -0,0 +1,124 @@
+class TallyMap {
+  constructor(propertyId) {
+    this.propertyId = propertyId;
+    this.addresses = new Map();
+    this.index = TallyMap.getIndex(propertyId);
+    this.feeCache = 0;
+    TallyMap.registerInstance(this);
+  }
+
+  static getIndex(propertyId) {
+    if (!TallyMap.index) {
+      TallyMap.index = new Map();
+    }
+    if (!TallyMap.index.has(propertyId)) {
+      TallyMap.index.set(propertyId, new Map());
+    }
+    return TallyMap.index.get(propertyId);
+  }
+
+  updateAvailableBalance(address, amount) {
+    const addressObj = this.getOrCreateAddress(address);
+    addressObj.available += amount;
+    this.updateFeeCache(-amount);
+  }
+
+  updateOrderReservedBalance(address, amount) {
+    const addressObj = this.getOrCreateAddress(address);
+    addressObj.orderReserved += amount;
+    this.updateFeeCache(-amount);
+  }
+
+  updateCommittedBalance(address, amount) {
+    const addressObj = this.getOrCreateAddress(address);
+    addressObj.committed += amount;
+    this.updateFeeCache(-amount);
+  }
+
+  updateMarginBalance(address, amount) {
+    const addressObj = this.getOrCreateAddress(address);
+    addressObj.margin += amount;
+    this.updateFeeCache(-amount);
+  }
+
+  updateFeeCache(amount) {
+    this.feeCache += amount;
+  }
+
+  getOrCreateAddress(address) {
+    if (!this.addresses.has(address)) {
+      const newAddress = {
+        string: address,
+        available: 0,
+        orderReserved: 0,
+        committed: 0,
+        margin: 0,
+        propertyId: this.propertyId,
+      };
+      this.addresses.set(address, newAddress);
+    }
+    return this.addresses.get(address);
+  }
+
+  totalTokens(propertyId) {
+    let total = 0;
+    for (const addressObj of this.addresses.values()) {
+      
+      total +=
+        addressObj.available +
+        addressObj.orderReserved +
+        addressObj.committed +
+        addressObj.margin;
+    }
+    return total;
+  }
+
+  static registerInstance(instance) {
+    // Maintain an array or object to store all the instances
+    // For example, using an array:
+    if (!TallyMap.instances) {
+      TallyMap.instances = [];
+    }
+    TallyMap.instances.push(instance);
+  }
+
+  static lookupInstancesByAddress(address) {
+    // Lookup all the instances that have a matching address
+    if (!TallyMap.instances) {
+      return [];
+    }
+    return TallyMap.instances.filter((instance) => instance.address === address);
+  }
+
+  static getAddressBalances(address) {
+    const balances = [];
+    for (const tallyMapIndex of TallyMap.index.values()) {
+      for (const tallyMap of tallyMapIndex.values()) {
+        if (tallyMap.addresses.has(address)) {
+          const addressObj = tallyMap.addresses.get(address);
+          balances.push({
+            propertyId: tallyMap.propertyId,
+            available: addressObj.available,
+            orderReserved: addressObj.orderReserved,
+            committed: addressObj.committed,
+            margin: addressObj.margin,
+          });
+        }
+      }
+    }
+    return balances;
+  }
+}
+
+
+
+// Example usage
+const tallyMap1 = new TallyMap(1);
+tallyMap1.updateAvailableBalance('address1', 100);
+tallyMap1.updateOrderReservedBalance('address2', 50);
+
+const tallyMap2 = new TallyMap(2);
+tallyMap2.updateAvailableBalance('address1', 200);
+tallyMap2.updateCommittedBalance('address2', 70);
+
+console.log('Address Balances:', TallyMap.getAddressBalances('address1'));

package/tradelayer.js/oldTests/tally3.js

@@ -0,0 +1,142 @@
+var tallyMapDB = require('./db')
+
+class TallyMap {
+    static instance;
+
+    constructor(path) {
+        if (!TallyMap.instance) {
+            this.addresses = new Map();
+            TallyMap.instance = this;
+        }
+        return TallyMap.instance;
+    }
+
+    updateBalance(address, propertyId, amount, available, reserved) {
+        if (!this.addresses.has(address)) {
+            this.addresses.set(address, {});
+        }
+        const addressObj = this.addresses.get(address);
+
+        if (!addressObj[propertyId]) {
+            addressObj[propertyId] = { amount: 0, available: 0, reserved: 0 };
+        }
+
+        addressObj[propertyId].amount += amount;
+        addressObj[propertyId].available += available;
+        addressObj[propertyId].reserved += reserved;
+    }
+
+    getAddressBalances(address) {
+        if (!this.addresses.has(address)) {
+            return [];
+        }
+
+        const addressObj = this.addresses.get(address);
+        const balances = [];
+
+        for (const propertyId in addressObj) {
+            if (Object.hasOwnProperty.call(addressObj, propertyId)) {
+                const balanceObj = addressObj[propertyId];
+                balances.push({
+                    propertyId: propertyId,
+                    amount: balanceObj.amount,
+                    available: balanceObj.available,
+                    reserved: balanceObj.reserved,
+                });
+            }
+        }
+        return balances;
+    }
+
+    totalTokens(propertyId) {
+        let total = 0;
+        for (const addressObj of this.addresses.values()) {
+            if (addressObj[propertyId]) {
+                total += addressObj[propertyId].available + addressObj[propertyId].reserved;
+            }
+        }
+        return total;
+    }
+
+    async save(blockHeight) {
+        const serializedData = JSON.stringify([...this.addresses]);
+        await this.db.put(`block-${blockHeight}`, serializedData);
+    }
+
+    async load(blockHeight) {
+        try {
+            const serializedData = await this.db.get(`block-${blockHeight}`);
+            const addressesArray = JSON.parse(serializedData);
+            this.addresses = new Map(addressesArray);
+        } catch (error) {
+            console.error('Error loading data:', error);
+        }
+    }
+
+    static getSingletonInstance() {
+        if (!TallyMap.instance) {
+            throw new Error("TallyMap instance has not been created yet");
+        }
+        return TallyMap.instance;
+    }
+
+    // Get the tally for a specific address and property
+    getTally(address, propertyId) {
+        const key = `${address}_${propertyId}`;
+        return this.tallyMap.get(key) || 0;
+    }
+
+    // Save the tally map to LevelDB
+    async saveTallyMap() {
+        const serializedMap = JSON.stringify(Array.from(this.tallyMap.entries()));
+        await this.dbInterface.storeData('tallyMap', serializedMap);
+    }
+
+    // Load the tally map from LevelDB
+    async loadTallyMap() {
+        const serializedMap = await this.dbInterface.getData('tallyMap');
+        if (serializedMap) {
+            this.tallyMap = new Map(JSON.parse(serializedMap));
+        }
+    }
+
+    getAddressBalances(address) {
+        const balances = [];
+        if (this.addresses.has(address)) {
+            const properties = this.addresses.get(address);
+            for (const [propertyId, balanceData] of Object.entries(properties)) {
+                balances.push({
+                    propertyId: propertyId,
+                    balance: balanceData
+                });
+            }
+        }
+        return balances;
+    }
+
+    /**
+     * Retrieves all addresses that have a balance for a given property.
+     * @param {number} propertyId - The property ID to check balances for.
+     * @return {Array} - An array of addresses that have a balance for the specified property.
+     */
+    getAddressesWithBalanceForProperty(propertyId) {
+        const addressesWithBalances = [];
+
+            for (const [address, balances] of this.addresses.entries()) {
+                if (balances[propertyId]) {
+                    const balanceInfo = balances[propertyId];
+                    if (balanceInfo.amount > 0 || balanceInfo.reserved > 0) {
+                        addressesWithBalances.push({
+                            address: address,
+                            amount: balanceInfo.amount,
+                            reserved: balanceInfo.reserved
+                        });
+                    }
+                }
+            }
+
+            return addressesWithBalances;
+    }
+}
+
+module.exports = TallyMap;

package/tradelayer.js/oldTests/tallyDiag.js

@@ -0,0 +1,38 @@
+const TallyMap = require('./tally.js'); // Adjust the path
+
+async function runUnitTest() {
+    console.log('Starting TallyMap Unit Test');
+
+    // Step 1: Initialize TallyMap
+    const blockHeight = 100; // Example block height
+    const tallyMap = await TallyMap.getInstance(blockHeight);
+
+    // Step 2: Update TallyMap
+    const address = 'test-address';
+    const propertyId = '1';
+    const amountChange = 100;
+    const availableChange = 50;
+    const reservedChange = 30;
+    const vestingChange = 20;
+
+    try {
+        await TallyMap.updateBalance(address, propertyId, amountChange, availableChange, reservedChange, vestingChange);
+        console.log('Balance updated successfully');
+    } catch (error) {
+        console.error('Error updating balance:', error);
+    }
+
+    // Step 3: Output Serialized TallyMap
+    const serializedTallyMap = JSON.stringify([...tallyMap.addresses]);
+    console.log('Serialized TallyMap:', serializedTallyMap);
+
+    // Extra Credit: Save to DB
+    try {
+        await tallyMap.saveToDB();
+        console.log('TallyMap saved to DB successfully');
+    } catch (error) {
+        console.error('Error saving TallyMap to DB:', error);
+    }
+}
+
+runUnitTest();

package/tradelayer.js/oldTests/testGetRaw.js

@@ -0,0 +1,40 @@
+const Litecoin = require('litecoin'); // Replace with your actual library import
+const util = require('util');
+
+// Configure your Litecoin client
+const client = new Litecoin.Client({
+    host: '127.0.0.1',
+    port: 18332,
+    user: 'user',
+    pass: 'pass',
+    timeout: 10000
+});
+
+// Promisify the getRawTransaction function
+const getRawTransactionAsync = util.promisify(client.getRawTransaction.bind(client));
+
+// List of txids to test
+const txids = [
+    '5b0b0c97398dfcfc62c41f80c4f1c64d5220bd3a9e99d3a68a1ed514b93c6ab0',
+    'e2c24ba7e7694cfdc3895e5690ab13b7a8dd8f061ae91fd6e58d896a6cf74737',
+    '3a9c8d7ddb4432f36d6d3d858354fa22acbee9e95bb512dc097ffb456c0d357a',
+    '19709105715a195f03cdb05cedb38b14f8d215418dc2ef416e083b40021e6fee'
+
+    // Add more txids here for testing
+];
+
+// Function to test getRawTransaction for each txid
+async function testGetRawTransaction() {
+    for (const txid of txids) {
+        try {
+            console.log(`Fetching transaction for txid: ${txid}`);
+            const transaction = await getRawTransactionAsync(txid, true);
+            console.log(`Transaction:`, transaction);
+        } catch (error) {
+            console.error(`Error fetching transaction for txid ${txid}:`, error);
+        }
+    }
+}
+
+// Run the test
+testGetRawTransaction();

package/tradelayer.js/oldTests/testHexConvert.js

@@ -0,0 +1,47 @@
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+function hexToBase58(hexStr) {
+    let num = BigInt('0x' + hexStr);
+    let base58 = '';
+    while (num > 0) {
+        const div = num / BigInt(BASE58_ALPHABET.length);
+        const mod = num % BigInt(BASE58_ALPHABET.length);
+        base58 = BASE58_ALPHABET[Number(mod)] + base58;
+        num = div;
+    }
+    // Add '1' for each leading '00' byte as per Base58 encoding
+    for (let i = 0; hexStr[i] === '0' && i < hexStr.length - 1; i += 2) {
+        base58 = '1' + base58;
+    }
+    return base58;
+}
+
+function base58ToHex(base58Str) {
+    let num = BigInt(0);
+    for (let char of base58Str) {
+        const charIndex = BASE58_ALPHABET.indexOf(char);
+        if (charIndex < 0) {
+            throw new Error(`Invalid character found: ${char}`);
+        }
+        num = num * BigInt(BASE58_ALPHABET.length) + BigInt(charIndex);
+    }
+    let hex = num.toString(16);
+    // Add '00' for each leading '1' as per Base58 encoding
+    for (let i = 0; base58Str[i] === '1' && i < base58Str.length - 1; i++) {
+        hex = '00' + hex;
+    }
+    // Ensure even length for the hex string
+    if (hex.length % 2) {
+        hex = '0' + hex;
+    }
+    return hex.toUpperCase();
+}
+
+// Example usage
+const hexValue = 'd745ac8daf473ba7d7f9dc2d426beca18af97ba53f1f0e143761782c65c6cffe';
+const base58Value = hexToBase58(hexValue);
+const convertedBackHex = base58ToHex(base58Value);
+
+console.log('Hex:', hexValue);
+console.log('Base58:', base58Value);
+console.log('Converted Back Hex:', convertedBackHex);

package/tradelayer.js/oldTests/testNewEncoding.js

@@ -0,0 +1,96 @@
+// Encode the transaction to base 256
+function encodeOmniTransaction(type, params) {
+  const payload = [type];
+
+  switch (type) {
+    case 1:
+      payload.push(params.type);
+      payload.push(params.initialAmount);
+      payload.push(params.ticker);
+      payload.push(params.whitelists || 0);
+      break;
+    case 2:
+      payload.push(params.propertyId);
+      payload.push(params.amount);
+      break;
+    case 3:
+      payload.push(params.propertyId);
+      payload.push(params.amount);
+      payload.push(params.satsExpected);
+      break;
+    case 4:
+      payload.push(params.propertyId);
+      payload.push(params.amount);
+      break;
+    case 5:
+      payload.push(params.propertyId);
+      payload.push(params.propertyIdDesired);
+      payload.push(params.amountOffered);
+      payload.push(params.amountExpected);
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  const encodedPayload = payload.map(num => num.toString(16).padStart(2, '0')).join('');
+  return encodedPayload;
+}
+
+// Decode the base 256 payload to a transaction object
+function decodeOmniTransaction(encodedPayload) {
+  const type = parseInt(encodedPayload.substr(0, 2), 16);
+  const params = {};
+
+  const payloadData = encodedPayload.substr(2);
+
+  switch (type) {
+    case 1:
+      params.type = parseInt(payloadData.substr(0, 2), 16);
+      params.initialAmount = parseInt(payloadData.substr(2, 8), 16);
+      params.ticker = payloadData.substr(10, 12);
+      params.whitelists = parseInt(payloadData.substr(22, 2), 16);
+      break;
+    case 2:
+      params.propertyId = parseInt(payloadData.substr(0, 8), 16);
+      params.amount = parseInt(payloadData.substr(8, 8), 16);
+      break;
+    case 3:
+      params.propertyId = parseInt(payloadData.substr(0, 8), 16);
+      params.amount = parseInt(payloadData.substr(8, 8), 16);
+      params.satsExpected = parseInt(payloadData.substr(16, 8), 16);
+      break;
+    case 4:
+      params.propertyId = parseInt(payloadData.substr(0, 8), 16);
+      params.amount = parseInt(payloadData.substr(8, 8), 16);
+      break;
+    case 5:
+      params.propertyId = parseInt(payloadData.substr(0, 8), 16);
+      params.propertyIdDesired = parseInt(payloadData.substr(8, 8), 16);
+      params.amountOffered = parseInt(payloadData.substr(16, 8), 16);
+      params.amountExpected = parseInt(payloadData.substr(24, 8), 16);
+      break;
+    default:
+      throw new Error("Unknown transaction type");
+  }
+
+  return { type, params };
+}
+
+// Logic test: Check if the encoded payload is <= 40 bytes
+function isPayloadSizeValid(encodedPayload) {
+  return encodedPayload.length <= 40;
+}
+
+// Example Usage:
+const tx = encodeOmniTransaction(1, {
+  type: 1,
+  initialAmount: 1000,
+  ticker: "TOKEN",
+  whitelists: 2,
+});
+
+console.log("Encoded Payload:", tx);
+console.log("Is Payload Size Valid:", isPayloadSizeValid(tx));
+
+const decodedTx = decodeOmniTransaction(tx);
+console.log("Decoded Transaction:", decodedTx);