bip46 1.0.0__py3-none-any.whl

bip46/__init__.py

@@ -0,0 +1,76 @@
+from embit.script import address_to_scriptpubkey
+from embit.transaction import Transaction, TransactionInput, TransactionOutput
+
+from .certificate import (
+    create_certificate_message,
+    recover_from_signature_and_message,
+    sign_certificate_message,
+)
+from .derivation import (
+    index_to_lockdate,
+    lockdate_to_derivation_path,
+    lockdate_to_index,
+    lockindex_to_derivation_path,
+)
+from .exceptions import (
+    Bip46Bech32Error,
+    Bip46IndexError,
+    Bip46PathError,
+    Bip46RecoverPubkeyError,
+    Bip46TimeError,
+)
+from .hdkey import (
+    hdkey_derive,
+    hdkey_from_mnemonic,
+    hdkey_from_seed,
+    hdkey_from_xpub,
+    hdkey_scan,
+    hdkey_scan_all,
+    hdkey_to_pubkey,
+)
+from .script import create_redeemscript, redeemscript_address, redeemscript_pubkey
+
+
+# WIP
+def create_redeem_transaction(
+    prevtxid: str,
+    vout: int,
+    redeemscript: bytes,
+    address: str,
+    fee_sats_vbyte: int = 10,
+    # network: str = DEFAULT_NETWORK,
+) -> str:
+    """Create a redeem transaction for a BIP46 timelock"""
+    tx_size = 100
+    amount = 100000 - fee_sats_vbyte * tx_size
+    receive_address = address_to_scriptpubkey(address)
+    txout = TransactionOutput(amount, receive_address)
+    txin = TransactionInput(prevtxid, vout, redeemscript)
+    tx = Transaction(2, [txin], [txout])
+    return tx.serialize().hex()
+
+
+__all__ = [
+    "Bip46Bech32Error",
+    "Bip46IndexError",
+    "Bip46PathError",
+    "Bip46RecoverPubkeyError",
+    "Bip46TimeError",
+    "create_certificate_message",
+    "create_redeemscript",
+    "hdkey_derive",
+    "hdkey_from_mnemonic",
+    "hdkey_from_seed",
+    "hdkey_from_xpub",
+    "hdkey_scan",
+    "hdkey_scan_all",
+    "hdkey_to_pubkey",
+    "index_to_lockdate",
+    "lockdate_to_derivation_path",
+    "lockdate_to_index",
+    "lockindex_to_derivation_path",
+    "recover_from_signature_and_message",
+    "redeemscript_address",
+    "redeemscript_pubkey",
+    "sign_certificate_message",
+]

bip46/certificate.py

@@ -0,0 +1,69 @@
+from base64 import b64decode
+from hashlib import sha256
+
+from secp256k1 import PrivateKey, PublicKey
+
+from .exceptions import Bip46RecoverPubkeyError
+
+
+def create_certificate_message(
+    pubkey: str,
+    message: str = "fidelity-bond-cert",
+    expiry: int = 375
+) -> str:
+    """Create a certificate message for a BIP46 timelock"""
+    return f"{message}|{pubkey}|{expiry}"
+
+
+def prepare_certificate_message(message: str) -> bytes:
+    """ message hash for signing """
+    msg = message.encode()
+    prefix = b"\x18Bitcoin Signed Message:\n"
+    data = prefix + bytes([len(msg)]) + msg
+    return sha256(sha256(data).digest()).digest()
+
+
+def sign_certificate_message(private_key: bytes, message: str) -> bytes:
+    """Sign a certificate message for a BIP46 timelock"""
+    message_hash = prepare_certificate_message(message)
+    key = PrivateKey(private_key)
+    raw_sig = key.ecdsa_sign_recoverable(message_hash, raw=True)
+    sig, recid = key.ecdsa_recoverable_serialize(raw_sig)
+    # 31 for p2pkh_address
+    return bytes([recid + 31]) + sig
+
+
+def convert_recoverable_message_signature(sig_base64: str) -> tuple[bytes, int, bool]:
+    """ Convert a recoverable signature to a normal signature """
+    sig = b64decode(sig_base64)
+    if len(sig) != 65:
+        raise Bip46RecoverPubkeyError("Invalid signature length")
+    header = int(sig[0])
+    if header < 27 or header > 42:
+        raise Bip46RecoverPubkeyError(f"Header out of range: {header}")
+    r = sig[1:33]
+    s = sig[33:]
+    compressed = False
+    if(header >= 39): # this is a bech32 signature
+        header -= 12
+        compressed = True
+    # this is a segwit p2sh signature
+    elif header >= 35:
+        header -= 8
+        compressed = True
+    # this is a compressed key signature
+    elif header >= 31:
+        compressed = True
+        header -= 4
+    rec_id = header - 27
+    return r + s, rec_id, compressed
+
+
+def recover_from_signature_and_message(sig_base64: str, message: str) -> bytes:
+    """Recover a pubkey from signature and message"""
+    message_hash = prepare_certificate_message(message)
+    sig, recid, _ = convert_recoverable_message_signature(sig_base64)
+    empty = PublicKey()
+    sig = empty.ecdsa_recoverable_deserialize(sig, recid)
+    pubkey = empty.ecdsa_recover(message_hash, sig, raw=True)
+    return PublicKey(pubkey).serialize()

