feat: working parser (at least for tx requests)

Author: coolaj86

bin/inspect2.js

@@ -13,8 +13,18 @@ async function main() {
   let hex = Fs.readFileSync(filepath, "utf8");
   hex = hex.trim();
 
-  let txInfo = Tx.parseUnknown(hex);
-  Tx._debugPrint(txInfo);
+  let txInfo;
+  try {
+    txInfo = Tx.parseUnknown(hex);
+  } catch (e) {
+    //@ts-ignore
+    console.log(e.transaction);
+    throw e;
+  }
+
+  console.info(txInfo);
+  let out = Tx._debugPrint(txInfo);
+  console.info(out);
 }
 
 main()

dashtx.js

@@ -8,7 +8,8 @@
  * @prop {Uint32} MAX_INPUT_PAD - 2 (possible ASN.1 BigInt padding)
  * @prop {Uint32} MAX_INPUT_SIZE - 149 each (with padding)
  * @prop {Uint32} OUTPUT_SIZE - 34 each
- * @prop {Uint32} SIGHASH_ALL - 0x01
+ * @prop {Uint32|0x00000001} SIGHASH_ALL - 0x01
+ * @prop {Uint32|0x00000080} SIGHASH_ANYONECANPAY - 0x80
  * @prop {TxAppraise} appraise
  * @prop {TxAppraiseCounts} _appraiseCounts
  * @prop {TxAppraiseMemos} _appraiseMemos
@@ -22,6 +23,10 @@
  * @prop {TxGetId} getId - only useful for fully signed tx
  * @prop {TxHashPartial} hashPartial - useful for computing sigs
  * @prop {TxCreateLegacyTx} createLegacyTx
+ * @prop {TxParseUnknown} parseUnknown
+ * @prop {TxParseRequest} parseRequest
+ * @prop {TxParseHashable} parseHashable
+ * @prop {TxParseSigned} parseSigned
  * @prop {TxSortBySats} sortBySatsAsc
  * @prop {TxSortBySats} sortBySatsDsc
  * @prop {TxSortInputs} sortInputs
@@ -32,12 +37,14 @@
  * @prop {Function} _create
  * @prop {Function} _createInsufficientFundsError
  * @prop {Function} _createMemoScript
+ * @prop {Function} _debugPrint
  * @prop {Function} _hash
  * @prop {Function} _hashAndSignAll
  * @prop {Function} _legacyMustSelectInputs
  * @prop {Function} _legacySelectOptimalUtxos
  * @prop {Function} _packInputs
  * @prop {Function} _packOutputs
+ * @prop {Function} _parse
  */
 
 /**
@@ -153,6 +160,7 @@ var DashTx = ("object" === typeof module && exports) || {};
     25; // lockscript
 
   Tx.SIGHASH_ALL = 0x01;
+  Tx.SIGHASH_ANYONECANPAY = 0x80;
 
   Tx.appraise = function (txInfo) {
     let extraSize = Tx._appraiseMemos(txInfo.outputs);
@@ -1368,8 +1376,8 @@ var DashTx = ("object" === typeof module && exports) || {};
       let sigHashTypeHex = TxUtils._toUint32LE(sigHashType);
       txSignable = `${txSignable}${sigHashTypeHex}`;
     }
-    //console.log("Signable Tx Hex");
-    //console.log(txSignable);
+    console.log("Signable Tx Hex");
+    console.log(txSignable);
 
     let u8 = Tx.utils.hexToBytes(txSignable);
     //console.log("Signable Tx Buffer");
@@ -1609,9 +1617,10 @@ if ("object" === typeof module) {
 // Type Aliases
 
 /** @typedef {Number} Float64 */
-/** @typedef {Number} Uint53 */
-/** @typedef {Number} Uint32 */
 /** @typedef {Number} Uint8 */
+/** @typedef {Number} Uint32 */
+/** @typedef {Number} Uint53 */
+/** @typedef {String} Hex */
 /** @typedef {Uint8Array} TxPrivateKey */
 /** @typedef {Uint8Array} TxPublicKey */
 /** @typedef {Uint8Array} TxSignature */
