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.
- kaleido_cli/__init__.py +3 -0
- kaleido_cli/__main__.py +6 -0
- kaleido_cli/app.py +204 -0
- kaleido_cli/commands/__init__.py +1 -0
- kaleido_cli/commands/asset.py +850 -0
- kaleido_cli/commands/channel.py +855 -0
- kaleido_cli/commands/config_cmd.py +113 -0
- kaleido_cli/commands/market.py +241 -0
- kaleido_cli/commands/node.py +874 -0
- kaleido_cli/commands/node_swap.py +274 -0
- kaleido_cli/commands/payment.py +364 -0
- kaleido_cli/commands/peer.py +108 -0
- kaleido_cli/commands/swap.py +460 -0
- kaleido_cli/commands/wallet.py +487 -0
- kaleido_cli/config.py +88 -0
- kaleido_cli/context.py +41 -0
- kaleido_cli/docker_manager.py +463 -0
- kaleido_cli/onboarding.py +275 -0
- kaleido_cli/output.py +123 -0
- kaleido_cli/utils/__init__.py +1 -0
- kaleido_cli/utils/assets.py +40 -0
- kaleido_cli/utils/channel_orders.py +822 -0
- kaleido_cli/utils/errors.py +17 -0
- kaleido_cli/utils/pairs.py +133 -0
- kaleido_cli/utils/prompts.py +102 -0
- kaleido_cli/utils/quotes.py +163 -0
- kaleido_cli/utils/swaps.py +142 -0
- kaleido_cli-0.1.2.dist-info/METADATA +416 -0
- kaleido_cli-0.1.2.dist-info/RECORD +32 -0
- kaleido_cli-0.1.2.dist-info/WHEEL +4 -0
- kaleido_cli-0.1.2.dist-info/entry_points.txt +2 -0
- kaleido_cli-0.1.2.dist-info/licenses/LICENSE +21 -0
|
@@ -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
|
+
)
|