kaleido-cli 0.1.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,17 @@
1
+ """Shared CLI command error handling."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from typing import NoReturn
6
+
7
+ import typer
8
+
9
+ from kaleido_cli.output import print_error
10
+
11
+
12
+ def raise_cli_error(error: Exception, *, prefix: str = "Error") -> NoReturn:
13
+ """Preserve deliberate CLI exits and normalize unexpected command errors."""
14
+ if isinstance(error, (typer.Exit, typer.Abort)):
15
+ raise error
16
+ print_error(f"{prefix}: {error}")
17
+ raise typer.Exit(1)
@@ -0,0 +1,133 @@
1
+ """Trading pair helpers for canonical and reversed pair lookup."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from collections.abc import Sequence
6
+
7
+ import typer
8
+ from kaleido_sdk import TradableAssetResponseModel, TradingPairResponseModel
9
+
10
+ from kaleido_cli.output import is_interactive, print_error, print_info
11
+
12
+
13
+ def canonical_pair(pair: TradingPairResponseModel) -> str:
14
+ """Return the canonical BASE/QUOTE representation for a trading pair."""
15
+ return f"{pair.base.ticker}/{pair.quote.ticker}".upper()
16
+
17
+
18
+ def reversed_pair(pair: TradingPairResponseModel) -> str:
19
+ """Return the reversed QUOTE/BASE representation for a trading pair."""
20
+ return f"{pair.quote.ticker}/{pair.base.ticker}".upper()
21
+
22
+
23
+ def pair_assets(
24
+ pair: TradingPairResponseModel, is_reversed: bool
25
+ ) -> tuple[TradableAssetResponseModel, TradableAssetResponseModel]:
26
+ """Return the from/to assets for the user-requested pair direction."""
27
+ if is_reversed:
28
+ return pair.quote, pair.base
29
+ return pair.base, pair.quote
30
+
31
+
32
+ def resolve_asset_id_for_layer(asset: TradableAssetResponseModel, layer: str) -> str:
33
+ """Resolve the exact asset identifier to use for the selected layer."""
34
+ normalized_layer = layer.strip().upper()
35
+ if normalized_layer.startswith("BTC"):
36
+ if asset.ticker.strip().upper() == "BTC":
37
+ return asset.asset_id
38
+ raise ValueError(
39
+ f"BTC* layers are only valid for BTC assets (got asset {asset.ticker!r} and layer {layer!r})."
40
+ )
41
+
42
+ if normalized_layer.startswith("RGB"):
43
+ if asset.ticker.strip().upper() == "BTC":
44
+ raise ValueError(
45
+ f"RGB* layers are only valid for RGB assets (got asset {asset.ticker!r} and layer {layer!r})."
46
+ )
47
+ return asset.asset_id
48
+
49
+ raise ValueError(f"Unsupported layer {layer!r} for asset {asset.ticker!r}.")
50
+
51
+
52
+ def resolve_trading_pair(
53
+ pairs: Sequence[TradingPairResponseModel] | None, pair: str
54
+ ) -> tuple[TradingPairResponseModel, bool] | None:
55
+ """Resolve a user-supplied pair against the maker pair list in either direction."""
56
+ normalized = pair.strip().upper()
57
+ for item in pairs or []:
58
+ if canonical_pair(item) == normalized:
59
+ return item, False
60
+
61
+ if reversed_pair(item) == normalized:
62
+ return item, True
63
+ return None
64
+
65
+
66
+ def _pair_direction_options(
67
+ pairs: Sequence[TradingPairResponseModel] | None,
68
+ ) -> list[tuple[str, TradingPairResponseModel, bool]]:
69
+ options: list[tuple[str, TradingPairResponseModel, bool]] = []
70
+ seen: set[str] = set()
71
+ for item in pairs or []:
72
+ for label, is_reversed in (
73
+ (canonical_pair(item), False),
74
+ (reversed_pair(item), True),
75
+ ):
76
+ if label in seen:
77
+ continue
78
+ seen.add(label)
79
+ options.append((label, item, is_reversed))
80
+ return options
81
+
82
+
83
+ def resolve_pair_from_options(
84
+ pairs: Sequence[TradingPairResponseModel] | None,
85
+ pair: str | None,
86
+ ) -> str:
87
+ """Validate an explicit pair or interactively select from live pair directions."""
88
+ if pair is not None:
89
+ normalized = pair.strip().upper()
90
+ if resolve_trading_pair(pairs, normalized):
91
+ return normalized
92
+ print_error(f"Pair {pair!r} not found.")
93
+ raise typer.Exit(1)
94
+
95
+ if not is_interactive():
96
+ print_error("PAIR argument is required in non-interactive mode.")
97
+ raise typer.Exit(1)
98
+
99
+ options = _pair_direction_options(pairs)
100
+ if not options:
101
+ print_error("No trading pairs are currently available.")
102
+ raise typer.Exit(1)
103
+
104
+ print_info("Available trading pairs:")
105
+ for index, (label, item, is_reversed) in enumerate(options, start=1):
106
+ route_count = len(item.routes or [])
107
+ direction = " (reverse)" if is_reversed else ""
108
+ status = " (inactive)" if not item.is_active else ""
109
+ print_info(
110
+ f"{index}. {label}{direction} - {route_count} route"
111
+ f"{'' if route_count == 1 else 's'}{status}"
112
+ )
113
+
114
+ while True:
115
+ selected = typer.prompt("Select trading pair number", type=int)
116
+ if 1 <= selected <= len(options):
117
+ return options[selected - 1][0]
118
+ print_error(f"Select a number from 1 to {len(options)}.")
119
+
120
+
121
+ def default_layer_for_asset(ticker: str) -> str:
122
+ """Return the default quote layer for an asset ticker."""
123
+ return "BTC_LN" if ticker.strip().upper() == "BTC" else "RGB_LN"
124
+
125
+
126
+ def resolve_quote_layers(
127
+ pair: str, from_layer: str | None, to_layer: str | None
128
+ ) -> tuple[str, str]:
129
+ """Resolve default layers from the user-requested pair direction."""
130
+ base_ticker, _, quote_ticker = pair.partition("/")
131
+ resolved_from_layer = from_layer or default_layer_for_asset(base_ticker)
132
+ resolved_to_layer = to_layer or default_layer_for_asset(quote_ticker)
133
+ return resolved_from_layer, resolved_to_layer
@@ -0,0 +1,102 @@
1
+ """Shared interactive prompt helpers for CLI commands."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import typer
6
+ from kaleido_sdk import parse_raw_amount
7
+
8
+ from kaleido_cli.output import is_interactive, print_error
9
+
10
+
11
+ def resolve_optional_text(value: str | None, prompt: str, default: str = "") -> str:
12
+ if value is not None and value.strip():
13
+ return value
14
+ if is_interactive():
15
+ return typer.prompt(prompt, default=default)
16
+ return default
17
+
18
+
19
+ def resolve_required_text(value: str | None, prompt: str, option_name: str) -> str:
20
+ if value is not None:
21
+ return value
22
+ if is_interactive():
23
+ return typer.prompt(prompt)
24
+ print_error(f"{option_name} is required in non-interactive mode.")
25
+ raise typer.Exit(1)
26
+
27
+
28
+ def resolve_required_int(value: int | None, prompt: str, option_name: str) -> int:
29
+ if value is not None:
30
+ return value
31
+ if is_interactive():
32
+ return typer.prompt(prompt, type=int)
33
+ print_error(f"{option_name} is required in non-interactive mode.")
34
+ raise typer.Exit(1)
35
+
36
+
37
+ def resolve_accept_reject(accept: bool, reject: bool, prompt: str) -> bool:
38
+ """Resolve mutually exclusive accept/reject flags, prompting when interactive."""
39
+ if is_interactive() and not accept and not reject:
40
+ return typer.confirm(prompt, default=False)
41
+ if accept == reject:
42
+ print_error("Must specify exactly one of --accept or --reject")
43
+ raise typer.Exit(1)
44
+ return accept
45
+
46
+
47
+ def require_option_when_set(
48
+ required_value: object | None,
49
+ required_name: str,
50
+ **dependent_options: object | None,
51
+ ) -> None:
52
+ """Require an option when one or more dependent options were supplied."""
53
+ supplied = [name for name, value in dependent_options.items() if value is not None]
54
+ if supplied and required_value is None:
55
+ verb = "requires" if len(supplied) == 1 else "require"
56
+ print_error(f"{' and '.join(supplied)} {verb} {required_name}.")
57
+ raise typer.Exit(1)
58
+
59
+
60
+ def resolve_pair(pair: str | None) -> str:
61
+ return resolve_required_text(
62
+ pair,
63
+ "Trading pair (e.g. BTC/USDT)",
64
+ "PAIR argument",
65
+ )
66
+
67
+
68
+ def resolve_amount_pair(
69
+ from_amount: str | None,
70
+ to_amount: str | None,
71
+ *,
72
+ pair: str,
73
+ ) -> tuple[str | None, str | None]:
74
+ base_ticker, _, _ = pair.partition("/")
75
+ send_label = base_ticker or "base asset"
76
+ if from_amount is None and to_amount is None:
77
+ if is_interactive():
78
+ return typer.prompt(f"Swap amount ({send_label}, display units)"), None
79
+ print_error("Provide --from-amount or --to-amount in non-interactive mode.")
80
+ raise typer.Exit(1)
81
+ if from_amount is not None and to_amount is not None:
82
+ print_error("Provide exactly one of --from-amount or --to-amount.")
83
+ raise typer.Exit(1)
84
+ return from_amount, to_amount
85
+
86
+
87
+ def display_amount_to_raw(
88
+ value: str,
89
+ *,
90
+ precision: int | None,
91
+ asset_label: str,
92
+ option_name: str,
93
+ ) -> int:
94
+ normalized = value.strip()
95
+ if not normalized:
96
+ print_error(f"{option_name} cannot be empty.")
97
+ raise typer.Exit(1)
98
+ try:
99
+ return parse_raw_amount(normalized, precision or 0)
100
+ except ValueError as exc:
101
+ print_error(f"{option_name} for {asset_label}: {exc}")
102
+ raise typer.Exit(1)
@@ -0,0 +1,163 @@
1
+ """Shared trading-pair quote resolution and request helpers."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from dataclasses import dataclass
6
+ from typing import Any
7
+
8
+ import typer
9
+ from kaleido_sdk import (
10
+ Layer,
11
+ PairQuoteRequest,
12
+ PairQuoteResponse,
13
+ SwapLegInput,
14
+ TradingPairsResponse,
15
+ )
16
+
17
+ from kaleido_cli.output import is_interactive, print_error, print_info
18
+ from kaleido_cli.utils.pairs import (
19
+ pair_assets,
20
+ resolve_asset_id_for_layer,
21
+ resolve_pair_from_options,
22
+ resolve_quote_layers,
23
+ resolve_trading_pair,
24
+ )
25
+ from kaleido_cli.utils.prompts import display_amount_to_raw, resolve_amount_pair
26
+
27
+
28
+ @dataclass(frozen=True, slots=True)
29
+ class QuoteInputs:
30
+ pairs: TradingPairsResponse
31
+ pair: str
32
+ from_amount: str | None
33
+ to_amount: str | None
34
+ from_layer: str
35
+ to_layer: str
36
+
37
+
38
+ @dataclass(frozen=True, slots=True)
39
+ class ResolvedQuote:
40
+ inputs: QuoteInputs
41
+ quote: PairQuoteResponse
42
+
43
+
44
+ async def resolve_quote_inputs(
45
+ client: Any,
46
+ *,
47
+ pair: str | None,
48
+ from_amount: str | None,
49
+ to_amount: str | None,
50
+ from_layer: str | None,
51
+ to_layer: str | None,
52
+ ) -> QuoteInputs:
53
+ """Fetch live pairs before resolving pair, amount, and layer inputs."""
54
+ if from_amount is not None and to_amount is not None:
55
+ print_error("Provide exactly one of --from-amount or --to-amount.")
56
+ raise typer.Exit(1)
57
+
58
+ interactive = is_interactive()
59
+ if not interactive:
60
+ if pair is None:
61
+ print_error("PAIR argument is required in non-interactive mode.")
62
+ raise typer.Exit(1)
63
+ if from_amount is None and to_amount is None:
64
+ print_error("Provide --from-amount or --to-amount in non-interactive mode.")
65
+ raise typer.Exit(1)
66
+
67
+ if interactive:
68
+ print_info("Fetching available trading pairs...")
69
+ pairs: TradingPairsResponse = await client.maker.list_pairs()
70
+ resolved_pair = resolve_pair_from_options(pairs.pairs, pair)
71
+ resolved_from_amount, resolved_to_amount = resolve_amount_pair(
72
+ from_amount,
73
+ to_amount,
74
+ pair=resolved_pair,
75
+ )
76
+ resolved_from_layer, resolved_to_layer = resolve_quote_layers(
77
+ resolved_pair, from_layer, to_layer
78
+ )
79
+ return QuoteInputs(
80
+ pairs=pairs,
81
+ pair=resolved_pair,
82
+ from_amount=resolved_from_amount,
83
+ to_amount=resolved_to_amount,
84
+ from_layer=resolved_from_layer,
85
+ to_layer=resolved_to_layer,
86
+ )
87
+
88
+
89
+ def build_pair_quote_request(inputs: QuoteInputs) -> PairQuoteRequest:
90
+ """Build an SDK quote request from a validated live pair selection."""
91
+ resolved_pair = resolve_trading_pair(inputs.pairs.pairs, inputs.pair)
92
+ if not resolved_pair:
93
+ print_error(f"Pair {inputs.pair!r} not found.")
94
+ raise typer.Exit(1)
95
+
96
+ matched_pair, is_reversed = resolved_pair
97
+ from_asset, to_asset = pair_assets(matched_pair, is_reversed)
98
+ try:
99
+ from_asset_id = resolve_asset_id_for_layer(from_asset, inputs.from_layer)
100
+ to_asset_id = resolve_asset_id_for_layer(to_asset, inputs.to_layer)
101
+ except ValueError as exc:
102
+ print_error(str(exc))
103
+ raise typer.Exit(1)
104
+
105
+ resolved_from_amount = (
106
+ display_amount_to_raw(
107
+ inputs.from_amount,
108
+ precision=from_asset.precision,
109
+ asset_label=from_asset.ticker,
110
+ option_name="--from-amount",
111
+ )
112
+ if inputs.from_amount is not None
113
+ else None
114
+ )
115
+ resolved_to_amount = (
116
+ display_amount_to_raw(
117
+ inputs.to_amount,
118
+ precision=to_asset.precision,
119
+ asset_label=to_asset.ticker,
120
+ option_name="--to-amount",
121
+ )
122
+ if inputs.to_amount is not None
123
+ else None
124
+ )
125
+
126
+ return PairQuoteRequest(
127
+ from_asset=SwapLegInput(
128
+ asset_id=from_asset_id,
129
+ layer=Layer(inputs.from_layer),
130
+ amount=resolved_from_amount,
131
+ ),
132
+ to_asset=SwapLegInput(
133
+ asset_id=to_asset_id,
134
+ layer=Layer(inputs.to_layer),
135
+ amount=resolved_to_amount,
136
+ ),
137
+ )
138
+
139
+
140
+ async def fetch_pair_quote(client: Any, inputs: QuoteInputs) -> PairQuoteResponse:
141
+ """Request a quote using the shared validated request builder."""
142
+ return await client.maker.get_quote(build_pair_quote_request(inputs))
143
+
144
+
145
+ async def resolve_and_fetch_quote(
146
+ client: Any,
147
+ *,
148
+ pair: str | None,
149
+ from_amount: str | None,
150
+ to_amount: str | None,
151
+ from_layer: str | None,
152
+ to_layer: str | None,
153
+ ) -> ResolvedQuote:
154
+ """Resolve live quote inputs and fetch their quote in one shared flow."""
155
+ inputs = await resolve_quote_inputs(
156
+ client,
157
+ pair=pair,
158
+ from_amount=from_amount,
159
+ to_amount=to_amount,
160
+ from_layer=from_layer,
161
+ to_layer=to_layer,
162
+ )
163
+ return ResolvedQuote(inputs=inputs, quote=await fetch_pair_quote(client, inputs))
@@ -0,0 +1,142 @@
1
+ """Swapstring parsing and validation helpers."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from dataclasses import dataclass
6
+
7
+ from kaleido_sdk import ConfirmSwapRequest, PairQuoteResponse, SwapRequest
8
+ from kaleido_sdk import Swap as MakerSwap
9
+
10
+
11
+ @dataclass(frozen=True)
12
+ class DecodedSwapString:
13
+ """Decoded swapstring payload returned by maker and node APIs."""
14
+
15
+ from_amount: int
16
+ from_asset: str
17
+ to_amount: int
18
+ to_asset: str
19
+ expiry: int
20
+ payment_hash: str
21
+
22
+
23
+ def swap_request_from_quote(quote: PairQuoteResponse) -> SwapRequest:
24
+ """Build an atomic swap initialization request from an accepted quote."""
25
+ return SwapRequest(
26
+ rfq_id=quote.rfq_id,
27
+ from_asset=quote.from_asset.asset_id,
28
+ from_amount=quote.from_asset.amount,
29
+ to_asset=quote.to_asset.asset_id,
30
+ to_amount=quote.to_asset.amount,
31
+ )
32
+
33
+
34
+ def confirm_swap_request(
35
+ *,
36
+ swapstring: str,
37
+ taker_pubkey: str,
38
+ payment_hash: str,
39
+ ) -> ConfirmSwapRequest:
40
+ """Build an atomic swap execution request."""
41
+ return ConfirmSwapRequest(
42
+ swapstring=swapstring,
43
+ taker_pubkey=taker_pubkey,
44
+ payment_hash=payment_hash,
45
+ )
46
+
47
+
48
+ def _normalize_asset_identifier(value: str) -> str:
49
+ """Normalize native asset tickers while preserving case-sensitive asset IDs."""
50
+ normalized = value.strip()
51
+ if ":" in normalized:
52
+ return normalized
53
+ return normalized.upper()
54
+
55
+
56
+ def decode_swapstring(swapstring: str) -> DecodedSwapString:
57
+ """Parse a swapstring into its component fields."""
58
+ parts = [part.strip() for part in swapstring.split("/")]
59
+ if len(parts) != 6:
60
+ raise ValueError("Swapstring must contain 6 slash-separated fields.")
61
+ if any(part == "" for part in parts):
62
+ raise ValueError("Swapstring fields must not be empty or whitespace.")
63
+
64
+ from_amount, from_asset, to_amount, to_asset, expiry, payment_hash = parts
65
+ try:
66
+ return DecodedSwapString(
67
+ from_amount=int(from_amount),
68
+ from_asset=from_asset,
69
+ to_amount=int(to_amount),
70
+ to_asset=to_asset,
71
+ expiry=int(expiry),
72
+ payment_hash=payment_hash,
73
+ )
74
+ except ValueError as exc:
75
+ raise ValueError("Swapstring contains invalid numeric fields.") from exc
76
+
77
+
78
+ def validate_swapstring_against_quote(
79
+ decoded: DecodedSwapString,
80
+ quote: PairQuoteResponse,
81
+ *,
82
+ payment_hash: str | None = None,
83
+ ) -> None:
84
+ """Ensure a swapstring matches the accepted quote and payment hash."""
85
+ if _normalize_asset_identifier(decoded.from_asset) != _normalize_asset_identifier(
86
+ quote.from_asset.asset_id
87
+ ):
88
+ raise ValueError(
89
+ f"Swapstring from_asset {decoded.from_asset!r} does not match quote asset {quote.from_asset.asset_id!r}."
90
+ )
91
+ if _normalize_asset_identifier(decoded.to_asset) != _normalize_asset_identifier(
92
+ quote.to_asset.asset_id
93
+ ):
94
+ raise ValueError(
95
+ f"Swapstring to_asset {decoded.to_asset!r} does not match quote asset {quote.to_asset.asset_id!r}."
96
+ )
97
+ if decoded.from_amount != quote.from_asset.amount:
98
+ raise ValueError(
99
+ f"Swapstring from_amount {decoded.from_amount} does not match quote amount {quote.from_asset.amount}."
100
+ )
101
+ if decoded.to_amount != quote.to_asset.amount:
102
+ raise ValueError(
103
+ f"Swapstring to_amount {decoded.to_amount} does not match quote amount {quote.to_asset.amount}."
104
+ )
105
+ if payment_hash is not None and decoded.payment_hash != payment_hash:
106
+ raise ValueError(
107
+ f"Swapstring payment_hash {decoded.payment_hash!r} does not match expected payment hash {payment_hash!r}."
108
+ )
109
+
110
+
111
+ def validate_swapstring_against_swap(
112
+ decoded: DecodedSwapString,
113
+ swap: MakerSwap,
114
+ *,
115
+ payment_hash: str | None = None,
116
+ ) -> None:
117
+ """Ensure a swapstring matches the maker's recorded swap payload."""
118
+ if swap.from_asset is not None and _normalize_asset_identifier(
119
+ decoded.from_asset
120
+ ) != _normalize_asset_identifier(swap.from_asset):
121
+ raise ValueError(
122
+ f"Swapstring from_asset {decoded.from_asset!r} does not match maker swap asset {swap.from_asset!r}."
123
+ )
124
+ if swap.to_asset is not None and _normalize_asset_identifier(
125
+ decoded.to_asset
126
+ ) != _normalize_asset_identifier(swap.to_asset):
127
+ raise ValueError(
128
+ f"Swapstring to_asset {decoded.to_asset!r} does not match maker swap asset {swap.to_asset!r}."
129
+ )
130
+ if decoded.from_amount != swap.qty_from:
131
+ raise ValueError(
132
+ f"Swapstring from_amount {decoded.from_amount} does not match maker swap amount {swap.qty_from}."
133
+ )
134
+ if decoded.to_amount != swap.qty_to:
135
+ raise ValueError(
136
+ f"Swapstring to_amount {decoded.to_amount} does not match maker swap amount {swap.qty_to}."
137
+ )
138
+ expected_payment_hash = payment_hash or swap.payment_hash
139
+ if decoded.payment_hash != expected_payment_hash:
140
+ raise ValueError(
141
+ f"Swapstring payment_hash {decoded.payment_hash!r} does not match expected payment hash {expected_payment_hash!r}."
142
+ )