bip46/cli.py

@@ -0,0 +1,135 @@
+""" bip46 CLI """
+
+
+import os
+import sys
+from datetime import UTC, datetime
+
+import click
+from embit.bip32 import HDKey
+
+from bip46 import (
+    create_redeemscript,
+    hdkey_derive,
+    hdkey_from_mnemonic,
+    hdkey_from_seed,
+    hdkey_from_xpub,
+    hdkey_scan,
+    hdkey_scan_all,
+    hdkey_to_pubkey,
+    index_to_lockdate,
+    lockdate_to_derivation_path,
+    redeemscript_address,
+    redeemscript_pubkey,
+)
+from bip46.consts import DEFAULT_NETWORK
+
+# disable tracebacks on exceptions
+sys.tracebacklimit = 0
+
+def _check_hdkey(network: str) -> HDKey:
+    """check if the environment is set"""
+    if "XPUB" in os.environ:
+        return hdkey_from_xpub(os.environ["XPUB"])
+    if "SEED" in os.environ:
+        return hdkey_from_seed(os.environ["SEED"].encode(), network)
+    if "MNEMONIC" in os.environ:
+        return hdkey_from_mnemonic(os.environ["MNEMONIC"], network)
+
+    click.echo("please set `XPUB`, `SEED` or `MNEMONIC` environment variable")
+    sys.exit(1)
+
+
+@click.group()
+def command_group():
+    """
+    Python CLI for bip46 timelocks\n
+    set `SEED` or `MNEMONIC` environment variable to set the seed
+    """
+
+
+@click.command()
+@click.argument("network", type=str, default=DEFAULT_NETWORK)
+def scan_all(network: str):
+    """
+    scan for all timelocks
+    """
+    key = _check_hdkey(network)
+    bonds = hdkey_scan_all(key, network)
+    print(f"Found {len(bonds)} timelocked bonds:")
+    for bond in bonds:
+        print(bond.index, bond.txid, bond.address)
+
+
+@click.command()
+@click.argument("index", type=int)
+@click.argument("network", type=str, default=DEFAULT_NETWORK)
+def scan(index: int, network: str):
+    """
+    scan for a timelock at a specific index
+    """
+    key = _check_hdkey(network)
+    bonds = hdkey_scan(index, key, network)
+    print(f"Found {len(bonds)} timelocked bonds")
+    for bond in bonds:
+        print(bond.index, bond.txid, bond.address)
+
+
+@click.command()
+@click.argument("year", type=int)
+@click.argument("month", type=int)
+@click.argument("network", type=str, default=DEFAULT_NETWORK)
+def create_timelock(year: int, month: int, network: str):
+    """
+    create a timelock address
+    """
+    key = _check_hdkey(network)
+    lock_date = datetime(year, month, 1, tzinfo=UTC)
+    lock_path = lockdate_to_derivation_path(lock_date, network)
+    redeem_child = hdkey_derive(key, lock_path)
+    redeem_pub_key = hdkey_to_pubkey(redeem_child)
+    redeem_script = create_redeemscript(lock_date, redeem_pub_key)
+    script_pubkey = redeemscript_pubkey(redeem_script)
+    script_address = redeemscript_address(script_pubkey, network=network)
+
+    print(f"network: {network}")
+    print(f"lock_date: {lock_date.isoformat()}")
+    print(f"lock_path: {lock_path}")
+    print(f"script address: {script_address}")
+
+
+@click.command()
+@click.argument("year", type=int)
+@click.argument("month", type=int)
+@click.argument("network", type=str, default=DEFAULT_NETWORK)
+def get_derivation_path(year: int, month: int, network: str):
+    """
+    create a timelock address
+    """
+    lock_date = datetime(year, month, 1, tzinfo=UTC)
+    lock_path = lockdate_to_derivation_path(lock_date, network)
+    print(lock_path)
+
+
+@click.command()
+@click.argument("index", type=int)
+def get_lockdate(index: int):
+    """
+    get the lock date from an index
+    """
+    lock_path = index_to_lockdate(index)
+    print(lock_path.isoformat())
+
+
+def main():
+    """main function"""
+    command_group.add_command(create_timelock)
+    command_group.add_command(scan)
+    command_group.add_command(scan_all)
+    command_group.add_command(get_derivation_path)
+    command_group.add_command(get_lockdate)
+    command_group()
+
+
+if __name__ == "__main__":
+    main()

