boltz_client 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

boltz_client/boltz.py

@@ -9,13 +9,11 @@ from typing import Optional
 import httpx
 
 from .helpers import req_wrap
-from .mempool import MempoolClient
 from .onchain import (
     create_claim_tx,
     create_key_pair,
     create_preimage,
     create_refund_tx,
-    get_txid,
     validate_address,
 )
 
@@ -58,7 +56,9 @@ class BoltzSwapTransactionException(Exception):
 
 @dataclass
 class BoltzSwapTransactionResponse:
+    transactionId: Optional[str] = None
     transactionHex: Optional[str] = None
+    timeoutEta: Optional[str] = None
     timeoutBlockHeight: Optional[str] = None
     failureReason: Optional[str] = None
 
@@ -69,6 +69,7 @@ class BoltzSwapStatusResponse:
     failureReason: Optional[str] = None
     zeroConfRejected: Optional[str] = None
     transaction: Optional[dict] = None
+    failureDetails: Optional[str] = None
 
 
 @dataclass
@@ -81,6 +82,7 @@ class BoltzSwapResponse:
     expectedAmount: int
     timeoutBlockHeight: int
     blindingKey: Optional[str] = None
+    referralId: Optional[str] = None
 
 
 @dataclass
@@ -92,6 +94,7 @@ class BoltzReverseSwapResponse:
     timeoutBlockHeight: int
     onchainAmount: int
     blindingKey: Optional[str] = None
+    referralId: Optional[str] = None
 
 
 @dataclass
@@ -100,8 +103,6 @@ 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"
     referral_id: str = "dni"
 
 
@@ -119,12 +120,8 @@ class BoltzClient:
 
         if self.pair == "L-BTC/BTC":
             self.network = self._cfg.network_liquid
-            mempool_url = self._cfg.mempool_liquid_url
         else:
             self.network = self._cfg.network
-            mempool_url = self._cfg.mempool_url
-
-        self.mempool = MempoolClient(mempool_url)
 
     def request(self, funcname, *args, **kwargs) -> dict:
         try:
@@ -171,13 +168,6 @@ class BoltzClient:
     def get_fee_estimation_refund(self) -> int:
         return self.fees["minerFees"]["baseAsset"]["normal"]
 
-    def get_fee_estimation(self, feerate: Optional[int]) -> int:
-        # TODO: hardcoded maximum tx size, in the future we try to get the size of the
-        # tx via embit we need a function like Transaction.vsize()
-        tx_size_vbyte = 200
-        mempool_fees = feerate if feerate else self.mempool.get_fees()
-        return mempool_fees * tx_size_vbyte
-
     def get_pairs(self) -> dict:
         data = self.request(
             "get",
@@ -223,24 +213,25 @@ class BoltzClient:
 
         return res
 
-    async def wait_for_txid(self, boltz_id: str) -> str:
+    async def wait_for_tx(self, boltz_id: str) -> str:
         while True:
             try:
                 swap_transaction = self.swap_transaction(boltz_id)
-                if swap_transaction.transactionHex:
-                    return get_txid(swap_transaction.transactionHex, self.pair)
-                raise ValueError("transactionHex is empty")
+                assert swap_transaction.transactionHex
+                return swap_transaction.transactionHex
             except (ValueError, BoltzApiException, BoltzSwapTransactionException):
                 await asyncio.sleep(3)
 
-    async def wait_for_txid_on_status(self, boltz_id: str) -> str:
+    async def wait_for_tx_on_status(self, boltz_id: str, zeroconf: bool = True) -> str:
         while True:
             try:
                 status = self.swap_status(boltz_id)
                 assert status.transaction
-                txid = status.transaction.get("id")
-                assert txid
-                return txid
+                txHex = status.transaction.get("hex")
+                assert txHex
+                if not zeroconf:
+                    assert status.status == "transaction.confirmed"
+                return txHex
             except (BoltzApiException, BoltzSwapStatusException, AssertionError):
                 await asyncio.sleep(3)
 
@@ -259,29 +250,22 @@ class BoltzClient:
         preimage_hex: str,
         redeem_script_hex: str,
         zeroconf: bool = True,
-        feerate: Optional[int] = None,
         blinding_key: Optional[str] = None,
     ):
