@alexbosworth/blockchain 3.0.0 → 3.2.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Versions
 
+## 3.2.0
+
+- `decode_bech32_address.js`: Add method to decode a bech32/bech32m address
+- `id_for_transaction.js`: Add method to derive the standard tx id for a raw tx
+
+## 3.1.0
+
+- `p2pkhOutputScript`: Add method to get an output script for a p2wpkh hash
+- `p2shOutputScript`: Add method to get an output script for a p2sh hash
+- `p2trOutputScript`: Add method to get an output script for a p2tr hash
+- `p2wpkhOutputScript`: Add method to get an output script for a p2wpkh hash
+- `p2wshOutputScript`: Add method to get an output script for a p2wsh hash
+- `unsignedTxFromPsbt`: Add method to get the unsigned tx out of a PSBT
+
 ## 3.0.0
 
 - `decodeBase58Address`: Add method to convert b58 address to hash and version

package/README.md

@@ -73,6 +73,24 @@ Derive output hash and version data from a base58 address string
       version: <Script Version Byte Number>
     }
 
+### decodeBech32Address
+
+Decode a bech32 address string to derive the address details
+
+    {
+      address: <Bech32 Encoded Address String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      data: <Output Data Buffer Object>
+      prefix: <Human Readable Prefix String>
+      version: <Witness Version Number>
+    }
+
 ### idForBlock
 
 Get an id for a block: the double sha256 hash of the block header
@@ -89,10 +107,28 @@ Get an id for a block: the double sha256 hash of the block header
       id: <Block Id Hex Encoded String>
     }
 
+### idForTransaction
+
+Derive the standard transaction id for a raw serialized tx
+
+    {
+      transaction: <Hex Encoded Transaction String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      id: <Transaction Id Hex Encoded String>
+    }
+
 ### idForTransactionComponents
 
 Determine a transaction id from transaction components
 
