boltz_client 0.2.0__tar.gz → 0.2.1__tar.gz

{boltz_client-0.2.0 → boltz_client-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boltz_client
-Version: 0.2.0
+Version: 0.2.1
 Summary: python boltz client
 Home-page: https://boltz.exchange
 License: MIT

{boltz_client-0.2.0 → boltz_client-0.2.1}/boltz_client/boltz.py

@@ -100,8 +100,8 @@ class BoltzConfig:
     network_liquid: str = "liquidv1"
     pairs: list = field(default_factory=lambda: ["BTC/BTC", "L-BTC/BTC"])
     api_url: str = "https://boltz.exchange/api"
-    mempool_url: str = "https://mempool.space/api/v1"
-    mempool_liquid_url: str = "https://liquid.network/api/v1"
+    mempool_url: str = "https://mempool.space/api"
+    mempool_liquid_url: str = "https://liquid.network/api"
     referral_id: str = "dni"
 
 

{boltz_client-0.2.0 → boltz_client-0.2.1}/boltz_client/cli.py

@@ -294,10 +294,21 @@ def show_pairs():
     click.echo(json.dumps(data))
 
 
+@click.command()
+def get_fees():
+    """
+    show mempool recommended fees
+    """
+    client = BoltzClient(config)
+    fees = client.mempool.get_fees()
+    click.echo(fees)
+
+
 def main():
     """main function"""
     command_group.add_command(swap_status)
     command_group.add_command(show_pairs)
+    command_group.add_command(get_fees)
     command_group.add_command(create_swap)
     command_group.add_command(refund_swap)
     command_group.add_command(create_reverse_swap)

{boltz_client-0.2.0 → boltz_client-0.2.1}/boltz_client/mempool.py

@@ -108,7 +108,7 @@ class MempoolClient:
                     txid=tx["txid"],
                     script_pub_key=vout["scriptpubkey_address"],
                     vout_cnt=i,
-                    vout_amount=vout["value"],
+                    vout_amount=vout.get("value") or 0,
                     status=status,
                 )
         return None
@@ -136,10 +136,13 @@ class MempoolClient:
 
     async def get_tx_from_txid(self, txid: str, address: str) -> LockupData:
         while True:
-            tx = self.get_tx(txid)
-            output = self.find_output(tx, address)
-            if output:
-                return output
+            try:
+                tx = self.get_tx(txid)
+                output = self.find_output(tx, address)
+                if output:
+                    return output
+            except MempoolApiException:
+                pass
             await asyncio.sleep(3)
 
     async def get_tx_from_address(self, address: str) -> LockupData:
@@ -152,9 +155,11 @@ class MempoolClient:
         return lockup_tx
 
     def get_fees(self) -> int:
+        # mempool.space quirk, needed for regtest
+        api_url = self._api_url.replace("/v1", "")
         data = self.request(
             "get",
-            f"{self._api_url}/fees/recommended",
+            f"{api_url}/v1/fees/recommended",
             headers={"Content-Type": "application/json"},
         )
         return int(data["halfHourFee"])

{boltz_client-0.2.0 → boltz_client-0.2.1}/boltz_client/onchain_wally.py

@@ -7,12 +7,73 @@ special thanks to @jgriffiths for helping debugging this!
 from __future__ import annotations
 
 import secrets
-from typing import Optional
+from dataclasses import dataclass
+from typing import Any, Optional
 
 from .mempool import LockupData
 
 
