@trezor/utxo-lib/lib/address.js

Client-side Bitcoin-like JavaScript library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.fromBase58Check = fromBase58Check;
exports.fromBech32 = fromBech32;
exports.toBech32 = toBech32;
exports.fromOutputScript = fromOutputScript;
exports.getAddressType = getAddressType;
exports.toOutputScript = toOutputScript;
const tslib_1 = require("tslib");
const bech32_1 = require("bech32");
const bs58check = tslib_1.__importStar(require("./bs58check"));
const networks_1 = require("./networks");
const payments = tslib_1.__importStar(require("./payments"));
const bscript = tslib_1.__importStar(require("./script"));
function fromBase58Check(address, network = networks_1.bitcoin) {
  return bs58check.decodeAddress(address, network);
}
function fromBech32(address) {
  let result;
  let version;
  try {
    result = bech32_1.bech32.decode(address);
  } catch {}
  if (result) {
    [version] = result.words;
    if (version !== 0) throw new TypeError(`${address} uses wrong encoding`);
  } else {
    result = bech32_1.bech32m.decode(address);
    [version] = result.words;
    if (version === 0) throw new TypeError(`${address} uses wrong encoding`);
  }
  const data = bech32_1.bech32.fromWords(result.words.slice(1));
  return {
    version,
    prefix: result.prefix,
    data: Buffer.from(data)
  };
}
function toBech32(data, version, prefix) {
  const words = bech32_1.bech32.toWords(data);
  words.unshift(version);
  return version === 0 ? bech32_1.bech32.encode(prefix, words) : bech32_1.bech32m.encode(prefix, words);
}
const FUTURE_SEGWIT_MAX_SIZE = 40;
const FUTURE_SEGWIT_MIN_SIZE = 2;
const FUTURE_SEGWIT_MAX_VERSION = 16;
const FUTURE_SEGWIT_MIN_VERSION = 1;
const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
function toFutureSegwitAddress(output, network = networks_1.bitcoin) {
  const data = output.subarray(2);
  if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE) throw new TypeError('Invalid program length for segwit address');
  const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
  if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION) throw new TypeError('Invalid version for segwit address');
  if (output[1] !== data.length) throw new TypeError('Invalid script for segwit address');
  return toBech32(data, version, network.bech32);
}
function fromOutputScript(output, network = networks_1.bitcoin) {
  try {
    return payments.p2pkh({
      output,
      network
    }).address;
  } catch {}
  try {
    return payments.p2sh({
      output,
      network
    }).address;
  } catch {}
  try {
    return payments.p2wpkh({
      output,
      network
    }).address;
  } catch {}
  try {
    return payments.p2wsh({
      output,
      network
    }).address;
  } catch {}
  try {
    return payments.p2tr({
      output,
      network
    }).address;
  } catch {}
  try {
    return toFutureSegwitAddress(output, network);
  } catch {}
  throw new Error(`${bscript.toASM(output)} has no matching Address`);
}
function decodeAddress(address, network) {
  try {
    const {
      hash,
      version
    } = fromBase58Check(address, network);
    return {
      success: true,
      format: 'base58',
      version,
      hash
    };
  } catch {
    try {
      const {
        data,
        prefix,
        version
      } = fromBech32(address);
      if (prefix === network.bech32) {
        return {
          success: true,
          format: 'bech32',
          version,
          hash: data
        };
      }
      return {
        success: false,
        error: 'bech32-invalid-prefix'
      };
    } catch {}
  }
  return {
    success: false,
    error: 'unknown-format'
  };
}
function identifyAddressType(format, version, hash, network) {
  if (format === 'base58') {
    if (version === network.pubKeyHash) return 'p2pkh';
    if (version === network.scriptHash) return 'p2sh';
  } else if (format === 'bech32') {
    if (version === 0) {
      if (hash.length === 20) return 'p2wpkh';
      if (hash.length === 32) return 'p2wsh';
    } else if (version === 1 && hash.length === 32) {
      return 'p2tr';
    } else if (version >= FUTURE_SEGWIT_MIN_VERSION && version <= FUTURE_SEGWIT_MAX_VERSION && hash.length >= FUTURE_SEGWIT_MIN_SIZE && hash.length <= FUTURE_SEGWIT_MAX_SIZE) {
      return 'p2w-unknown';
    }
  }
  return 'unknown';
}
function createOutputScript(type, hash, version) {
  switch (type) {
    case 'p2pkh':
      return payments.p2pkh({
        hash
      }).output;
    case 'p2sh':
      return payments.p2sh({
        hash
      }).output;
    case 'p2wpkh':
      return payments.p2wpkh({
        hash
      }).output;
    case 'p2wsh':
      return payments.p2wsh({
        hash
      }).output;
    case 'p2tr':
    case 'p2w-unknown':
      return bscript.compile([version + FUTURE_SEGWIT_VERSION_DIFF, hash]);
  }
}
function getAddressType(address, network = networks_1.bitcoin) {
  const {
    success,
    format,
    version,
    hash
  } = decodeAddress(address, network);
  return success ? identifyAddressType(format, version, hash, network) : 'unknown';
}
function toOutputScript(address, network = networks_1.bitcoin) {
  const {
    success,
    format,
    version,
    hash,
    error
  } = decodeAddress(address, network);
  if (success) {
    const type = identifyAddressType(format, version, hash, network);
    if (type !== 'unknown') {
      return createOutputScript(type, hash, version);
    }
  } else if (error === 'bech32-invalid-prefix') {
    throw new Error(`${address} has an invalid prefix`);
  }
  throw new Error(`${address} has no matching Script`);
}
//# sourceMappingURL=address.js.map