@alexbosworth/blockchain 1.4.0 → 1.6.0

package/CHANGELOG.md

@@ -1,4 +1,12 @@
-# Changelog
+# Versions
+
+## 1.6.0
+
+- `previousBlockId`: Add method to get the previous block id from a block
+
+## 1.5.0
+
+- `scriptAsScriptElements`: Convert an encoded script into script elements
 
 ## 1.4.0
 

package/README.md

@@ -105,6 +105,38 @@ Convert a number to compact size integer serialization
       encoded: <Serialized Compact Integer Buffer Object>
     }
 
+### previousBlockId
+
+Given a raw block, return the previous block id
+
+    {
+      block: <Hex Encoded Block String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      previous: <Previous Block Id Hex String>
+    }
+
+### scriptAsScriptElements
+
+Map a serialized script into an array of script elements
+
+    {
+      script: <Script Hex String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      [elements]: [<Data Buffer>, <Script OP_CODE Number>]
+    }
+
 ### scriptElementsAsScript
 
 Map array of script buffer elements to a fully formed script

package/hashes/index.js

@@ -1,4 +1,5 @@
 const idForBlock = require('./id_for_block');
 const noLocktimeIdForTransaction = require('./no_locktime_id_for_transaction');
+const previousBlockId = require('./previous_block_id');
 
-module.exports = {idForBlock, noLocktimeIdForTransaction};
+module.exports = {idForBlock, noLocktimeIdForTransaction, previousBlockId};

package/hashes/previous_block_id.js

@@ -0,0 +1,28 @@
+const hashBytesHexCount = 32 * 2;
+const reverseByteOrder = n => Buffer.from(n, 'hex').reverse().toString('hex');
+const versionBytesHexCount = 4 * 2;
+
+/** Given a raw block, return the previous block id
+
+  {
+    block: <Hex Encoded Block String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    previous: <Previous Block Id Hex String>
+  }
+*/
+module.exports = ({block}) => {
+  if (!block) {
+    throw new Error('ExpectedHexEncodedBlockToDerivePreviousBlockId');
+  }
+
+  const end = hashBytesHexCount + versionBytesHexCount;
+  const start = versionBytesHexCount;
+
+  return {previous: reverseByteOrder(block.substring(start, end))};
+};

package/index.js

@@ -3,6 +3,8 @@ const {componentsOfTransaction} = require('./transactions');
 const {idForBlock} = require('./hashes');
 const {noLocktimeIdForTransaction} = require('./hashes');
 const {numberAsCompactInt} = require('./numbers');
+const {previousBlockId} = require('./hashes');
+const {scriptAsScriptElements} = require('./script');
 const {scriptElementsAsScript} = require('./script');
 
 module.exports = {
@@ -11,5 +13,7 @@ module.exports = {
   idForBlock,
   noLocktimeIdForTransaction,
   numberAsCompactInt,
+  previousBlockId,
+  scriptAsScriptElements,
   scriptElementsAsScript,
 };

package/package.json

@@ -7,9 +7,6 @@
     "url": "https://github.com/alexbosworth/blockchain/issues"
   },
   "description": "Blockchain data utility methods",
-  "devDependencies": {
-    "@alexbosworth/tap": "15.0.12"
-  },
   "engines": {
     "node": ">=16"
   },