-def get_entropy(num_outputs_to_blind):
+@dataclass
+class Network:
+    name: str
+    lbtc_asset: bytes
+    blech32_prefix: str
+    bech32_prefix: str
+
+    def wif_net(self, wally) -> Any:
+        if self.name == "mainnet":
+            return wally.WALLY_ADDRESS_VERSION_WIF_MAINNET
+        return wally.WALLY_ADDRESS_VERSION_WIF_TESTNET
+
+    def blinded_prefix(self, wally) -> Any:
+        if self.name == "mainnet":
+            return wally.WALLY_CA_PREFIX_LIQUID
+        if self.name == "testnet":
+            return wally.WALLY_CA_PREFIX_LIQUID_TESTNET
+        return wally.WALLY_CA_PREFIX_LIQUID_REGTEST
+
+    def wally_network(self, wally) -> Any:
+        if self.name == "mainnet":
+            return wally.WALLY_NETWORK_LIQUID
+        if self.name == "testnet":
+            return wally.WALLY_NETWORK_LIQUID_TESTNET
+        return wally.WALLY_NETWORK_LIQUID_REGTEST
+
+    @staticmethod
+    def parse_asset(asset: str) -> bytes:
+        return bytes.fromhex(asset)[::-1]
+
+
+# TODO: is this type hint compatible with all support Python versions of lnbits
+NETWORKS: list[Network] = [
+    Network(
+        name="mainnet",
+        lbtc_asset=Network.parse_asset(
+            "6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d"
+        ),
+        blech32_prefix="lq",
+        bech32_prefix="ex",
+    ),
+    Network(
+        name="testnet",
+        lbtc_asset=Network.parse_asset(
+            "144c654344aa716d6f3abcc1ca90e5641e4e2a7f633bc09fe3baf64585819a49"
+        ),
+        blech32_prefix="tlq",
+        bech32_prefix="tex",
+    ),
+    Network(
+        name="regtest",
+        lbtc_asset=Network.parse_asset(
+            "5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225"
+        ),
+        blech32_prefix="el",
+        bech32_prefix="ert",
+    ),
+]
+
+
+def get_entropy(num_outputs_to_blind: int) -> bytes:
     # For each output to blind, we need 32 bytes of entropy for each of:
     # - Output assetblinder
     # - Output amountblinder
@@ -22,6 +83,69 @@ def get_entropy(num_outputs_to_blind):
     return secrets.token_bytes(num_outputs_to_blind * 5 * 32)
 
 