-
         self.validate_address(receive_address)
-        _lockup_address = self.validate_address(lockup_address)
-        lockup_txid = await self.wait_for_txid_on_status(boltz_id)
-        lockup_tx = await self.mempool.get_tx_from_txid(lockup_txid, _lockup_address)
-
-        if not zeroconf and lockup_tx.status != "confirmed":
-            await self.mempool.wait_for_tx_confirmed(lockup_tx.txid)
+        self.validate_address(lockup_address)
+        lockup_rawtx = await self.wait_for_tx_on_status(boltz_id, zeroconf)
 
         transaction = create_claim_tx(
-            lockup_tx=lockup_tx,
+            lockup_address=lockup_address,
+            lockup_rawtx=lockup_rawtx,
             receive_address=receive_address,
             privkey_wif=privkey_wif,
             redeem_script_hex=redeem_script_hex,
             preimage_hex=preimage_hex,
             pair=self.pair,
             blinding_key=blinding_key,
-            fees=self.get_fee_estimation(feerate)
-            if feerate
-            else self.get_fee_estimation_claim(),
+            fees=self.get_fee_estimation_claim(),
         )
         return self.send_onchain_tx(transaction)
 
@@ -293,25 +277,23 @@ class BoltzClient:
         receive_address: str,
         redeem_script_hex: str,
         timeout_block_height: int,
-        feerate: Optional[int] = None,
         blinding_key: Optional[str] = None,
     ) -> str:
-        self.mempool.check_block_height(timeout_block_height)
+        # self.mempool.check_block_height(timeout_block_height)
         self.validate_address(receive_address)
-        _lockup_address = self.validate_address(lockup_address)
-        lockup_txid = await self.wait_for_txid(boltz_id)
-        lockup_tx = await self.mempool.get_tx_from_txid(lockup_txid, _lockup_address)
+        self.validate_address(lockup_address)
+
+        lockup_rawtx = await self.wait_for_tx(boltz_id)
         transaction = create_refund_tx(
-            lockup_tx=lockup_tx,
+            lockup_address=lockup_address,
+            lockup_rawtx=lockup_rawtx,
             privkey_wif=privkey_wif,
             receive_address=receive_address,
             redeem_script_hex=redeem_script_hex,
             timeout_block_height=timeout_block_height,
             pair=self.pair,
             blinding_key=blinding_key,
-            fees=self.get_fee_estimation(feerate)
-            if feerate
-            else self.get_fee_estimation_refund(),
+            fees=self.get_fee_estimation_refund(),
         )
         return self.send_onchain_tx(transaction)
 

boltz_client/cli.py

@@ -21,8 +21,6 @@ config = BoltzConfig()
 #     network="regtest",
 #     network_liquid="elementsregtest",
 #     api_url="http://localhost:9001",
-#     mempool_url="http://localhost:8999/api/v1",
-#     mempool_liquid_url="http://localhost:8998/api/v1",
 # )
 
 
