@alexbosworth/blockchain 1.3.0 → 1.5.0

package/CHANGELOG.md

@@ -1,4 +1,12 @@
-# Changelog
+# Versions
+
+## 1.5.0
+
+- `scriptAsScriptElements`: Convert an encoded script into script elements
+
+## 1.4.0
+
+- `scriptElementsAsScript`: Convert an array of script elements to a script
 
 ## 1.3.0
 

package/README.md

@@ -104,3 +104,35 @@ Convert a number to compact size integer serialization
     {
       encoded: <Serialized Compact Integer Buffer Object>
     }
+
+### 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
+
+    {
+      elements: [<Data Buffer>, <Script OP_CODE Number>]
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Script Hex String>
+    }

package/index.js

@@ -3,6 +3,8 @@ const {componentsOfTransaction} = require('./transactions');
 const {idForBlock} = require('./hashes');
 const {noLocktimeIdForTransaction} = require('./hashes');
 const {numberAsCompactInt} = require('./numbers');
+const {scriptAsScriptElements} = require('./script');
+const {scriptElementsAsScript} = require('./script');
 
 module.exports = {
   compactIntAsNumber,
@@ -10,4 +12,6 @@ module.exports = {
   idForBlock,
   noLocktimeIdForTransaction,
   numberAsCompactInt,
+  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/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.3.0"
+  "version": "1.5.0"
 }

package/script/index.js

@@ -0,0 +1,4 @@
+const scriptAsScriptElements = require('./script_as_script_elements');
+const scriptElementsAsScript = require('./script_elements_as_script');
+
+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/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_id_for_block.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 {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/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

@@ -0,0 +1,32 @@
+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 elements 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, (t, end) => {
+    if (!!error) {
+      throws(() => scriptElementsAsScript(args), new Error(error), 'Got err');
+    } else {
+      const res = scriptElementsAsScript(args);
+
+      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();