@@ -1878,6 +1887,30 @@ if ("object" === typeof module) {
  * @returns {Promise<TxInfo>}
  */
 
+/**
+ * @callback TxParseRequest
+ * @param {Hex} hex - a tx request with unsigned or partially signed inputs
+ * @returns {TxInfo}
+ */
+
+/**
+ * @callback TxParseHashable
+ * @param {Hex} hex - a ready-to-sign tx with input script and trailing sighash byte
+ * @returns {TxInfo}
+ */
+
+/**
+ * @callback TxParseSigned
+ * @param {Hex} hex - a fully signed, ready-to-broadcast transaction
+ * @returns {TxInfo}
+ */
+
+/**
+ * @callback TxParseUnknown
+ * @param {Hex} hex - a tx request, hashable tx, or signed tx
+ * @returns {TxInfo}
+ */
+
 /**
  * @callback TxReverseHex
  * @param {String} hex

txparser.js

@@ -18,8 +18,15 @@ Tx.parseUnknown = function (txHex) {
     //@ts-ignore - trust me bro, it's an error
     let err = e;
     let msg = err.message;
+    let out = "";
+    try {
+      out = Tx._debugPrint(txInfo);
+    } catch (e) {
+      //@ts-ignore
+      out = e.message;
+    }
     Object.assign(err, {
-      message: Tx._debugPrint(txInfo),
+      message: out,
       code: "E_TX_PARSE",
       transaction: txInfo,
     });
@@ -47,37 +54,31 @@ Tx._parse = function (tx, hex) {
   tx.offset += 8;
   tx.version = version;
   tx.versionHex = versionHex;
-  tx.inputs = [];
-  tx.outputs = [];
 
   let [numInputs, numInputsSize] = parseVarIntHex(hex, tx.offset);
   tx.offset += numInputsSize;
   tx.numInputsHex = numInputs.toString(16);
   tx.numInputsHex = tx.numInputsHex.padStart(2, "0");
   tx.numInputs = numInputs;
 
+  tx.inputs = [];
   for (let i = 0; i < numInputs; i += 1) {
     let input = {};
     tx.inputs.push(input);
 
     input.txidHex = hex.substr(tx.offset, 64);
-    input.txid = Tx.utils.reverseHex(tx.txidHex);
+    input.txid = Tx.utils.reverseHex(input.txidHex);
+    input.txId = input.txid; // TODO
     tx.offset += 64;
 
     input.outputIndexHex = hex.substr(tx.offset, 8);
     let outputIndexHexLe = Tx.utils.reverseHex(input.outputIndexHex);
     input.outputIndex = parseInt(outputIndexHexLe, 16);
-    // console.info(
-    //   `    ${outputIndexHex}              # Previous Output index (${outputIndex})`,
-    // );
     tx.offset += 8;
 
     // TODO VarInt
     input.scriptSizeHex = hex.substr(tx.offset, 2);
     input.scriptSize = parseInt(input.scriptSizeHex, 16);
-    // console.info(
-    //   `    ${input.scriptSizeHex}                    # Script Size (${input.scriptSize} bytes)`,
-    // );
     tx.offset += 2;
 
     input.script = "";
@@ -204,13 +205,14 @@ Tx._parse = function (tx, hex) {
   tx.numOutputsHex = tx.numOutputsHex.padStart(2, "0");
   tx.numOutputs = numOutputs;
 
+  tx.outputs = [];
   for (let i = 0; i < tx.numOutputs; i += 1) {
     let output = {};
     tx.outputs.push(output);
 
     output.satoshisHex = hex.substr(tx.offset, 16);
     tx.offset += 16;
-    let satsHex = Tx.utils.reverseHex(tx.satoshisHex);
+    let satsHex = Tx.utils.reverseHex(output.satoshisHex);
     output.satoshis = parseInt(satsHex, 16);
     tx.totalSatoshis += output.satoshis;
     // console.info(
@@ -230,6 +232,7 @@ Tx._parse = function (tx, hex) {
 
     output.scriptTypeHex = output.script.slice(0, 2);
     output.scriptType = parseInt(output.scriptTypeHex, 16);
+    output.pubKeyHash = "";
     output.memo = "";
     output.message = "";
     if (output.scriptType === OP_RETURN) {
@@ -242,6 +245,9 @@ Tx._parse = function (tx, hex) {
       } catch (e) {
         output.message = "<non-UTF-8 bytes>";
       }
+    } else {
+      // TODO check the script type
+      output.pubKeyHash = output.script.slice(6, -4);
     }
   }
 
@@ -328,7 +334,7 @@ Tx._debugPrint = function (tx) {
   lines.push(
     `${tx.numInputsHex}                        # Inputs (${tx.numInputs})`,
   );
-  for (let i = 0; i < tx.inputs.length; i += 1) {
+  for (let i = 0; i < tx.inputs?.length; i += 1) {
     let count = i + 1;
     let input = tx.inputs[i];
     lines.push("");
@@ -338,18 +344,26 @@ Tx._debugPrint = function (tx) {
     let txid2 = input.txidHex.slice(16, 32);
     let txid3 = input.txidHex.slice(32, 48);
     let txid4 = input.txidHex.slice(48, 64);
-    lines.push(`    ${txid1}      # Previous Output TX ID"`);
+    lines.push(`    ${txid1}      # Previous Output TX ID`);
     lines.push(`    ${txid2}`);
     lines.push(`    ${txid3}`);
     lines.push(`    ${txid4}`);
+
+    lines.push(
+      `    ${input.outputIndexHex}              # Previous Output index (${input.outputIndex})`,
+    );
+
+    lines.push(
+      `    ${input.scriptSizeHex}                    # Script Size (${input.scriptSize} bytes)`,
+    );
   }
 
   // outputs
   lines.push("");
   lines.push(
     `${tx.numOutputsHex}                        # Outputs (${tx.numOutputs})`,
   );
-  for (let i = 0; i < tx.outputs.length; i += 1) {
+  for (let i = 0; i < tx.outputs?.length; i += 1) {
     let count = i + 1;
     let output = tx.outputs[i];