address-encoder 1.0.0__py3-none-any.whl

address_encoder/coins/ar.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base64url import base64url_nopad_decode, base64url_nopad_encode
+
+encode_ar_address = base64url_nopad_encode
+decode_ar_address = base64url_nopad_decode
+
+ar = CoinCoder(
+    name="ar",
+    coin_type=472,
+    encode=encode_ar_address,
+    decode=decode_ar_address,
+)
+

address_encoder/coins/ardr.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+_PREFIX = "ARDOR"
+_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ"
+_CODEWORD_MAP = [3, 2, 1, 0, 7, 6, 5, 4, 13, 14, 15, 16, 12, 8, 9, 10, 11]
+
+_GLOG = [
+    0, 0, 1, 18, 2, 5, 19, 11, 3, 29, 6, 27, 20, 8, 12, 23, 4, 10, 30, 17, 7, 22,
+    28, 26, 21, 25, 9, 16, 13, 14, 24, 15,
+]
+_GEXP = [
+    1, 2, 4, 8, 16, 5, 10, 20, 13, 26, 17, 7, 14, 28, 29, 31, 27, 19, 3, 6, 12,
+    24, 21, 15, 30, 25, 23, 11, 22, 9, 18, 1,
+]
+
+
+def _gmult(a: int, b: int) -> int:
+    if a == 0 or b == 0:
+        return 0
+    return _GEXP[(_GLOG[a] + _GLOG[b]) % 31]
+
+
+def _ardr_checksum(source: bytes) -> bool:
+    sum_value = 0
+    for i in range(1, 5):
+        t = 0
+        for j in range(31):
+            if j > 12 and j < 27:
+                continue
+            pos = j - 14 if j > 26 else j
+            t ^= _gmult(source[pos], _GEXP[(i * j) % 31])
+        sum_value |= t
+    return sum_value == 0
+
+
+def encode_ardr_address(source: bytes) -> str:
+    chars = [""] * 17
+    for index, byte in enumerate(source):
+        write_index = _CODEWORD_MAP[index]
+        chars[write_index] = _ALPHABET[16 * ((byte & 0xF0) >> 4) + (byte & 0x0F)]
+    return (
+        f"{_PREFIX}-{''.join(chars[0:4])}-{''.join(chars[4:8])}-"
+        f"{''.join(chars[8:12])}-{''.join(chars[12:17])}"
+    )
+
+
+def decode_ardr_address(source: str) -> bytes:
+    if not source.startswith(f"{_PREFIX}-") or len(source) != 26:
+        raise ValueError("Unrecognised address format")
+
+    joined = source[6:]
+    codeword = bytearray([1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+    j = 0
+    for i in range(20):
+        char = joined[i]
+        if char == "-":
+            continue
+        pos = _ALPHABET.index(char)
+        write_index = _CODEWORD_MAP[j]
+        j += 1
+        codeword[write_index] = pos
+
+    if not _ardr_checksum(bytes(codeword)):
+        raise ValueError("Unrecognised address format")
+
+    return bytes(codeword)
+
+
+ardr = CoinCoder(
+    name="ardr",
+    coin_type=16754,
+    encode=encode_ardr_address,
+    decode=decode_ardr_address,
+)
+

address_encoder/coins/ark.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import base58_check_decode, base58_check_encode
+
+
+def encode_ark_address(source: bytes) -> str:
+    return base58_check_encode(source)
+
+
+def decode_ark_address(source: str) -> bytes:
+    decoded = base58_check_decode(source)
+    if decoded[0] != 23:
+        raise ValueError("Invalid address")
+    return decoded
+
+
+ark = CoinCoder(
+    name="ark",
+    coin_type=111,
+    encode=encode_ark_address,
+    decode=decode_ark_address,
+)
+

address_encoder/coins/atom.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bech32_ import create_bech32_decoder, create_bech32_encoder
+
+encode_atom_address = create_bech32_encoder("cosmos")
+decode_atom_address = create_bech32_decoder("cosmos")
+
+atom = CoinCoder(
+    name="atom",
+    coin_type=118,
+    encode=encode_atom_address,
+    decode=decode_atom_address,
+)

address_encoder/coins/avax.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.bech32_ import create_bech32_decoder, create_bech32_encoder
+
+_hrp = "avax"
+_decode_bech32 = create_bech32_decoder(_hrp)
+_encode_bech32 = create_bech32_encoder(_hrp)
+
+
+def encode_avax_address(source: bytes) -> str:
+    return _encode_bech32(source)
+
+
+def decode_avax_address(source: str) -> bytes:
+    address = source
+    chain_id, _, possible_addr = source.partition("-")
+    if possible_addr:
+        address = possible_addr
+    else:
+        chain_id = ""
+    return _decode_bech32(address)
+
+
+avax = CoinCoder(
+    name="avax",
+    coin_type=9000,
+    encode=encode_avax_address,
+    decode=decode_avax_address,
+)
+

address_encoder/coins/bcd.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bitcoin import BitcoinCoderParameters, create_bitcoin_decoder, create_bitcoin_encoder
+
+_params = BitcoinCoderParameters(
+    hrp="bcd",
+    p2pkh_versions=(bytes([0]),),
+    p2sh_versions=(bytes([5]),),
+)
+encode_bcd_address = create_bitcoin_encoder(_params)
+decode_bcd_address = create_bitcoin_decoder(_params)
+
+bcd = CoinCoder(
+    name="bcd",
+    coin_type=999,
+    encode=encode_bcd_address,
+    decode=decode_bcd_address,
+)

address_encoder/coins/bch.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import create_base58_versioned_decoder
+from address_encoder.utils.bch import decode_bch_address_to_type_and_hash, encode_bch_address_with_version
+
+_p2pkh_versions = (bytes([0x00]),)
+_p2sh_versions = (bytes([0x05]),)
+_bch_base58_decode = create_base58_versioned_decoder(_p2pkh_versions, _p2sh_versions)
+
+
+def encode_bch_address(source: bytes) -> str:
+    if source[0] == 0x76:
+        if source[1] != 0xA9 or source[-2] != 0x88 or source[-1] != 0xAC:
+            raise ValueError("Unrecognised address format")
+        return encode_bch_address_with_version(0, source[3 : 3 + source[2]])
+    if source[0] == 0xA9:
+        if source[-1] != 0x87:
+            raise ValueError("Unrecognised address format")
+        return encode_bch_address_with_version(8, source[2 : 2 + source[1]])
+    raise ValueError("Unrecognised address format")
+
+
+def decode_bch_address(source: str) -> bytes:
+    try:
+        return _bch_base58_decode(source)
+    except ValueError:
+        address_type, hash_bytes = decode_bch_address_to_type_and_hash(source)
+        if address_type == 0:
+            return b"\x76\xa9\x14" + hash_bytes + b"\x88\xac"
+        if address_type == 8:
+            return b"\xa9\x14" + hash_bytes + b"\x87"
+        raise ValueError("Unrecognised address format") from None
+
+
+bch = CoinCoder(
+    name="bch",
+    coin_type=145,
+    encode=encode_bch_address,
+    decode=decode_bch_address,
+)
+

address_encoder/coins/bcn.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from Crypto.Hash import keccak
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import base58xmr_decode, base58xmr_encode
+
+_VALID_TAGS = (bytes([0x06]), bytes([0xCE, 0xF6, 0x22]))
+
+
+def _bcn_checksum(data: bytes) -> bytes:
+    return keccak.new(digest_bits=256, data=data).digest()[:4]
+
+
+def _bcn_checksum_decode(data: bytes) -> bytes:
+    payload, checksum = data[:-4], data[-4:]
+    if _bcn_checksum(payload) != checksum:
+        raise ValueError("Invalid checksum")
+    return payload
+
+
+def encode_bcn_address(source: bytes) -> str:
+    checksum = _bcn_checksum(source)
+    return base58xmr_encode(source + checksum)
+
+
+def decode_bcn_address(source: str) -> bytes:
+    decoded = base58xmr_decode(source)
+    tag = decoded[:-68]
+    if len(decoded) < 68 or tag not in _VALID_TAGS:
+        raise ValueError("Unrecognised address format")
+    return _bcn_checksum_decode(decoded)
+
+
+bcn = CoinCoder(
+    name="bcn",
+    coin_type=204,
+    encode=encode_bcn_address,
+    decode=decode_bcn_address,
+)
+

address_encoder/coins/bdx.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import base58xmr_decode, base58xmr_encode
+
+encode_bdx_address = base58xmr_encode
+decode_bdx_address = base58xmr_decode
+
+bdx = CoinCoder(
+    name="bdx",
+    coin_type=570,
+    encode=encode_bdx_address,
+    decode=decode_bdx_address,
+)
+

address_encoder/coins/bnb.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bech32_ import create_bech32_decoder, create_bech32_encoder
+
+encode_bnb_address = create_bech32_encoder("bnb")
+decode_bnb_address = create_bech32_decoder("bnb")
+
+bnb = CoinCoder(
+    name="bnb",
+    coin_type=714,
+    encode=encode_bnb_address,
+    decode=decode_bnb_address,
+)

address_encoder/coins/bps.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.base58_ import create_base58_versioned_decoder, create_base58_versioned_encoder
+
+_p2pkh = (bytes([0]),)
+_p2sh = (bytes([5]),)
+encode_bps_address = create_base58_versioned_encoder(_p2pkh[0], _p2sh[0])
+decode_bps_address = create_base58_versioned_decoder(_p2pkh, _p2sh)
+
+bps = CoinCoder(
+    name="bps",
+    coin_type=576,
+    encode=encode_bps_address,
+    decode=decode_bps_address,
+)

address_encoder/coins/bsv.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import base58_check_decode, base58_check_encode
+
+_VERSION = bytes([0x00])
+
+
+def encode_bsv_address(source: bytes) -> str:
+    return base58_check_encode(_VERSION + source)
+
+
+def decode_bsv_address(source: str) -> bytes:
+    decoded = base58_check_decode(source)
+    if len(decoded) != 21:
+        raise ValueError("Unrecognised address format")
+    if decoded[0] != 0x00:
+        raise ValueError("Unrecognised address format")
+    return decoded[1:]
+
+
+bsv = CoinCoder(
+    name="bsv",
+    coin_type=236,
+    encode=encode_bsv_address,
+    decode=decode_bsv_address,
+)
+

address_encoder/coins/btc.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bitcoin import BitcoinCoderParameters, create_bitcoin_decoder, create_bitcoin_encoder
+
+_params = BitcoinCoderParameters(
+    hrp="bc",
+    p2pkh_versions=(bytes([0]),),
+    p2sh_versions=(bytes([5]),),
+)
+encode_btc_address = create_bitcoin_encoder(_params)
+decode_btc_address = create_bitcoin_decoder(_params)
+
+btc = CoinCoder(
+    name="btc",
+    coin_type=0,
+    encode=encode_btc_address,
+    decode=decode_btc_address,
+)

address_encoder/coins/btg.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bitcoin import BitcoinCoderParameters, create_bitcoin_decoder, create_bitcoin_encoder
+
+_params = BitcoinCoderParameters(
+    hrp="btg",
+    p2pkh_versions=(bytes([38]),),
+    p2sh_versions=(bytes([23]),),
+)
+encode_btg_address = create_bitcoin_encoder(_params)
+decode_btg_address = create_bitcoin_decoder(_params)
+
+btg = CoinCoder(
+    name="btg",
+    coin_type=156,
+    encode=encode_btg_address,
+    decode=decode_btg_address,
+)

address_encoder/coins/btm.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bech32_ import create_bech32_segwit_decoder, create_bech32_segwit_encoder
+
+encode_btm_address = create_bech32_segwit_encoder("bm")
+decode_btm_address = create_bech32_segwit_decoder("bm")
+
+btm = CoinCoder(
+    name="btm",
+    coin_type=153,
+    encode=encode_btm_address,
+    decode=decode_btm_address,
+)

address_encoder/coins/bts.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.eosio import create_eos_decoder, create_eos_encoder
+
+encode_bts_address = create_eos_encoder("BTS")
+decode_bts_address = create_eos_decoder("BTS")
+
+bts = CoinCoder(
+    name="bts",
+    coin_type=308,
+    encode=encode_bts_address,
+    decode=decode_bts_address,
+)

address_encoder/coins/cca.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.base58_ import create_base58_versioned_decoder, create_base58_versioned_encoder
+
+_p2pkh = (bytes([11]),)
+_p2sh = (bytes([5]),)
+encode_cca_address = create_base58_versioned_encoder(_p2pkh[0], _p2sh[0])
+decode_cca_address = create_base58_versioned_decoder(_p2pkh, _p2sh)
+
+cca = CoinCoder(
+    name="cca",
+    coin_type=489,
+    encode=encode_cca_address,
+    decode=decode_cca_address,
+)

address_encoder/coins/ccxx.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bitcoin import BitcoinCoderParameters, create_bitcoin_decoder, create_bitcoin_encoder
+
+_params = BitcoinCoderParameters(
+    hrp="ccx",
+    p2pkh_versions=(bytes([137]),),
+    p2sh_versions=(bytes([75]), bytes([5]),),
+)
+encode_ccxx_address = create_bitcoin_encoder(_params)
+decode_ccxx_address = create_bitcoin_decoder(_params)
+
+ccxx = CoinCoder(
+    name="ccxx",
+    coin_type=571,
+    encode=encode_ccxx_address,
+    decode=decode_ccxx_address,
+)

address_encoder/coins/celoLegacy.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.hex_ import create_hex_checksummed_decoder, create_hex_checksummed_encoder
+
+encode_celoLegacy_address = create_hex_checksummed_encoder()
+decode_celoLegacy_address = create_hex_checksummed_decoder()
+
+celoLegacy = CoinCoder(
+    name="celoLegacy",
+    coin_type=52752,
+    encode=encode_celoLegacy_address,
+    decode=decode_celoLegacy_address,
+)

address_encoder/coins/ckb.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bech32_ import create_bech32_decoder, create_bech32_encoder
+
+encode_ckb_address = create_bech32_encoder("ckb")
+decode_ckb_address = create_bech32_decoder("ckb")
+
+ckb = CoinCoder(
+    name="ckb",
+    coin_type=309,
+    encode=encode_ckb_address,
+    decode=decode_ckb_address,
+)

address_encoder/coins/cloLegacy.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.hex_ import create_hex_checksummed_decoder, create_hex_checksummed_encoder
+
+encode_cloLegacy_address = create_hex_checksummed_encoder()
+decode_cloLegacy_address = create_hex_checksummed_decoder()
+
+cloLegacy = CoinCoder(
+    name="cloLegacy",
+    coin_type=820,
+    encode=encode_cloLegacy_address,
+    decode=decode_cloLegacy_address,
+)

address_encoder/coins/dash.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.base58_ import create_base58_versioned_decoder, create_base58_versioned_encoder
+
+_p2pkh = (bytes([76]),)
+_p2sh = (bytes([16]),)
+encode_dash_address = create_base58_versioned_encoder(_p2pkh[0], _p2sh[0])
+decode_dash_address = create_base58_versioned_decoder(_p2pkh, _p2sh)
+
+dash = CoinCoder(
+    name="dash",
+    coin_type=5,
+    encode=encode_dash_address,
+    decode=decode_dash_address,
+)

address_encoder/coins/dcr.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import base58_unchecked_decode, base58_unchecked_encode
+
+encode_dcr_address = base58_unchecked_encode
+decode_dcr_address = base58_unchecked_decode
+
+dcr = CoinCoder(
+    name="dcr",
+    coin_type=42,
+    encode=encode_dcr_address,
+    decode=decode_dcr_address,
+)
+

address_encoder/coins/dgb.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bitcoin import BitcoinCoderParameters, create_bitcoin_decoder, create_bitcoin_encoder
+
+_params = BitcoinCoderParameters(
+    hrp="dgb",
+    p2pkh_versions=(bytes([30]),),
+    p2sh_versions=(bytes([63]),),
+)
+encode_dgb_address = create_bitcoin_encoder(_params)
+decode_dgb_address = create_bitcoin_decoder(_params)
+
+dgb = CoinCoder(
+    name="dgb",
+    coin_type=20,
+    encode=encode_dgb_address,
+    decode=decode_dgb_address,
+)

address_encoder/coins/divi.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.base58_ import create_base58_versioned_decoder, create_base58_versioned_encoder
+
+_p2pkh = (bytes([30]),)
+_p2sh = (bytes([13]),)
+encode_divi_address = create_base58_versioned_encoder(_p2pkh[0], _p2sh[0])
+decode_divi_address = create_base58_versioned_decoder(_p2pkh, _p2sh)
+
+divi = CoinCoder(
+    name="divi",
+    coin_type=301,
+    encode=encode_divi_address,
+    decode=decode_divi_address,
+)

address_encoder/coins/doge.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.base58_ import create_base58_versioned_decoder, create_base58_versioned_encoder
+
+_p2pkh = (bytes([30]),)
+_p2sh = (bytes([22]),)
+encode_doge_address = create_base58_versioned_encoder(_p2pkh[0], _p2sh[0])
+decode_doge_address = create_base58_versioned_decoder(_p2pkh, _p2sh)
+
+doge = CoinCoder(
+    name="doge",
+    coin_type=3,
+    encode=encode_doge_address,
+    decode=decode_doge_address,
+)

address_encoder/coins/dot.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.dot import create_dot_address_decoder, create_dot_address_encoder
+
+encode_dot_address = create_dot_address_encoder(0)
+decode_dot_address = create_dot_address_decoder(0)
+
+dot = CoinCoder(
+    name="dot",
+    coin_type=354,
+    encode=encode_dot_address,
+    decode=decode_dot_address,
+)

address_encoder/coins/egld.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.bech32_ import create_bech32_decoder, create_bech32_encoder
+
+encode_egld_address = create_bech32_encoder("erd")
+decode_egld_address = create_bech32_decoder("erd")
+
+egld = CoinCoder(
+    name="egld",
+    coin_type=508,
+    encode=encode_egld_address,
+    decode=decode_egld_address,
+)

address_encoder/coins/ela.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+from address_encoder.utils.base58_ import base58_unchecked_decode, base58_unchecked_encode
+
+encode_ela_address = base58_unchecked_encode
+decode_ela_address = base58_unchecked_decode
+
+ela = CoinCoder(
+    name="ela",
+    coin_type=2305,
+    encode=encode_ela_address,
+    decode=decode_ela_address,
+)
+

address_encoder/coins/eos.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from address_encoder.types import CoinCoder
+
+from address_encoder.utils.eosio import create_eos_decoder, create_eos_encoder
+
+encode_eos_address = create_eos_encoder("EOS")
+decode_eos_address = create_eos_decoder("EOS")
+
+eos = CoinCoder(
+    name="eos",
+    coin_type=194,
+    encode=encode_eos_address,
+    decode=decode_eos_address,
+)