+Note: remember the input hash is the reversed byte order of a normal tx id
+
     {
       inputs: [{
         hash: <Spending Internal Byte Order Transaction Id Buffer Object>
@@ -149,6 +185,86 @@ Convert a number to compact size integer serialization
       encoded: <Serialized Compact Integer Buffer Object>
     }
 
+### p2pkhOutputScript
+
+Get a Pay To Witness Public Key Hash Output Script
+
+    {
+      hash: <Public Key Hash Buffer Object>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Output Script Buffer Object>
+    }
+
+### p2shOutputScript
+
+Get a Pay To Script Hash Output Script
+
+    {
+      hash: <Script Hash Buffer Object>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Output Script Buffer Object>
+    }
+
+### p2trOutputScript
+
+Get a Pay To Taproot Output Script
+
+    {
+      hash: <Taproot Hash Buffer Object>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Output Script Buffer Object>
+    }
+
+### p2wpkhOutputScript
+
+Get a Pay To Witness Public Key Hash Output Script
+
+    {
+      hash: <Witness Public Key Hash Buffer Object>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Output Script Buffer Object>
+    }
+
+### p2wshOutputScript
+
+Get a Pay To Witness Script Hash Output Script
+
+    {
+      hash: <Witness Script Hash Buffer Object>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      script: <Output Script Buffer Object>
+    }
+
 ### previousBlockId
 
 Given a raw block, return the previous block id
@@ -218,3 +334,19 @@ Map array of script buffer elements to a fully formed script
     {
       script: <Script Hex String>
     }
+
+### unsignedTxFromPsbt
+
+Get the unsigned transaction out of a PSBT
+
+    {
+      psbt: <PSBT Hex String>
+    }
+
+    @throws
+    <Error>
+
+    @returns
+    {
+      transaction: <Unsigned Transaction Buffer Object>
+    }

package/addresses/bech32_type.js

@@ -0,0 +1,52 @@
+const modifyBech32Accumulator = require('./modify_bech32_accumulator');
+
+const codeForBech32 = 1;
+const codeForBech32m = 0x2bc830a3;
+const {from} = Array;
+const separator = 0;
+
+/** Determine the type of bech32 data being represented and verify checksum
+
+  {
+    prefix: <Lowercase Human Readable Prefix String>
+    words: [<Bech32 5-Bit Data Number>]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    type: <Bech32 Type String>
+  }
+*/
+module.exports = ({prefix, words}) => {
+  let accumulator = 1;
+
+  // Collect the high bits
+  const highBits = from(
+    {length: prefix.length},
+    (_, i) => prefix.charCodeAt(i) >> 5
+  );
+
+  // Collect the low bits
+  const lowBits = from(
+    {length: prefix.length},
+    (_, i) => prefix.charCodeAt(i) & 31
+  );
+
+  [...highBits, separator, ...lowBits, ...words].forEach(v => {
+    return accumulator = modifyBech32Accumulator(accumulator) ^ (v & 31);
+  });
+
+  switch (accumulator) {
+  case codeForBech32:
+    return {type: 'bech32'};
+
+  case codeForBech32m:
+    return {type: 'bech32m'};
+
+  default:
+    throw new Error('UnexpectedChecksumValueForBech32DataAndPrefix');
+  }
+};

package/addresses/decode_bech32.js

@@ -0,0 +1,79 @@
+const bech32Type = require('./bech32_type');
+
+const alphabet = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+const knownPrefixes = ['bc', 'tb', 'bcrt'];
+const lengthSeparator = 1;
+const lengthChecksum = 6;
+const prefixDividerCharacter = '1';
+const maximumCharactersLength = 90;
+const minimumCharactersLength = 8;
+const minimumDividerPosition = 1;
+const notFoundIndex = -1;
+const removeChecksum = words => words.slice(0, -6);
+const split = (str, index) => [str.slice(0, index), str.slice(index + 1)];
+
+/** Decode a Bech32/Bech32m encoded string and validate/remove checksum
+
+  {
+    encoded: <Bech32/Bech32m Encoded String
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    prefix: <Human Readable Part String>
+    type: <Bech32 Type String>
+    words: [<Data Words Number>]
+  }
+*/
+module.exports = ({encoded}) => {
+  if (typeof encoded !== 'string') {
+    throw new Error('ExpectedEncodedStringToDecodeBech32String');
+  }
+
+  if (encoded.length > maximumCharactersLength) {
+    throw new Error('ExpectedShorterBech32EncodedStringToDecode');
+  }
+
+  if (encoded.length < minimumCharactersLength) {
+    throw new Error('ExpectedLongerBech32EncodedStringToDecode');
+  }
+
+  const converted = encoded.toLowerCase();
+
+  if (encoded !== converted && encoded !== encoded.toUpperCase()) {
+    throw new Error('ExpectedSingleCasingStyleForBech32EncodedString');
+  }
+
+  // Find the last index of the prefix divider character
+  const dividerPosition = converted.lastIndexOf(prefixDividerCharacter);
+
+  if (dividerPosition < minimumDividerPosition) {
+    throw new Error('ExpectedLaterDividerPositionForBech32String');
+  }
+
+  if (converted.length - dividerPosition < lengthSeparator + lengthChecksum) {
+    throw new Error('ExpectedChecksumDataForBech32String');
+  }
+
+  // Divide the data from the human readable prefix
+  const [prefix, data] = split(converted, dividerPosition);
+
+  // Make sure the prefix is a known one
+  if (!knownPrefixes.includes(prefix)) {
+    throw new Error('ExpectedKnownBech32AddressPrefixToDecodeBech32');
+  }
+
+  // Convert data part into bech32 words
+  const words = [...data].map(char => alphabet.indexOf(char));
+
+  if (words.includes(notFoundIndex)) {
+    throw new Error('ExpectedAllKnownCharactersForBech32EncodedString');
+  }
+
+  const {type} = bech32Type({prefix, words});
+
+  return {prefix, type, words: removeChecksum(words)};
+};

package/addresses/decode_bech32_address.js

@@ -0,0 +1,86 @@
+const decodeBech32 = require('./decode_bech32');
+
+const bitsPerBech32Word = 5;
+const bitsPerByte = 8;
+const byteMask = 0xff;
+const bytesArrayAsBuffer = arr => Buffer.from(arr);
+const knownV0ProgramLengths = [20, 32];
+const maxProgLength = 40;
+const maximumSegwitVersion = 16;
+const minimumProgLength = 2;
+const typeBech32V1 = 'bech32m';
+const typeInitialSegwit = 'bech32';
+const versionInitialSegwit = 0;
+
+/** Decode a bech32 address string to derive the address details
+
+  {
+    address: <Bech32 Encoded Address String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    prefix: <Human Readable Prefix String>
+    program: <Output Data Buffer Object>
+    version: <Witness Version Number>
+  }
+*/
+module.exports = ({address}) => {
+  const {prefix, type, words} = decodeBech32({encoded: address});
+
+  if (!words.length) {
+    throw new Error('ExpectedNonEmptyWitnessCommitmentDataInBech32Address');
+  }
+
+  const [version, ...data] = words;
+
+  if (version > maximumSegwitVersion) {
+    throw new Error('UnexpectedHighSegwitWitnessVersion');
+  }
+
+  if (version === versionInitialSegwit && type !== typeInitialSegwit) {
+    throw new Error('ExpectedInitialSegwitTypeForInitialSegwitVersion');
+  }
+
+  if (version !== versionInitialSegwit && type !== typeBech32V1) {
+    throw new Error('ExpectedUseOfLaterVersionBech32PostInitialSegwit');
+  }
+
+  let bits = 0;
+  let carry = 0;
+  const program = [];
+
+  // Convert the 5 bit bech32 words into 8 bit (ie bytes) data
+  data.forEach(value => {
+    carry = (carry << bitsPerBech32Word) | value;
+
+    bits += bitsPerBech32Word;
+
+    while (bits >= bitsPerByte) {
+      bits -= bitsPerByte;
+
+      program.push((carry >> bits) & byteMask);
+    }
+  });
+
+  if (bits >= bitsPerBech32Word) {
+    throw new Error('ExpectedNoPaddingOnBech32Address');
+  };
+
+  if (((carry << (bitsPerByte - bits)) & byteMask) !== 0) {
+    throw new Error('UnexpectedNonZeroPadding');
+  }
+
+  if (program.length < minimumProgLength || program.length > maxProgLength) {
+    throw new Error('UnexpectedSizeOfBech32AddressProgram');
+  }
+
+  if (version === 0 && !knownV0ProgramLengths.includes(program.length)) {
+    throw new Error('UnexpectedBech32AddressProgramSizeForV0Address')
+  }
+
+  return {version, prefix, program: bytesArrayAsBuffer(program)};
+};

package/addresses/index.js

@@ -1,3 +1,4 @@
 const decodeBase58Address = require('./decode_base58_address');
+const decodeBech32Address = require('./decode_bech32_address');
 
-module.exports = {decodeBase58Address};
+module.exports = {decodeBase58Address, decodeBech32Address};

package/addresses/modify_bech32_accumulator.js

@@ -0,0 +1,24 @@
+const generatedModifierValues = [[0x01, 0x3b6a57b2], [0x02, 0x26508e6d], [0x04, 0x1ea119fa], [0x08, 0x3d4233dd], [0x10, 0x2a1462b3]];
+const lowerBitsBitMask = 0x1ffffff;
+
+/** Update the 30 bit accumulator with Bech32 precomputed values
+
+  accumulator: <Current Accumulator 32-Bit Range Integer Number>
+
+  @returns
+  <Bech32 Generator Constants Modified Number>
+*/
+module.exports = accumulator => {
+  // Take the top 5 bits of the accumulator value (30 - 5 = 25)
+  const topBits = accumulator >> 25;
+
+  // Shift the lower 25 bits up by 5
+  let modified = ((accumulator & lowerBitsBitMask) << 5) >>> 0;
+
+  // Based on bit masks, apply the appropriate precomputed Bech32 values
+  generatedModifierValues
+    .filter(([mask]) => topBits & mask)
+    .forEach(([, modifier]) => modified ^= modifier);
+
+  return modified;
+};

package/hashes/id_for_transaction_components.js

@@ -12,6 +12,8 @@ const sha256 = preimage => createHash('sha256').update(preimage).digest();
 
 /** Determine a transaction id from transaction components
 
+  Note: remember the input hash is the reversed byte order of a normal tx id
+
   {
     inputs: [{
       hash: <Spending Internal Byte Order Transaction Id Buffer Object>

package/index.js

@@ -1,25 +1,41 @@
 const {compactIntAsNumber} = require('./numbers');
 const {componentsOfTransaction} = require('./transactions');
 const {decodeBase58Address} = require('./addresses');
+const {decodeBech32Address} = require('./addresses');
 const {idForBlock} = require('./hashes');
+const {idForTransaction} = require('./transactions');
 const {idForTransactionComponents} = require('./hashes');
 const {noLocktimeIdForTransaction} = require('./transactions');
 const {numberAsCompactInt} = require('./numbers');
+const {p2pkhOutputScript} = require('./script');
+const {p2shOutputScript} = require('./script');
+const {p2trOutputScript} = require('./script');
+const {p2wpkhOutputScript} = require('./script');
+const {p2wshOutputScript} = require('./script');
 const {previousBlockId} = require('./hashes');
 const {queryTransactions} = require('./transactions');
 const {scriptAsScriptElements} = require('./script');
 const {scriptElementsAsScript} = require('./script');
+const {unsignedTxFromPsbt} = require('./transactions');
 
 module.exports = {
   compactIntAsNumber,
   componentsOfTransaction,
   decodeBase58Address,
+  decodeBech32Address,
   idForBlock,
+  idForTransaction,
   idForTransactionComponents,
   noLocktimeIdForTransaction,
   numberAsCompactInt,
+  p2pkhOutputScript,
+  p2shOutputScript,
+  p2trOutputScript,
+  p2wpkhOutputScript,
+  p2wshOutputScript,
   previousBlockId,
   queryTransactions,
   scriptAsScriptElements,
   scriptElementsAsScript,
+  unsignedTxFromPsbt,
 };

package/package.json

@@ -19,5 +19,5 @@
   "scripts": {
     "test": "npx nyc@17.1.0 node --experimental-test-coverage --test test/addresses/*.js test/hashes/*.js test/numbers/*.js test/script/*.js test/transactions/*.js"
   },
-  "version": "3.0.0"
+  "version": "3.2.0"
 }

package/script/index.js

@@ -1,4 +1,17 @@
+const p2pkhOutputScript = require('./p2pkh_output_script');
+const p2shOutputScript = require('./p2sh_output_script');
+const p2trOutputScript = require('./p2tr_output_script');
+const p2wpkhOutputScript = require('./p2wpkh_output_script');
+const p2wshOutputScript = require('./p2wsh_output_script');
 const scriptAsScriptElements = require('./script_as_script_elements');
 const scriptElementsAsScript = require('./script_elements_as_script');
 
-module.exports = {scriptAsScriptElements, scriptElementsAsScript};
+module.exports = {
+  p2pkhOutputScript,
+  p2shOutputScript,
+  p2trOutputScript,
+  p2wpkhOutputScript,
+  p2wshOutputScript,
+  scriptAsScriptElements,
+  scriptElementsAsScript,
+};

package/script/p2pkh_output_script.js

@@ -0,0 +1,37 @@
+const scriptElementsAsOutput = require('./script_elements_as_output');
+
+const expectedHashLength = 20;
+const OP_CHECKSIG = 0xac;
+const OP_DUP = 0x76;
+const OP_EQUALVERIFY = 0x88;
+const OP_HASH160 = 0xa9;
+
+/** Get a Pay To Public Key Hash Output Script
+
+  {
+    hash: <Public Key Hash Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Output Script Buffer Object>
+  }
+*/
+module.exports = ({hash}) => {
+  if (!hash) {
+    throw new Error('ExpectedPublicKeyHashToDeriveOutputScript');
+  }
+
+  if (hash.length !== expectedHashLength) {
+    throw new Error('UnexpectedHashLengthForPublicKeyHashOutputScript');
+  }
+
+  const {output} = scriptElementsAsOutput({
+    elements: [OP_DUP, OP_HASH160, hash, OP_EQUALVERIFY, OP_CHECKSIG],
+  });
+
+  return {script: output};
+};

package/script/p2sh_output_script.js

@@ -0,0 +1,35 @@
+const scriptElementsAsOutput = require('./script_elements_as_output');
+
+const expectedHashLength = 20;
+const OP_EQUAL = 0x87;
+const OP_HASH160 = 0xa9;
+
+/** Get a Pay To Script Hash Output Script
+
+  {
+    hash: <Script Hash Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Output Script Buffer Object>
+  }
+*/
+module.exports = ({hash}) => {
+  if (!hash) {
+    throw new Error('ExpectedScriptHashToDerivePayToScriptOutputScript');
+  }
+
+  if (hash.length !== expectedHashLength) {
+    throw new Error('UnexpectedHashLengthForPayToScriptHashOutputScript');
+  }
+
+  const {output} = scriptElementsAsOutput({
+    elements: [OP_HASH160, hash, OP_EQUAL],
+  });
+
+  return {script: output};
+};

package/script/p2tr_output_script.js

@@ -0,0 +1,32 @@
+const scriptElementsAsOutput = require('./script_elements_as_output');
+
+const expectedHashLength = 32;
+const OP_1 = 0x51;
+
+/** Get a Pay To Taproot Output Script
+
+  {
+    hash: <Taproot Hash Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Output Script Buffer Object>
+  }
+*/
+module.exports = ({hash}) => {
+  if (!hash) {
+    throw new Error('ExpectedTaprootHashToDeriveOutputScript');
+  }
+
+  if (hash.length !== expectedHashLength) {
+    throw new Error('ExpectedKnownLengthTaprootHashForOutputScript');
+  }
+
+  const {output} = scriptElementsAsOutput({elements: [OP_1, hash]});
+
+  return {script: output};
+};

package/script/p2wpkh_output_script.js

@@ -0,0 +1,32 @@
+const scriptElementsAsOutput = require('./script_elements_as_output');
+
+const expectedHashLength = 20;
+const OP_0 = 0x00;
+
+/** Get a Pay To Witness Public Key Hash Output Script
+
+  {
+    hash: <Witness Public Key Hash Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Output Script Buffer Object>
+  }
+*/
+module.exports = ({hash}) => {
+  if (!hash) {
+    throw new Error('ExpectedWitnessPublicKeyHashToDeriveOutputScript');
+  }
+
+  if (hash.length !== expectedHashLength) {
+    throw new Error('ExpectedKnownLengthWitnessPublicKeyHashForOutputScript');
+  }
+
+  const {output} = scriptElementsAsOutput({elements: [OP_0, hash]});
+
+  return {script: output};
+};

package/script/p2wsh_output_script.js

@@ -0,0 +1,32 @@
+const scriptElementsAsOutput = require('./script_elements_as_output');
+
+const expectedHashLength = 32;
+const OP_0 = 0x00;
+
+/** Get a Pay To Witness Script Hash Output Script
+
+  {
+    hash: <Witness Script Hash Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    script: <Output Script Buffer Object>
+  }
+*/
+module.exports = ({hash}) => {
+  if (!hash) {
+    throw new Error('ExpectedWitnessScriptHashToDeriveOutputScript');
+  }
+
+  if (hash.length !== expectedHashLength) {
+    throw new Error('ExpectedKnownLengthWitnessScriptHashForOutputScript');
+  }
+
+  const {output} = scriptElementsAsOutput({elements: [OP_0, hash]});
+
+  return {script: output};
+};