@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/src/clearlist.js

@@ -0,0 +1,364 @@
+const dbInstance = require('./db.js');
+
+class clearlistManager {
+    static clearlists = new Map();
+    static banlist = ["US", "KP", "SY", "RU", "IR", "CU"];
+    static xpubCache = new Map(); // xpub -> derived addresses array
+
+    static async createClearlist(adminAddress, name, url, description, backupAddress,id) {
+
+        if(!id){
+            id = await this.getNextId();
+        }
+        
+        const clearlistData = {
+            id: id,
+            admin: adminAddress,
+            name: name,
+            description: description,
+            backup: backupAddress
+        };
+
+        const base = await dbInstance.getDatabase('clearlists')
+        await base.updateAsync(
+            { _id: id },
+            { $set: { data: clearlistData } },
+            { upsert: true }
+        );
+
+        return clearlistData;
+    }
+
+    static async loadClearlists() {
+        try {
+            const base = await dbInstance.getDatabase('clearlists')
+            const clearLists = await base.findAsync({});
+            clearLists.forEach(({ _id, data }) => {
+                this.clearlists.set(_id, data);
+            });
+
+            return clearLists
+        } catch (error) {
+            console.error('Error loading clearlists from the database:', error);
+        }
+    }
+
+    static async getClearlistById(clearlistId) {
+        try {
+            // Load all clearlists into memory
+            await this.loadClearlists();
+
+            // Check if the clearlistId exists in the Map
+            if (this.clearlists.has(clearlistId)) {
+                const clearlistData = this.clearlists.get(clearlistId);
+                console.log(`Clearlist found: ID ${clearlistId}`, clearlistData);
+                return clearlistData;
+            }
+
+            console.log(`Clearlist ID ${clearlistId} not found.`);
+            return false; // Return false if the clearlistId doesn't exist
+        } catch (error) {
+            console.error(`Error finding clearlist with ID ${clearlistId}:`, error.message);
+            throw error;
+        }
+    }
+
+
+    static async getList(id) {
+        try {
+            const base = await dbInstance.getDatabase('attestations')
+            const clearlist = await base.findOneAsync({ _id: id });
+            if (clearlist) {
+                return clearlist.data;
+            } else {
+                console.log(`No clearlist found for ID: ${id}`);
+                return null;
+            }
+        } catch (error) {
+            console.error(`Error loading clearlist with ID ${id}:`, error);
+            throw error;
+        }
+    }
+
+    static async verifyAdmin(clearlistId, adminAddress) {
+        const clearlist = this.clearlists.get(clearlistId);
+
+        if (!clearlist) {
+            throw new Error('Clearlist not found');
+        }
+
+        return clearlist.adminAddress === adminAddress;
+    }
+
+    static async updateAdmin(clearlistId, newAdminAddress, backup) {
+        const clearlistKey = `${clearlistId}`;
+        const clearlist = this.clearlists.get(clearlistId);
+
+        if (!clearlist) {
+            throw new Error('Clearlist not found');
+        }
+
+        if (backup) {
+            clearlist.backupAddress = newAdminAddress;
+        } else {
+            clearlist.adminAddress = newAdminAddress;
+        }
+        await this.db.updateAsync({ _id: clearlistKey }, { $set: { data: clearlist } });
+        this.clearlists.set(clearlistId, clearlist);
+
+        console.log(`Clearlist ID ${clearlistId} admin updated to ${newAdminAddress}`);
+    }
+
+    static async getNextId() {
+        let maxId = 0;
+        await this.loadClearlists();
+        for (const key of this.clearlists.keys()) {
+            const currentId = parseInt(key);
+            if (currentId > maxId) {
+                maxId = currentId;
+            }
+        }
+        return maxId + 1;
+    }
+
+    static async addAttestation(clearlistId, address, metaData, block) {
+        const attestationId = address;
+
+        // Detect xpub prefix in metaData
+        let xpub = null;
+        if (typeof metaData === 'string' && metaData.startsWith('xpub:')) {
+            xpub = metaData.slice(5); // strip 'xpub:' prefix
+        }
+
+        const attestationData = {
+            listId: clearlistId,
+            address: address,
+            status: 'active',
+            data: metaData,
+            xpub: xpub,
+            timestamp: block
+        };
+
+        const base = await dbInstance.getDatabase('attestations');
+        await base.updateAsync(
+            { _id: attestationId },
+            { $set: { data: attestationData } },
+            { upsert: true }
+        );
+
+        return attestationId;
+    }
+
+    static async addAttestationWithXpub(clearlistId, address, metaData, xpub, block) {
+        const attestationId = address;
+        const attestationData = {
+            listId: clearlistId,
+            address: address,
+            status: 'active',
+            data: metaData,
+            xpub: xpub || null,
+            timestamp: block
+        };
+
+        const base = await dbInstance.getDatabase('attestations');
+        await base.updateAsync(
+            { _id: attestationId },
+            { $set: { data: attestationData } },
+            { upsert: true }
+        );
+
+        return attestationId;
+    }
+
+    /**
+     * Derive first N addresses from an xpub (receive chain m/0/0..m/0/19 and change chain m/1/0..m/1/19).
+     * Uses bitcore-lib-ltc HDPublicKey. Results are cached per xpub.
+     */
+    static deriveAddressesFromXpub(xpub, network) {
+        if (this.xpubCache.has(xpub)) {
+            return this.xpubCache.get(xpub);
+        }
+
+        const addresses = [];
+        const GAP_LIMIT = 20;
+
+        try {
+            // Try bitcore-lib-ltc first (LTC network)
+            let HDPublicKey, Networks;
+            try {
+                const litecore = require('bitcore-lib-ltc');
+                HDPublicKey = litecore.HDPublicKey;
+                Networks = litecore.Networks;
+            } catch (e) {
+                const bitcore = require('bitcore-lib');
+                HDPublicKey = bitcore.HDPublicKey;
+                Networks = bitcore.Networks;
+            }
+
+            const hdPubKey = new HDPublicKey(xpub);
+
+            // Derive receive chain (m/0/i) and change chain (m/1/i)
+            for (const chain of [0, 1]) {
+                const chainKey = hdPubKey.deriveChild(chain);
+                for (let i = 0; i < GAP_LIMIT; i++) {
+                    const derived = chainKey.deriveChild(i);
+                    const addr = derived.publicKey.toAddress().toString();
+                    addresses.push(addr);
+                }
+            }
+        } catch (e) {
+            console.error('Error deriving addresses from xpub:', e.message);
+            return [];
+        }
+
+        this.xpubCache.set(xpub, addresses);
+        return addresses;
+    }
+
+    /**
+     * Check if an address is in a clearlist either directly or via xpub derivation.
+     */
+    static async isAddressInClearlistOrDerived(clearlistId, address) {
+        // First check direct attestation
+        const direct = await this.isAddressInClearlist(clearlistId, address);
+        if (direct) return true;
+
+        // Check xpub-bearing attestations in this clearlist
+        const base = await dbInstance.getDatabase('attestations');
+        const xpubAttestations = await base.findAsync({
+            'data.listId': clearlistId,
+            'data.status': 'active',
+            'data.xpub': { $exists: true, $ne: null }
+        });
+
+        for (const att of xpubAttestations) {
+            const xpub = att.data.xpub;
+            if (!xpub) continue;
+            const derivedAddresses = this.deriveAddressesFromXpub(xpub);
+            if (derivedAddresses.includes(address)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    static async revokeAttestation(attestationId, targetAddress, revokeReason,block) {
+        const attestationKey = `attestation:${targetAddress}`;
+        const base= await dbInstance.getDatabase('attestations')
+        const attestation = await base.findOneAsync({ _id: attestationKey });
+
+        if (!attestation) {
+            throw new Error('Attestation not found');
+        }
+
+        attestation.data.status = 'revoked';
+        attestation.data.id = attestationId;
+        attestation.data.revokeReason = revokeReason;
+        attestation.data.timestamp = block
+
+        await this.attestationsDb.updateAsync(
+            { _id: attestationKey },
+            { $set: { data: attestation.data } }
+        );
+
+        return attestationId;
+    }
+
+    static async getCountryCodeByAddress(address) {
+        try {
+            const base = await dbInstance.getDatabase('attestations');
+            
+            // Fetch all attestations for the given address
+            const attestations = await base.findAsync({ 'data.address': address });
+
+            if (!attestations || attestations.length === 0) {
+                console.log(`No attestations found for address: ${address}`);
+                return null; // No attestations for this address
+            }
+
+            // Loop through attestations to find one with clearListId: 0 and a valid countryCode
+            for (const attestation of attestations) {
+                const { listId, data} = attestation.data;
+                
+                if (listId === 0 && data) {
+                    return {
+                        address,
+                        countryCode: data,
+                        blockHeight: attestation.data.blockHeight || null, // Optional blockHeight in metadata
+                    };
+                }
+            }
+
+            // If no valid attestation with clearListId: 0 and countryCode is found
+            console.log(`No valid attestation with clearListId 0 and country code found for address: ${address}`);
+            return null;
+        } catch (error) {
+            console.error(`Error fetching country code for address ${address}:`, error);
+            return null; // Gracefully return null on error
+        }
+    }
+
+    static async setBanlist(banlistArray,block) {
+        try {
+            const base = await dbInstance.getDatabase('clearlists');
+            await base.updateAsync(
+                { _id: 'globalBanlist' }, // Fixed ID for the banlist entity
+                { $set: { data: banlistArray, timestamp: block } },
+                { upsert: true }
+            );
+            console.log('Banlist updated successfully.');
+        } catch (error) {
+            console.error('Error updating Banlist in database:', error);
+            throw error;
+        }
+        this.banlist= banlistArray
+    }
+
+    static async getBanlist() {
+        try {
+            const base = await dbInstance.getDatabase('clearlists');
+            const banlist = await base.findAsync({ _id: 'globalBanlist' });
+            if (banlist) {
+                return banlist.data; // Return the banlist array
+            } else {
+                console.log('No Banlist found in the database.');
+                return null; // Return null if no Banlist exists
+            }
+        } catch (error) {
+            console.error('Error fetching Banlist from database:', error);
+            throw error;
+        }
+    }
+
+    static async getAttestations(clearlistId) {
+        const base = await dbInstance.getDatabase('attestations')
+        return await base.findAsync({ 'data.clearlistId': clearlistId });
+    }
+    
+    static async getAttestationHistory(address, clearlistId) {
+        const base = await dbInstance.getDatabase('attestations');
+
+        // Fetch all matching records for the address and listId
+        const records = await base.findAsync({ 'data.address': address, 'data.listId': clearlistId });
+
+        // Sort by timestamp (descending)
+        const sortedRecords = records.sort((a, b) => b.data.timestamp - a.data.timestamp);
+
+        return sortedRecords; // Return sorted array
+    }
+
+
+    static async isAddressInClearlist(clearlistId, address) {
+
+        const base = await dbInstance.getDatabase('attestations')
+        const attestations = await base.findAsync({
+            'data.clearlistId': clearlistId,
+            'data.address': address,
+            'data.status': 'active'
+        });
+        return attestations.length > 0;
+    }
+}
+
+module.exports = clearlistManager;

package/tradelayer.js/src/client.js

@@ -0,0 +1,295 @@
+const util = require('util');
+const Litecoin = require('litecoin');
+const Bitcoin = require('bitcoin');
+const Doge = require('dogecoind-rpc');
+
+// --- ENV bootstrap helpers (safe if .env is missing) ---
+const path = require('path');
+
+function loadDotenvFromKnownLocations() {
+  // lazy-load to avoid hard dependency if dotenv isn't installed yet
+  let dotenv;
+  try { dotenv = require('dotenv'); } catch { return; }
+
+  // 1) repo-style: one level up relative to this file (…/ .env)
+  const repoEnv = path.join(__dirname, '..', '.env');
+  dotenv.config({ path: repoEnv, override: false });
+
+  // 2) fallback: current working directory (.env)
+  dotenv.config({ override: false });
+}
+
+function getRpcBootstrapFromEnv(defaultChain = 'LTC') {
+  loadDotenvFromKnownLocations();
+
+  const env = process.env;
+  const ENV_CHAIN  = (env.CHAIN || '').toUpperCase();
+  const AUTODETECT = (env.AUTODETECT || '1') !== '0'; // AUTODETECT=0 → lock env, skip discovery
+
+  const DEFAULT_PORT = { BTC: 8332, BTCTEST: 18332, LTC: 9332, LTCTEST: 19332, DOGE: 22555, DOGETEST:44555 };
+  const chain = ['BTC', 'LTC', 'DOGE'].includes(ENV_CHAIN) ? ENV_CHAIN : defaultChain;
+
+  const host = env.RPC_HOST || '127.0.0.1';
+  const user = env.RPC_USER || 'user';
+  const pass = env.RPC_PASS || 'pass';
+  const port = Number(env.RPC_PORT || DEFAULT_PORT[chain]);
+  const timeout = Number(env.TIMEOUT_MS || 60000);
+
+  // If any of CHAIN / RPC_PORT is provided OR AUTODETECT=0, we consider this a "locked" bootstrap.
+  const locked = (!AUTODETECT) || !!env.CHAIN || !!env.RPC_PORT;
+
+  return {
+    // normalized values
+    chain, host, port, user, pass, timeout,
+    // whether the caller should skip autodetect and return immediately
+    locked,
+  };
+}
+
+
+let clientInstance = null;
+
+class ClientWrapper {
+   constructor() {
+    if (clientInstance) {
+      return clientInstance;
+    }
+    this.chain = null;
+    this.client = null;
+    this.initializing = false
+    clientInstance = this;  // Assign the instance to the singleton variable
+  }
+
+   async init() {
+
+     // If already initializing, wait for the process to finish
+    if (this.isInitializing) {
+      console.log('Client initialization already in progress. Waiting...');
+      return this.waitForInitialization();  // Wait for ongoing initialization to complete
+    }
+
+	    this.isInitializing = true; // Set flag to indicate initialization is in progress
+
+	    if(!this.client){
+	     const boot = this.getEnvBootstrap('LTCTEST'); // default LTC; change to 'BTC' if you prefer
+
+	this.config = {
+	  host: boot.host,
+	  port: boot.port,
+	  user: boot.user,
+	  pass: boot.pass,
+	  timeout: boot.timeout,
+	};
+
+	// Build a client immediately using the env-chosen CHAIN (or default)
+	this.chain  = boot.chain;
+	this.client = this._createClientByChain(this.chain);
+
+	// If .env told us to lock (AUTODETECT=0 or CHAIN/RPC_PORT provided), stop here.
+	// (No probing needed; this lets desktop/server scripts fully control startup.)
+	if (boot.locked) {
+	  return this.chain;
+	}
+
+      // Wait for the blockchain to finish initial block download and indexing
+      let isTest = true
+       try {
+          const blockchainInfo = await this.getBlockchainInfo();
+           isTest = blockchainInfo.chain === 'test';
+           console.log('is test '+isTest)
+        }catch (error) {
+            if (error.code === -28) {
+              console.log('Getting the err on the second call.');
+            }
+        }
+
+      const networkInfo = await this.getNetworkInfo();
+      console.log('determining chain in init '+JSON.stringify(networkInfo))
+      this.chain = this.determineChainFromSubversion(networkInfo.subversion);
+
+      if (!this.chain) throw new Error('Unable to determine blockchain chain.');
+
+      this.config.port = isTest 
+        ? (this.chain === 'BTC' ? 18332 : this.chain === 'DOGE' ? 44556 : 19332)
+        : (this.chain === 'BTC' ? 8332 : this.chain === 'DOGE' ? 22555 : 9332);
+
+      this.client = this._createClientByChain(this.chain);
+      }
+      return this.chain
+  }
+
+   async waitForInitialization() {
+    while (this.isInitializing) {
+      console.log('waiting for initialization')
+      await new Promise(resolve => setTimeout(resolve, 100)); // Wait 100ms between checks
+    }
+    return this.chain;  // Return the chain after initialization completes
+  }
+
+  // inside your existing class (e.g., RpcClient / whatever it’s named)
+	getEnvBootstrap(defaultChain = 'LTC') {
+  		return getRpcBootstrapFromEnv(defaultChain);
+	}
+
+
+
+  _createClientByChain(chain) {
+    switch (chain) {
+      case 'BTC':
+        return new Bitcoin.Client(this.config);
+      case 'DOGE':
+        return new Doge.Client(this.config);
+      default:
+        return new Litecoin.Client(this.config);
+    }
+  }
+
+   static async getInstance(txIndex) {
+    if (!clientInstance) {
+      if(txIndex){console.log('initializing client by way of txIndex')}
+        if(this.isInitializing){await this.waitForInitialization()}
+      const clientWrapper = new ClientWrapper();
+    console.log('constructed client wrapper now init')
+      await clientWrapper.init();
+    }
+    return clientInstance;
+  }
+
+  determineChainFromSubversion(subversion, flag) {
+    console.log('chain subversion '+subversion+' '+flag )
+    subversion = subversion.toLowerCase();
+    if (subversion.includes('litecoin')) return 'LTC';
+    if (subversion.includes('bitcoin')) return 'BTC';
+    if (subversion.includes('dogecoin')) return 'DOGE';
+    throw new Error(`Unknown chain in subversion: ${subversion}`);
+  }
+
+  getBlockchainInfo() {
+    return util.promisify(this.client.cmd.bind(this.client, 'getblockchaininfo'))();
+  }
+
+  getRawTransaction(txId, verbose = true, blockHash) {
+    return util.promisify(this.client.cmd.bind(this.client, 'getrawtransaction'))(txId, verbose);
+  }
+
+  getnewaddress() {
+    return util.promisify(this.client.cmd.bind(this.client, 'getnewaddress'))();
+  }
+
+  sendtoaddress(addr,amt){
+    return util.promisify(this.client.cmd.bind(this.client, 'sendtoaddress'))(addr,amt)
+  }
+
+  getNetworkInfo(){
+    return util.promisify(this.client.cmd.bind(this.client, 'getnetworkinfo'))()
+  }
+
+  getTransaction(txId) {
+    return util.promisify(this.client.cmd.bind(this.client, 'gettransaction'))(txId);
+  }
+
+  getBlock(blockHash) {
+    return util.promisify(this.client.cmd.bind(this.client, 'getblock'))(blockHash);
+  }
+
+  getBlockHash(height) {
+    return util.promisify(this.client.cmd.bind(this.client, 'getblockhash'))(height);
+  }
+
+  createRawTransaction(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'createrawtransaction'))(...params);
+  }
+
+  listUnspent(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'listunspent'))(...params);
+  }
+
+  decoderawtransaction(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'decoderawtransaction'))(...params);
+  }
+
+  signrawtransactionwithwallet(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'signrawtransactionwithwallet'))(...params);
+  }
+
+  dumpprivkey(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'dumpprivkey'))(...params);
+  }
+
+  sendrawtransaction(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'sendrawtransaction'))(...params);
+  }
+
+  validateAddress(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'validateaddress'))(...params);
+  }
+
+  getBlockCount() {
+      return util.promisify(this.client.cmd.bind(this.client, 'getblockcount'))();
+  }
+
+  loadWallet(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'loadwallet'))(...params);
+  }
+
+  listlabels(...params) {
+    return util.promisify(this.client.cmd.bind(this.client, 'listlabels'))(...params);
+  }
+
+  getaddressesbylabel(label) {
+    return util.promisify(this.client.cmd.bind(this.client, 'getaddressesbylabel'))(label);
+  }
+
+  getwalletinfo() {
+    return util.promisify(this.client.cmd.bind(this.client, 'getwalletinfo'))();
+  }
+
+  listunspent() {
+    return util.promisify(this.client.cmd.bind(this.client, 'listunspent'))();
+  }
+
+
+  // Add this method to the ClientWrapper class
+  async verifyClientChain() {
+    try {
+      const networkInfo = await clientInstance.getNetworkInfo();
+      const subversion = networkInfo.subversion.toLowerCase();
+      let match;
+      if (subversion.includes('litecoin')) {
+        match = 'LTC';
+      } else if (subversion.includes('bitcoin')) {
+        match = 'BTC';
+      } else if (subversion.includes('dogecoin')) {
+        match = 'DOGE';
+      }
+
+      if (match && match !== this.chain) {
+        console.warn(`Mismatch: Configured chain is ${this.chain}, but detected ${match}.`);
+        this.chain = match;
+      } else {
+        console.log(`Verified chain: ${this.chain}`);
+      }
+    } catch (error) {
+      console.error('Error verifying chain:', error);
+    }
+  }
+
+  async getChain() {
+    const bleh= await this.getNetworkInfo(); // Double-check chain type
+    console.log('determining chain in get chain')  
+    return this.determineChainFromSubversion(bleh.subversion, true);
+  }
+
+  async getTest(){
+    const blockchainInfo = await this.getBlockchainInfo();
+    return blockchainInfo.chain === 'test';
+  }
+
+  clientInstance = this;
+
+
+  // Additional RPC methods as needed...
+}
+
+// Export singleton instance
+module.exports = ClientWrapper;