@@ -20,7 +17,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/script/*.js test/transactions/*.js"
+    "test": "npx nyc@latest node --experimental-test-coverage --test test/hashes/*.js test/numbers/*.js test/script/*.js test/transactions/*.js"
   },
-  "version": "1.4.0"
+  "version": "1.6.0"
 }

package/script/index.js

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

package/script/parse_push_bytes_count.js

@@ -0,0 +1,69 @@
+const countUInt16Bytes = 2;
+const countUInt32Bytes = 4;
+const OP_PUSHDATA1 = 76;
+const OP_PUSHDATA2 = 77;
+const OP_PUSHDATA4 = 78;
+
+/** Parse a script data push which is a number of bytes and then bytes
+
+  {
+    offset: <Offset Number>
+    script: <Script Buffer Object>
+  }
+
+  @returns
+  {
+    bytes: <Byte Count Bytes Buffer Object>
+    count: <Pushed Data Buffer Object>
+  }
+*/
+module.exports = ({offset, script}) => {
+  const code = script.readUInt8(offset);
+
+  // Exit early when the bytes count is low enough to encode in a single byte
+  if (code < OP_PUSHDATA1) {
+    return {bytes: script.slice(offset, offset + [code].length), count: code};
+  }
+
+  // The data to consider will not include the push data code
+  const data = script.slice(offset + [code].length);
+
+  switch (code) {
+  case OP_PUSHDATA1:
+    // Exit early when there isn't any byte count data
+    if (!data.length) {
+      return {};
+    }
+
+    // OP_PUSHDATA1 means read one byte for the length
+    const [nextByte] = data;
+
+    return {
+      bytes: script.slice(offset, offset + [code, nextByte].length),
+      count: nextByte,
+    };
+
+  case OP_PUSHDATA2:
+    // Exit early when there isn't enough data for UInt16
+    if (data.length < countUInt16Bytes) {
+      return {};
+    }
+
+    return {
+      bytes: script.slice(offset, offset + [code].length + countUInt16Bytes),
+      count: data.readUInt16LE(),
+    };
+
+  case OP_PUSHDATA4:
+  default:
+    // Exit early when there isn't enough data for UInt32
+    if (data.length < countUInt32Bytes) {
+      return {};
+    }
+
+    return {
+      bytes: script.slice(offset, offset + [code].length + countUInt32Bytes),
+      count: data.readUInt32LE(),
+    };
+  }
+};

package/script/script_as_script_elements.js

@@ -0,0 +1,75 @@
+const parsePushBytesCount = require('./parse_push_bytes_count');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+const isHex = n => n !== undefined && !(n.length%2) && /^[0-9A-F]*$/i.test(n);
+const OP_0 = 0;
+const OP_1 = 81;
+const OP_16 = 96;
+const OP_PUSHDATA4 = 78;
+const start = 0;
+
+/** Map a serialized script into an array of script elements
+
+  {
+    script: <Script Hex String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [elements]: [<Data Buffer>, <Script OP_CODE Number>]
+  }
+*/
+module.exports = ({script}) => {
+  if (!isHex(script)) {
+    throw new Error('ExpectedHexEncodedScriptToDecodeScriptElements');
+  }
+
+  const elements = [];
+  const scriptData = hexAsBuffer(script);
+  let offset = start;
+
+  const scriptLength = scriptData.length;
+
+  // Run through the script data and parse out pushes and op codes
+  while (offset < scriptLength) {
+    const cursor = scriptData[offset];
+
+    // Exit early when the cursor is a simple op code and not a data push
+    if (cursor === OP_0 || cursor > OP_PUSHDATA4) {
+      elements.push(cursor);
+
+      // We read a byte off of the wire
+      offset++;
+
+      continue;
+    }
+
+    const size = parsePushBytesCount({offset, script: scriptData});
+
+    // Exit early when the bytes to push isn't well-formed
+    if (!size.bytes) {
+      return {};
+    }
+
+    // Data will start after the size data encoding
+    const dataStart = offset + size.bytes.length;
+
+    // The push data can be found after the size counter, with length size
+    const data = scriptData.slice(dataStart, dataStart + size.count);
+
+    // Push offset forward to account for the push data and size counter
+    offset += size.bytes.length + size.count;
+
+    // Exit early when the bytes to read in the script were insufficient
+    if (data.length < size.count) {
+      return {};
+    }
+
+    elements.push(data);
+  }
+
+  return {elements};
+};

package/test/hashes/test_id_for_block.js

