@alexbosworth/blockchain 3.0.0 → 3.2.0

package/script/script_elements_as_output.js

@@ -0,0 +1,41 @@
+const {numberAsCompactInt} = require('./../numbers');
+
+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 an output script
+
+  {
+    elements: [<Data Buffer>, <Script OP_CODE Number>]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    output: <Script Output Buffer Object>
+  }
+*/
+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 {output: flatten(fullScript)};
+};

package/script/script_elements_as_script.js

@@ -1,12 +1,6 @@
-const {numberAsCompactInt} = require('./../numbers');
+const scriptElementsAsOutput = require('./script_elements_as_output');
 
 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
 
@@ -23,20 +17,7 @@ const {isBuffer} = Buffer;
   }
 */
 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]);
-  });
+  const {output} = scriptElementsAsOutput({elements});
 
-  return {script: bufferAsHex(flatten(fullScript))};
+  return {script: bufferAsHex(output)};
 };

package/test/addresses/test_bech32_type.js

@@ -0,0 +1,29 @@
+const {deepEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const bech32Type = require('./../../addresses/bech32_type');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {prefix: 'bc', words: [0, 0, 0, 0, 0, 0]},
+    description: 'The checksum must derive to a known value',
+    error: 'UnexpectedChecksumValueForBech32DataAndPrefix',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => bech32Type(args), new Error(error), 'Err');
+    } else {
+      const res = bech32Type(args);
+
+      deepEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/addresses/test_decode_bech32.js

@@ -0,0 +1,49 @@
+const {deepEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const decodeBech32 = require('./../../addresses/decode_bech32');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {encoded: null},
+    description: 'A bech32 string is expected',
+    error: 'ExpectedEncodedStringToDecodeBech32String',
+  },
+  {
+    args: {encoded: 'b'.repeat(91)},
+    description: 'A short bech32 string is expected',
+    error: 'ExpectedShorterBech32EncodedStringToDecode',
+  },
+  {
+    args: {encoded: 'b'.repeat(7)},
+    description: 'A long bech32 string is expected',
+    error: 'ExpectedLongerBech32EncodedStringToDecode',
+  },
+  {
+    args: {encoded: '1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P'},
+    description: 'A farther divider is expected',
+    error: 'ExpectedLaterDividerPositionForBech32String',
+  },
+  {
+    args: {encoded: 'BCKJBC1QR5'},
+    description: 'A shorter divider is expected',
+    error: 'ExpectedChecksumDataForBech32String',
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => decodeBech32(args), new Error(error), 'Err');
+    } else {
+      const res = decodeBech32(args);
+
+      deepEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/addresses/test_decode_bech32_address.js

@@ -0,0 +1,188 @@
+const {deepEqual} = require('node:assert').strict;
+const test = require('node:test');
+const {throws} = require('node:assert').strict;
+
+const {decodeBech32Address} = require('./../../');
+
+const hexAsBuffer = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {
+      address: 'tc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq5zuyut',
+    },
+    description: 'Invalid human-readable part',
+    error: 'ExpectedKnownBech32AddressPrefixToDecodeBech32',
+  },
+  {
+    args: {
+      address: 'bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqh2y7hd',
+    },
+    description: 'Invalid checksum (Bech32 instead of Bech32m)',
+    error: 'ExpectedUseOfLaterVersionBech32PostInitialSegwit',
+  },
+  {
+    args: {
+      address: 'tb1z0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqglt7rf',
+    },
+    description: 'Invalid tb checksum (Bech32 instead of Bech32m)',
+    error: 'ExpectedUseOfLaterVersionBech32PostInitialSegwit',
+  },
+  {
+    args: {
+      address: 'BC1S0XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ54WELL',
+    },
+    description: 'Invalid BC checksum (Bech32 instead of Bech32m)',
+    error: 'ExpectedUseOfLaterVersionBech32PostInitialSegwit',
+  },
+  {
+    args: {address: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kemeawh'},
+    description: 'Invalid checksum (Bech32m instead of Bech32)',
+    error: 'ExpectedInitialSegwitTypeForInitialSegwitVersion',
+  },
+  {
+    args: {
+      address: 'tb1q0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq24jc47',
+    },
+    description: 'Invalid tb checksum (Bech32m instead of Bech32)',
+    error: 'ExpectedInitialSegwitTypeForInitialSegwitVersion',
+  },
+  {
+    args: {
+      address: 'bc1p38j9r5y49hruaue7wxjce0updqjuyyx0kh56v8s25huc6995vvpql3jow4',
+    },
+    description: 'Invalid character in checksum',
+    error: 'ExpectedAllKnownCharactersForBech32EncodedString',
+  },
+  {
+    args: {
+      address: 'BC130XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ7ZWS8R',
+    },
+    description: 'Invalid witness version',
+    error: 'UnexpectedHighSegwitWitnessVersion',
+  },
+  {
+    args: {address: 'bc1pw5dgrnzv'},
+    description: 'Invalid program length (1 byte)',
+    error: 'UnexpectedSizeOfBech32AddressProgram',
+  },
+  {
+    args: {
+      address: 'bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v8n0nx0muaewav253zgeav',
+    },
+    description: 'Invalid program length (41 bytes)',
+    error: 'UnexpectedSizeOfBech32AddressProgram',
+  },
+  {
+    args: {address: 'BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P'},
+    description: 'Invalid program length for witness version 0 (per BIP141)',
+    error: 'UnexpectedBech32AddressProgramSizeForV0Address',
+  },
+  {
+    args: {
+      address: 'tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq47Zagq',
+    },
+    description: 'Mixed case',
+    error: 'ExpectedSingleCasingStyleForBech32EncodedString',
+  },
+  {
+    args: {
+      address: 'bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v07qwwzcrf',
+    },
+    description: 'zero padding of more than 4 bits',
+    error: 'ExpectedNoPaddingOnBech32Address',
+  },
+  {
+    args: {
+      address: 'tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vpggkg4j',
+    },
+    description: 'Non-zero padding in 8-to-5 conversion',
+    error: 'UnexpectedNonZeroPadding',
+  },
+  {
+    args: {address: 'bc1gmk9yu'},
+    description: 'Empty data section',
+    error: 'ExpectedNonEmptyWitnessCommitmentDataInBech32Address',
+  },
+  {
+    args: {address: 'BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4'},
+    description: 'Details are returned for a btc1q address',
+    expected: {
+      prefix: 'bc',
+      program: hexAsBuffer('751e76e8199196d454941c45d1b3a323f1433bd6'),
+      version: 0,
+    },
+  },
+  {
+    args: {
+      address: 'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7',
+    },
+    description: 'Details are returned for a tb1q address',
+    expected: {
+      prefix: 'tb',
+      program: hexAsBuffer('1863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262'),
+      version: 0,
+    },
+  },
+  {
+    args: {
+      address: 'bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y',
+    },
+    description: 'Details are returned for a bc1p address',
+    expected: {
+      prefix: 'bc',
+      program: hexAsBuffer('751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6'),
+      version: 1,
+    },
+  },
+  {
+    args: {address: 'BC1SW50QGDZ25J'},
+    description: 'Details are returned for a short bc1 address',
+    expected: {prefix: 'bc', program: hexAsBuffer('751e'), version: 16},
+  },
+  {
+    args: {address: 'bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs'},
+    description: 'Details are returned for a midsize bc1 address',
+    expected: {
+      prefix: 'bc',
+      program: hexAsBuffer('751e76e8199196d454941c45d1b3a323'),
+      version: 2,
+    },
+  },
+  {
+    args: {
+      address: 'tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy',
+    },
+    description: 'Details are returned for a zero starting tb address',
+    expected: {
+      prefix: 'tb',
+      program: hexAsBuffer('000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433'),
+      version: 0,
+    },
+  },
+  {
+    args: {
+      address: 'bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqzk5jj0',
+    },
+    description: 'Details are returned for a bc1 v1 address',
+    expected: {
+      prefix: 'bc',
+      program: hexAsBuffer('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+      version: 1,
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => decodeBech32Address(args), new Error(error), 'Err');
+    } else {
+      const res = decodeBech32Address(args);
+
+      deepEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/script/test_p2pkh_output_script.js

@@ -0,0 +1,41 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {p2pkhOutputScript} = require('./../../');
+
+const bufferFromHex = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {},
+    description: 'A hash is required',
+    error: 'ExpectedPublicKeyHashToDeriveOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('12ab8dc588ca9d5787dde7eb29569da63c3a23')},
+    description: 'A correctly sized hash is required',
+    error: 'UnexpectedHashLengthForPublicKeyHashOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('12ab8dc588ca9d5787dde7eb29569da63c3a238c')},
+    description: 'An output script is derived for a hash',
+    expected: {
+      script: bufferFromHex('76a91412ab8dc588ca9d5787dde7eb29569da63c3a238c88ac'),
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => p2pkhOutputScript(args), new Error(error), 'Got err');
+    } else {
+      const res = p2pkhOutputScript(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/script/test_p2sh_output_script.js

@@ -0,0 +1,41 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {p2shOutputScript} = require('./../../');
+
+const bufferFromHex = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {},
+    description: 'A hash is required',
+    error: 'ExpectedScriptHashToDerivePayToScriptOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('433ec2ac1ffa1b7b7d027f564529c57197f9ae')},
+    description: 'A correctly sized hash is required',
+    error: 'UnexpectedHashLengthForPayToScriptHashOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('433ec2ac1ffa1b7b7d027f564529c57197f9ae88')},
+    description: 'An output script is derived for a hash',
+    expected: {
+      script: bufferFromHex('a914433ec2ac1ffa1b7b7d027f564529c57197f9ae8887'),
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => p2shOutputScript(args), new Error(error), 'Got err');
+    } else {
+      const res = p2shOutputScript(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/script/test_p2tr_output_script.js

@@ -0,0 +1,43 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {p2trOutputScript} = require('./../../');
+
+const bufferFromHex = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {},
+    description: 'A hash is required',
+    error: 'ExpectedTaprootHashToDeriveOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('8d7a0a3461e3891723e5fdf8129caa0075060c')},
+    description: 'A correctly sized hash is required',
+    error: 'ExpectedKnownLengthTaprootHashForOutputScript',
+  },
+  {
+    args: {
+      hash: bufferFromHex('667bdd93c7c029767fd516d2ea292624b938fefefa175ac9f1220cf508963ff3'),
+    },
+    description: 'An output script is derived for a hash',
+    expected: {
+      script: bufferFromHex('5120667bdd93c7c029767fd516d2ea292624b938fefefa175ac9f1220cf508963ff3'),
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => p2trOutputScript(args), new Error(error), 'Got err');
+    } else {
+      const res = p2trOutputScript(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/script/test_p2wpkh_output_script.js

@@ -0,0 +1,41 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {p2wpkhOutputScript} = require('./../../');
+
+const bufferFromHex = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {},
+    description: 'A hash is required',
+    error: 'ExpectedWitnessPublicKeyHashToDeriveOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('8d7a0a3461e3891723e5fdf8129caa0075060c')},
+    description: 'A correctly sized hash is required',
+    error: 'ExpectedKnownLengthWitnessPublicKeyHashForOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('8d7a0a3461e3891723e5fdf8129caa0075060cff')},
+    description: 'An output script is derived for a hash',
+    expected: {
+      script: bufferFromHex('00148d7a0a3461e3891723e5fdf8129caa0075060cff'),
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => p2wpkhOutputScript(args), new Error(error), 'Got err');
+    } else {
+      const res = p2wpkhOutputScript(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/script/test_p2wsh_output_script.js

@@ -0,0 +1,43 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {p2wshOutputScript} = require('./../../');
+
+const bufferFromHex = hex => Buffer.from(hex, 'hex');
+
+const tests = [
+  {
+    args: {},
+    description: 'A hash is required',
+    error: 'ExpectedWitnessScriptHashToDeriveOutputScript',
+  },
+  {
+    args: {hash: bufferFromHex('8d7a0a3461e3891723e5fdf8129caa0075060c')},
+    description: 'A correctly sized hash is required',
+    error: 'ExpectedKnownLengthWitnessScriptHashForOutputScript',
+  },
+  {
+    args: {
+      hash: bufferFromHex('cdbf909e935c855d3e8d1b61aeb9c5e3c03ae8021b286839b1a72f2e48fdba70'),
+    },
+    description: 'An output script is derived for a hash',
+    expected: {
+      script: bufferFromHex('0020cdbf909e935c855d3e8d1b61aeb9c5e3c03ae8021b286839b1a72f2e48fdba70'),
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => p2wshOutputScript(args), new Error(error), 'Got err');
+    } else {
+      const res = p2wshOutputScript(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});

package/test/transactions/test_id_for_transaction.js

@@ -0,0 +1,72 @@
+const {deepStrictEqual} = require('node:assert').strict;
+const {throws} = require('node:assert').strict;
+const test = require('node:test');
+
+const {idForTransaction} = require('./../../');
+
+const tests = [
+  {
+    args: {transaction: ''},
+    description: 'A transaction hex is required',
+    error: 'ExpectedHexEncodedTransactionToGetComponentsOf',
+  },
+  {
+    args: {
+      transaction: '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff4d04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73ffffffff0100f2052a01000000434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac00000000',
+    },
+    description: 'A coinbase transaction',
+    expected: {
+      id: '4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b',
+    },
+  },
+  {
+    args: {
+      transaction: '01000000019ac03d5ae6a875d970128ef9086cef276a1919684a6988023cc7254691d97e6d010000006b4830450221009d41dc793ba24e65f571473d40b299b6459087cea1509f0d381740b1ac863cb6022039c425906fcaf51b2b84d8092569fb3213de43abaff2180e2a799d4fcb4dd0aa012102d5ede09a8ae667d0f855ef90325e27f6ce35bbe60a1e6e87af7f5b3c652140fdffffffff080100000000000000010101000000000000000202010100000000000000014c0100000000000000034c02010100000000000000014d0100000000000000044dffff010100000000000000014e0100000000000000064effffffff0100000000',
+    },
+    description: 'invalid script',
+    expected: {
+      id: 'ebc9fa1196a59e192352d76c0f6e73167046b9d37b8302b6bb6968dfd279b767',
+    },
+  },
+  {
+    args: {
+      transaction: '02000000000103ae8caf3aad8861142597a29d6377f524a55f4542d5294c8292ce123a956d3e520000000000ffffffff9cbb1c5531a677b90c489d75a198a14f02d49e554ab9cdaa17bd956b127724570200000000ffffffff9cbb1c5531a677b90c489d75a198a14f02d49e554ab9cdaa17bd956b127724570100000000ffffffff0640420f0000000000160014eaa9b76637b1ad340b6efadf773a73b53637d5b6de91f62901000000225120f4c82416bcb08422c195af995e1d248d1378d8b48dafa9f45bc213b83101d49240420f00000000001600148729d17b2aa507ab19051a028384bc6e0ce25e455e368900000000002251200249ccc5af06fa5642f12d42d2a34bfbb08688d54a9b99d07b98619b35df03b440420f0000000000160014d2d59a8a59f997cbc8888411010faf1658e0e3465e368900000000002251207febd720c78518b52aa1a2443823cc8f55e373910f616e112d5d7bd622fe1ab2024830450221008ac71eff4d7e298941be012fc14f0ac9bf62ae6ffeac13522bb27b5b4108d3aa0220192a69ad6fdb86b1e09c7fdcaaafeb58d25060e44199c734dc0d7d385b5d800d0121029943eaccd3987fa495a6b4f47f2fafeb0521e4e12f39498d9465a564ef75329602483045022100f9cde9adb00c0a6c62dae8604ca750039201288c0dafff952461da3caf05e3ae0220679c01f2518413951de3b62531b1cf36bb92562e3bd4197f0fa6e6e3e231272e0121027326b48c9f2729597e328ab6d05f5af75866e1ffa203fadf78387a3b202ff80d0247304402202550beec478845af2df929abf85708f9fcceaae31377f2e01d803e2acf7b426f022036c312b1e38ca333fe70aa37d3093387ac7486f08438eb8eed323699594468cb012102275a197f7ccfece19cf0532b068b6e38ceceda146e791875ecbdc55500bb7efe00000000',
+    },
+    description: 'Transaction with witnesses and P2TR and P2WPKH outputs',
+    expected: {
+      id: 'ab940e8efd07f7f85f907e36f8e6509ab795de91bbd3e0fa69781549464506a4',
+    },
+  },
+  {
+    args: {
+      transaction: '0100000001f709fa82596e4f908ee331cb5e0ed46ab331d7dcfaf697fe95891e73dac4ebcb000000008c20ca42095840735e89283fec298e62ac2ddea9b5f34a8cbb7097ad965b87568100201b1b01dc829177da4a14551d2fc96a9db00c6501edfa12f22cd9cefd335c227f483045022100a9df60536df5733dd0de6bc921fab0b3eee6426501b43a228afa2c90072eb5ca02201c78b74266fac7d1db5deff080d8a403743203f109fbcabf6d5a760bf87386d20100ffffffff01c075790000000000232103611f9a45c18f28f06f19076ad571c344c82ce8fcfe34464cf8085217a2d294a6ac00000000',
+    },
+    description: 'A non-segwit transaction is read',
+    expected: {
+      id: 'cc60b1f899ec0a69b7c3f25ddf32c4524096a9c5b01cbd84c6d0312a0c478984',
+    },
+  },
+  {
+    args: {
+      transaction: '0100000001c997a5e56e104102fa209c6a852dd90660a20b2d9c352423edce25857fcd3704000000004847304402204e45e16932b8af514961a1d3a1a25fdf3f4f7732e9d624c6c61548ab5fb8cd410220181522ec8eca07de4860a4acdd12909d831cc56cbbac4622082221a8768d1d0901ffffffff0200ca9a3b00000000434104ae1a62fe09c5f51b13905f07f06b99a2f7159b2225f374cd378d71302fa28414e7aab37397f554a7df5f142c21c1b7303b8a0626f1baded5c72a704f7e6cd84cac00286bee0000000043410411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3ac00000000',
+    },
+    description: 'A P2PK transaction is read',
+    expected: {
+      id: 'f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16',
+    },
+  },
+];
+
+tests.forEach(({args, description, error, expected}) => {
+  return test(description, (t, end) => {
+    if (!!error) {
+      throws(() => idForTransaction(args), new Error(error), 'Got err');
+    } else {
+      const res = idForTransaction(args);
+
+      deepStrictEqual(res, expected, 'Got expected result');
+    }
+
+    return end();
+  });
+});