bip46/consts.py

@@ -0,0 +1,25 @@
+ELECTRS_SERVER = "https://testnet-electrs.b1tco1n.org"
+MAX_INDEX = 959
+DEFAULT_NETWORK = "testnet"
+NETWORKS = {
+    "mainnet": {
+        "bech32": "bc",
+        "xprv": b"\x04\x88\xad\xe4",
+        "bip32": 0,  # coin type for bip32 derivation
+    },
+    "testnet": {
+        "bech32": "tb",
+        "xprv": b"\x04\x35\x83\x94",
+        "bip32": 1,
+    },
+    "regtest": {
+        "bech32": "bcrt",
+        "xprv": b"\x04\x35\x83\x94",
+        "bip32": 1,
+    },
+    "signet": {
+        "bech32": "tb",
+        "xprv": b"\x04\x35\x83\x94",
+        "bip32": 1,
+    },
+}

bip46/derivation.py

@@ -0,0 +1,37 @@
+from datetime import UTC, datetime
+
+from .consts import DEFAULT_NETWORK, NETWORKS
+from .exceptions import Bip46IndexError, Bip46TimeError
+
+
+def index_to_lockdate(index: int) -> datetime:
+    """Convert a BIP46 timelock index to a datetime"""
+    if index < 0 or index > 959:
+        raise Bip46IndexError("index must be between 0 and 959")
+    year = 2020 + index // 12
+    month = 1 + index % 12
+    day = 1
+    return datetime(year, month, day, tzinfo=UTC)
+
+
+def lockdate_to_index(lock_date: datetime) -> int:
+    """Convert a datetime to a BIP46 timelock index"""
+    if lock_date.year < 2020:
+        raise Bip46TimeError("lock_date must be after 2020")
+    if lock_date.year > 2099:
+        raise Bip46TimeError("lock_date must be before 2100")
+    return (lock_date.year - 2020) * 12 + lock_date.month - 1
+
+
+def lockdate_to_derivation_path(
+    lock_date: datetime, network: str = DEFAULT_NETWORK
+) -> str:
+    """Derive the path for a BIP46 timelock from a date"""
+    i = lockdate_to_index(lock_date)
+    return lockindex_to_derivation_path(i, network)
+
+
+def lockindex_to_derivation_path(index: int, network: str = DEFAULT_NETWORK) -> str:
+    """Derive the path for a BIP46 timelock from an index"""
+    bip32 = NETWORKS[network]["bip32"]
+    return f"m/84'/{bip32}'/0'/2/{index}"

bip46/electrs.py

