@alexbosworth/blockchain 1.2.1 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 1.4.0
+
+- `scriptElementsAsScript`: Convert an array of script elements to a script
+
+## 1.3.0
+
+- `componentsOfTransaction`: Parse transaction hex into its component elements
+
 ## 1.2.1
 
 - `noLocktimeIdForTransaction`: Fix id derivation to correct value

package/README.md

@@ -1,3 +1,122 @@
 # Blockchain
 
 Utility methods for working with Blockchain data
+
+## Methods
+
+### compactIntAsNumber
+
+Convert a compact integer to a regular number
+
+    {
+      encoded: <Compact Integer Encoded Number Buffer Object>
+      [start]: <Buffer Offset Start Index Number>
+    }
+
+    @returns
+    {
+      bytes: <Byte Count Number>
+      number: <Integer Number>
+    }
+
+Example:
+
+```node
+const {compactIntAsNumber} = require('@alexbosworth/blockchain');
+
+// Decode the plain number from the encoded compact int bytes
+const {number} = compactIntAsNumber({encoded: Buffer.from('fdfd00', 'hex')});
+```
+
+### componentsOfTransaction
+
+Get the components of a hex-encoded transaction
+
+    {
+      transaction: <Hex Encoded Transaction String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      inputs: [{
+        id: <Spending Transaction Id Hex String>
+        script: <ScriptSig Script Hex String>
+        sequence: <Sequence Number>
+        vout: <Spending Transaction Output Index Number>
+        [witness]: [<Script Stack Element Hex String>]
+      }]
+      locktime: <Timelock nLockTime Number>
+      outputs: [{
+        script: <ScriptPub Script Hex String>
+        tokens: <Tokens Count Number>
+      }]
+      version: <Version Number>
+    }
+
+### idForBlock
+
+Get an id for a block: the double sha256 hash of the block header
+
+    {
+      block: <Hex Encoded Block Data String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      id: <Block Id Hex Encoded String>
+    }
+
+### noLocktimeIdForTransaction
+
+Get an id for a transaction with witness data and mlocktime not included
+
+    {
+      buffer: <Data Buffer Object>
+      [start]: <Starting Offset Index Number>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      id: <No nLockTime Transaction Id Hex String>
+    }
+
+### numberAsCompactInt
+
+Convert a number to compact size integer serialization
+
+    {
+      number: <Amount to Convert to Compact Integer Serialization Number>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      encoded: <Serialized Compact Integer Buffer Object>
+    }
+
+### scriptElementsAsScript
+
+Map array of script buffer elements to a fully formed script
+
+    {
+      elements: [<Data Buffer>, <Script OP_CODE Number>]
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Script Hex String>
+    }

package/hashes/id_for_block.js

@@ -7,7 +7,7 @@ const hexAsBuffer = hex => Buffer.from(hex, 'hex');
 const isHex = n => !!n && !(n.length % 2) && /^[0-9A-F]*$/i.test(n);
 const sha256 = preimage => createHash('sha256').update(preimage).digest();
 