@@ -1,4 +1,6 @@
-const {test} = require('@alexbosworth/tap');
+const {deepStrictEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
 
 const {idForBlock} = require('./../../');
 
@@ -22,13 +24,13 @@ const tests = [
 ];
 
 tests.forEach(({args, description, error, expected}) => {
-  return test(description, ({end, strictSame, throws}) => {
+  return test(description, (t, end) => {
     if (!!error) {
       throws(() => idForBlock(args), new Error(error), 'Err');
     } else {
       const res = idForBlock(args);
 
-      strictSame(res, expected, 'Got expected result');
+      deepStrictEqual(res, expected, 'Got expected result');
     }
 
     return end();

package/test/hashes/test_no_locktime_id_for_transaction.js

@@ -1,4 +1,6 @@
-const {test} = require('@alexbosworth/tap');
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
 
 const {noLocktimeIdForTransaction} = require('./../../');
 
@@ -40,13 +42,13 @@ const tests = [
 ];
 
 tests.forEach(({args, description, error, expected}) => {
-  return test(description, ({end, strictSame, throws}) => {
+  return test(description, (t, end) => {
     if (!!error) {
       throws(() => noLocktimeIdForTransaction(args), new Error(error), 'Err');
     } else {
       const res = noLocktimeIdForTransaction(args);
 
-      strictSame(res, expected, 'Got expected result');
+      deepStrictEqual(res, expected, 'Got expected result');
     }
 
     return end();

package/test/hashes/test_previous_block_id.js

@@ -0,0 +1,38 @@
+const {deepEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {previousBlockId} = require('./../../');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {block: ''},
+    description: 'A hex encoded block is required',
+    error: 'ExpectedHexEncodedBlockToDerivePreviousBlockId',
+  },
+  {
+    args: {
+      block: '00609c32519912209ce3196c09d7a409035874057780d4072fa31adc1f0000000000000090882aac112a7353ffc0cf13ebc8196620bc83c810b03bd5d6678b536a203c4b1a45d264f4422e193e7ea2ab01010000000001010000000000000000000000000000000000000000000000000000000000000000ffffffff1a03ceb625012013090909200909200904631e00a3290000000000ffffffff02be40250000000000160014820d4a343a44e915c36494995c2899abe37418930000000000000000266a24aa21a9ede2f61c3f71d1defd3fa999dfa36953755c690689799962b48bebd836974e8cf90120000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+    description: 'The previous block id is returned',
+    expected: {
+      previous: '000000000000001fdc1aa32f07d480770574580309a4d7096c19e39c20129951',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => previousBlockId(args), new Error(error), 'Error returned');
+    } else {
+      const res = previousBlockId(args);
+
+      deepEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/numbers/test_compact_int_as_number.js

@@ -1,4 +1,6 @@
-const {test} = require('@alexbosworth/tap');
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
 
 const {compactIntAsNumber} = require('./../../');
 
@@ -61,7 +63,7 @@ const tests = [
 ];
 
 tests.forEach(({args, description, error, expected}) => {
-  return test(description, ({end, strictSame, throws}) => {
+  return test(description, (t, end) => {
     args.encoded = !!args.encoded ? Buffer.from(args.encoded, 'hex') : null;
 
     if (!!error) {
@@ -69,7 +71,7 @@ tests.forEach(({args, description, error, expected}) => {
     } else {
       const res = compactIntAsNumber(args);
 
-      strictSame(res, expected, 'Got expected result');
+      deepStrictEqual(res, expected, 'Got expected result');
     }
 
     return end();

package/test/numbers/test_number_as_compact_int.js

@@ -1,4 +1,6 @@
-const {test} = require('@alexbosworth/tap');
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
 
 const {numberAsCompactInt} = require('./../../');
 
@@ -56,13 +58,13 @@ const tests = [
 ];
 
 tests.forEach(({args, description, error, expected}) => {
-  return test(description, ({end, strictSame, throws}) => {
+  return test(description, (t, end) => {
     if (!!error) {
       throws(() => numberAsCompactInt(args), new Error(error), 'Error');
     } else {
       const res = numberAsCompactInt(args);
 
-      strictSame(res.encoded.toString('hex'), expected, 'Got expected result');
+      deepStrictEqual(res.encoded.toString('hex'), expected, 'Got result');
     }
 
     return end();

package/test/script/test_script_as_script_elements.js

@@ -0,0 +1,84 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {scriptAsScriptElements} = require('./../../');
+
+const tests = [
+  {
+    args: {script: 'z'},
+    description: 'A script is required',
+    error: 'ExpectedHexEncodedScriptToDecodeScriptElements',
+  },
+  {
+    args: {script: '76a914000000000000000000000000000000000000000088ac'},
+    description: 'An output script is mapped to elements',
+    expected: {elements: [118, 169, Buffer.alloc(20), 136, 172]},
+  },
+  {
+    args: {script: '000100'},
+    description: 'Zero bytes on the stack',
+    expected: {elements: [0, Buffer.alloc(1)]},
+  },
+  {
+    args: {
+      script: '4cff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
+    },
+    description: 'Long data push',
+    expected: {elements: [Buffer.alloc(255)]},
+  },
+  {
+    args: {script: '01'},
+    description: 'Specify one byte, but there is zero bytes',
+    expected: {},
+  },
+  {
+    args: {script: '0201'},
+    description: 'Specify two bytes but there is only one',
+    expected: {},
+  },
+  {
+    args: {script: '4c'},
+    description: 'Not any data for pushdata 1',
+    expected: {},
+  },
+  {
+    args: {script: '4c0201'},
+    description: 'Not enough data for pushdata 1',
+    expected: {},
+  },
+  {
+    args: {script: '4dffff01'},
+    description: 'Not enough data for pushdata 2',
+    expected: {},
+  },
+  {
+    args: {script: '4dff'},
+    description: 'Not enough data for pushdata 2 number',
+    expected: {},
+  },
+  {
+    args: {script: '4effffffff01'},
+    description: 'Not enough data for pushdata 4',
+    expected: {},
+  },
+  {
+    args: {script: '4eff'},
+    description: 'Not enough data for pushdata 4 number',
+    expected: {},
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => scriptAsScriptElements(args), new Error(error), 'Got err');
+    } else {
+      const res = scriptAsScriptElements(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/script/test_script_elements_as_script.js

@@ -1,11 +1,13 @@
-const {test} = require('@alexbosworth/tap');
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
 
 const {scriptElementsAsScript} = require('./../../');
 
 const tests = [
   {
     args: {},
-    description: 'An array of eleemnts is required',
+    description: 'An array of elements is required',
     error: 'ExpectedArrayOfScriptElementsToEncodeScript',
   },
   {
@@ -16,13 +18,13 @@ const tests = [
 ];
 
 tests.forEach(({args, description, error, expected}) => {
-  return test(description, ({end, strictSame, throws}) => {
+  return test(description, (t, end) => {
     if (!!error) {
       throws(() => scriptElementsAsScript(args), new Error(error), 'Got err');
     } else {
       const res = scriptElementsAsScript(args);
 
-      strictSame(res, expected, 'Got expected result');
+      deepStrictEqual(res, expected, 'Got expected result');
     }
 
     return end();

package/test/transactions/test_components_of_transaction.js

@@ -1,4 +1,6 @@
-const {test} = require('@alexbosworth/tap');
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
 
 const {componentsOfTransaction} = require('./../../');
 
@@ -201,13 +203,13 @@ const tests = [
 ];
 
 tests.forEach(({args, description, error, expected}) => {
-  return test(description, ({end, strictSame, throws}) => {
+  return test(description, (t, end) => {
     if (!!error) {
       throws(() => componentsOfTransaction(args), new Error(error), 'Got err');
     } else {
       const res = componentsOfTransaction(args);
 
-      strictSame(res, expected, 'Got expected result');
+      deepStrictEqual(res, expected, 'Got expected result');
     }
 
     return end();