text: #!/usr/bin/env python3
  # Copyright (c) 2016 The Bitcoin Core developers
  # Distributed under the MIT software license, see the accompanying
  # file COPYING or http://www.opensource.org/licenses/mit-license.php.
  """Encode and decode BASE58, P2PKH and P2SH addresses."""
  
  from .script import hash256, hash160, sha256, CScript, OP_0
  from .util import bytes_to_hex_str, hex_str_to_bytes
  import binascii
  
  chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
  
  def byte_to_base58(b, version):
      result = ''
      str = bytes_to_hex_str(b)
      str = bytes_to_hex_str(chr(version).encode('latin-1')) + str
      checksum = bytes_to_hex_str(hash256(hex_str_to_bytes(str)))
      str += checksum[:8]
      value = int('0x'+str,0)
      while value > 0:
          result = chars[value % 58] + result
          value //= 58
      while (str[:2] == '00'):
          result = chars[0] + result
          str = str[2:]
      return result
  
  # TODO: def base58_decode
  def base58_to_byte(v, length):
    """ decode v into a string of len bytes
    """
    __b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    __b58base = len(__b58chars)
    long_value = 0
    for (i, c) in enumerate(v[::-1]):
      long_value += __b58chars.find(c) * (__b58base**i)
  
    result = ''
    while long_value >= 256:
      div, mod = divmod(long_value, 256)
      result = chr(mod) + result
      long_value = div
    result = chr(long_value) + result
  
    nPad = 0
    for c in v:
      if c == __b58chars[0]: nPad += 1
      else: break
  
    result = chr(0)*nPad + result
    if length is not None and len(result) != length:
      return None
  
    hexresult = binascii.hexlify(bytes(result.encode('latin-1')))
  
    version = int(hexresult[0:2], 16)
    hsh = hexresult[2:-8]
    checksum = hexresult[-8:]
    return (version, hsh, checksum)
  
  def keyhash_to_p2pkh(hash, main = False):
      assert (len(hash) == 20)
      version = 58 if main else 120
      return byte_to_base58(hash, version)
  
  def scripthash_to_p2sh(hash, main = False):
      assert (len(hash) == 20)
      version = 50 if main else 110
      return byte_to_base58(hash, version)
  
  def key_to_p2pkh(key, main = False):
      key = check_key(key)
      return keyhash_to_p2pkh(hash160(key), main)
  
  def script_to_p2sh(script, main = False):
      script = check_script(script)
      return scripthash_to_p2sh(hash160(script), main)
  
  def key_to_p2sh_p2wpkh(key, main = False):
      key = check_key(key)
      p2shscript = CScript([OP_0, hash160(key)])
      return script_to_p2sh(p2shscript, main)
  
  def script_to_p2sh_p2wsh(script, main = False):
      script = check_script(script)
      p2shscript = CScript([OP_0, sha256(script)])
      return script_to_p2sh(p2shscript, main)
  
  def check_key(key):
      if (type(key) is str):
          key = hex_str_to_bytes(key) # Assuming this is hex string
      if (type(key) is bytes and (len(key) == 33 or len(key) == 65)):
          return key
      assert(False)
  
  def check_script(script):
      if (type(script) is str):
          script = hex_str_to_bytes(script) # Assuming this is hex string
      if (type(script) is bytes or type(script) is CScript):
          return script
      assert(False)
  