@tradelayerprotocol/tradelayer 1.9.1

package/tradelayer.js/oldTests/encodeDecode.js

@@ -0,0 +1,340 @@
+// encodeDecode.js
+
+// Function to encode "Simple Token Issue" transaction (Type 1)
+function encodeSimpleTokenIssue(type, params) {
+    const payload = [type, params.initialAmount, params.ticker, params.whitelists || 0];
+    return payload.join(',');
+}
+
+// Function to decode "Simple Token Issue" transaction (Type 1)
+function decodeSimpleTokenIssue(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        initialAmount: parseInt(parts[1], 10),
+        ticker: parts[2],
+        whitelists: parseInt(parts[3], 10),
+    };
+    return { type, params };
+}
+
+// Function to encode "Simple Send" transaction (Type 2)
+function encodeSimpleSend(type, params) {
+    const payload = [type, params.propertyId, params.amount];
+    return payload.join(',');
+}
+
+// Function to decode "Simple Send" transaction (Type 2)
+function decodeSimpleSend(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        propertyId: parseInt(parts[1], 10),
+        amount: parseInt(parts[2], 10),
+    };
+    return { type, params };
+}
+
+// Encode and decode functions for remaining transaction types (3 to 16).
+
+// Function to encode "Trade Token for UTXO" transaction (Type 3)
+function encodeTradeTokenForUTXO(type, params) {
+    const payload = [type, params.propertyId, params.amount, params.satsExpected];
+    return payload.join(',');
+}
+
+// Function to decode "Trade Token for UTXO" transaction (Type 3)
+function decodeTradeTokenForUTXO(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        propertyId: parseInt(parts[1], 10),
+        amount: parseInt(parts[2], 10),
+        satsExpected: parseInt(parts[3], 10),
+    };
+    return { type, params };
+}
+
+// Function to encode "Commit Token" transaction (Type 4)
+function encodeCommitToken(type, params) {
+    const payload = [type, params.propertyId, params.amount];
+    return payload.join(',');
+}
+
+// Function to decode "Commit Token" transaction (Type 4)
+function decodeCommitToken(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        propertyId: parseInt(parts[1], 10),
+        amount: parseInt(parts[2], 10),
+    };
+    return { type, params };
+}
+
+// Function to encode "On-chain Token for Token" transaction (Type 5)
+function encodeOnChainTokenForToken(type, params) {
+    const payload = [type, params.propertyId, params.propertyIdDesired, params.amountOffered, params.amountExpected];
+    return payload.join(',');
+}
+
+// Function to decode "On-chain Token for Token" transaction (Type 5)
+function decodeOnChainTokenForToken(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        propertyId: parseInt(parts[1], 10),
+        propertyIdDesired: parseInt(parts[2], 10),
+        amountOffered: parseInt(parts[3], 10),
+        amountExpected: parseInt(parts[4], 10),
+    };
+    return { type, params };
+}
+
+// Continue by adding functions for transaction types 6 to 16.
+
+// Function to encode "Create Whitelist" transaction (Type 6)
+function encodeCreateWhitelist(type, params) {
+    const payload = [type, params.backupAddress];
+    return payload.join(',');
+}
+
+// Function to decode "Create Whitelist" transaction (Type 6)
+function decodeCreateWhitelist(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        backupAddress: parts[1],
+    };
+    return { type, params };
+}
+
+// Function to encode "Update Whitelist Admin" transaction (Type 7)
+function encodeUpdateWhitelistAdmin(type, params) {
+    const payload = [type, params.newAddress];
+    return payload.join(',');
+}
+
+// Function to decode "Update Whitelist Admin" transaction (Type 7)
+function decodeUpdateWhitelistAdmin(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        newAddress: parts[1],
+    };
+    return { type, params };
+}
+
+// Function to encode "Issue Attestation" transaction (Type 8)
+function encodeIssueAttestation(type, params) {
+    const payload = [type, params.targetAddress];
+    return payload.join(',');
+}
+
+// Function to decode "Issue Attestation" transaction (Type 8)
+function decodeIssueAttestation(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        targetAddress: parts[1],
+    };
+    return { type, params };
+}
+
+// Function to encode "Revoke Attestation" transaction (Type 9)
+function encodeRevokeAttestation(type, params) {
+    const payload = [type, params.targetAddress];
+    return payload.join(',');
+}
+
+// Function to decode "Revoke Attestation" transaction (Type 9)
+function decodeRevokeAttestation(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        targetAddress: parts[1],
+    };
+    return { type, params };
+}
+
+// Function to encode "Create Managed Token" transaction (Type 10)
+function encodeCreateManagedToken(type, params) {
+    const payload = [
+        type,
+        params.initialAmount,
+        params.ticker,
+        params.url,
+        params.whitelists.join(','),
+        params.backupAddress,
+    ];
+    return payload.join(',');
+}
+
+// Function to decode "Create Managed Token" transaction (Type 10)
+function decodeCreateManagedToken(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        initialAmount: parseInt(parts[1], 10),
+        ticker: parts[2],
+        url: parts[3],
+        whitelists: parts[4].split(',').map(value => parseInt(value, 10)),
+        backupAddress: parts[5],
+    };
+    return { type, params };
+}
+
+// Continue by adding functions for transaction types 11 to 16.
+
+// ... Functions for transaction types 11 to 16
+
+// Function to encode "Grant Managed Token" transaction (Type 11)
+function encodeGrantManagedToken(type, params) {
+    const payload = [type, params.amountGranted, params.addressToGrant];
+    return payload.join(',');
+}
+
+// Function to decode "Grant Managed Token" transaction (Type 11)
+function decodeGrantManagedToken(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        amountGranted: parseInt(parts[1], 10),
+        addressToGrant: parts[2],
+    };
+    return { type, params };
+}
+
+// Function to encode "Redeem Managed Token" transaction (Type 12)
+function encodeRedeemManagedToken(type, params) {
+    const payload = [type, params.amountDestroyed];
+    return payload.join(',');
+}
+
+// Function to decode "Redeem Managed Token" transaction (Type 12)
+function decodeRedeemManagedToken(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        amountDestroyed: parseInt(parts[1], 10),
+    };
+    return { type, params };
+}
+
+// Function to encode "Update Managed Token Admin" transaction (Type 13)
+function encodeUpdateManagedTokenAdmin(type, params) {
+    const payload = [type, params.newAddress];
+    return payload.join(',');
+}
+
+// Function to decode "Update Managed Token Admin" transaction (Type 13)
+function decodeUpdateManagedTokenAdmin(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        newAddress: parts[1],
+    };
+    return { type, params };
+}
+
+// Function to encode "Create Oracle" transaction (Type 14)
+function encodeCreateOracle(type, params) {
+    const payload = [
+        type,
+        params.ticker,
+        params.url,
+        params.backupAddress,
+        params.whitelists.join(','),
+        params.lag,
+    ];
+    return payload.join(',');
+}
+
+// Function to decode "Create Oracle" transaction (Type 14)
+function decodeCreateOracle(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        ticker: parts[1],
+        url: parts[2],
+        backupAddress: parts[3],
+        whitelists: parts[4].split(',').map(value => parseInt(value, 10)),
+        lag: parseInt(parts[5], 10),
+    };
+    return { type, params };
+}
+
+// Function to encode "Publish Oracle Data" transaction (Type 15)
+function encodePublishOracleData(type, params) {
+    const payload = [type, params.price];
+    if (params.high) payload.push(params.high);
+    if (params.low) payload.push(params.low);
+    if (params.close) payload.push(params.close);
+    return payload.join(',');
+}
+
+// Function to decode "Publish Oracle Data" transaction (Type 15)
+function decodePublishOracleData(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        price: parseInt(parts[1], 10),
+    };
+    if (parts[2]) params.high = parseInt(parts[2], 10);
+    if (parts[3]) params.low = parseInt(parts[3], 10);
+    if (parts[4]) params.close = parseInt(parts[4], 10);
+    return { type, params };
+}
+
+// Function to encode "Update Oracle Admin" transaction (Type 16)
+function encodeUpdateOracleAdmin(type, params) {
+    const payload = [type, params.newAddress];
+    return payload.join(',');
+}
+
+// Function to decode "Update Oracle Admin" transaction (Type 16)
+function decodeUpdateOracleAdmin(encodedPayload) {
+    const parts = encodedPayload.split(',');
+    const type = parseInt(parts[0], 10);
+    const params = {
+        newAddress: parts[1],
+    };
+    return { type, params };
+}
+
+module.exports = {
+    // Previous functions for transaction types 1 to 5
+    encodeSimpleTokenIssue,
+    decodeSimpleTokenIssue,
+    encodeSimpleSend,
+    decodeSimpleSend,
+    encodeTradeTokenForUTXO,
+    decodeTradeTokenForUTXO,
+    encodeCommitToken,
+    decodeCommitToken,
+    encodeOnChainTokenForToken,
+    decodeOnChainTokenForToken,
+    encodeCreateWhitelist,
+    decodeCreateWhitelist,
+    encodeUpdateWhitelistAdmin,
+    decodeUpdateWhitelistAdmin,
+    encodeIssueAttestation,
+    decodeIssueAttestation,
+    encodeRevokeAttestation,
+    decodeRevokeAttestation,
+    encodeCreateManagedToken,
+    decodeCreateManagedToken,
+    encodeGrantManagedToken,
+    decodeGrantManagedToken,
+    encodeRedeemManagedToken,
+    decodeRedeemManagedToken,
+    encodeUpdateManagedTokenAdmin,
+    decodeUpdateManagedTokenAdmin,
+    encodeCreateOracle,
+    decodeCreateOracle,
+    encodePublishOracleData,
+    decodePublishOracleData,
+    encodeUpdateOracleAdmin,
+    decodeUpdateOracleAdmin,
+    // Continue adding functions for other transaction types (11 to 16).
+};

