Пример #1
0
    def Decode(hrp: str, addr: str) -> bytes:
        """ Decode from Atom Bech32.

        Args:
            hrp (str) : Human readable part
            addr (str): Address

        Returns:
            bytes: Data

        Raises:
            Bech32FormatError: If the bech32 string is not valid
            Bech32ChecksumError: If the checksum is not valid
        """

        # Decode string
        hrpgot, data = AtomBech32Decoder._DecodeBech32(
            addr, AtomBech32Const.SEPARATOR, AtomBech32Const.CHECKSUM_LEN)

        # Check HRP
        if hrpgot != hrp:
            raise Bech32FormatError(
                "Invalid format (HRP not valid, expected %s, got %s)" %
                (hrp, hrpgot))

        # Convert back from base32
        conv_data = Bech32BaseUtils.ConvertFromBase32(data)

        # Check converted data
        if len(conv_data) < AtomBech32Const.DATA_MIN_LEN or len(
                conv_data) > AtomBech32Const.DATA_MAX_LEN:
            raise Bech32FormatError("Invalid format (length not valid)")

        return ConvUtils.ListToBytes(conv_data)
Пример #2
0
    def Decode(cls, hrp: str, addr: str) -> bytes:
        """
        Decode from Bech32.

        Args:
            hrp (str) : Human readable part
            addr (str): Address

        Returns:
            bytes: Decoded address

        Raises:
            ValueError: If the bech32 string is not valid
            Bech32ChecksumError: If the checksum is not valid
        """

        # Decode string
        hrp_got, data = cls._DecodeBech32(addr, Bech32Const.SEPARATOR,
                                          Bech32Const.CHECKSUM_STR_LEN)
        # Check HRP
        if hrp != hrp_got:
            raise ValueError(
                f"Invalid format (HRP not valid, expected {hrp}, got {hrp_got})"
            )

        # Convert back from base32
        return BytesUtils.FromList(Bech32BaseUtils.ConvertFromBase32(data))
Пример #3
0
    def Decode(hrp, addr):
        """ Decode from Segwit Bech32.

        Args:
            hrp (str) : Human readable part
            addr (str): Address

        Returns:
            tuple: Witness version (index 0) and witness program (index 1)

        Raises:
            SegwitBech32FormatError: If the address is not valid
            Bech32FormatError: If the bech32 string is not valid
            Bech32ChecksumError: If the checksum is not valid
        """

        # Decode string
        hrpgot, data = SegwitBech32Decoder._DecodeBech32(addr, SegwitBech32Const.SEPARATOR, SegwitBech32Const.CHECKSUM_LEN)
        # Check HRP
        if hrpgot != hrp:
            raise SegwitBech32FormatError("Invalid segwit format (HRP not valid, expected %s, got %s)" % (hrp, hrpgot))

        # Convert back from base32
        conv_data = Bech32BaseUtils.ConvertFromBase32(data[1:])

        # Check converted data
        if len(conv_data) < SegwitBech32Const.DATA_MIN_LEN or len(conv_data) > SegwitBech32Const.DATA_MAX_LEN:
            raise SegwitBech32FormatError("Invalid segwit format (length not valid)")
        elif data[0] > SegwitBech32Const.WITNESS_VER_MAX_VAL:
            raise SegwitBech32FormatError("Invalid segwit format (witness version not valid)")
        elif data[0] == 0 and not len(conv_data) in SegwitBech32Const.WITNESS_VER_ZERO_DATA_LEN:
            raise SegwitBech32FormatError("Invalid segwit format (length not valid)")

        return (data[0], ConvUtils.ListToBytes(conv_data))
Пример #4
0
    def Decode(hrp, addr):
        """ Decode from Bitcoin Cash Bech32.

        Args:
            hrp (str) : Human readable part
            addr (str): Address

        Returns:
            tuple: Net version (index 0) and data (index 1)

        Raises:
            BchBech32FormatError: If the address is not valid
            Bech32FormatError: If the bech32 string is not valid
            Bech32ChecksumError: If the checksum is not valid
        """

        # Decode string
        hrpgot, data = BchBech32Decoder._DecodeBech32(
            addr, BchBech32Const.SEPARATOR, BchBech32Const.CHECKSUM_LEN)

        # Check HRP
        if hrpgot != hrp:
            raise BchBech32FormatError(
                "Invalid BCH format (HRP not valid, expected %s, got %s)" %
                (hrp, hrpgot))

        # Convert back from base32
        conv_data = Bech32BaseUtils.ConvertFromBase32(data)

        # Check converted data
        if len(conv_data) < BchBech32Const.DATA_MIN_LEN or len(
                conv_data) > BchBech32Const.DATA_MAX_LEN:
            raise BchBech32FormatError("Invalid BCH format (length not valid)")

        return (conv_data[0], ConvUtils.ListToBytes(conv_data[1:]))
Пример #5
0
    def Decode(cls, hrp: str, addr: str) -> Tuple[int, bytes]:
        """
        Decode from Segwit Bech32.

        Args:
            hrp (str) : Human readable part
            addr (str): Address

        Returns:
            tuple[int, bytes]: Witness version (index 0) and witness program (index 1)

        Raises:
            Bech32ChecksumError: If the checksum is not valid
            ValueError: If the bech32 string is not valid
        """

        # Decode string
        hrp_got, data = cls._DecodeBech32(addr, SegwitBech32Const.SEPARATOR,
                                          SegwitBech32Const.CHECKSUM_BYTE_LEN)
        # Check HRP
        if hrp != hrp_got:
            raise ValueError(
                f"Invalid format (HRP not valid, expected {hrp}, got {hrp_got})"
            )

        # Convert back from base32 (remove witness version)
        conv_data = Bech32BaseUtils.ConvertFromBase32(data[1:])

        # Check data length
        if (len(conv_data) < SegwitBech32Const.WITNESS_PROG_MIN_BYTE_LEN or
                len(conv_data) > SegwitBech32Const.WITNESS_PROG_MAX_BYTE_LEN):
            raise ValueError(
                f"Invalid format (witness program length not valid: {len(conv_data)})"
            )
        # Check witness version
        wit_ver = data[0]
        if wit_ver > SegwitBech32Const.WITNESS_VER_MAX_VAL:
            raise ValueError(
                f"Invalid format (witness version not valid: {wit_ver})")
        if wit_ver == 0 and not len(
                conv_data) in SegwitBech32Const.WITNESS_VER_ZERO_DATA_BYTE_LEN:
            raise ValueError(
                f"Invalid format (length not valid: {len(conv_data)})")

        return wit_ver, BytesUtils.FromList(conv_data)