boltz_client 0.2.1__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"
-    mempool_liquid_url: str = "https://liquid.network/api"
     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()
@@ -294,21 +292,10 @@ 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/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

@@ -10,8 +10,6 @@ import secrets
 from dataclasses import dataclass
 from typing import Any, Optional
 
-from .mempool import LockupData
-
 
 @dataclass
 class Network:
@@ -147,7 +145,8 @@ def decode_address(
 
 
 def create_liquid_tx(
-    lockup_tx: LockupData,
+    lockup_rawtx: str,
+    lockup_address: str,
     receive_address: str,
     privkey_wif: str,
     redeem_script_hex: str,
@@ -184,19 +183,19 @@ def create_liquid_tx(
         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
-
-        # 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
+        if script_out:
+            if script_out == lockup_script_pubkey:
+                vout_n = vout
+                break
 
     assert vout_n is not None, "Lockup vout not found"
 

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.1.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,189 +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.get("value") or 0,
-                    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:
-            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:
-        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:
-        # mempool.space quirk, needed for regtest
-        api_url = self._api_url.replace("/v1", "")
-        data = self.request(
-            "get",
-            f"{api_url}/v1/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.1.dist-info/METADATA

@@ -1,50 +0,0 @@
-Metadata-Version: 2.1
-Name: boltz_client
-Version: 0.2.1
-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.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-boltz_client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boltz_client/boltz.py,sha256=RAElhX4ZFqE-iMyfMIQlMedOTIU7_FGtW1NWG1PdWUo,11949
-boltz_client/cli.py,sha256=HXPzp95ynb_0--Hbi0f8ZkF6k6avs2jJBgkuUHa4HR8,9734
-boltz_client/helpers.py,sha256=pJVQKnki2xE9zJTz_ra_JIqSeet0A-jKDMi3AGj0dwE,374
-boltz_client/mempool.py,sha256=Jx8hTz-HQOxJWbjMyRLiivQpCz2dFM4Q4wykHhnNkX4,6410
-boltz_client/onchain.py,sha256=BV4vsOJJKC4OlsIhepYj2rEC4p-2Bs9xB2FKiQQwpqc,5246
-boltz_client/onchain_wally.py,sha256=FyX5KNwTPSYZxuQBO96b5Cz9wIkk0IMB_hxS3B4jAck,12126
-boltz_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-boltz_client-0.2.1.dist-info/LICENSE,sha256=ums-fB6x3ajzBZydnEwnKxO1n6oXTNr9NGdOYiWucmU,1062
-boltz_client-0.2.1.dist-info/METADATA,sha256=YacgtJdRXcl7ZggCC4Me_ogFAmxBin1IS2WFGzHmNds,1212
-boltz_client-0.2.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-boltz_client-0.2.1.dist-info/entry_points.txt,sha256=9u_t10YVlH8kHbl-M0nOZw91F3Fx4HJOZdSf2s42dhM,47
-boltz_client-0.2.1.dist-info/RECORD,,