@@ -0,0 +1,38 @@
+
+import httpx
+
+from .consts import ELECTRS_SERVER
+
+
+def request(url: str) -> dict:
+    with httpx.Client() as client:
+        resp = client.get(url)
+        resp.raise_for_status()
+        return resp.json()
+
+
+def get_tx(txid: str, electrs_server: str = ELECTRS_SERVER) -> dict:
+    """Get a transaction from a block explorer"""
+    url = f"{electrs_server}/tx/{txid}"
+    return request(url)
+
+
+def get_txs_from_address(address: str, electrs_server: str = ELECTRS_SERVER) -> dict:
+    """Get a transaction from a block explorer"""
+    url = f"{electrs_server}/address/{address}/txs"
+    return request(url)
+
+
+def get_vout_from_tx(tx: dict, address: str) -> tuple[str, int, int] | None:
+    for i, out in enumerate(tx["vout"]):
+        if out["scriptpubkey_address"] == address:
+            return tx["txid"], i, out["value"]
+    return None
+
+
+def get_vout_from_txs(txs: dict, address: str) -> tuple[str, int, int] | None:
+    for tx in txs:
+        vout = get_vout_from_tx(tx, address)
+        if vout:
+            return vout
+    return None

bip46/exceptions.py

@@ -0,0 +1,21 @@
+""" Custom exceptions for the bip46 module """
+
+
+class Bip46TimeError(Exception):
+    """Raised when a locktime is not in the valid range for BIP46 timelocks"""
+
+
+class Bip46IndexError(Exception):
+    """Raised when a locktime index is not in the valid range for BIP46 timelocks"""
+
+
+class Bip46PathError(Exception):
+    """Raised when the derivation path is invalid"""
+
+
+class Bip46Bech32Error(Exception):
+    """Raised when the bech32 encoding fails"""
+
+
+class Bip46RecoverPubkeyError(Exception):
+    """Raised when we could not recover the pubkey from signature and message"""

bip46/hdkey.py

@@ -0,0 +1,106 @@
+from dataclasses import dataclass
+
+from embit.bip32 import HDKey
+from embit.bip39 import mnemonic_to_seed
+
+from .consts import DEFAULT_NETWORK, MAX_INDEX, NETWORKS
+from .derivation import index_to_lockdate, lockindex_to_derivation_path
+from .electrs import get_txs_from_address
+from .exceptions import Bip46PathError
+from .script import create_redeemscript, redeemscript_address, redeemscript_pubkey
+
+
+@dataclass
+class Bond:
+    index: int
+    address: str
+    txid: str
+    hdkey: HDKey
+
+
+def hdkey_scan(index: int, hdkey: HDKey, network: str = DEFAULT_NETWORK) -> list[Bond]:
+    """
+    Scan a path for all possible keys timelocks
+    """
+    bonds = []
+    path = lockindex_to_derivation_path(index, network)
+    hdkey_i = hdkey.derive(path)
+    pubkey = hdkey_to_pubkey(hdkey_i)
+    lock_date = index_to_lockdate(index)
+    redeemscript = create_redeemscript(lock_date, pubkey)
+    address = redeemscript_address(redeemscript_pubkey(redeemscript), network)
+    print(f"({index}/{MAX_INDEX}) Scanning timelocks for address {address}")
+    txs = get_txs_from_address(address)
+    if len(txs) > 0:
+        print(f"Found {len(txs)} timelocks for index {index} !!!")
+        for tx in txs:
+            bonds.append(Bond(index, address, tx.get("txid"), hdkey_i))
+    return bonds
+
+
+def hdkey_scan_all(hdkey: HDKey, network: str = DEFAULT_NETWORK) -> list[Bond]:
+    """
+    Scan a path for all possible keys timelocks
+    """
+    bonds = []
+    for i in range(MAX_INDEX + 1):
+        bonds.extend(hdkey_scan(i, hdkey, network))
+    return bonds
+
+
+def hdkey_from_seed(seed: bytes, network: str = DEFAULT_NETWORK) -> HDKey:
+    """Create a HDKey from a seed"""
+    version = NETWORKS[network]["xprv"]
+    master = HDKey.from_seed(seed, version=version)
+    return master
+
+
+def hdkey_from_mnemonic(mnemonic: str, network: str = DEFAULT_NETWORK) -> HDKey:
+    """Create a HDKey from a mnemonic"""
+    seed = mnemonic_to_seed(mnemonic)
+    return hdkey_from_seed(seed, network)
+
+
+def hdkey_from_xpub(xpub: str) -> HDKey:
+    """Create a public HDKey from an account-level xpub."""
+    hdkey = HDKey.from_base58(xpub)
+    if hdkey.is_private:
+        raise Bip46PathError("Expected a public extended key")
+    return hdkey
+
+
+def hdkey_derive(hdkey: HDKey, path: str) -> HDKey:
+    """
+    Derive a child key from a hdkey
+    Path should be in the form of m/x/y/z where x' means hardened
+    first child path for mainnet is m/84'/0'/0'/2/0
+    """
+    if not path.startswith("m"):
+        raise Bip46PathError(f"Invalid Path, should start with `m`: {path}")
+    if not path.endswith(f"/2/{path.split('/')[-1]}"):
+        raise Bip46PathError(f"Invalid Path, should end with `/2/x`: {path}")
+    if not hdkey.is_private:
+        path = _account_xpub_path(hdkey, path)
+    return hdkey.derive(path)
+
+
+def hdkey_to_pubkey(hdkey: HDKey) -> bytes:
+    """Get the pubkey from an HDKey"""
+    return hdkey.get_public_key().sec()
+
+
+def _account_xpub_path(hdkey: HDKey, path: str) -> str:
+    if hdkey.depth != 3:
+        raise Bip46PathError(
+            "Public derivation requires an account-level xpub for m/84'/coin'/0'"
+        )
+
+    parts = path.split("/")
+    if len(parts) == 6 and all(part.endswith("'") for part in parts[1:4]):
+        return "m/" + "/".join(parts[4:])
+    if len(parts) == 3:
+        return path
+    raise Bip46PathError(
+        "Public derivation requires an account-level xpub for m/84'/coin'/0' "
+        "and a BIP46 path ending in /2/index"
+    )