-/** Get an id for a block
+/** Get an id for a block: the double sha256 hash of the block header
 
   {
     block: <Hex Encoded Block Data String>
@@ -18,7 +18,7 @@ const sha256 = preimage => createHash('sha256').update(preimage).digest();
 
   @returns
   {
-    id: <Block Hex String>
+    id: <Block Id Hex Encoded String>
   }
 */
 module.exports = ({block}) => {

package/hashes/no_locktime_id_for_transaction.js

@@ -1,22 +1,9 @@
 const {createHash} = require('crypto');
 
-const {compactIntAsNumber} = require('./../numbers');
+const {parseTransaction} = require('./../transactions');
 
 const bufferAsHex = buffer => buffer.toString('hex');
-const byteCountHash = 32;
-const byteCountInt8 = 1;
-const byteCountInt32 = 4;
-const byteCountInt64 = 8;
-const byteCountMarkerFlag = 2;
-const byteCountNoMarkerFlag = 0;
-const decodeCompactInt = (b, o) => compactIntAsNumber({encoded: b, start: o});
-const defaultStartIndex = 0;
-const defaultWitnessCount = 0;
-const {isBuffer} = Buffer;
-const segWitV0Marker = 0;
-const segWitV0Flag = 1;
 const sha256 = preimage => createHash('sha256').update(preimage).digest();
-const times = n => [...Array(n).keys()];
 
 /** Get an id for a transaction with witness data and mlocktime not included
 
@@ -34,92 +21,12 @@ const times = n => [...Array(n).keys()];
   }
 */
 module.exports = ({buffer, start}) => {
-  if (!isBuffer(buffer)) {
-    throw new Error('ExpectedDataBufferToGetNoLocktimeIdForTransaction');
-  }
-
-  let offset = start || defaultStartIndex;
-
-  // Transaction version is a signed 4 byte integer
-  const version = buffer.readInt32LE(offset, offset + byteCountInt32);
-
-  offset += byteCountInt32;
-
-  // For SegWit transactions, the next 2 bytes would be a marker and flag
-  const markerFlagSplit = offset + byteCountInt8;
-
-  const marker = buffer.readUInt8(offset, markerFlagSplit);
-
-  const flag = buffer.readUInt8(markerFlagSplit, offset + byteCountMarkerFlag);
-
-  // The presence of the marker and flag indicates SegWit tx encoding
-  const isSegWit = !marker && flag === segWitV0Flag;
-
-  // When tx isn't SegWit though, the bytes are not marker and flag
-  offset += isSegWit ? byteCountMarkerFlag : byteCountNoMarkerFlag;
-
-  const inputsCount = decodeCompactInt(buffer, offset);
-
-  offset += inputsCount.bytes;
-
-  // For SegWit the witness stacks will be at the end of the transaction
-  const witnessCount = isSegWit ? inputsCount.number : defaultWitnessCount;
-
-  // Read in the inputs
-  const inputs = times(inputsCount.number).map(i => {
-    // The hash is the internal byte order hash of the tx being spent
-    const hash = buffer.subarray(offset, offset + byteCountHash);
-
-    offset += byteCountHash;
-
-    // The vout is the 4 byte output index of the tx being spent in this input
-    const vout = buffer.readUInt32LE(offset, offset + byteCountInt32);
-
-    offset += byteCountInt32;
-
-    // Before SegWit, scripts were encoded in this input space
-    const scriptLength = decodeCompactInt(buffer, offset);
-
-    offset += scriptLength.bytes;
-
-    // Scripts are variable byte length
-    const script = buffer.subarray(offset, offset + scriptLength.number);
-
-    offset += scriptLength.number;
-
-    // Sequence is a 4 byte unsigned number for an input, used for CSV mainly
-    const sequence = buffer.readUInt32LE(offset, offset + byteCountInt32);
-
-    offset += byteCountInt32;
-
-    return {hash, script, sequence, vout};
-  });
-
-  const outputsCount = decodeCompactInt(buffer, offset);
-
-  offset += outputsCount.bytes;
-
-  // Read in the outputs of the transaction
-  const outputs = times(outputsCount.number).map(i => {
-    // The value being spent
-    const tokens = buffer.readBigUInt64LE(offset, offset + byteCountInt64);
-
-    offset += byteCountInt64;
-
-    // The script being spent to has a variable length
-    const scriptLength = decodeCompactInt(buffer, offset);
-
-    offset += scriptLength.bytes;
-
-    const script = buffer.subarray(offset, offset + scriptLength.number);
-
-    offset += scriptLength.number;
-
-    return {script, tokens};
-  });
-
   // The remainder of the transaction bytes are witnesses and nlocktime
-  const bytes = buffer.subarray(start, offset);
+  const {bytes} = parseTransaction({
+    buffer,
+    start,
+    is_terminating_after_outputs: true,
+  });
 
   return {id: bufferAsHex(sha256(bytes))};
 };

package/index.js

@@ -1,11 +1,15 @@
 const {compactIntAsNumber} = require('./numbers');
+const {componentsOfTransaction} = require('./transactions');
 const {idForBlock} = require('./hashes');
 const {noLocktimeIdForTransaction} = require('./hashes');
 const {numberAsCompactInt} = require('./numbers');
+const {scriptElementsAsScript} = require('./script');
 
 module.exports = {
   compactIntAsNumber,
+  componentsOfTransaction,
   idForBlock,
   noLocktimeIdForTransaction,
   numberAsCompactInt,
+  scriptElementsAsScript,
 };

package/package.json

@@ -20,7 +20,7 @@
     "url": "https://github.com/alexbosworth/blockchain.git"
   },
   "scripts": {
-    "test": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/hashes/*.js test/numbers/*.js"
+    "test": "tap -j 2 --branches=1 --functions=1 --lines=1 --statements=1 -t 200 test/hashes/*.js test/numbers/*.js test/script/*.js test/transactions/*.js"
   },
-  "version": "1.2.1"
+  "version": "1.4.0"
 }

package/script/index.js

@@ -0,0 +1,3 @@
+const scriptElementsAsScript = require('./script_elements_as_script');
+
+module.exports = {scriptElementsAsScript};

package/script/script_elements_as_script.js

@@ -0,0 +1,42 @@
+const {numberAsCompactInt} = require('./../numbers');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const {concat} = Buffer;
+const encode = number => numberAsCompactInt({number}).encoded;
+const flatten = arr => arr.reduce((sum, n) => Buffer.concat([sum, n]));
+const {from} = Buffer;
+const {isArray} = Array;
+const {isBuffer} = Buffer;
+
+/** Map array of script buffer elements to a fully formed script
+
+  {
+    elements: [<Data Buffer>, <Script OP_CODE Number>]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Script Hex String>
+  }
+*/
+module.exports = ({elements}) => {
+  if (!isArray(elements)) {
+    throw new Error('ExpectedArrayOfScriptElementsToEncodeScript');
+  }
+
+   // Convert numbers to buffers and hex data to pushdata
+  const fullScript = elements.map(element => {
+    // Exit early when element is a data push
+    if (isBuffer(element)) {
+      return concat([encode(element.length), element]);
+    }
+
+    // Non data elements are direct bytes
+    return from([element]);
+  });
+
+  return {script: bufferAsHex(flatten(fullScript))};
+};

package/test/hashes/test_no_locktime_id_for_transaction.js

@@ -8,7 +8,7 @@ const tests = [
   {
     args: {},
     description: 'A data buffer with a transaction is required',
-    error: 'ExpectedDataBufferToGetNoLocktimeIdForTransaction',
+    error: 'ExpectedDataBufferToReadTransactionDataOutOf',
   },
   {
     args: {

package/test/script/test_script_elements_as_script.js

@@ -0,0 +1,30 @@
+const {test} = require('@alexbosworth/tap');
+
+const {scriptElementsAsScript} = require('./../../');
+
+const tests = [
+  {
+    args: {},
+    description: 'An array of eleemnts is required',
+    error: 'ExpectedArrayOfScriptElementsToEncodeScript',
+  },
+  {
+    args: {elements: [118, 169, Buffer.alloc(20), 136, 172]},
+    description: 'Elements are mapped to an output script',
+    expected: {script: '76a914000000000000000000000000000000000000000088ac'},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => scriptElementsAsScript(args), new Error(error), 'Got err');
+    } else {
+      const res = scriptElementsAsScript(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/transactions/test_components_of_transaction.js

@@ -0,0 +1,215 @@
+const {test} = require('@alexbosworth/tap');
+
+const {componentsOfTransaction} = require('./../../');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {transaction: ''},
+    description: 'A transaction hex is required',
+    error: 'ExpectedHexEncodedTransactionToGetComponentsOf',
+  },
+  {
+    args: {
+      transaction: '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000',
+    },
+    description: 'A coinbase transaction is parsed',
+    expected: {
+      inputs: [{
+        id: '0000000000000000000000000000000000000000000000000000000000000000',
+        script: '04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73',
+        sequence: 4294967295,
+        vout: 4294967295,
+        witness: undefined,
+      }],
+      locktime: 0,
+      outputs: [{
+        script: '4104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac',
+        tokens: 5000000000,
+      }],
+      version: 1,
+    },
+  },
+  {
+    args: {
+      transaction: '01000000019ac03d5ae6a875d970128ef9086cef276a1919684a6988023cc7254691d97e6d010000006b4830450221009d41dc793ba24e65f571473d40b299b6459087cea1509f0d381740b1ac863cb6022039c425906fcaf51b2b84d8092569fb3213de43abaff2180e2a799d4fcb4dd0aa012102d5ede09a8ae667d0f855ef90325e27f6ce35bbe60a1e6e87af7f5b3c652140fdffffffff080100000000000000010101000000000000000202010100000000000000014c0100000000000000034c02010100000000000000014d0100000000000000044dffff010100000000000000014e0100000000000000064effffffff0100000000',
+    },
+    description: 'invalid script',
+    expected: {
+      inputs: [{
+        id: '6d7ed9914625c73c0288694a6819196a27ef6c08f98e1270d975a8e65a3dc09a',
+        script: '4830450221009d41dc793ba24e65f571473d40b299b6459087cea1509f0d381740b1ac863cb6022039c425906fcaf51b2b84d8092569fb3213de43abaff2180e2a799d4fcb4dd0aa012102d5ede09a8ae667d0f855ef90325e27f6ce35bbe60a1e6e87af7f5b3c652140fd',
+        sequence: 4294967295,
+        vout: 1,
+        witness: undefined,
+      }],
+      locktime: 0,
+      outputs: [
+        {
+          script: '01',
+          tokens: 1,
+        },
+        {
+          script: '0201',
+          tokens: 1,
+        },
+        {
+          script: '4c',
+          tokens: 1,
+        },
+        {
+          script: '4c0201',
+          tokens: 1,
+        },
+        {
+          script: '4d',
+          tokens: 1,
+        },
+        {
+          script: '4dffff01',
+          tokens: 1,
+        },
+        {
+          script: '4e',
+          tokens: 1,
+        },
+        {
+          script: '4effffffff01',
+          tokens: 1,
+        },
+      ],
+      version: 1,
+    },
+  },
+  {
+    args: {
+      transaction: '02000000000103ae8caf3aad8861142597a29d6377f524a55f4542d5294c8292ce123a956d3e520000000000ffffffff9cbb1c5531a677b90c489d75a198a14f02d49e554ab9cdaa17bd956b127724570200000000ffffffff9cbb1c5531a677b90c489d75a198a14f02d49e554ab9cdaa17bd956b127724570100000000ffffffff0640420f0000000000160014eaa9b76637b1ad340b6efadf773a73b53637d5b6de91f62901000000225120f4c82416bcb08422c195af995e1d248d1378d8b48dafa9f45bc213b83101d49240420f00000000001600148729d17b2aa507ab19051a028384bc6e0ce25e455e368900000000002251200249ccc5af06fa5642f12d42d2a34bfbb08688d54a9b99d07b98619b35df03b440420f0000000000160014d2d59a8a59f997cbc8888411010faf1658e0e3465e368900000000002251207febd720c78518b52aa1a2443823cc8f55e373910f616e112d5d7bd622fe1ab2024830450221008ac71eff4d7e298941be012fc14f0ac9bf62ae6ffeac13522bb27b5b4108d3aa0220192a69ad6fdb86b1e09c7fdcaaafeb58d25060e44199c734dc0d7d385b5d800d0121029943eaccd3987fa495a6b4f47f2fafeb0521e4e12f39498d9465a564ef75329602483045022100f9cde9adb00c0a6c62dae8604ca750039201288c0dafff952461da3caf05e3ae0220679c01f2518413951de3b62531b1cf36bb92562e3bd4197f0fa6e6e3e231272e0121027326b48c9f2729597e328ab6d05f5af75866e1ffa203fadf78387a3b202ff80d0247304402202550beec478845af2df929abf85708f9fcceaae31377f2e01d803e2acf7b426f022036c312b1e38ca333fe70aa37d3093387ac7486f08438eb8eed323699594468cb012102275a197f7ccfece19cf0532b068b6e38ceceda146e791875ecbdc55500bb7efe00000000',
+    },
+    description: 'Transaction with witnesses and P2TR and P2WPKH outputs',
+    expected: {
+      inputs: [
+        {
+          id: '523e6d953a12ce92824c29d542455fa524f577639da29725146188ad3aaf8cae',
+          script: '',
+          sequence: 4294967295,
+          vout: 0,
+          witness: [
+            '30450221008ac71eff4d7e298941be012fc14f0ac9bf62ae6ffeac13522bb27b5b4108d3aa0220192a69ad6fdb86b1e09c7fdcaaafeb58d25060e44199c734dc0d7d385b5d800d01',
+            '029943eaccd3987fa495a6b4f47f2fafeb0521e4e12f39498d9465a564ef753296',
+          ],
+        },
+        {
+          id: '572477126b95bd17aacdb94a559ed4024fa198a1759d480cb977a631551cbb9c',
+          script: '',
+          sequence: 4294967295,
+          vout: 2,
+          witness: [
+            '3045022100f9cde9adb00c0a6c62dae8604ca750039201288c0dafff952461da3caf05e3ae0220679c01f2518413951de3b62531b1cf36bb92562e3bd4197f0fa6e6e3e231272e01',
+            '027326b48c9f2729597e328ab6d05f5af75866e1ffa203fadf78387a3b202ff80d',
+          ],
+        },
+        {
+          id: '572477126b95bd17aacdb94a559ed4024fa198a1759d480cb977a631551cbb9c',
+          script: '',
+          sequence: 4294967295,
+          vout: 1,
+          witness: [
+            '304402202550beec478845af2df929abf85708f9fcceaae31377f2e01d803e2acf7b426f022036c312b1e38ca333fe70aa37d3093387ac7486f08438eb8eed323699594468cb01',
+            '02275a197f7ccfece19cf0532b068b6e38ceceda146e791875ecbdc55500bb7efe'
+          ],
+        }
+      ],
+      locktime: 0,
+      outputs: [
+        {
+          script: '0014eaa9b76637b1ad340b6efadf773a73b53637d5b6',
+          tokens: 1000000,
+        },
+        {
+          script: '5120f4c82416bcb08422c195af995e1d248d1378d8b48dafa9f45bc213b83101d492',
+          tokens: 4998992350,
+        },
+        {
+          script: '00148729d17b2aa507ab19051a028384bc6e0ce25e45',
+          tokens: 1000000,
+        },
+        {
+          script: '51200249ccc5af06fa5642f12d42d2a34bfbb08688d54a9b99d07b98619b35df03b4',
+          tokens: 8992350,
+        },
+        {
+          script: '0014d2d59a8a59f997cbc8888411010faf1658e0e346',
+          tokens: 1000000,
+        },
+        {
+          script: '51207febd720c78518b52aa1a2443823cc8f55e373910f616e112d5d7bd622fe1ab2',
+          tokens: 8992350,
+        },
+      ],
+      version: 2,
+    },
+  },
+  {
+    args: {
+      transaction: '0100000001f709fa82596e4f908ee331cb5e0ed46ab331d7dcfaf697fe95891e73dac4ebcb000000008c20ca42095840735e89283fec298e62ac2ddea9b5f34a8cbb7097ad965b87568100201b1b01dc829177da4a14551d2fc96a9db00c6501edfa12f22cd9cefd335c227f483045022100a9df60536df5733dd0de6bc921fab0b3eee6426501b43a228afa2c90072eb5ca02201c78b74266fac7d1db5deff080d8a403743203f109fbcabf6d5a760bf87386d20100ffffffff01c075790000000000232103611f9a45c18f28f06f19076ad571c344c82ce8fcfe34464cf8085217a2d294a6ac00000000',
+    },
+    description: 'A non-segwit transaction is read',
+    expected: {
+      inputs: [{
+        id: 'cbebc4da731e8995fe97f6fadcd731b36ad40e5ecb31e38e904f6e5982fa09f7',
+        script: '20ca42095840735e89283fec298e62ac2ddea9b5f34a8cbb7097ad965b87568100201b1b01dc829177da4a14551d2fc96a9db00c6501edfa12f22cd9cefd335c227f483045022100a9df60536df5733dd0de6bc921fab0b3eee6426501b43a228afa2c90072eb5ca02201c78b74266fac7d1db5deff080d8a403743203f109fbcabf6d5a760bf87386d20100',
+        sequence: 4294967295,
+        vout: 0,
+        witness: undefined,
+      }],
+      locktime: 0,
+      outputs: [{
+        script: '2103611f9a45c18f28f06f19076ad571c344c82ce8fcfe34464cf8085217a2d294a6ac',
+        tokens: 7960000,
+      }],
+      version: 1,
+    },
+  },
+  {
+    args: {
+      transaction: '0100000001c997a5e56e104102fa209c6a852dd90660a20b2d9c352423edce25857fcd3704000000004847304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901ffffffff0200ca9a3b00000000434104ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84cac00286bee0000000043410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac00000000',
+    },
+    description: 'A P2PK transaction is read',
+    expected: {
+      inputs: [{
+        id: '0437cd7f8525ceed2324359c2d0ba26006d92d856a9c20fa0241106ee5a597c9',
+        script: '47304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901',
+        sequence: 4294967295,
+        vout: 0,
+        witness: undefined,
+      }],
+      locktime: 0,
+      outputs: [
+        {
+          script: '4104ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84cac',
+          tokens: 1000000000,
+        },
+        {
+          script: '410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac',
+          tokens: 4000000000,
+        },
+      ],
+      version: 1,
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, ({end, strictSame, throws}) => {
+    if (!!error) {
+      throws(() => componentsOfTransaction(args), new Error(error), 'Got err');
+    } else {
+      const res = componentsOfTransaction(args);
+
+      strictSame(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/transactions/components_of_transaction.js

@@ -0,0 +1,56 @@
+const parseTransaction = require('./parse_transaction');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const isHex = n => !!n && !(n.length % 2) && /^[0-9A-F]*$/i.test(n);
+const txHashAsTxId = hash => hash.reverse();
+
+/** Get the components of a hex-encoded transaction
+
+  {
+    transaction: <Hex Encoded Transaction String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    inputs: [{
+      id: <Spending Transaction Id Hex String>
+      script: <ScriptSig Script Hex String>
+      sequence: <Sequence Number>
+      vout: <Spending Transaction Output Index Number>
+      [witness]: [<Script Stack Element Hex String>]
+    }]
+    locktime: <Timelock nLockTime Number>
+    outputs: [{
+      script: <ScriptPub Script Hex String>
+      tokens: <Tokens Count Number>
+    }]
+    version: <Version Number>
+  }
+*/
+module.exports = ({transaction}) => {
+  if (!isHex(transaction)) {
+    throw new Error('ExpectedHexEncodedTransactionToGetComponentsOf');
+  }
+
+  const details = parseTransaction({buffer: hexAsBuffer(transaction)});
+
+  return {
+    inputs: details.inputs.map(input => ({
+      id: bufferAsHex(txHashAsTxId(input.hash)),
+      script: bufferAsHex(input.script),
+      sequence: input.sequence,
+      vout: input.vout,
+      witness: !!input.witness ? input.witness.map(bufferAsHex) : undefined,
+    })),
+    locktime: details.locktime,
+    outputs: details.outputs.map(output => ({
+      script: bufferAsHex(output.script),
+      tokens: output.tokens,
+    })),
+    version: details.version,
+  };
+};

package/transactions/index.js

@@ -0,0 +1,4 @@
+const componentsOfTransaction = require('./components_of_transaction');
+const parseTransaction = require('./parse_transaction');
+
+module.exports = {componentsOfTransaction, parseTransaction};

package/transactions/parse_transaction.js

@@ -0,0 +1,176 @@
+const {compactIntAsNumber} = require('./../numbers');
+
+const byteCountHash = 32;
+const byteCountInt8 = 1;
+const byteCountInt32 = 4;
+const byteCountInt64 = 8;
+const byteCountMarkerFlag = 2;
+const byteCountNoMarkerFlag = 0;
+const decodeCompactInt = (b, o) => compactIntAsNumber({encoded: b, start: o});
+const defaultLocktime = 0;
+const defaultStartIndex = 0;
+const defaultWitnessCount = 0;
+const {isBuffer} = Buffer;
+const segWitV0Marker = 0;
+const segWitV0Flag = 1;
+const times = n => [...Array(n).keys()];
+
+/** Parse a raw transaction out of a buffer at a specific offset start
+
+  {
+    buffer: <Data Buffer Object>
+    is_terminating_after_outputs: <Ignore Data After Outputs Bool>
+    [start]: <Starting Offset Index Number>
+  }
+
+  @returns
+  {
+    bytes: <Raw Transaction Bytes Buffer Object>
+    inputs: [{
+      hash: <Spending Internal Byte Order Transaction Id Buffer Object>
+      script: <Script Buffer Object>
+      sequence: <Sequence Number>
+      vout: <Spending Transaction Output Index Number>
+      [witness]: [<Script Stack Element Buffer Object>]
+    }]
+    locktime: <Timelock nLockTime Number>
+    outputs: [{
+      script: <Output Script Buffer Object>
+      tokens: <Tokens Count Number>
+    }]
+    version: <Version Number>
+  }
+*/
+module.exports = args => {
+  if (!isBuffer(args.buffer)) {
+    throw new Error('ExpectedDataBufferToReadTransactionDataOutOf');
+  }
+
+  const start = args.start || defaultStartIndex;
+
+  let offset = start;
+
+  // Transaction version is a signed 4 byte integer
+  const version = args.buffer.readInt32LE(offset, offset + byteCountInt32);
+
+  offset += byteCountInt32;
+
+  // For SegWit transactions, the next 2 bytes would be a marker and flag
+  const flagSplit = offset + byteCountInt8;
+
+  const marker = args.buffer.readUInt8(offset, flagSplit);
+
+  const flag = args.buffer.readUInt8(flagSplit, offset + byteCountMarkerFlag);
+
+  // The presence of the marker and flag indicates SegWit tx encoding
+  const isSegWit = !marker && flag === segWitV0Flag;
+
+  // When tx isn't SegWit though, the bytes are not marker and flag
+  offset += isSegWit ? byteCountMarkerFlag : byteCountNoMarkerFlag;
+
+  const inputsCount = decodeCompactInt(args.buffer, offset);
+
+  offset += inputsCount.bytes;
+
+  // For SegWit the witness stacks will be at the end of the transaction
+  const witnessCount = isSegWit ? inputsCount.number : defaultWitnessCount;
+
+  // Read in the inputs
+  const inputs = times(inputsCount.number).map(i => {
+    // The hash is the internal byte order hash of the tx being spent
+    const hash = args.buffer.subarray(offset, offset + byteCountHash);
+
+    offset += byteCountHash;
+
+    // The vout is the 4 byte output index of the tx being spent in this input
+    const vout = args.buffer.readUInt32LE(offset, offset + byteCountInt32);
+
+    offset += byteCountInt32;
+
+    // Before SegWit, scripts were encoded in this input space
+    const scriptLength = decodeCompactInt(args.buffer, offset);
+
+    offset += scriptLength.bytes;
+
+    // Scripts are variable byte length
+    const script = args.buffer.subarray(offset, offset + scriptLength.number);
+
+    offset += scriptLength.number;
+
+    // Sequence is a 4 byte unsigned number for an input, used for CSV mainly
+    const sequence = args.buffer.readUInt32LE(offset, offset + byteCountInt32);
+
+    offset += byteCountInt32;
+
+    return {hash, script, sequence, vout};
+  });
+
+  const outputsCount = decodeCompactInt(args.buffer, offset);
+
+  offset += outputsCount.bytes;
+
+  // Read in the outputs of the transaction
+  const outputs = times(outputsCount.number).map(i => {
+    // The value being spent
+    const value = args.buffer.readBigUInt64LE(offset, offset + byteCountInt64);
+
+    offset += byteCountInt64;
+
+    // The script being spent to has a variable length
+    const scriptLength = decodeCompactInt(args.buffer, offset);
+
+    offset += scriptLength.bytes;
+
+    const script = args.buffer.subarray(offset, offset + scriptLength.number);
+
+    offset += scriptLength.number;
+
+    return {script, tokens: Number(value)};
+  });
+
+  // Exit early when ignoring data after the outputs
+  if (!!args.is_terminating_after_outputs) {
+    return {
+      inputs,
+      outputs,
+      version,
+      bytes: args.buffer.subarray(start, offset),
+      locktime: defaultLocktime,
+    };
+  }
+
+  // SegWit places the input witnesses after the outputs
+  times(witnessCount).forEach(i => {
+    // Witnesses are a stack of witness elements
+    const stackElementsCount = decodeCompactInt(args.buffer, offset);
+
+    offset += stackElementsCount.bytes;
+
+    // Read in the witness stack elements
+    const elements = [...Array(stackElementsCount.number).keys()].map(i => {
+      // Stack elements are variable length
+      const elementLength = decodeCompactInt(args.buffer, offset);
+
+      offset += elementLength.bytes;
+
+      const item = args.buffer.subarray(offset, offset + elementLength.number);
+
+      offset += elementLength.number;
+
+      return item;
+    });
+
+    // Insert the witness stack into the related input
+    return inputs[i].witness = elements;
+  });
+
+  // The final element is the 4 byte transaction nLockTime
+  const locktime = args.buffer.readUInt32LE(offset, offset + byteCountInt32);
+
+  offset += byteCountInt32;
+
+  // Take the bytes of this transaction
+  const bytes = args.buffer.subarray(start, offset);
+
+  return {bytes, inputs, locktime, outputs, version};
+};