+def get_address_network(wally, address: str) -> Network:
+    def address_has_network_prefix(n: Network) -> bool:
+        # If address decoding doesn't fail -> correct network
+        try:
+            decode_address(wally, n, address)
+            return True
+        except Exception:
+            return False
+
+    network = next(
+        (network for network in NETWORKS if address_has_network_prefix(network)),
+        None,
+    )
+
+    if network is None:
+        raise ValueError("Unknown network of address")
+
+    return network
+
+
+def is_possible_confidential_address(wally, address) -> bool:
+    expected_len = (
+        2 + wally.EC_PUBLIC_KEY_LEN + wally.HASH160_LEN + wally.BASE58_CHECKSUM_LEN
+    )
+    try:
+        return wally.base58_n_get_length(address, len(address)) == expected_len
+    except ValueError:
+        return False
+
+
+# TODO: is this type hint compatible with all support Python versions of lnbits
+def decode_address(
+    wally, network: Network, address: str
+) -> tuple[bytearray, bytearray]:
+    if address.lower().startswith(network.blech32_prefix):
+        blinding_key = wally.confidential_addr_segwit_to_ec_public_key(
+            address, network.blech32_prefix
+        )
+        unconfidential_address = wally.confidential_addr_to_addr_segwit(
+            address, network.blech32_prefix, network.bech32_prefix
+        )
+
+        return blinding_key, wally.addr_segwit_to_bytes(
+            unconfidential_address, network.bech32_prefix, 0
+        )
+
+    if is_possible_confidential_address(wally, address):
+        unconfidential_address = wally.confidential_addr_to_addr(
+            address, network.blinded_prefix(wally)
+        )
+
+        blinding_key = wally.confidential_addr_to_ec_public_key(
+            address,
+            network.blinded_prefix(wally),
+        )
+
+        return blinding_key, wally.address_to_scriptpubkey(
+            unconfidential_address, network.wally_network(wally)
+        )
+
+    raise ValueError("only confidential addresses are supported")
+
+
 def create_liquid_tx(
     lockup_tx: LockupData,
     receive_address: str,
@@ -33,7 +157,6 @@ def create_liquid_tx(
     preimage_hex: str = "",
     blinding_key: Optional[str] = None,
 ) -> str:
-
     try:
         import wallycore as wally
     except ImportError as exc:
@@ -41,28 +164,13 @@ def create_liquid_tx(
             "`wallycore` is not installed, but required for liquid support."
         ) from exc
 
-    if receive_address.startswith("ert") or receive_address.startswith("el"):
-        lasset_hex = "5ac9f65c0efcc4775e0baec4ec03abdde22473cd3cf33c0419ca290e0751b225"
-        confidential_addr_prefix = "ert"
-        confidential_addr_family = "el"
-    elif receive_address.startswith("tex") or receive_address.startswith("tlq"):
-        lasset_hex = "144c654344aa716d6f3abcc1ca90e5641e4e2a7f633bc09fe3baf64585819a49"
-        confidential_addr_prefix = "tex"
-        confidential_addr_family = "tlq"
-    elif receive_address.startswith("ex") or receive_address.startswith("lq"):
-        lasset_hex = "6f0279e9ed041c3d710a9f57d0c02928416460c4b722ae3457a11eec381c526d"
-        confidential_addr_prefix = "ex"
-        confidential_addr_family = "lq"
-    else:
-        raise ValueError(f"Unknown prefix: {receive_address[:3]}")
-
-    LASSET = bytes.fromhex(lasset_hex)[::-1]
+    network = get_address_network(wally, receive_address)
 
     redeem_script = bytes.fromhex(redeem_script_hex)
     preimage = bytes.fromhex(preimage_hex)
     private_key = wally.wif_to_bytes(
         privkey_wif,
-        wally.WALLY_ADDRESS_VERSION_WIF_TESTNET,
+        network.wif_net(wally),
         wally.WALLY_WIF_FLAG_COMPRESSED,
     )  # type: ignore
 
@@ -72,15 +180,9 @@ def create_liquid_tx(
     except ValueError as exc:
         raise ValueError("blinding_key must be hex encoded") from exc
 
-    receive_blinding_pubkey = wally.confidential_addr_segwit_to_ec_public_key(
-        receive_address, confidential_addr_family
-    )  # type: ignore
-    receive_unconfidential_address = wally.confidential_addr_to_addr_segwit(
-        receive_address, confidential_addr_family, confidential_addr_prefix
-    )  # type: ignore
-    receive_script_pubkey = wally.addr_segwit_to_bytes(
-        receive_unconfidential_address, confidential_addr_prefix, 0
-    )  # type: ignore
+    receive_blinding_pubkey, receive_script_pubkey = decode_address(
+        wally, network, receive_address
+    )
 
     # parse lockup tx
     lockup_transaction = wally.tx_from_hex(
@@ -89,7 +191,9 @@ def create_liquid_tx(
     vout_n: Optional[int] = None
     for vout in range(wally.tx_get_num_outputs(lockup_transaction)):
         script_out = wally.tx_get_output_script(lockup_transaction, vout)  # type: ignore
-        pub_key = wally.addr_segwit_from_bytes(script_out, confidential_addr_prefix, 0)
+
+        # Lockup addresses on liquid are always bech32
+        pub_key = wally.addr_segwit_from_bytes(script_out, network.bech32_prefix, 0)
         if pub_key == lockup_tx.script_pub_key:
             vout_n = vout
             break
@@ -113,7 +217,7 @@ def create_liquid_tx(
         lockup_asset_commitment,
     )  # type: ignore
 
-    assert unblinded_asset == LASSET, "Wrong asset"
+    assert unblinded_asset == network.lbtc_asset, "Wrong asset"
 
     # INITIALIZE PSBT (PSET)
     num_vin = 1

{boltz_client-0.2.0 → boltz_client-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "boltz_client"
-version = "0.2.0"
+version = "0.2.1"
 description = "python boltz client"
 license = "MIT"
 authors = ["dni <office@dnilabs.com>"]
@@ -63,4 +63,5 @@ disable = [
   "too-many-instance-attributes",
   "too-many-locals",
   "too-many-statements",
+  "broad-exception-caught",
 ]