bip46/script.py

@@ -0,0 +1,44 @@
+from datetime import datetime
+from hashlib import sha256
+
+import bech32
+
+from .consts import DEFAULT_NETWORK, NETWORKS
+from .exceptions import Bip46Bech32Error
+
+
+def lockdate_to_little_endian(locktime: datetime) -> bytes:
+    """Convert a lockdate to little-endian bytes for use in a script"""
+    # max signed int for 4bytes
+    max_int = 2**31 - 1
+    ts = int(locktime.timestamp())
+    size = 4 if ts <= max_int else 5
+    return ts.to_bytes(size, "little")
+
+
+def create_redeemscript(lock_date: datetime, pubkey: bytes) -> bytes:
+    """Create a redeemscript pubkey for a BIP46 timelock"""
+    locktime_bytes = lockdate_to_little_endian(lock_date)
+    return (
+        bytes([len(locktime_bytes)])  # 1 byte len of locktime
+        + locktime_bytes  # 4 or 5 bytes of locktime
+        + bytes([177, 117]) # OP_CLTV OP_DROP
+        + bytes([len(pubkey)]) # 1 byte len of pubkey
+        + pubkey # pubkey
+        + bytes([172]) # OP_CHECKSIG
+    )
+
+
+def redeemscript_pubkey(redeemscript: bytes) -> bytes:
+    """Create a redeemscript pubkey for a BIP46 timelock"""
+    hashed = sha256(redeemscript).digest()
+    return bytes([0, len(hashed)]) + hashed
+
+
+def redeemscript_address(script_pubkey: bytes, network: str = DEFAULT_NETWORK) -> str:
+    """Create a p2wpkh_address redeemscript address for a BIP46 timelock"""
+    hrp = NETWORKS[network]["bech32"]
+    address = bech32.encode(str(hrp), 0, script_pubkey[2:])
+    if not address:
+        raise Bip46Bech32Error("Could not encode address")
+    return address