package/tradelayer.js/oldTests/expressTest.js

@@ -0,0 +1,29 @@
+const InterfaceChild = require('./interfaceChild.js');
+const adminAddress = "tltc1qa0kd2d39nmeph3hvcx8ytv65ztcywg5sazhtw8"; // Replace with your admin address
+
+async function testInterfaceChild() {
+    try {
+
+    	const interfaceChild = new InterfaceChild();
+		interfaceChild.initMain().then(() => {
+		    console.log("initMain command sent.");
+		}).catch((error) => {
+		    console.error("Error sending initMain command:", error);
+		});
+
+        // Query for balance on the admin address
+        const adminBalance = await tradeLayerInterfaceChild.getAllBalancesForAddress(adminAddress);
+        console.log(`Balance for admin address (${adminAddress}):`, adminBalance);
+
+        // Query for the property list
+        const propertyList = await tradeLayerInterfaceChild.listProperties();
+        console.log("Property List:", propertyList);
+
+        // ... additional queries as needed ...
+
+    } catch (error) {
+        console.error("Error during test:", error);
+    }
+}
+
+testInterfaceChild();

package/tradelayer.js/oldTests/extractBlocksVanilla.js

@@ -0,0 +1,214 @@
+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
+var totalBlocks = 20
+
+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+totalBlocks) {
+          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 = 2093623;
+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("getting ready to loop through a new block: "+placement+" "+start)
+  var thisBlock = blockData[placement]
+  /*try{
+    if(thisBlock.tx.length=undefined){thisBlock=blockData[placement+1]}else{indexPlaceholder=start}
+  }catch{
+    console.log('block is apparently undefined')
+  }*/
+
+  if(start>=startHeight+totalBlocks){
+     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 not undefined: "+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){
+    var newBlock = block.height+1
+    console.log("i>tx.length block done!... now:"+newBlock);
+    return extractProtocolTx(block.height+1,false)
+  }
+
+  var tx = block.tx[i];
+    
+      if (tx === undefined || tx === '') {
+        console.log("Jim, abort!");
+        return loopThroughBlock(block,i+1)
+      }
+
+  try{
+    console.log(tx);
+    client.getRawTransaction(tx,true,function(err,rawtx){      
+        
+        if (rawtx === undefined) {
+          console.log("raw tx undefined")
+          return loopThroughBlock(block, i + 1);
+        }
+
+        let confirmations;
+        try {
+          confirmations = rawtx.confirmations;
+        } catch {
+          return loopThroughBlock(block, i + 1);
+        }
+
+        var thisConfirmations = confirmations;
+
+        for (let v = 0; v < rawtx.vout.length; v++) {
+          console.log(v)
+          var vout = rawtx.vout[v];
+          var ASMstring = vout.scriptPubKey.asm.slice(0,9);
+          console.log(ASMstring)
+          if (ASMstring === "OP_RETURN" && confirmations >= 1) {
+
+            var payload = vout.scriptPubKey.asm.slice(11,vout.scriptPubKey.asm.length);
+            console.log(payload)           
+            var marker =decode(payload.slice(0,1))
+
+            var txObj = { tx: tx, payload: payload, marker: marker };
+            console.log(decodedPayload,marker,txObj)
+            if (marker === "om") {
+              marker = payload.slice(0,3)
+              txObj.marker=marker
+              payload=payload.slice(4,payload.length)
+              txObj.payload=payload
+              omniTxCount+=1
+              console.log("Omni tx "+omniTxCount)
+              thisBlockOm.push(txObj);
+            }
+            if (marker === "tl") {
+              payload=payload.slice(2,payload.length)
+              txObj.payload=payload
+              thisBlockTl.push(txObj);
+            }
+          } else if (ASMstring === "OP_RETURN" && confirmations === 0) {
+            var payload = vout.scriptPubKey.asm.split(' ');
+            var decodedPayload = decodeOPReturnPayload(payload);
+            var marker = decodedPayload.slice(0, 1);
+            var txObj = { tx: tx, payload: payload, decode: decode, marker: marker };
+            if (marker === "om" || marker === "tl") {
+              memPool.push(tx);
+            }
+          }
+        }
+        return loopThroughBlock(block,i+1)
+    })
+  }catch{
+        console.log("is rawtx undefined", rawtx);
+  }
+}
+
+
+
+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' };
+  }
+}