@@ -30,7 +28,7 @@ config = BoltzConfig()
 def command_group():
     """
     Python CLI of boltz-client-python, enjoy submarine swapping. :)
-    Uses mempool.space for retrieving onchain data"""
+    """
 
 
 @click.command()

boltz_client/onchain.py

@@ -7,25 +7,12 @@ from embit import ec, script
 from embit.base import EmbitError
 from embit.liquid.addresses import to_unconfidential
 from embit.liquid.networks import NETWORKS as LNETWORKS
-from embit.liquid.transaction import LTransaction
 from embit.networks import NETWORKS
 from embit.transaction import SIGHASH, Transaction, TransactionInput, TransactionOutput
 
-from .mempool import LockupData
 from .onchain_wally import create_liquid_tx
 
 
-def get_txid(tx_hex: str, pair: str = "BTC/BTC") -> str:
-    try:
-        if pair == "L-BTC/BTC":
-            tx = LTransaction.from_string(tx_hex)
-        else:
-            tx = Transaction.from_string(tx_hex)
-        return tx.txid().hex()
-    except EmbitError as exc:
-        raise ValueError("Invalid transaction hex") from exc
-
-
 def validate_address(address: str, network: str, pair: str) -> str:
     if pair == "L-BTC/BTC":
         net = LNETWORKS[network]
@@ -69,7 +56,8 @@ def create_refund_tx(
     receive_address: str,
     redeem_script_hex: str,
     timeout_block_height: int,
-    lockup_tx: LockupData,
+    lockup_address: str,
+    lockup_rawtx: str,
     pair: str,
     fees: int,
     blinding_key: Optional[str] = None,
@@ -79,10 +67,11 @@ def create_refund_tx(
     rs += sha256(bytes.fromhex(redeem_script_hex)).digest()
     script_sig = rs
     return create_onchain_tx(
+        lockup_address=lockup_address,
         sequence=0xFFFFFFFE,
         redeem_script_hex=redeem_script_hex,
         privkey_wif=privkey_wif,
-        lockup_tx=lockup_tx,
+        lockup_rawtx=lockup_rawtx,
         receive_address=receive_address,
         timeout_block_height=timeout_block_height,
         script_sig=script_sig,
@@ -93,18 +82,20 @@ def create_refund_tx(
 
 
 def create_claim_tx(
+    lockup_address: str,
     preimage_hex: str,
     privkey_wif: str,
     receive_address: str,
     redeem_script_hex: str,
-    lockup_tx: LockupData,
+    lockup_rawtx: str,
     fees: int,
     pair: str,
     blinding_key: Optional[str] = None,
 ) -> str:
     return create_onchain_tx(
+        lockup_address=lockup_address,
         preimage_hex=preimage_hex,
-        lockup_tx=lockup_tx,
+        lockup_rawtx=lockup_rawtx,
         receive_address=receive_address,
         privkey_wif=privkey_wif,
         redeem_script_hex=redeem_script_hex,
@@ -115,7 +106,8 @@ def create_claim_tx(
 
 
 def create_onchain_tx(
-    lockup_tx: LockupData,
+    lockup_address: str,
+    lockup_rawtx: str,
     receive_address: str,
     privkey_wif: str,
     redeem_script_hex: str,
@@ -133,7 +125,8 @@ def create_onchain_tx(
             raise ValueError("Blinding key is required for L-BTC/BTC pair")
 
         return create_liquid_tx(
-            lockup_tx=lockup_tx,
+            lockup_rawtx=lockup_rawtx,
+            lockup_address=lockup_address,
             receive_address=receive_address,
             privkey_wif=privkey_wif,
             redeem_script_hex=redeem_script_hex,
@@ -144,14 +137,31 @@ def create_onchain_tx(
             blinding_key=blinding_key,
         )
 
+    try:
+        lockup_transaction = Transaction.from_string(lockup_rawtx)
+    except EmbitError as exc:
+        raise ValueError("Invalid lockup transaction hex") from exc
+
+    txid = lockup_transaction.txid()
+    vout_amount: Optional[int] = None
+    vout_index: int = 0
+    for vout in lockup_transaction.vout:
+        if vout.script_pubkey == script.address_to_scriptpubkey(lockup_address):
+            vout_amount = vout.value
+            break
+        vout_index += 1
+
+    if vout_amount is None:
+        raise ValueError("No matching vout found in lockup transaction")
+
     vout = TransactionOutput(
-        lockup_tx.vout_amount - fees,
+        vout_amount - fees,
         script.address_to_scriptpubkey(receive_address),
     )
     vout = [vout]
     vin = TransactionInput(
-        bytes.fromhex(lockup_tx.txid),
-        lockup_tx.vout_cnt,
+        txid,
+        vout_index,
         sequence=sequence,
         script_sig=script.Script(data=script_sig) if script_sig else None,
     )
@@ -161,7 +171,7 @@ def create_onchain_tx(
         tx.locktime = timeout_block_height
 
     redeem_script = script.Script(data=bytes.fromhex(redeem_script_hex))
-    h = tx.sighash_segwit(0, redeem_script, lockup_tx.vout_amount)
+    h = tx.sighash_segwit(0, redeem_script, vout_amount)
     sig = ec.PrivateKey.from_wif(privkey_wif).sign(h).serialize() + bytes([SIGHASH.ALL])
     witness_script = script.Witness(
         items=[sig, bytes.fromhex(preimage_hex), bytes.fromhex(redeem_script_hex)]

boltz_client/onchain_wally.py

@@ -7,12 +7,71 @@ special thanks to @jgriffiths for helping debugging this!
 from __future__ import annotations
 
 import secrets
-from typing import Optional
-
-from .mempool import LockupData
-
-
-def get_entropy(num_outputs_to_blind):
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+@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,8 +81,72 @@ 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,
+    lockup_rawtx: str,
+    lockup_address: str,
     receive_address: str,
     privkey_wif: str,
     redeem_script_hex: str,
@@ -33,7 +156,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 +163,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,27 +179,23 @@ 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
+    )
+
+    _, lockup_script_pubkey = decode_address(wally, network, lockup_address)
 
     # parse lockup tx
     lockup_transaction = wally.tx_from_hex(
-        lockup_tx.tx_hex, wally.WALLY_TX_FLAG_USE_ELEMENTS
+        lockup_rawtx, wally.WALLY_TX_FLAG_USE_ELEMENTS
     )
     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)
-        if pub_key == lockup_tx.script_pub_key:
-            vout_n = vout
-            break
+        if script_out:
+            if script_out == lockup_script_pubkey:
+                vout_n = vout
+                break
 
     assert vout_n is not None, "Lockup vout not found"
 
@@ -113,7 +216,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.2.dist-info/METADATA

@@ -0,0 +1,123 @@
+Metadata-Version: 2.1
+Name: boltz_client
+Version: 0.2.2
+Summary: python boltz client
+Home-page: https://boltz.exchange
+License: MIT
+Author: dni
+Author-email: office@dnilabs.com
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8)
+Requires-Dist: embit (>=0.7.0,<0.8.0)
+Requires-Dist: httpx (>=0.23)
+Requires-Dist: wallycore (==1.0.0)
+Requires-Dist: websockets (>=10)
+Project-URL: Repository, https://github.com/dni/boltz-client-python
+Description-Content-Type: text/markdown
+
+# Boltz Python Client
+Boltz Client in Python, implementing mainchain and liquid submarine swaps. Used by e.g. https://github.com/lnbits/boltz.
+
+# CLI
+```console
+$ boltz --help
+Usage: boltz [OPTIONS] COMMAND [ARGS]...
+
+  Python CLI of boltz-client-python, enjoy submarine swapping. :)
+
+Options:
+  --help  Show this message and exit.
+
+Commands:
+  calculate-swap-send-amount     calculate the amount of the invoice you...
+  claim-reverse-swap             claims a reverse swap
+  create-reverse-swap            create a reverse swap
+  create-reverse-swap-and-claim  create a reverse swap and claim
+  create-swap                    create a swap boltz will pay your...
+  refund-swap                    refund a swap
+  show-pairs                     show pairs of possible assets to swap
+  swap-status                    get swap status retrieves the status of...
+```
+install the latest release from [PyPI](https://pypi.org/project/boltz-client) via `pip install boltz_client`.
+
+# LIB
+### initialize the client
+```python
+from boltz_client import BoltzClient, BoltzConfig
+config = BoltzConfig() # default config
+client = BoltzClient(config, "BTC/BTC")
+```
+### lifecycle swap
+```python
+pr = create_lightning_invoice(100000) # example function to create a lightning invoice
+refund_privkey_wif, swap = client.create_swap(pr)
+print(f"pay this amount: {swap.expectedAmount}")
+print(f"to this address: {swap.address}")
+# when you pay the amount the invoice will be settled after the boltz claimed the swap
+```
+if swap fails you can refund like this
+```python
+# example function to create an onchain address
+onchain_address = create_onchain_address()
+txid = await client.refund_swap(
+    boltz_id=swap.id,
+    privkey_wif=refund_privkey_wif,
+    lockup_address=swap.address,
+    receive_address=onchain_address,
+    redeem_script_hex=swap.redeemScript,
+    timeout_block_height=swap.timeoutBlockHeight,
+)
+```
+
+### lifecycle reverse swap
+```python
+claim_privkey_wif, preimage_hex, swap = client.create_reverse_swap(50000)
+# example function to pay the invoice
+pay_task = asyncio.create_task(pay_invoice(swap.invoice))
+# example function to create an onchain address
+new_address = create_onchain_address()
+task = asyncio.create_task(client.claim_reverse_swap(
+    boltz_id=swap.id,
+    receive_address=new_address,
+    lockup_address=swap.lockupAddress,
+    redeem_script_hex=swap.redeemScript,
+    blinding_key=swap.blindingKey,
+    privkey_wif=claim_privkey_wif,
+    preimage_hex=preimage_hex,
+    zeroconf=True,
+))
+txid = await task
+await pay_task
+```
+
+
+# development
+
+## installing
+```console
+poetry install
+```
+
+## running cli
+```console
+poetry run boltz
+```
+
+## starting regtest
+```console
+cd docker
+chmod +x regtest
+./regtest
+```
+
+## running tests
+```console
+poetry run pytest
+```
+

boltz_client-0.2.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+boltz_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boltz_client/boltz.py,sha256=ZBTX3IZM1nLV5iwZJLNSNMkMaOZXnCEGPnZZPSy6HBM,11052
+boltz_client/cli.py,sha256=OIqpRCMkBAiAvU8nA4mGnuzOBCR0C_o9icahUh6pWLU,9365
+boltz_client/helpers.py,sha256=pJVQKnki2xE9zJTz_ra_JIqSeet0A-jKDMi3AGj0dwE,374
+boltz_client/onchain.py,sha256=7-LJ1-O3vlCrwtS47HW4LOt_AB-skz8DsgnX_G6QvJM,5556
+boltz_client/onchain_wally.py,sha256=QIWLpc4zHCb4zmz7HRkTnZghkIO-2WAC0gQwIt1kTfc,12081
+boltz_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boltz_client-0.2.2.dist-info/LICENSE,sha256=ums-fB6x3ajzBZydnEwnKxO1n6oXTNr9NGdOYiWucmU,1062
+boltz_client-0.2.2.dist-info/METADATA,sha256=hAyIswWKc3t_L-csYIzspHT21SriNFQsPcBx2415vz0,3552
+boltz_client-0.2.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+boltz_client-0.2.2.dist-info/entry_points.txt,sha256=9u_t10YVlH8kHbl-M0nOZw91F3Fx4HJOZdSf2s42dhM,47
+boltz_client-0.2.2.dist-info/RECORD,,

{boltz_client-0.2.0.dist-info → boltz_client-0.2.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

boltz_client/mempool.py

@@ -1,184 +0,0 @@
-""" boltz_client mempool module """
-
-import asyncio
-import json
-from dataclasses import dataclass
-from typing import Optional
-
-import httpx
-from websockets.client import connect
-from websockets.exceptions import ConnectionClosed
-
-from .helpers import req_wrap
-
-
-@dataclass
-class LockupData:
-    status: str
-    tx_hex: str
-    txid: str
-    script_pub_key: str
-    vout_cnt: int
-    vout_amount: int
-
-
-class MempoolApiException(Exception):
-    pass
-
-
-class MempoolBlockHeightException(Exception):
-    pass
-
-
-class MempoolClient:
-    def __init__(self, url):
-        self._api_url = url
-        ws_url = url.replace("https", "wss")
-        ws_url = url.replace("http", "ws")
-        ws_url += "/ws"
-        self._ws_url = ws_url
-        # just check if mempool is available
-        self.get_blockheight()
-
-    def request(self, funcname, *args, **kwargs) -> dict:
-        try:
-            return req_wrap(funcname, *args, **kwargs)
-        except httpx.RequestError as exc:
-            msg = f"unreachable: {exc.request.url!r}."
-            raise MempoolApiException(f"mempool api connection error: {msg}") from exc
-        except httpx.HTTPStatusError as exc:
-            msg = (
-                f"{exc.response.status_code} while requesting "
-                f"{exc.request.url!r}. message: {exc.response.text}"
-            )
-            raise MempoolApiException(f"mempool api status error: {msg}") from exc
-
-    async def wait_for_websocket_message(self, send, message_key):
-        async for websocket in connect(self._ws_url):
-            try:
-                await websocket.send(json.dumps({"action": "want", "data": ["blocks"]}))
-                await websocket.send(json.dumps(send))
-                async for raw in websocket:
-                    message = json.loads(raw)
-                    if message_key in message:
-                        return message.get(message_key)
-            except ConnectionClosed:
-                continue
-
-    async def wait_for_one_websocket_message(self, send):
-        async with connect(self._ws_url) as websocket:
-            await websocket.send(
-                json.dumps({"action": "want", "data": ["blocks", "mempool-blocks"]})
-            )
-            await websocket.send(json.dumps(send))
-            raw = await asyncio.wait_for(websocket.recv(), timeout=10)
-            return json.loads(raw) if raw else None
-
-    async def wait_for_tx_confirmed(self, txid: str):
-        return await self.wait_for_websocket_message({"track-tx": txid}, "txConfirmed")
-
-    async def wait_for_lockup_tx(self, address: str) -> LockupData:
-        message = await self.wait_for_websocket_message(
-            {"track-address": address}, "address-transactions"
-        )
-        if not message:
-            # restart
-            return await self.wait_for_lockup_tx(address)
-        lockup_tx = self.find_tx_and_output(message, address)
-        if not lockup_tx:
-            # restart
-            return await self.wait_for_lockup_tx(address)
-        return lockup_tx
-
-    def find_tx_and_output(self, txs, address: str) -> Optional[LockupData]:
-        if len(txs) == 0:
-            return None
-        for tx in txs:
-            output = self.find_output(tx, address)
-            if output:
-                return output
-        return None
-
-    def find_output(self, tx, address: str) -> Optional[LockupData]:
-        for i, vout in enumerate(tx["vout"]):
-            if vout["scriptpubkey_address"] == address:
-                status = "confirmed" if tx["status"]["confirmed"] else "unconfirmed"
-                return LockupData(
-                    tx_hex=self.get_tx_hex(tx["txid"]),
-                    txid=tx["txid"],
-                    script_pub_key=vout["scriptpubkey_address"],
-                    vout_cnt=i,
-                    vout_amount=vout["value"],
-                    status=status,
-                )
-        return None
-
-    def get_tx(self, txid: str):
-        return self.request(
-            "get",
-            f"{self._api_url}/tx/{txid}",
-            headers={"Content-Type": "application/json"},
-        )
-
-    def get_tx_hex(self, txid: str) -> str:
-        return self.request(
-            "get",
-            f"{self._api_url}/tx/{txid}/hex",
-            headers={"Content-Type": "text/plain"},
-        )["text"]
-
-    def get_txs_from_address(self, address: str):
-        return self.request(
-            "get",
-            f"{self._api_url}/address/{address}/txs",
-            headers={"Content-Type": "application/json"},
-        )
-
-    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
-            await asyncio.sleep(3)
-
-    async def get_tx_from_address(self, address: str) -> LockupData:
-        txs = self.get_txs_from_address(address)
-        if len(txs) == 0:
-            return await self.wait_for_lockup_tx(address)
-        lockup_tx = self.find_tx_and_output(txs, address)
-        if not lockup_tx:
-            return await self.wait_for_lockup_tx(address)
-        return lockup_tx
-
-    def get_fees(self) -> int:
-        data = self.request(
-            "get",
-            f"{self._api_url}/fees/recommended",
-            headers={"Content-Type": "application/json"},
-        )
-        return int(data["halfHourFee"])
-
-    def get_blockheight(self) -> int:
-        data = self.request(
-            "get",
-            f"{self._api_url}/blocks/tip/height",
-            headers={"Content-Type": "text/plain"},
-        )
-        return int(data["text"])
-
-    def check_block_height(self, timeout_block_height: int) -> None:
-        current_block_height = self.get_blockheight()
-        if current_block_height < timeout_block_height:
-            raise MempoolBlockHeightException(
-                f"current_block_height ({current_block_height}) "
-                f"has not yet exceeded ({timeout_block_height})"
-            )
-
-    def send_onchain_tx(self, tx_hex: str):
-        return self.request(
-            "post",
-            f"{self._api_url}/tx",
-            headers={"Content-Type": "text/plain"},
-            content=tx_hex,
-        )

boltz_client-0.2.0.dist-info/METADATA

@@ -1,50 +0,0 @@
-Metadata-Version: 2.1
-Name: boltz_client
-Version: 0.2.0
-Summary: python boltz client
-Home-page: https://boltz.exchange
-License: MIT
-Author: dni
-Author-email: office@dnilabs.com
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: click (>=8)
-Requires-Dist: embit (>=0.7.0,<0.8.0)
-Requires-Dist: httpx (>=0.23)
-Requires-Dist: wallycore (==1.0.0)
-Requires-Dist: websockets (>=10)
-Project-URL: Repository, https://github.com/dni/boltz-client-python
-Description-Content-Type: text/markdown
-
-# Boltz Python Client
-Boltz Reference Client in Python, used by e.g. https://github.com/lnbits/boltz
-
-## installing
-```console
-poetry install
-```
-
-## running cli
-```console
-poetry run boltz
-```
-
-## starting regtest
-```console
-cd docker
-chmod +x regtest
-./regtest
-```
-
-## running tests
-```console
-poetry run pytest
-```
-
-Or install the latest release from [PyPI](https://pypi.org/project/boltz-client) via `pip install boltz-client`.
-

boltz_client-0.2.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-boltz_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boltz_client/boltz.py,sha256=SKqfcOLOoYPdFuME1uqnaWTnsKcMd1TU5KBDQkfjdsg,11955
-boltz_client/cli.py,sha256=DhA7lWUtdeVBBO-nHW2n8KEsV7RydtEBVcBlE-_FV3E,9518
-boltz_client/helpers.py,sha256=pJVQKnki2xE9zJTz_ra_JIqSeet0A-jKDMi3AGj0dwE,374
-boltz_client/mempool.py,sha256=-PxivS27PhH-fhgKiXy4YzJ9_DEqVUwkJ4Ec9_vQvFk,6209
-boltz_client/onchain.py,sha256=BV4vsOJJKC4OlsIhepYj2rEC4p-2Bs9xB2FKiQQwpqc,5246
-boltz_client/onchain_wally.py,sha256=Z2r0uxY2pf4FgdnS9fhHE9rO3_zAZv2kWMDGE4B8f18,9437
-boltz_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boltz_client-0.2.0.dist-info/LICENSE,sha256=ums-fB6x3ajzBZydnEwnKxO1n6oXTNr9NGdOYiWucmU,1062
-boltz_client-0.2.0.dist-info/METADATA,sha256=RCEm1OAD6VIvAMGAwzQtquJOzUG7p2bqLO67JvTMo6M,1212
-boltz_client-0.2.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-boltz_client-0.2.0.dist-info/entry_points.txt,sha256=9u_t10YVlH8kHbl-M0nOZw91F3Fx4HJOZdSf2s42dhM,47
-boltz_client-0.2.0.dist-info/RECORD,,