bip46-1.0.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: bip46
+Version: 1.0.0
+Summary: A Python implementation of BIP46: Address Scheme for Timelocked Fidelity Bonds
+Author-email: dni <dni@lnbits.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: bech32<2.0.0,>=1.2.0
+Requires-Dist: click<9.0.0,>=8.1.7
+Requires-Dist: embit<0.9.0,>=0.8.0
+Requires-Dist: httpx<1.0.0,>=0.27.2
+Requires-Dist: secp256k1<0.15.0,>=0.14.0
+Description-Content-Type: text/markdown
+
+# BIP46 - Address Scheme for Timelocked Fidelity Bonds
+
+Python implementation of BIP46: Address Scheme for Timelocked Fidelity Bonds.
+
+## Example
+
+### Create a redeem script from a mnemonic
+
+```python
+from datetime import UTC, datetime
+
+from bip46 import (
+    create_redeemscript,
+    hdkey_derive,
+    hdkey_from_mnemonic,
+    hdkey_to_pubkey,
+    lockdate_to_derivation_path,
+    redeemscript_address,
+    redeemscript_pubkey,
+)
+
+network = "mainnet"
+lock_date = datetime(2042, 6, 1, tzinfo=UTC)
+lock_path = lockdate_to_derivation_path(lock_date, network=network)
+
+hdkey = hdkey_from_mnemonic(
+    "abandon abandon abandon abandon abandon abandon"
+    " abandon abandon abandon abandon abandon about",
+    network=network,
+)
+redeem_key = hdkey_derive(hdkey, lock_path)
+redeem_pub_key = hdkey_to_pubkey(redeem_key)
+redeem_script = create_redeemscript(lock_date, redeem_pub_key)
+script_pubkey = redeemscript_pubkey(redeem_script)
+script_address = redeemscript_address(script_pubkey, network=network)
+```
+
+### Create addresses from an xpub
+
+BIP46 paths include hardened account components: `m/84'/coin_type'/0'/2/index`.
+A public key cannot derive those hardened components, so pass an account-level xpub
+for `m/84'/coin_type'/0'`. The library will derive the public BIP46 suffix
+`2/index` from that account xpub.
+
+```python
+from datetime import UTC, datetime
+
+from bip46 import (
+    create_redeemscript,
+    hdkey_derive,
+    hdkey_from_xpub,
+    hdkey_to_pubkey,
+    lockdate_to_derivation_path,
+    redeemscript_address,
+    redeemscript_pubkey,
+)
+
+network = "mainnet"
+lock_date = datetime(2042, 6, 1, tzinfo=UTC)
+lock_path = lockdate_to_derivation_path(lock_date, network=network)
+
+hdkey = hdkey_from_xpub("xpub...")
+redeem_key = hdkey_derive(hdkey, lock_path)
+redeem_pub_key = hdkey_to_pubkey(redeem_key)
+redeem_script = create_redeemscript(lock_date, redeem_pub_key)
+script_pubkey = redeemscript_pubkey(redeem_script)
+script_address = redeemscript_address(script_pubkey, network=network)
+```
+
+The CLI also accepts an account xpub:
+
+```sh
+XPUB="xpub..." uv run bip46 create-timelock 2042 6 mainnet
+```

bip46-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bip46/__init__.py,sha256=QmOukqjhY3Wd1pw6YMjwcQ0rnrw1QD93obIguWJBWhE,1953
+bip46/certificate.py,sha256=hK3ULNQKvyy79dvbd8N6wbZ1hySbGyNgX5WrJRYVQRc,2338
+bip46/cli.py,sha256=h8OSBdSn71_C3Qhr5EUTLa3mnogE2fjWhw48djwBj4Y,3682
+bip46/consts.py,sha256=9NyEhKSkKmZiNFZrrZCkTznL8btQN24dRiFhR5E2ud0,569
+bip46/derivation.py,sha256=kFbu4zbZ0InSya3sNuJnoaxwc-Eibfgu1vHZ6dMpEr0,1290
+bip46/electrs.py,sha256=3LJcE_UXL43kK74E25zrERm_iuuAw2n72dgrhrYBAyA,1043
+bip46/exceptions.py,sha256=XchCU6VLnsUk-glgmAxtUzZa9NgMetXsGAopcrcULTc,580
+bip46/hdkey.py,sha256=2U74EhFoNjXsKxHnZwcwe4CA7SeAnr-zjwx1QfB8i7Q,3466
+bip46/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bip46/script.py,sha256=a7cfNL59guLe8wPp_uyQAb-12_do3avOLsinou1aoug,1514
+bip46-1.0.0.dist-info/METADATA,sha256=SPqaBnMgF2uoLOQw2l_DnOYkJoCjybEju9sdJT1qQTY,2573
+bip46-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+bip46-1.0.0.dist-info/entry_points.txt,sha256=erLAErWuxedSmof6WoPRgby4KJuFotSBW_8Frln9v_Y,41
+bip46-1.0.0.dist-info/licenses/LICENSE,sha256=5nXjp5shAeUfsQid_GPb2_rUzhDxjW4G96kn0RL8C94,1064
+bip46-1.0.0.dist-info/RECORD,,

bip46-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

bip46-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bip46 = bip46.cli:main

bip46-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 dni ⚡
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.