From 90e57728f8af67f11a9d4b651042579a9784f623 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 01:35:45 +0400 Subject: [PATCH 01/31] Add WASM cryptography module (port of go-sdk/wasm) Full port of the Go SDK's wasm-bindgen host shim to wasmtime-py: - all 31 host imports from './wasm_wrappers_bg.js' (RNG via os.urandom, JSON serde round-trip for TxAdditionalInfo, error side-channel capture, externref table index arrays with callee-ownership-correct cleanup) - vendored wasm_wrappers_bg.wasm with load-time sha256 pinning - complete API surface: key derivation, addresses, ids, inputs/outputs encoding, timelocks, fees, transactions, witnesses/signing, staking, intents (78 public methods across 11 area mixins) - byte-for-byte parity with the Go SDK verified (deterministic mnemonic derivation, addresses, fees, timelocks, spend maturity) - result buffers zeroed before free; thread-safe via RLock + @synchronized - ruff + mypy clean --- .gitignore | 14 + mintlayer/__init__.py | 7 + mintlayer/wasm/__init__.py | 68 ++++ mintlayer/wasm/_core.py | 407 ++++++++++++++++++++ mintlayer/wasm/_util.py | 25 ++ mintlayer/wasm/addresses.py | 40 ++ mintlayer/wasm/client.py | 41 ++ mintlayer/wasm/fees.py | 45 +++ mintlayer/wasm/host.py | 327 ++++++++++++++++ mintlayer/wasm/ids.py | 39 ++ mintlayer/wasm/inputs.py | 178 +++++++++ mintlayer/wasm/intent.py | 72 ++++ mintlayer/wasm/keys.py | 59 +++ mintlayer/wasm/outputs.py | 322 ++++++++++++++++ mintlayer/wasm/signing.py | 231 +++++++++++ mintlayer/wasm/staking.py | 71 ++++ mintlayer/wasm/timelocks.py | 28 ++ mintlayer/wasm/transactions.py | 189 +++++++++ mintlayer/wasm/types.py | 193 ++++++++++ mintlayer/wasm/wasm_wrappers_bg.wasm | Bin 0 -> 3585770 bytes mintlayer/wasm/wasm_wrappers_bg.wasm.sha256 | 1 + pyproject.toml | 19 +- 22 files changed, 2373 insertions(+), 3 deletions(-) create mode 100644 mintlayer/__init__.py create mode 100644 mintlayer/wasm/__init__.py create mode 100644 mintlayer/wasm/_core.py create mode 100644 mintlayer/wasm/_util.py create mode 100644 mintlayer/wasm/addresses.py create mode 100644 mintlayer/wasm/client.py create mode 100644 mintlayer/wasm/fees.py create mode 100644 mintlayer/wasm/host.py create mode 100644 mintlayer/wasm/ids.py create mode 100644 mintlayer/wasm/inputs.py create mode 100644 mintlayer/wasm/intent.py create mode 100644 mintlayer/wasm/keys.py create mode 100644 mintlayer/wasm/outputs.py create mode 100644 mintlayer/wasm/signing.py create mode 100644 mintlayer/wasm/staking.py create mode 100644 mintlayer/wasm/timelocks.py create mode 100644 mintlayer/wasm/transactions.py create mode 100644 mintlayer/wasm/types.py create mode 100644 mintlayer/wasm/wasm_wrappers_bg.wasm create mode 100644 mintlayer/wasm/wasm_wrappers_bg.wasm.sha256 diff --git a/.gitignore b/.gitignore index f4c91a2..4a542a9 100644 --- a/.gitignore +++ b/.gitignore @@ -9,5 +9,19 @@ build/ .ruff_cache/ .pytest_cache/ .coverage +htmlcov/ .wrangler/ uv.lock + +# secrets +.env* +*.pem +*.key +*.seed +*.env +*.p12 +*.pfx +id_rsa* +id_ed25519* +id_ecdsa* +secrets/ diff --git a/mintlayer/__init__.py b/mintlayer/__init__.py new file mode 100644 index 0000000..d02cbcc --- /dev/null +++ b/mintlayer/__init__.py @@ -0,0 +1,7 @@ +"""Mintlayer Python SDK: node, indexer, and wallet clients plus WASM cryptography.""" + +from __future__ import annotations + +__version__ = "0.1.0" + +__all__ = ["__version__"] diff --git a/mintlayer/wasm/__init__.py b/mintlayer/wasm/__init__.py new file mode 100644 index 0000000..212b082 --- /dev/null +++ b/mintlayer/wasm/__init__.py @@ -0,0 +1,68 @@ +"""Mintlayer WASM cryptography and transaction-building client. + +Mirrors go-sdk/wasm (Go package ``mintlayer``). Instantiates the embedded +wasm-bindgen module via wasmtime and exposes key derivation, address encoding, +transaction building, signing and fee queries. +""" + +from __future__ import annotations + +from .client import Client +from .types import ( + Amount, + CurrencyAmountKind, + FreezableToken, + Network, + OrderBalance, + OrderInfo, + PoolInfo, + SignatureHashType, + SimpleCurrencyAmount, + SourceId, + TokenUnfreezable, + TotalSupply, + TxAdditionalInfo, + WasmError, +) + +# Convenience aliases matching the Go SDK's constant names. +MAINNET = Network.MAINNET +TESTNET = Network.TESTNET +REGTEST = Network.REGTEST +SIGNET = Network.SIGNET + +SIGHASH_ALL = SignatureHashType.SIGHASH_ALL +SIGHASH_NONE = SignatureHashType.SIGHASH_NONE +SIGHASH_SINGLE = SignatureHashType.SIGHASH_SINGLE +SIGHASH_ANYONECANPAY = SignatureHashType.SIGHASH_ANYONECANPAY + +SOURCE_TRANSACTION = SourceId.SOURCE_TRANSACTION +SOURCE_BLOCK_REWARD = SourceId.SOURCE_BLOCK_REWARD + +__all__ = [ + "Client", + "Amount", + "Network", + "MAINNET", + "TESTNET", + "REGTEST", + "SIGNET", + "SignatureHashType", + "SIGHASH_ALL", + "SIGHASH_NONE", + "SIGHASH_SINGLE", + "SIGHASH_ANYONECANPAY", + "SourceId", + "SOURCE_TRANSACTION", + "SOURCE_BLOCK_REWARD", + "TotalSupply", + "FreezableToken", + "TokenUnfreezable", + "CurrencyAmountKind", + "SimpleCurrencyAmount", + "OrderBalance", + "OrderInfo", + "PoolInfo", + "TxAdditionalInfo", + "WasmError", +] diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py new file mode 100644 index 0000000..0991d79 --- /dev/null +++ b/mintlayer/wasm/_core.py @@ -0,0 +1,407 @@ +"""Core WASM machinery shared by all method mixins. + +:class:`~mintlayer.wasm.client.Client` combines this core with the per-area +method mixins (keys, addresses, transactions, ...). + +Key material in memory: result buffers carrying private keys, derived keys and +signatures are zeroed before being released, but input buffers and WASM-side +intermediate copies of secrets persist in WASM linear memory until the +allocator reuses them (inherited from the wasm-bindgen design; the host cannot +reach them). Treat the process memory of a long-lived ``Client`` as sensitive. +""" + +from __future__ import annotations + +import contextlib +import hashlib +import threading +from pathlib import Path +from typing import Any + +from wasmtime import Engine, Instance, Linker, Memory, Module, Store, Table + +from .types import Amount, WasmError + +_WASM_PATH = Path(__file__).parent / "wasm_wrappers_bg.wasm" +_WASM_BYTES = _WASM_PATH.read_bytes() + + +def _verify_wasm_integrity() -> None: + """Fail closed if the vendored WASM binary does not match its pinned hash.""" + pin_path = _WASM_PATH.with_suffix(".wasm.sha256") + expected = pin_path.read_text().split()[0].strip() + actual = hashlib.sha256(_WASM_BYTES).hexdigest() + if actual != expected: + raise WasmError( + f"mintlayer: WASM binary integrity check failed " + f"(expected sha256 {expected}, got {actual})" + ) + + +_verify_wasm_integrity() + + +class _CallState: + """Per-call side channel populated by host functions.""" + + __slots__ = ("err_msg", "last_json") + + def __init__(self) -> None: + self.err_msg: str = "" + self.last_json: bytearray | None = None + + def reset(self) -> None: + self.err_msg = "" + self.last_json = None + + +class _WasmCore: + """Core WASM machinery: lifecycle, call conventions and memory helpers.""" + + def __init__(self) -> None: + self.lock = threading.RLock() + self.call_state = _CallState() + self._last_err_msg = "" + self._last_json: bytearray | None = None + + engine = Engine() + self._engine = engine + self.store = Store(engine) + self._module = Module(engine, _WASM_BYTES) + linker = Linker(engine) + + from .host import register_host_functions + + register_host_functions(self, linker) + + instance = linker.instantiate(self.store, self._module) + self._instance: Instance | None = instance + + raw_exports = instance.exports(self.store) + exports = {name: raw_exports[name] for name in raw_exports} + self._exports = exports + memory = exports.get("memory") + if not isinstance(memory, Memory): + raise WasmError("mintlayer: memory export not found") + self.memory: Memory = memory + table = exports.get("__wbindgen_externrefs") + if not isinstance(table, Table): + raise WasmError("mintlayer: __wbindgen_externrefs table not found") + self.table: Table = table + + # ── lifecycle ──────────────────────────────────────────────────────────── + + def close(self) -> None: + """Release WASM resources. Subsequent calls raise.""" + with self.lock: + self._instance = None + self._exports = {} + self.memory = None # type: ignore[assignment] + self.table = None # type: ignore[assignment] + + def __enter__(self) -> _WasmCore: + return self + + def __exit__(self, *_exc: object) -> None: + self.close() + + # ── export lookup ──────────────────────────────────────────────────────── + + def get_export(self, name: str) -> Any: + return self._exports.get(name) + + def _fn(self, name: str) -> Any: + fn = self._exports.get(name) + if fn is None: + if self._instance is None: + raise WasmError("mintlayer: client is closed") + raise WasmError(f'mintlayer: function "{name}" not found') + return fn + + # ── low-level call ─────────────────────────────────────────────────────── + + def _call(self, name: str, *params: Any) -> list: + """Execute a WASM export and return the raw results.""" + self._last_err_msg = "" + self._last_json = None + self.call_state.reset() + fn = self._fn(name) + try: + res = fn(self.store, *params) + except Exception as exc: + # WasmThrow (from the host's __wbindgen_throw) and traps land here. + if self.call_state.err_msg: + raise WasmError(f"mintlayer: {self.call_state.err_msg}") from None + raise WasmError(f"mintlayer: call {name}: {exc}") from None + self._last_err_msg = self.call_state.err_msg + self._last_json = self.call_state.last_json + # Func.__call__ returns None / scalar / list depending on result count. + if res is None: + return [] + if not isinstance(res, list): + return [res] + return res + + def _extract_error(self, err_idx: int) -> WasmError: + if self._last_err_msg: + return WasmError(f"mintlayer: {self._last_err_msg}") + return WasmError(f"mintlayer: wasm returned error (ref={err_idx})") + + # ── call-return conventions ────────────────────────────────────────────── + + def _call_return_bytes(self, name: str, *params: Any) -> bytes: + """fn expects [ptr, len, errRef, errFlag].""" + ret = self._call(name, *params) + if len(ret) >= 4 and ret[3] != 0: + raise self._extract_error(ret[2]) + if len(ret) < 2: + raise WasmError(f"mintlayer: unexpected return count from {name}") + ptr, length = ret[0], ret[1] + if length == 0: + return b"" + data = self._read_bytes(ptr, length) + if data is None: + raise WasmError("mintlayer: memory read failed") + with contextlib.suppress(Exception): + self.memory.write(self.store, b"\x00" * length, ptr) + self._free_wasm(ptr, length) + return bytes(data) + + def _call_return_bytes_no_err(self, name: str, *params: Any) -> bytes: + """fn expects [ptr, len] (infallible).""" + ret = self._call(name, *params) + if len(ret) < 2: + raise WasmError(f"mintlayer: unexpected return count from {name}") + ptr, length = ret[0], ret[1] + if length == 0: + return b"" + data = self._read_bytes(ptr, length) + if data is None: + raise WasmError("mintlayer: memory read failed") + with contextlib.suppress(Exception): + self.memory.write(self.store, b"\x00" * length, ptr) + self._free_wasm(ptr, length) + return bytes(data) + + def _call_return_string(self, name: str, *params: Any) -> str: + """fn expects [ptr, len, errRef, errFlag]; result is UTF-8.""" + ret = self._call(name, *params) + if len(ret) >= 4 and ret[3] != 0: + raise self._extract_error(ret[2]) + if len(ret) < 2: + raise WasmError(f"mintlayer: unexpected return count from {name}") + ptr, length = ret[0], ret[1] + data = self._read_bytes(ptr, length) + if data is None: + raise WasmError("mintlayer: memory read failed") + with contextlib.suppress(Exception): + self.memory.write(self.store, b"\x00" * length, ptr) + self._free_wasm(ptr, length) + return bytes(data).decode("utf-8") + + def _call_return_bool(self, name: str, *params: Any) -> bool: + """fn expects [bool, errRef, errFlag].""" + ret = self._call(name, *params) + if len(ret) >= 3 and ret[2] != 0: + raise self._extract_error(ret[1]) + return ret[0] != 0 + + def _call_return_u32(self, name: str, *params: Any) -> int: + """fn expects [u32, errRef, errFlag].""" + ret = self._call(name, *params) + if len(ret) >= 3 and ret[2] != 0: + raise self._extract_error(ret[1]) + return ret[0] & 0xFFFFFFFF + + def _call_return_u64(self, name: str, *params: Any) -> int: + """fn expects [u64, errRef, errFlag].""" + ret = self._call(name, *params) + if len(ret) >= 3 and ret[2] != 0: + raise self._extract_error(ret[1]) + return ret[0] & 0xFFFFFFFFFFFFFFFF + + def _call_return_amount(self, name: str, *params: Any) -> Amount: + """fn returns a single Amount pointer (infallible).""" + ret = self._call(name, *params) + if len(ret) == 0: + raise WasmError(f"mintlayer: no return value from {name}") + return self._read_amount(ret[0]) + + def _call_return_amount_fallible(self, name: str, *params: Any) -> Amount: + """fn expects [amtPtr, errRef, errFlag].""" + ret = self._call(name, *params) + if len(ret) >= 3 and ret[2] != 0: + raise self._extract_error(ret[1]) + if len(ret) == 0: + raise WasmError(f"mintlayer: no return value from {name}") + return self._read_amount(ret[0]) + + def _call_void_fallible(self, name: str, *params: Any) -> None: + """fn expects [errRef, errFlag] (void on success).""" + ret = self._call(name, *params) + if len(ret) >= 2 and ret[1] != 0: + raise self._extract_error(ret[0]) + + def _call_return_json(self, name: str, *params: Any) -> bytes: + """fn returns a JSON object captured by the host's JSON.parse.""" + ret = self._call(name, *params) + if len(ret) >= 3 and ret[2] != 0: + raise self._extract_error(ret[1]) + if self._last_json is not None: + return bytes(self._last_json) + raise WasmError(f"mintlayer: no JSON result from {name}") + + # ── memory helpers ─────────────────────────────────────────────────────── + + def _read_bytes(self, ptr: int, length: int) -> bytearray | None: + return self.memory.read(self.store, ptr, ptr + length) + + def _write_bytes(self, data: bytes) -> tuple[int, int]: + """Copy ``data`` into WASM heap; returns (ptr, len). Caller frees.""" + if not data: + return 0, 0 + ptr = self._invoke1("__wbindgen_malloc", len(data), 1) + if self.memory.write(self.store, data, ptr) is None: + raise WasmError("mintlayer: memory write failed") + return ptr, len(data) + + def _write_string(self, s: str) -> tuple[int, int]: + return self._write_bytes(s.encode("utf-8")) + + def _free_wasm(self, ptr: int, size: int, align: int = 1) -> None: + if ptr == 0: + return + with contextlib.suppress(Exception): + self._fn("__wbindgen_free")(self.store, ptr, size, align) + + def _write_optional_string(self, s: str | None) -> tuple[int, int]: + if s is None: + return 0, 0 + return self._write_string(s) + + def _write_optional_bytes(self, b: bytes | None) -> tuple[int, int]: + if b is None: + return 0, 0 + return self._write_bytes(b) + + def _new_wasm_amount(self, amount: Amount) -> int: + """Allocate an Amount in the WASM heap and return its handle. + + ``amount_from_atoms`` takes ownership of the string allocation, so the + string is NOT freed here. + """ + str_ptr, str_len = self._write_string(amount.atoms) + try: + return self._invoke1("amount_from_atoms", str_ptr, str_len) + except WasmError: + self._free_wasm(str_ptr, str_len) + raise + + def _read_amount(self, wasm_ptr: int) -> Amount: + """Read the atom string from a WASM Amount handle (consumes it).""" + ret = self._call_export("amount_atoms", wasm_ptr) + if len(ret) < 2: + raise WasmError("mintlayer: amount_atoms failed") + ptr, length = ret[0], ret[1] + data = self._read_bytes(ptr, length) + if data is None: + raise WasmError("mintlayer: memory read for amount failed") + atoms = data.decode("utf-8") + self._free_wasm(ptr, length) + return Amount.from_atoms(atoms) + + # ── externref-index arrays (passArrayJsValueToWasm0 pattern) ───────────── + # + # Ownership: the WASM callee takes ownership of BOTH the index array and + # the Uint8Array backing buffers during the call. Host-side cleanup must + # therefore only release the externref table slots (exactly once each) and + # must never re-read or free the array memory after the call. + + def _write_string_array(self, strs: list[str]) -> tuple[int, list[int]]: + """Write ``[string]`` as an array of externref table indices. + + Returns (array_ptr, table_indices). Release the table slots with + :meth:`_dealloc_indices` after the call; the array itself is owned by + the callee (passArrayJsValueToWasm0 ownership transfer). + """ + indices: list[int] = [] + if not strs: + return 0, indices + arr_ptr = self._malloc_array(len(strs)) + try: + for i, s in enumerate(strs): + idx = self._invoke1("__externref_table_alloc") + indices.append(idx) + self.table.set(self.store, idx, s) + self.memory.write(self.store, idx.to_bytes(4, "little"), arr_ptr + i * 4) + except BaseException: + self._dealloc_indices(indices) + with contextlib.suppress(Exception): + self._fn("__wbindgen_free")(self.store, arr_ptr, len(strs) * 4, 4) + raise + return arr_ptr, indices + + def _write_uint8_array_array( + self, slices: list[bytes] + ) -> tuple[int, list[int], list[tuple[int, int]]]: + """Write ``[bytes]`` as an array of externref table indices. + + Each slice is copied into WASM heap and wrapped as a Uint8Array. + Returns (array_ptr, table_indices, backing_buffers). Release the table + slots with :meth:`_dealloc_indices` and free the backing buffers + (host-side) after the call: the callee copies the bytes and never + frees the originals; the index array itself is callee-owned. + """ + from .host import Uint8ArrayRef + + indices: list[int] = [] + buffers: list[tuple[int, int]] = [] + if not slices: + return 0, indices, buffers + arr_ptr = self._malloc_array(len(slices)) + try: + for i, b in enumerate(slices): + wasm_ptr, wasm_len = self._write_bytes(b) + buffers.append((wasm_ptr, wasm_len)) + idx = self._invoke1("__externref_table_alloc") + indices.append(idx) + self.table.set(self.store, idx, Uint8ArrayRef(wasm_ptr, wasm_len)) + self.memory.write(self.store, idx.to_bytes(4, "little"), arr_ptr + i * 4) + except BaseException: + self._dealloc_indices(indices) + for ptr, length in buffers: + self._free_wasm(ptr, length) + with contextlib.suppress(Exception): + self._fn("__wbindgen_free")(self.store, arr_ptr, len(slices) * 4, 4) + raise + return arr_ptr, indices, buffers + + def _malloc_array(self, count: int) -> int: + return self._invoke1("__wbindgen_malloc", count * 4, 4) + + def _call_export(self, name: str, *params: Any) -> list: + """Call a WASM export, normalising the result to a list.""" + res = self._fn(name)(self.store, *params) + if res is None: + return [] + if not isinstance(res, list): + return [res] + return res + + def _invoke1(self, name: str, *params: Any) -> int: + """Call a WASM export returning exactly one i32/i64 result.""" + ret = self._call_export(name, *params) + if len(ret) != 1: + raise WasmError(f"mintlayer: {name} returned {len(ret)} results") + return ret[0] + + def _dealloc_indices(self, indices: list[int]) -> None: + """Release externref table slots (exactly once per slot).""" + if not indices: + return + dealloc = self.get_export("__externref_table_dealloc") + if dealloc is None: + return + for idx in indices: + with contextlib.suppress(Exception): + dealloc(self.store, idx) diff --git a/mintlayer/wasm/_util.py b/mintlayer/wasm/_util.py new file mode 100644 index 0000000..0b5d48b --- /dev/null +++ b/mintlayer/wasm/_util.py @@ -0,0 +1,25 @@ +"""Shared helpers for public WASM client methods.""" + +from __future__ import annotations + +import functools +from collections.abc import Callable +from typing import Any, TypeVar + +F = TypeVar("F", bound=Callable[..., Any]) + + +def synchronized(method: F) -> F: + """Serialise a public method so the single WASM instance is never shared.""" + + @functools.wraps(method) + def wrapper(self: Any, *args: Any, **kwargs: Any) -> Any: + with self.lock: + return method(self, *args, **kwargs) + + return wrapper # type: ignore[return-value] + + +def bool_to_int(b: bool) -> int: + """Encode a Python bool as the WASM ABI's 0/1.""" + return 1 if b else 0 diff --git a/mintlayer/wasm/addresses.py b/mintlayer/wasm/addresses.py new file mode 100644 index 0000000..07ebefc --- /dev/null +++ b/mintlayer/wasm/addresses.py @@ -0,0 +1,40 @@ +"""Address encoding (mirrors go-sdk/wasm/addresses.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Network + + +class AddressesMixin(_WasmCore): + @synchronized + def encode_destination(self, address: str, network: Network) -> bytes: + """Encode a bech32m address string into a binary destination.""" + ptr, length = self._write_string(address) + return self._call_return_bytes("encode_destination", ptr, length, int(network)) + + @synchronized + def pubkey_to_pubkeyhash_address(self, pubkey: bytes, network: Network) -> str: + """Derive a pay-to-public-key-hash bech32m address.""" + ptr, length = self._write_bytes(pubkey) + return self._call_return_string("pubkey_to_pubkeyhash_address", ptr, length, int(network)) + + @synchronized + def encode_multisig_challenge( + self, pubkeys: bytes, min_required_signatures: int, network: Network + ) -> bytes: + """Encode a multisig challenge (script) into binary. + + ``pubkeys`` is the concatenation of encoded public keys. + """ + ptr, length = self._write_bytes(pubkeys) + return self._call_return_bytes( + "encode_multisig_challenge", ptr, length, min_required_signatures, int(network) + ) + + @synchronized + def multisig_challenge_to_address(self, challenge: bytes, network: Network) -> str: + """Convert a binary multisig challenge into its bech32m address.""" + ptr, length = self._write_bytes(challenge) + return self._call_return_string("multisig_challenge_to_address", ptr, length, int(network)) diff --git a/mintlayer/wasm/client.py b/mintlayer/wasm/client.py new file mode 100644 index 0000000..c0134a2 --- /dev/null +++ b/mintlayer/wasm/client.py @@ -0,0 +1,41 @@ +"""WASM cryptography and transaction-building client. + +Mirrors go-sdk/wasm/client.go: instantiates the embedded ``wasm_wrappers_bg`` +module with a wasm-bindgen host shim and exposes the full API surface as +methods. The core machinery lives in :mod:`mintlayer.wasm._core`; the per-area +method groups (keys, addresses, …) are mixins, combined here into ``Client``. +""" + +from __future__ import annotations + +from .addresses import AddressesMixin +from .fees import FeesMixin +from .ids import IdsMixin +from .inputs import InputsMixin +from .intent import IntentMixin +from .keys import KeysMixin +from .outputs import OutputsMixin +from .signing import SigningMixin +from .staking import StakingMixin +from .timelocks import TimelocksMixin +from .transactions import TransactionsMixin + + +class Client( + KeysMixin, + AddressesMixin, + IdsMixin, + InputsMixin, + OutputsMixin, + TimelocksMixin, + FeesMixin, + TransactionsMixin, + SigningMixin, + StakingMixin, + IntentMixin, +): + """Provides access to all Mintlayer WASM functions. + + A ``Client`` is safe for concurrent use from multiple threads; every + public method serialises access to the single WASM instance. + """ diff --git a/mintlayer/wasm/fees.py b/mintlayer/wasm/fees.py new file mode 100644 index 0000000..0be9059 --- /dev/null +++ b/mintlayer/wasm/fees.py @@ -0,0 +1,45 @@ +"""Fee queries (mirrors go-sdk/wasm/fees.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Amount, Network + + +class FeesMixin(_WasmCore): + @synchronized + def fungible_token_issuance_fee(self, current_block_height: int, network: Network) -> Amount: + """Fee required to issue a new fungible token at the given block height.""" + return self._call_return_amount( + "fungible_token_issuance_fee", current_block_height, int(network) + ) + + @synchronized + def nft_issuance_fee(self, current_block_height: int, network: Network) -> Amount: + """Fee required to issue a new NFT at the given block height.""" + return self._call_return_amount("nft_issuance_fee", current_block_height, int(network)) + + @synchronized + def data_deposit_fee(self, current_block_height: int, network: Network) -> Amount: + """Fee required to create a DataDeposit output at the given block height.""" + return self._call_return_amount("data_deposit_fee", current_block_height, int(network)) + + @synchronized + def token_supply_change_fee(self, current_block_height: int, network: Network) -> Amount: + """Fee required to mint or unmint tokens at the given block height.""" + return self._call_return_amount( + "token_supply_change_fee", current_block_height, int(network) + ) + + @synchronized + def token_freeze_fee(self, current_block_height: int, network: Network) -> Amount: + """Fee required to freeze or unfreeze a token at the given block height.""" + return self._call_return_amount("token_freeze_fee", current_block_height, int(network)) + + @synchronized + def token_change_authority_fee(self, current_block_height: int, network: Network) -> Amount: + """Fee required to change a token's authority at the given block height.""" + return self._call_return_amount( + "token_change_authority_fee", current_block_height, int(network) + ) diff --git a/mintlayer/wasm/host.py b/mintlayer/wasm/host.py new file mode 100644 index 0000000..db87750 --- /dev/null +++ b/mintlayer/wasm/host.py @@ -0,0 +1,327 @@ +"""Host module for the embedded WASM module. + +The WASM binary imports all host functions from the module +``"./wasm_wrappers_bg.js"`` (the wasm-bindgen JS glue). This module implements +those 31 imports natively for wasmtime, mirroring go-sdk/wasm/host.go: + +* random number generation (``os.urandom``) feeds key generation and signing, +* JSON round-tripping implements the tsify/serde ``TxAdditionalInfo`` path, +* error strings are captured per call via a side channel (``cast_...2`` / + ``__wbindgen_throw``) instead of being read from the externref table. + +Externref values are real Python objects; ``None`` represents the null/undefined +externref (registry handle 0 in the Go SDK). +""" + +from __future__ import annotations + +import json +import os +from typing import TYPE_CHECKING, Any + +from wasmtime import Func, FuncType, Linker, ValType + +if TYPE_CHECKING: + from ._core import _WasmCore + +HOST_MODULE = "./wasm_wrappers_bg.js" + +_I32 = ValType.i32() +_ANYREF = ValType.externref() + + +class _GlobalSentinel: + """Represents JavaScript ``globalThis``.""" + + +class _CryptoSentinel: + """Represents the ``crypto`` object on globalThis.""" + + +class Uint8ArrayRef: + """A JS Uint8Array whose backing store lives in WASM linear memory.""" + + __slots__ = ("ptr", "length") + + def __init__(self, ptr: int, length: int) -> None: + self.ptr = ptr + self.length = length + + +class FunctionSentinel: + """A JS function created via ``new Function(code)``.""" + + __slots__ = ("code",) + + def __init__(self, code: str) -> None: + self.code = code + + +GLOBAL = _GlobalSentinel() +CRYPTO = _CryptoSentinel() + + +class WasmThrow(Exception): + """Raised by ``__wbindgen_throw`` to abort the current WASM invocation.""" + + +def _json_dumps(value: Any) -> str: + """Serialise a host value to JSON, honouring SDK types (serde shape).""" + if hasattr(value, "to_json_value"): + value = value.to_json_value() + return json.dumps(value, separators=(",", ":")) + + +def register_host_functions(client: _WasmCore, linker: Linker) -> None: + """Define the 31 host imports on ``linker`` for ``client``'s store.""" + store = client.store + state = client.call_state + + def invoke(fn_name: str, *args: Any) -> list: + """Call a WASM export from within a host function; results as list.""" + fn = client.get_export(fn_name) + if fn is None: + raise WasmThrow(f"{fn_name} not found") + res = fn(store, *args) + if res is None: + return [] + if not isinstance(res, list): + return [res] + return res + + def alloc_table_slot(value: Any) -> int: + """Allocate an externref-table slot, store ``value`` in it, return the index.""" + idx = invoke("__externref_table_alloc")[0] + client.table.set(store, idx, value) + return idx + + def signal_exception(msg: str) -> None: + """Mirror JS ``handleError``: stash the exception so WASM returns Err.""" + if client.get_export("__externref_table_alloc") is None: + return + if client.get_export("__wbindgen_exn_store") is None: + return + idx = invoke("__externref_table_alloc")[0] + invoke("__wbindgen_exn_store", idx) + + def write_string_to_mem(out_ptr: int, s: str) -> None: + """Write (ptr, len) of ``s`` as two LE u32s at ``out_ptr``.""" + zeros = (0).to_bytes(4, "little") + data = s.encode() + if not data: + client.memory.write(store, zeros, out_ptr) + client.memory.write(store, zeros, out_ptr + 4) + return + ptr = invoke("__wbindgen_malloc", len(data), 1)[0] + client.memory.write(store, data, ptr) + client.memory.write(store, ptr.to_bytes(4, "little"), out_ptr) + client.memory.write(store, len(data).to_bytes(4, "little"), out_ptr + 4) + + def fill_random(buf: Any) -> None: + if not isinstance(buf, Uint8ArrayRef): + signal_exception("fillRandom: expected Uint8Array") + return + data = os.urandom(buf.length) + client.memory.write(store, data, buf.ptr) + + def debug_string(value: Any) -> str: + if value is None: + return "undefined" + if isinstance(value, str): + return json.dumps(value) + if isinstance(value, Uint8ArrayRef): + return f"Uint8Array({value.length})" + if isinstance(value, _GlobalSentinel): + return "[object global]" + if isinstance(value, _CryptoSentinel): + return "[object Crypto]" + if isinstance(value, FunctionSentinel): + return f"function {value.code}" + return _json_dumps(value) + + def def_func(name: str, params: list, results: list, func: Any) -> None: + linker.define(store, HOST_MODULE, name, Func(store, FuncType(params, results), func)) + + # ── global accessors: () -> i32 (externref table index) ────────────────── + def _global_accessor() -> int: + return alloc_table_slot(GLOBAL) + + def _null_accessor() -> int: + return 0 + + def_func("__wbg_static_accessor_GLOBAL_12837167ad935116", [], [_I32], _global_accessor) + def_func("__wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f", [], [_I32], _global_accessor) + def_func("__wbg_static_accessor_SELF_a621d3dfbb60d0ce", [], [_I32], _null_accessor) + def_func("__wbg_static_accessor_WINDOW_f8727f0cf888e0bd", [], [_I32], _null_accessor) + + # ── crypto property access: (anyref) -> anyref ─────────────────────────── + def _crypto(value: Any) -> Any: + if isinstance(value, _GlobalSentinel): + return CRYPTO + return None + + def _null_value(value: Any) -> Any: + return None + + def_func("__wbg_crypto_86f2631e91b51511", [_ANYREF], [_ANYREF], _crypto) + def_func("__wbg_msCrypto_d562bbe83e0d4b91", [_ANYREF], [_ANYREF], _null_value) + def_func("__wbg_process_3975fd6c72f520aa", [_ANYREF], [_ANYREF], _null_value) + def_func("__wbg_node_e1f24f89a7336c2e", [_ANYREF], [_ANYREF], _null_value) + def_func("__wbg_versions_4e31226f5e8dc909", [_ANYREF], [_ANYREF], _null_value) + + # ── RNG: (anyref, anyref) -> () ────────────────────────────────────────── + def_func( + "__wbg_getRandomValues_b3f15fcbfabb0f8b", + [_ANYREF, _ANYREF], + [], + lambda _obj, buf: fill_random(buf), + ) + def_func( + "__wbg_randomFillSync_f8c153b79f285817", + [_ANYREF, _ANYREF], + [], + lambda _obj, buf: fill_random(buf), + ) + + # ── require: () -> anyref (null so WASM skips the Node.js crypto path) ─── + def_func("__wbg_require_b74f47fc2d022fd6", [], [_ANYREF], lambda: None) + + # ── function call stubs ────────────────────────────────────────────────── + def _call2(fn: Any, _this: Any) -> Any: + if isinstance(fn, FunctionSentinel) and fn.code == "return this": + return GLOBAL + signal_exception("unsupported call/2") + return None + + def _call3(_fn: Any, _this: Any, _arg: Any) -> Any: + signal_exception("unsupported call (one arg)") + return None + + def_func("__wbg_call_389efe28435a9388", [_ANYREF, _ANYREF], [_ANYREF], _call2) + def_func("__wbg_call_4708e0c13bdc8e95", [_ANYREF, _ANYREF, _ANYREF], [_ANYREF], _call3) + + # ── Uint8Array operations ──────────────────────────────────────────────── + def _length(value: Any) -> int: + if isinstance(value, Uint8ArrayRef): + return value.length + return 0 + + def _new_with_length(size: int) -> Any: + ptr = invoke("__wbindgen_malloc", size, 1)[0] + client.memory.write(store, b"\x00" * size, ptr) + return Uint8ArrayRef(ptr, size) + + def _prototypesetcall(dst_ptr: int, dst_len: int, src: Any) -> None: + if isinstance(src, Uint8ArrayRef): + n = min(src.length, dst_len) + data = client.memory.read(store, src.ptr, src.ptr + n) + if data: + client.memory.write(store, data, dst_ptr) + + def _subarray(value: Any, start: int, end: int) -> Any: + if isinstance(value, Uint8ArrayRef): + return Uint8ArrayRef(value.ptr + start, end - start) + return None + + def_func("__wbg_length_32ed9a279acd054c", [_ANYREF], [_I32], _length) + def_func("__wbg_new_with_length_a2c39cbe88fd8ff1", [_I32], [_ANYREF], _new_with_length) + def_func( + "__wbg_prototypesetcall_bdcdcc5842e4d77d", [_I32, _I32, _ANYREF], [], _prototypesetcall + ) + def_func("__wbg_subarray_a96e1fef17ed23cb", [_ANYREF, _I32, _I32], [_ANYREF], _subarray) + + # ── JSON: JSON.parse captures the raw bytes for decode_*_to_js results ─── + def _parse(ptr: int, length: int) -> Any: + data = client.memory.read(store, ptr, ptr + length) + if data is None: + signal_exception("JSON.parse: memory read failed") + return None + try: + value = json.loads(data.decode("utf-8")) + except (ValueError, UnicodeDecodeError) as exc: + signal_exception(f"JSON.parse: {exc}") + return None + state.last_json = data + return value + + def _stringify(value: Any) -> Any: + if value is None: + signal_exception("JSON.stringify: unknown reference") + return None + try: + return _json_dumps(value) + except (TypeError, ValueError) as exc: + signal_exception(f"JSON.stringify: {exc}") + return None + + def_func("__wbg_parse_708461a1feddfb38", [_I32, _I32], [_ANYREF], _parse) + def_func("__wbg_stringify_8d1cc6ff383e8bae", [_ANYREF], [_ANYREF], _stringify) + + # ── new Function(code): (i32, i32) -> anyref ───────────────────────────── + def _new_no_args(ptr: int, length: int) -> Any: + data = client.memory.read(store, ptr, ptr + length) + return FunctionSentinel(data.decode("utf-8", errors="replace") if data else "") + + def_func("__wbg_new_no_args_1c7c842f08d00ebb", [_I32, _I32], [_ANYREF], _new_no_args) + + # ── cast intrinsics: (i32, i32) -> anyref ──────────────────────────────── + def _cast_uint8array(ptr: int, length: int) -> Any: + return Uint8ArrayRef(ptr, length) + + def _cast_string(ptr: int, length: int) -> Any: + data = client.memory.read(store, ptr, ptr + length) + s = data.decode("utf-8", errors="replace") if data else "" + # Rust errors cross here as their Display string; capture for the caller. + state.err_msg = s + return s + + def_func("__wbindgen_cast_0000000000000001", [_I32, _I32], [_ANYREF], _cast_uint8array) + def_func("__wbindgen_cast_0000000000000002", [_I32, _I32], [_ANYREF], _cast_string) + + # ── debug / type predicates: (anyref) -> i32 ───────────────────────────── + def _debug_string(out_ptr: int, value: Any) -> None: + write_string_to_mem(out_ptr, debug_string(value)) + + def _is_function(value: Any) -> int: + return 1 if isinstance(value, FunctionSentinel) else 0 + + def _is_object(value: Any) -> int: + return 1 if isinstance(value, (_GlobalSentinel, _CryptoSentinel, Uint8ArrayRef)) else 0 + + def _is_string(value: Any) -> int: + return 1 if isinstance(value, str) else 0 + + def _is_undefined(value: Any) -> int: + return 1 if value is None else 0 + + def_func("__wbg___wbindgen_debug_string_0bc8482c6e3508ae", [_I32, _ANYREF], [], _debug_string) + def_func("__wbg___wbindgen_is_function_0095a73b8b156f76", [_ANYREF], [_I32], _is_function) + def_func("__wbg___wbindgen_is_object_5ae8e5880f2c1fbd", [_ANYREF], [_I32], _is_object) + def_func("__wbg___wbindgen_is_string_cd444516edc5b180", [_ANYREF], [_I32], _is_string) + def_func("__wbg___wbindgen_is_undefined_9e4d92534c42d778", [_ANYREF], [_I32], _is_undefined) + + # ── string_get: (i32, anyref) -> () ────────────────────────────────────── + def _string_get(out_ptr: int, value: Any) -> None: + if isinstance(value, str): + write_string_to_mem(out_ptr, value) + return + client.memory.write(store, (0).to_bytes(4, "little"), out_ptr) + client.memory.write(store, (0).to_bytes(4, "little"), out_ptr + 4) + + def_func("__wbg___wbindgen_string_get_72fb696202c56729", [_I32, _ANYREF], [], _string_get) + + # ── throw: (i32, i32) -> () — aborts the WASM invocation ───────────────── + def _throw(ptr: int, length: int) -> None: + data = client.memory.read(store, ptr, ptr + length) + msg = data.decode("utf-8", errors="replace") if data else "" + state.err_msg = msg + raise WasmThrow(f"wasm throw: {msg}") + + def_func("__wbg___wbindgen_throw_be289d5034ed271b", [_I32, _I32], [], _throw) + + # ── externref table init: () -> () ─────────────────────────────────────── + def _init_externref_table() -> None: + for _ in range(4): + invoke("__externref_table_alloc") + + def_func("__wbindgen_init_externref_table", [], [], _init_externref_table) diff --git a/mintlayer/wasm/ids.py b/mintlayer/wasm/ids.py new file mode 100644 index 0000000..cd54a19 --- /dev/null +++ b/mintlayer/wasm/ids.py @@ -0,0 +1,39 @@ +"""Object ID derivation (mirrors go-sdk/wasm/ids.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Network + + +class IdsMixin(_WasmCore): + @synchronized + def get_pool_id(self, inputs: bytes, network: Network) -> str: + """Return the pool ID derived from a transaction's inputs.""" + ptr, length = self._write_bytes(inputs) + return self._call_return_string("get_pool_id", ptr, length, int(network)) + + @synchronized + def get_token_id(self, inputs: bytes, current_block_height: int, network: Network) -> str: + """Return the fungible or NFT token ID derived from a transaction's inputs. + + ``current_block_height`` selects the token ID scheme for the active + network upgrade. + """ + ptr, length = self._write_bytes(inputs) + return self._call_return_string( + "get_token_id", ptr, length, current_block_height, int(network) + ) + + @synchronized + def get_delegation_id(self, inputs: bytes, network: Network) -> str: + """Return the delegation ID derived from a transaction's inputs.""" + ptr, length = self._write_bytes(inputs) + return self._call_return_string("get_delegation_id", ptr, length, int(network)) + + @synchronized + def get_order_id(self, inputs: bytes, network: Network) -> str: + """Return the DEX order ID derived from a transaction's inputs.""" + ptr, length = self._write_bytes(inputs) + return self._call_return_string("get_order_id", ptr, length, int(network)) diff --git a/mintlayer/wasm/inputs.py b/mintlayer/wasm/inputs.py new file mode 100644 index 0000000..bd32f87 --- /dev/null +++ b/mintlayer/wasm/inputs.py @@ -0,0 +1,178 @@ +"""Transaction input encoding (mirrors go-sdk/wasm/inputs.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Amount, Network, TokenUnfreezable + + +class InputsMixin(_WasmCore): + @synchronized + def encode_input_for_utxo(self, outpoint_source_id: bytes, output_index: int) -> bytes: + """Encode a UTXO input from an outpoint source ID and output index.""" + ptr, length = self._write_bytes(outpoint_source_id) + return self._call_return_bytes("encode_input_for_utxo", ptr, length, output_index) + + @synchronized + def encode_input_for_withdraw_from_delegation( + self, delegation_id: str, amount: Amount, nonce: int, network: Network + ) -> bytes: + """Create an input that withdraws from a delegation.""" + id_ptr, id_len = self._write_string(delegation_id) + amt_ptr = self._new_wasm_amount(amount) + return self._call_return_bytes( + "encode_input_for_withdraw_from_delegation", + id_ptr, + id_len, + amt_ptr, + nonce, + int(network), + ) + + @synchronized + def encode_input_for_mint_tokens( + self, token_id: str, amount: Amount, nonce: int, network: Network + ) -> bytes: + """Create an input to mint tokens.""" + id_ptr, id_len = self._write_string(token_id) + amt_ptr = self._new_wasm_amount(amount) + return self._call_return_bytes( + "encode_input_for_mint_tokens", id_ptr, id_len, amt_ptr, nonce, int(network) + ) + + @synchronized + def encode_input_for_unmint_tokens(self, token_id: str, nonce: int, network: Network) -> bytes: + """Create an input to unmint tokens.""" + id_ptr, id_len = self._write_string(token_id) + return self._call_return_bytes( + "encode_input_for_unmint_tokens", id_ptr, id_len, nonce, int(network) + ) + + @synchronized + def encode_input_for_lock_token_supply( + self, token_id: str, nonce: int, network: Network + ) -> bytes: + """Create an input to lock the token supply.""" + id_ptr, id_len = self._write_string(token_id) + return self._call_return_bytes( + "encode_input_for_lock_token_supply", id_ptr, id_len, nonce, int(network) + ) + + @synchronized + def encode_input_for_freeze_token( + self, + token_id: str, + is_token_unfreezable: TokenUnfreezable, + nonce: int, + network: Network, + ) -> bytes: + """Create an input to freeze a token.""" + id_ptr, id_len = self._write_string(token_id) + return self._call_return_bytes( + "encode_input_for_freeze_token", + id_ptr, + id_len, + int(is_token_unfreezable), + nonce, + int(network), + ) + + @synchronized + def encode_input_for_unfreeze_token(self, token_id: str, nonce: int, network: Network) -> bytes: + """Create an input to unfreeze a token.""" + id_ptr, id_len = self._write_string(token_id) + return self._call_return_bytes( + "encode_input_for_unfreeze_token", id_ptr, id_len, nonce, int(network) + ) + + @synchronized + def encode_input_for_change_token_authority( + self, token_id: str, new_authority: str, nonce: int, network: Network + ) -> bytes: + """Create an input to change the token authority.""" + id_ptr, id_len = self._write_string(token_id) + auth_ptr, auth_len = self._write_string(new_authority) + return self._call_return_bytes( + "encode_input_for_change_token_authority", + id_ptr, + id_len, + auth_ptr, + auth_len, + nonce, + int(network), + ) + + @synchronized + def encode_input_for_change_token_metadata_uri( + self, token_id: str, new_metadata_uri: str, nonce: int, network: Network + ) -> bytes: + """Create an input to change the token metadata URI.""" + id_ptr, id_len = self._write_string(token_id) + uri_ptr, uri_len = self._write_string(new_metadata_uri) + return self._call_return_bytes( + "encode_input_for_change_token_metadata_uri", + id_ptr, + id_len, + uri_ptr, + uri_len, + nonce, + int(network), + ) + + @synchronized + def encode_input_for_conclude_order( + self, order_id: str, nonce: int, current_block_height: int, network: Network + ) -> bytes: + """Create an input that concludes an order.""" + id_ptr, id_len = self._write_string(order_id) + return self._call_return_bytes( + "encode_input_for_conclude_order", + id_ptr, + id_len, + nonce, + current_block_height, + int(network), + ) + + @synchronized + def encode_input_for_fill_order( + self, + order_id: str, + fill_amount: Amount, + destination: str, + nonce: int, + current_block_height: int, + network: Network, + ) -> bytes: + """Create an input that fills an order. + + FillOrder inputs should not be signed (use ``encode_witness_no_signature``). + """ + id_ptr, id_len = self._write_string(order_id) + amt_ptr = self._new_wasm_amount(fill_amount) + dest_ptr, dest_len = self._write_string(destination) + return self._call_return_bytes( + "encode_input_for_fill_order", + id_ptr, + id_len, + amt_ptr, + dest_ptr, + dest_len, + nonce, + current_block_height, + int(network), + ) + + @synchronized + def encode_input_for_freeze_order( + self, order_id: str, current_block_height: int, network: Network + ) -> bytes: + """Create an input that freezes an order. + + Order freezing is available only after the orders V1 fork. + """ + id_ptr, id_len = self._write_string(order_id) + return self._call_return_bytes( + "encode_input_for_freeze_order", id_ptr, id_len, current_block_height, int(network) + ) diff --git a/mintlayer/wasm/intent.py b/mintlayer/wasm/intent.py new file mode 100644 index 0000000..ebd8ff4 --- /dev/null +++ b/mintlayer/wasm/intent.py @@ -0,0 +1,72 @@ +"""Transaction intents (mirrors go-sdk/wasm/intent.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Network + + +class IntentMixin(_WasmCore): + @synchronized + def make_transaction_intent_message_to_sign(self, intent: str, transaction_id: str) -> bytes: + """Return the canonical message that must be signed for a transaction intent. + + ``transaction_id`` should be a hex-encoded transaction ID returned by + ``get_transaction_id``. + """ + int_ptr, int_len = self._write_string(intent) + txid_ptr, txid_len = self._write_string(transaction_id) + return self._call_return_bytes( + "make_transaction_intent_message_to_sign", int_ptr, int_len, txid_ptr, txid_len + ) + + @synchronized + def encode_signed_transaction_intent( + self, signed_message: bytes, signatures: list[bytes] + ) -> bytes: + """Combine a signed message with per-input signatures into a SignedTransactionIntent. + + ``signed_message`` must be produced by + ``make_transaction_intent_message_to_sign``. ``signatures`` is one raw + signature per transaction input, each produced by ``sign_challenge``. + """ + msg_ptr, msg_len = self._write_bytes(signed_message) + sigs_ptr, sigs_indices, sigs_buffers = self._write_uint8_array_array(signatures) + try: + return self._call_return_bytes( + "encode_signed_transaction_intent", msg_ptr, msg_len, sigs_ptr, len(sigs_indices) + ) + finally: + self._dealloc_indices(sigs_indices) + for ptr, length in sigs_buffers: + self._free_wasm(ptr, length) + + @synchronized + def verify_transaction_intent( + self, + expected_signed_message: bytes, + encoded_signed_intent: bytes, + input_destinations: list[str], + network: Network, + ) -> None: + """Verify a signed transaction intent. + + ``input_destinations`` contains one bech32m address per transaction input. + """ + msg_ptr, msg_len = self._write_bytes(expected_signed_message) + intent_ptr, intent_len = self._write_bytes(encoded_signed_intent) + dests_ptr, dests_indices = self._write_string_array(input_destinations) + try: + self._call_void_fallible( + "verify_transaction_intent", + msg_ptr, + msg_len, + intent_ptr, + intent_len, + dests_ptr, + len(dests_indices), + int(network), + ) + finally: + self._dealloc_indices(dests_indices) diff --git a/mintlayer/wasm/keys.py b/mintlayer/wasm/keys.py new file mode 100644 index 0000000..9f3a803 --- /dev/null +++ b/mintlayer/wasm/keys.py @@ -0,0 +1,59 @@ +"""Key derivation (mirrors go-sdk/wasm/keys.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Network + + +class KeysMixin(_WasmCore): + @synchronized + def make_private_key(self) -> bytes: + """Generate a new random private key.""" + return self._call_return_bytes_no_err("make_private_key") + + @synchronized + def make_default_account_privkey(self, mnemonic: str, network: Network) -> bytes: + """Derive the extended private key for the default account (account 0). + + Derivation path: 44'/mintlayer_coin_type'/0' + """ + ptr, length = self._write_string(mnemonic) + return self._call_return_bytes("make_default_account_privkey", ptr, length, int(network)) + + @synchronized + def public_key_from_private_key(self, privkey: bytes) -> bytes: + """Derive the compressed public key for a private key.""" + ptr, length = self._write_bytes(privkey) + return self._call_return_bytes("public_key_from_private_key", ptr, length) + + @synchronized + def extended_public_key_from_extended_private_key(self, privkey: bytes) -> bytes: + """Derive the extended public key from an extended private key.""" + ptr, length = self._write_bytes(privkey) + return self._call_return_bytes("extended_public_key_from_extended_private_key", ptr, length) + + @synchronized + def make_receiving_address(self, account_privkey: bytes, key_index: int) -> bytes: + """Derive a receiving (external) address key at the given index.""" + ptr, length = self._write_bytes(account_privkey) + return self._call_return_bytes("make_receiving_address", ptr, length, key_index) + + @synchronized + def make_change_address(self, account_privkey: bytes, key_index: int) -> bytes: + """Derive a change (internal) address key at the given index.""" + ptr, length = self._write_bytes(account_privkey) + return self._call_return_bytes("make_change_address", ptr, length, key_index) + + @synchronized + def make_receiving_address_public_key(self, account_pubkey: bytes, key_index: int) -> bytes: + """Derive the receiving address public key from an extended public key.""" + ptr, length = self._write_bytes(account_pubkey) + return self._call_return_bytes("make_receiving_address_public_key", ptr, length, key_index) + + @synchronized + def make_change_address_public_key(self, account_pubkey: bytes, key_index: int) -> bytes: + """Derive the change address public key from an extended public key.""" + ptr, length = self._write_bytes(account_pubkey) + return self._call_return_bytes("make_change_address_public_key", ptr, length, key_index) diff --git a/mintlayer/wasm/outputs.py b/mintlayer/wasm/outputs.py new file mode 100644 index 0000000..84a68f8 --- /dev/null +++ b/mintlayer/wasm/outputs.py @@ -0,0 +1,322 @@ +"""Transaction output encoding (mirrors go-sdk/wasm/outputs.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Amount, FreezableToken, Network, TotalSupply + + +class OutputsMixin(_WasmCore): + @synchronized + def encode_output_transfer(self, amount: Amount, address: str, network: Network) -> bytes: + """Create a Transfer output sending coins to an address.""" + amt_ptr = self._new_wasm_amount(amount) + addr_ptr, addr_len = self._write_string(address) + return self._call_return_bytes( + "encode_output_transfer", amt_ptr, addr_ptr, addr_len, int(network) + ) + + @synchronized + def encode_output_token_transfer( + self, amount: Amount, address: str, token_id: str, network: Network + ) -> bytes: + """Create a Transfer output sending tokens to an address.""" + amt_ptr = self._new_wasm_amount(amount) + addr_ptr, addr_len = self._write_string(address) + tid_ptr, tid_len = self._write_string(token_id) + return self._call_return_bytes( + "encode_output_token_transfer", + amt_ptr, + addr_ptr, + addr_len, + tid_ptr, + tid_len, + int(network), + ) + + @synchronized + def encode_output_lock_then_transfer( + self, amount: Amount, address: str, lock: bytes, network: Network + ) -> bytes: + """Create a LockThenTransfer output for coins. + + ``lock`` is an encoded timelock (see ``encode_lock_for_*``). + """ + amt_ptr = self._new_wasm_amount(amount) + addr_ptr, addr_len = self._write_string(address) + lock_ptr, lock_len = self._write_bytes(lock) + return self._call_return_bytes( + "encode_output_lock_then_transfer", + amt_ptr, + addr_ptr, + addr_len, + lock_ptr, + lock_len, + int(network), + ) + + @synchronized + def encode_output_token_lock_then_transfer( + self, amount: Amount, address: str, token_id: str, lock: bytes, network: Network + ) -> bytes: + """Create a LockThenTransfer output for tokens.""" + amt_ptr = self._new_wasm_amount(amount) + addr_ptr, addr_len = self._write_string(address) + tid_ptr, tid_len = self._write_string(token_id) + lock_ptr, lock_len = self._write_bytes(lock) + return self._call_return_bytes( + "encode_output_token_lock_then_transfer", + amt_ptr, + addr_ptr, + addr_len, + tid_ptr, + tid_len, + lock_ptr, + lock_len, + int(network), + ) + + @synchronized + def encode_output_coin_burn(self, amount: Amount) -> bytes: + """Create a Burn output for coins.""" + amt_ptr = self._new_wasm_amount(amount) + return self._call_return_bytes("encode_output_coin_burn", amt_ptr) + + @synchronized + def encode_output_token_burn(self, amount: Amount, token_id: str, network: Network) -> bytes: + """Create a Burn output for tokens.""" + amt_ptr = self._new_wasm_amount(amount) + tid_ptr, tid_len = self._write_string(token_id) + return self._call_return_bytes( + "encode_output_token_burn", amt_ptr, tid_ptr, tid_len, int(network) + ) + + @synchronized + def encode_output_create_delegation( + self, pool_id: str, owner_address: str, network: Network + ) -> bytes: + """Create an output that creates a staking delegation.""" + pid_ptr, pid_len = self._write_string(pool_id) + addr_ptr, addr_len = self._write_string(owner_address) + return self._call_return_bytes( + "encode_output_create_delegation", pid_ptr, pid_len, addr_ptr, addr_len, int(network) + ) + + @synchronized + def encode_output_delegate_staking( + self, amount: Amount, delegation_id: str, network: Network + ) -> bytes: + """Create an output that delegates coins to a staking pool.""" + amt_ptr = self._new_wasm_amount(amount) + did_ptr, did_len = self._write_string(delegation_id) + return self._call_return_bytes( + "encode_output_delegate_staking", amt_ptr, did_ptr, did_len, int(network) + ) + + @synchronized + def encode_output_create_stake_pool( + self, pool_id: str, pool_data: bytes, network: Network + ) -> bytes: + """Create an output that creates a staking pool. + + ``pool_data`` is encoded stake pool data (see ``encode_stake_pool_data``). + """ + pid_ptr, pid_len = self._write_string(pool_id) + pd_ptr, pd_len = self._write_bytes(pool_data) + return self._call_return_bytes( + "encode_output_create_stake_pool", pid_ptr, pid_len, pd_ptr, pd_len, int(network) + ) + + @synchronized + def encode_output_produce_block_from_stake( + self, pool_id: str, staker: str, network: Network + ) -> bytes: + """Create a ProduceBlockFromStake output. + + This UTXO is consumed when decommissioning a pool (if the pool has + staked at least once). + """ + pid_ptr, pid_len = self._write_string(pool_id) + stk_ptr, stk_len = self._write_string(staker) + return self._call_return_bytes( + "encode_output_produce_block_from_stake", + pid_ptr, + pid_len, + stk_ptr, + stk_len, + int(network), + ) + + @synchronized + def encode_output_data_deposit(self, data: bytes) -> bytes: + """Create a DataDeposit output for arbitrary on-chain data.""" + ptr, length = self._write_bytes(data) + return self._call_return_bytes("encode_output_data_deposit", ptr, length) + + @synchronized + def encode_output_htlc( + self, + amount: Amount, + token_id: str | None, + secret_hash: str, + spend_address: str, + refund_address: str, + refund_timelock: bytes, + network: Network, + ) -> bytes: + """Create a hash time-lock contract (HTLC) output for coins or tokens. + + ``token_id`` may be ``None`` for coin HTLCs. ``refund_timelock`` is an + encoded timelock. + """ + amt_ptr = self._new_wasm_amount(amount) + tid_ptr, tid_len = self._write_optional_string(token_id) + sh_ptr, sh_len = self._write_string(secret_hash) + sa_ptr, sa_len = self._write_string(spend_address) + ra_ptr, ra_len = self._write_string(refund_address) + tl_ptr, tl_len = self._write_bytes(refund_timelock) + return self._call_return_bytes( + "encode_output_htlc", + amt_ptr, + tid_ptr, + tid_len, + sh_ptr, + sh_len, + sa_ptr, + sa_len, + ra_ptr, + ra_len, + tl_ptr, + tl_len, + int(network), + ) + + @synchronized + def encode_output_issue_fungible_token( + self, + authority: str, + token_ticker: str, + metadata_uri: str, + number_of_decimals: int, + total_supply: TotalSupply, + supply_amount: Amount | None, + is_token_freezable: FreezableToken, + current_block_height: int, + network: Network, + ) -> bytes: + """Create an output that issues a new fungible token. + + ``supply_amount`` may be ``None`` unless ``total_supply`` is + ``TotalSupply.FIXED``. + """ + auth_ptr, auth_len = self._write_string(authority) + tkr_ptr, tkr_len = self._write_string(token_ticker) + uri_ptr, uri_len = self._write_string(metadata_uri) + sa_ptr = 0 + if supply_amount is not None: + sa_ptr = self._new_wasm_amount(supply_amount) + return self._call_return_bytes( + "encode_output_issue_fungible_token", + auth_ptr, + auth_len, + tkr_ptr, + tkr_len, + uri_ptr, + uri_len, + number_of_decimals, + int(total_supply), + sa_ptr, + int(is_token_freezable), + current_block_height, + int(network), + ) + + @synchronized + def encode_output_issue_nft( + self, + token_id: str, + authority: str, + name: str, + ticker: str, + description: str, + media_hash: bytes, + creator: bytes | None, + media_uri: str | None, + icon_uri: str | None, + additional_metadata_uri: str | None, + current_block_height: int, + network: Network, + ) -> bytes: + """Create an output that issues a new NFT. + + ``creator``, ``media_uri``, ``icon_uri`` and ``additional_metadata_uri`` + may be ``None``. + """ + tid_ptr, tid_len = self._write_string(token_id) + auth_ptr, auth_len = self._write_string(authority) + name_ptr, name_len = self._write_string(name) + tkr_ptr, tkr_len = self._write_string(ticker) + desc_ptr, desc_len = self._write_string(description) + mh_ptr, mh_len = self._write_bytes(media_hash) + cr_ptr, cr_len = self._write_optional_bytes(creator) + mu_ptr, mu_len = self._write_optional_string(media_uri) + iu_ptr, iu_len = self._write_optional_string(icon_uri) + am_ptr, am_len = self._write_optional_string(additional_metadata_uri) + return self._call_return_bytes( + "encode_output_issue_nft", + tid_ptr, + tid_len, + auth_ptr, + auth_len, + name_ptr, + name_len, + tkr_ptr, + tkr_len, + desc_ptr, + desc_len, + mh_ptr, + mh_len, + cr_ptr, + cr_len, + mu_ptr, + mu_len, + iu_ptr, + iu_len, + am_ptr, + am_len, + current_block_height, + int(network), + ) + + @synchronized + def encode_create_order_output( + self, + ask_amount: Amount, + ask_token_id: str | None, + give_amount: Amount, + give_token_id: str | None, + conclude_address: str, + network: Network, + ) -> bytes: + """Create an output that creates an order for token exchange. + + ``ask_token_id`` and ``give_token_id`` may be ``None`` for coin amounts. + """ + ask_amt_ptr = self._new_wasm_amount(ask_amount) + ask_tid_ptr, ask_tid_len = self._write_optional_string(ask_token_id) + give_amt_ptr = self._new_wasm_amount(give_amount) + give_tid_ptr, give_tid_len = self._write_optional_string(give_token_id) + ca_ptr, ca_len = self._write_string(conclude_address) + return self._call_return_bytes( + "encode_create_order_output", + ask_amt_ptr, + ask_tid_ptr, + ask_tid_len, + give_amt_ptr, + give_tid_ptr, + give_tid_len, + ca_ptr, + ca_len, + int(network), + ) diff --git a/mintlayer/wasm/signing.py b/mintlayer/wasm/signing.py new file mode 100644 index 0000000..0cfb8b0 --- /dev/null +++ b/mintlayer/wasm/signing.py @@ -0,0 +1,231 @@ +"""Witness and signature encoding (mirrors go-sdk/wasm/signing.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Network, SignatureHashType, TxAdditionalInfo + + +class SigningMixin(_WasmCore): + @synchronized + def encode_witness( + self, + sighash_type: SignatureHashType, + private_key: bytes, + input_owner_dest: str, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, + ) -> bytes: + """Sign a transaction input and return the encoded InputWitness. + + ``private_key`` is the raw encoded private key. + ``input_owner_dest`` is the bech32m address that owns the input being signed. + ``input_utxos`` is a concatenated set of optional UTXO outputs (one per + input; prefix 0 for non-UTXO, 1+encoded-output for UTXO). + """ + pk_ptr, pk_len = self._write_bytes(private_key) + dest_ptr, dest_len = self._write_string(input_owner_dest) + tx_ptr, tx_len = self._write_bytes(transaction) + utxos_ptr, utxos_len = self._write_bytes(input_utxos) + return self._call_return_bytes( + "encode_witness", + int(sighash_type), + pk_ptr, + pk_len, + dest_ptr, + dest_len, + tx_ptr, + tx_len, + utxos_ptr, + utxos_len, + input_index, + additional_info, + block_height, + int(network), + ) + + @synchronized + def encode_witness_no_signature(self) -> bytes: + """Return an InputWitness that carries no signature (for FillOrder inputs).""" + return self._call_return_bytes_no_err("encode_witness_no_signature") + + @synchronized + def encode_witness_htlc_spend( + self, + sighash_type: SignatureHashType, + private_key: bytes, + input_owner_dest: str, + transaction: bytes, + input_utxos: bytes, + input_index: int, + secret: bytes, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, + ) -> bytes: + """Sign an HTLC input for spending (revealing the secret).""" + pk_ptr, pk_len = self._write_bytes(private_key) + dest_ptr, dest_len = self._write_string(input_owner_dest) + tx_ptr, tx_len = self._write_bytes(transaction) + utxos_ptr, utxos_len = self._write_bytes(input_utxos) + sec_ptr, sec_len = self._write_bytes(secret) + return self._call_return_bytes( + "encode_witness_htlc_spend", + int(sighash_type), + pk_ptr, + pk_len, + dest_ptr, + dest_len, + tx_ptr, + tx_len, + utxos_ptr, + utxos_len, + input_index, + sec_ptr, + sec_len, + additional_info, + block_height, + int(network), + ) + + @synchronized + def encode_witness_htlc_refund_single_sig( + self, + sighash_type: SignatureHashType, + private_key: bytes, + input_owner_dest: str, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, + ) -> bytes: + """Sign an HTLC input for refunding via a single-sig address.""" + pk_ptr, pk_len = self._write_bytes(private_key) + dest_ptr, dest_len = self._write_string(input_owner_dest) + tx_ptr, tx_len = self._write_bytes(transaction) + utxos_ptr, utxos_len = self._write_bytes(input_utxos) + return self._call_return_bytes( + "encode_witness_htlc_refund_single_sig", + int(sighash_type), + pk_ptr, + pk_len, + dest_ptr, + dest_len, + tx_ptr, + tx_len, + utxos_ptr, + utxos_len, + input_index, + additional_info, + block_height, + int(network), + ) + + @synchronized + def encode_witness_htlc_refund_multisig( + self, + sighash_type: SignatureHashType, + private_key: bytes, + key_index: int, + input_witness: bytes, + multisig_challenge: bytes, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, + ) -> bytes: + """Add a partial signature to an HTLC refund witness for a multisig refund address. + + ``key_index`` is the index of ``private_key`` within the multisig + challenge. ``input_witness`` may be empty (first signer) or a previous + partial result. + """ + pk_ptr, pk_len = self._write_bytes(private_key) + wit_ptr, wit_len = self._write_bytes(input_witness) + chal_ptr, chal_len = self._write_bytes(multisig_challenge) + tx_ptr, tx_len = self._write_bytes(transaction) + utxos_ptr, utxos_len = self._write_bytes(input_utxos) + return self._call_return_bytes( + "encode_witness_htlc_refund_multisig", + int(sighash_type), + pk_ptr, + pk_len, + key_index, + wit_ptr, + wit_len, + chal_ptr, + chal_len, + tx_ptr, + tx_len, + utxos_ptr, + utxos_len, + input_index, + additional_info, + block_height, + int(network), + ) + + @synchronized + def sign_challenge(self, private_key: bytes, message: bytes) -> bytes: + """Sign an arbitrary message with the given private key. + + Use ``verify_challenge`` to verify the result. + """ + pk_ptr, pk_len = self._write_bytes(private_key) + msg_ptr, msg_len = self._write_bytes(message) + return self._call_return_bytes("sign_challenge", pk_ptr, pk_len, msg_ptr, msg_len) + + @synchronized + def verify_challenge( + self, address: str, network: Network, signed_challenge: bytes, message: bytes + ) -> bool: + """Verify a challenge signature produced by ``sign_challenge``. + + ``address`` must be a pubkeyhash bech32m address. + """ + addr_ptr, addr_len = self._write_string(address) + sig_ptr, sig_len = self._write_bytes(signed_challenge) + msg_ptr, msg_len = self._write_bytes(message) + return self._call_return_bool( + "verify_challenge", + addr_ptr, + addr_len, + int(network), + sig_ptr, + sig_len, + msg_ptr, + msg_len, + ) + + @synchronized + def sign_message_for_spending(self, private_key: bytes, message: bytes) -> bytes: + """Sign a message for use as a transaction input witness. + + Use ``verify_signature_for_spending`` to verify the result. + """ + pk_ptr, pk_len = self._write_bytes(private_key) + msg_ptr, msg_len = self._write_bytes(message) + return self._call_return_bytes( + "sign_message_for_spending", pk_ptr, pk_len, msg_ptr, msg_len + ) + + @synchronized + def verify_signature_for_spending( + self, public_key: bytes, signature: bytes, message: bytes + ) -> bool: + """Verify a spending signature produced by ``sign_message_for_spending``.""" + pk_ptr, pk_len = self._write_bytes(public_key) + sig_ptr, sig_len = self._write_bytes(signature) + msg_ptr, msg_len = self._write_bytes(message) + return self._call_return_bool( + "verify_signature_for_spending", pk_ptr, pk_len, sig_ptr, sig_len, msg_ptr, msg_len + ) diff --git a/mintlayer/wasm/staking.py b/mintlayer/wasm/staking.py new file mode 100644 index 0000000..54887d0 --- /dev/null +++ b/mintlayer/wasm/staking.py @@ -0,0 +1,71 @@ +"""Staking helpers (mirrors go-sdk/wasm/staking.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized +from .types import Amount, Network + + +class StakingMixin(_WasmCore): + @synchronized + def encode_stake_pool_data( + self, + value: Amount, + staker: str, + vrf_public_key: str, + decommission_key: str, + margin_ratio_per_thousand: int, + cost_per_block: Amount, + network: Network, + ) -> bytes: + """Encode the parameters of a staking pool into binary form. + + Suitable for use in ``encode_output_create_stake_pool``. + + ``staker`` is the bech32m address allowed to produce blocks. + ``vrf_public_key`` is the bech32m-encoded VRF public key for the pool. + ``decommission_key`` is the bech32m address that can decommission the pool. + ``margin_ratio_per_thousand`` is the share of block rewards kept by the + staker (0-1000). + ``cost_per_block`` is a fixed amount subtracted from block rewards + before margin calculation. + """ + val_ptr = self._new_wasm_amount(value) + staker_ptr, staker_len = self._write_string(staker) + vrf_ptr, vrf_len = self._write_string(vrf_public_key) + decomm_ptr, decomm_len = self._write_string(decommission_key) + cpb_ptr = self._new_wasm_amount(cost_per_block) + return self._call_return_bytes( + "encode_stake_pool_data", + val_ptr, + staker_ptr, + staker_len, + vrf_ptr, + vrf_len, + decomm_ptr, + decomm_len, + margin_ratio_per_thousand, + cpb_ptr, + int(network), + ) + + @synchronized + def effective_pool_balance( + self, network: Network, pledge_amount: Amount, pool_balance: Amount + ) -> Amount: + """Compute the effective balance of a staking pool used for stake selection.""" + pledge_ptr = self._new_wasm_amount(pledge_amount) + pool_ptr = self._new_wasm_amount(pool_balance) + return self._call_return_amount_fallible( + "effective_pool_balance", int(network), pledge_ptr, pool_ptr + ) + + @synchronized + def staking_pool_spend_maturity_block_count( + self, current_block_height: int, network: Network + ) -> int: + """Blocks that must pass after a pool decommissions before funds are spendable.""" + return self._call_return_u64( + "staking_pool_spend_maturity_block_count", current_block_height, int(network) + ) diff --git a/mintlayer/wasm/timelocks.py b/mintlayer/wasm/timelocks.py new file mode 100644 index 0000000..6a6853c --- /dev/null +++ b/mintlayer/wasm/timelocks.py @@ -0,0 +1,28 @@ +"""Timelock encoding (mirrors go-sdk/wasm/timelocks.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import synchronized + + +class TimelocksMixin(_WasmCore): + @synchronized + def encode_lock_for_block_count(self, block_count: int) -> bytes: + """Encode a "lock until N more blocks have passed" timelock.""" + return self._call_return_bytes_no_err("encode_lock_for_block_count", block_count) + + @synchronized + def encode_lock_for_seconds(self, seconds: int) -> bytes: + """Encode a "lock for N more seconds" timelock.""" + return self._call_return_bytes_no_err("encode_lock_for_seconds", seconds) + + @synchronized + def encode_lock_until_height(self, block_height: int) -> bytes: + """Encode a "lock until absolute block height" timelock.""" + return self._call_return_bytes_no_err("encode_lock_until_height", block_height) + + @synchronized + def encode_lock_until_time(self, timestamp_seconds: int) -> bytes: + """Encode a "lock until absolute UNIX timestamp" timelock.""" + return self._call_return_bytes_no_err("encode_lock_until_time", timestamp_seconds) diff --git a/mintlayer/wasm/transactions.py b/mintlayer/wasm/transactions.py new file mode 100644 index 0000000..4320986 --- /dev/null +++ b/mintlayer/wasm/transactions.py @@ -0,0 +1,189 @@ +"""Transaction encoding and decoding (mirrors go-sdk/wasm/transactions.go).""" + +from __future__ import annotations + +from ._core import _WasmCore +from ._util import bool_to_int, synchronized +from .types import Network, SourceId, TxAdditionalInfo + + +class TransactionsMixin(_WasmCore): + @synchronized + def encode_transaction(self, inputs: bytes, outputs: bytes, flags: int) -> bytes: + """Encode an unsigned transaction from its inputs and outputs. + + ``inputs`` and ``outputs`` must be concatenated encoded bytes from the + respective ``encode_*`` functions. + """ + in_ptr, in_len = self._write_bytes(inputs) + out_ptr, out_len = self._write_bytes(outputs) + return self._call_return_bytes( + "encode_transaction", in_ptr, in_len, out_ptr, out_len, flags + ) + + @synchronized + def encode_outpoint_source_id(self, id_: bytes, source_id: SourceId) -> bytes: + """Encode a source ID (transaction hash or block reward ID) into binary form.""" + ptr, length = self._write_bytes(id_) + return self._call_return_bytes_no_err( + "encode_outpoint_source_id", ptr, length, int(source_id) + ) + + @synchronized + def get_transaction_id(self, transaction: bytes, strict_byte_size: bool) -> str: + """Return the transaction ID (hex string) for the given encoded transaction. + + Set ``strict_byte_size`` to require the bytes to represent exactly one + Transaction object. + """ + ptr, length = self._write_bytes(transaction) + return self._call_return_string( + "get_transaction_id", ptr, length, bool_to_int(strict_byte_size) + ) + + @synchronized + def estimate_transaction_size( + self, inputs: bytes, input_utxos_dests: list[str], outputs: bytes, network: Network + ) -> int: + """Estimate the encoded size of a signed transaction in bytes. + + ``input_utxos_dests`` must contain one address string per input (the + spending destination of each UTXO). + """ + in_ptr, in_len = self._write_bytes(inputs) + dests_ptr, dests_indices = self._write_string_array(input_utxos_dests) + try: + out_ptr, out_len = self._write_bytes(outputs) + return self._call_return_u32( + "estimate_transaction_size", + in_ptr, + in_len, + dests_ptr, + len(dests_indices), + out_ptr, + out_len, + int(network), + ) + finally: + self._dealloc_indices(dests_indices) + + @synchronized + def encode_signed_transaction(self, transaction: bytes, signatures: bytes) -> bytes: + """Combine an unsigned transaction with its witness signatures.""" + tx_ptr, tx_len = self._write_bytes(transaction) + sig_ptr, sig_len = self._write_bytes(signatures) + return self._call_return_bytes( + "encode_signed_transaction", tx_ptr, tx_len, sig_ptr, sig_len + ) + + @synchronized + def encode_partially_signed_transaction( + self, + transaction: bytes, + signatures: bytes, + input_utxos: bytes, + input_destinations: bytes, + htlc_secrets: bytes, + additional_info: TxAdditionalInfo, + network: Network, + ) -> bytes: + """Create a PartiallySignedTransaction object. + + ``additional_info`` provides pool/order data required for signing. + """ + tx_ptr, tx_len = self._write_bytes(transaction) + sig_ptr, sig_len = self._write_bytes(signatures) + utxos_ptr, utxos_len = self._write_bytes(input_utxos) + dests_ptr, dests_len = self._write_bytes(input_destinations) + htlc_ptr, htlc_len = self._write_bytes(htlc_secrets) + return self._call_return_bytes( + "encode_partially_signed_transaction", + tx_ptr, + tx_len, + sig_ptr, + sig_len, + utxos_ptr, + utxos_len, + dests_ptr, + dests_len, + htlc_ptr, + htlc_len, + additional_info, + int(network), + ) + + @synchronized + def decode_partially_signed_transaction_to_js( + self, transaction: bytes, network: Network + ) -> bytes: + """Decode a partially signed transaction into a JSON object (raw JSON bytes).""" + ptr, length = self._write_bytes(transaction) + return self._call_return_json( + "decode_partially_signed_transaction_to_js", ptr, length, int(network) + ) + + @synchronized + def decode_signed_transaction_to_js(self, transaction: bytes, network: Network) -> bytes: + """Decode a signed transaction into a JSON object (raw JSON bytes).""" + ptr, length = self._write_bytes(transaction) + return self._call_return_json("decode_signed_transaction_to_js", ptr, length, int(network)) + + @synchronized + def extract_htlc_secret( + self, + signed_tx: bytes, + strict_byte_size: bool, + htlc_outpoint_source_id: bytes, + htlc_output_index: int, + ) -> bytes: + """Extract the pre-image secret from a signed HTLC-spend transaction.""" + tx_ptr, tx_len = self._write_bytes(signed_tx) + src_ptr, src_len = self._write_bytes(htlc_outpoint_source_id) + return self._call_return_bytes( + "extract_htlc_secret", + tx_ptr, + tx_len, + bool_to_int(strict_byte_size), + src_ptr, + src_len, + htlc_output_index, + ) + + @synchronized + def internal_verify_witness( + self, + sighash_type: int, + input_owner_dest: str | None, + witness: bytes, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, + ) -> None: + """Verify an input witness against the transaction. + + ``input_owner_dest`` may be ``None`` for inputs where the destination is + not required. + """ + dest_ptr, dest_len = self._write_optional_string(input_owner_dest) + wit_ptr, wit_len = self._write_bytes(witness) + tx_ptr, tx_len = self._write_bytes(transaction) + utxos_ptr, utxos_len = self._write_bytes(input_utxos) + self._call_void_fallible( + "internal_verify_witness", + int(sighash_type), + dest_ptr, + dest_len, + wit_ptr, + wit_len, + tx_ptr, + tx_len, + utxos_ptr, + utxos_len, + input_index, + additional_info, + block_height, + int(network), + ) diff --git a/mintlayer/wasm/types.py b/mintlayer/wasm/types.py new file mode 100644 index 0000000..6956035 --- /dev/null +++ b/mintlayer/wasm/types.py @@ -0,0 +1,193 @@ +"""Types shared across the WASM cryptography client. + +Mirrors go-sdk/wasm/types.go: enums are passed to WASM as their integer +discriminant, and JSON shapes match the Rust serde structures exactly. +""" + +from __future__ import annotations + +import enum +from dataclasses import dataclass, field + + +class WasmError(Exception): + """Error raised by WASM operations. Messages are prefixed with ``mintlayer: ``.""" + + +class Network(enum.IntEnum): + """Mintlayer blockchain network.""" + + MAINNET = 0 + TESTNET = 1 + REGTEST = 2 + SIGNET = 3 + + +class SignatureHashType(enum.IntEnum): + """Controls which parts of a transaction are covered by a signature.""" + + SIGHASH_ALL = 0 + SIGHASH_NONE = 1 + SIGHASH_SINGLE = 2 + SIGHASH_ANYONECANPAY = 3 + + +class SourceId(enum.IntEnum): + """Whether a UTXO comes from a transaction output or a block reward.""" + + SOURCE_TRANSACTION = 0 + SOURCE_BLOCK_REWARD = 1 + + +class TotalSupply(enum.IntEnum): + """Supply policy of a fungible token.""" + + LOCKABLE = 0 + UNLIMITED = 1 + FIXED = 2 + + +class FreezableToken(enum.IntEnum): + """Whether a token can be frozen after issuance.""" + + NO = 0 + YES = 1 + + +class TokenUnfreezable(enum.IntEnum): + """Whether a frozen token can later be unfrozen.""" + + NO = 0 + YES = 1 + + +class CurrencyAmountKind(enum.IntEnum): + """Selects the coins/tokens variant of a SimpleCurrencyAmount.""" + + COINS = 0 + TOKENS = 1 + + +@dataclass(frozen=True) +class Amount: + """A coin or token quantity as a decimal atom count. + + Atoms are the smallest indivisible unit; 1 ML = 100000000000 (1e11) atoms. + """ + + atoms: str + + @classmethod + def from_atoms(cls, atoms: str) -> Amount: + """Create an Amount from a decimal atom string (e.g. ``"100000000000"``).""" + return cls(atoms=atoms) + + @classmethod + def zero(cls) -> Amount: + """An Amount representing zero atoms.""" + return cls(atoms="0") + + def to_json_value(self) -> dict: + return {"atoms": self.atoms} + + def __str__(self) -> str: + return self.atoms + + +@dataclass(frozen=True) +class SimpleCurrencyAmount: + """Ask/give balances inside TxAdditionalInfo. + + Serialised as the externally tagged CurrencyAmount enum: + + * ``{"coins":{"atoms":""}}`` + * ``{"tokens":{"amount":{"atoms":""},"token_id":""}}`` + """ + + atoms: str + kind: CurrencyAmountKind = CurrencyAmountKind.COINS + token_id: str | None = None + + @classmethod + def coins(cls, atoms: str) -> SimpleCurrencyAmount: + return cls(atoms=atoms, kind=CurrencyAmountKind.COINS, token_id=None) + + @classmethod + def tokens(cls, atoms: str, token_id: str) -> SimpleCurrencyAmount: + return cls(atoms=atoms, kind=CurrencyAmountKind.TOKENS, token_id=token_id) + + def to_json_value(self) -> dict: + if self.kind == CurrencyAmountKind.TOKENS: + return { + "tokens": { + "amount": {"atoms": self.atoms}, + "token_id": self.token_id, + } + } + return {"coins": {"atoms": self.atoms}} + + +@dataclass(frozen=True) +class OrderBalance: + """One side of a DEX order's remaining balance. + + Serialised with the redundant-but-required shape + ``{"atoms":"...","amount":{"atoms":"..."},"token_id":null|"..."}``. + """ + + atoms: str + token_id: str | None = None + + def to_json_value(self) -> dict: + return { + "atoms": self.atoms, + "amount": {"atoms": self.atoms}, + "token_id": self.token_id, + } + + +@dataclass(frozen=True) +class PoolInfo: + """Pool-related data required for signing pool UTXOs.""" + + staker_balance: Amount + + def to_json_value(self) -> dict: + return {"staker_balance": self.staker_balance.to_json_value()} + + +@dataclass(frozen=True) +class OrderInfo: + """DEX order data required for signing order UTXOs.""" + + initially_asked: SimpleCurrencyAmount + initially_given: SimpleCurrencyAmount + ask_balance: OrderBalance + give_balance: OrderBalance + + def to_json_value(self) -> dict: + return { + "initially_asked": self.initially_asked.to_json_value(), + "initially_given": self.initially_given.to_json_value(), + "ask_balance": self.ask_balance.to_json_value(), + "give_balance": self.give_balance.to_json_value(), + } + + +@dataclass +class TxAdditionalInfo: + """Out-of-band pool/order state needed when signing pool or order UTXOs. + + Maps are keyed by the bech32m pool/order ID. An empty dict serialises as an + empty JSON object (no pool/order data); the WASM module rejects ``null`` + maps, so defaults are empty dicts rather than ``None``. + """ + + pool_info: dict[str, PoolInfo] = field(default_factory=dict) + order_info: dict[str, OrderInfo] = field(default_factory=dict) + + def to_json_value(self) -> dict: + return { + "pool_info": {k: v.to_json_value() for k, v in self.pool_info.items()}, + "order_info": {k: v.to_json_value() for k, v in self.order_info.items()}, + } diff --git a/mintlayer/wasm/wasm_wrappers_bg.wasm b/mintlayer/wasm/wasm_wrappers_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..c24e04f2b463f800263abefa35366e19f0ff29f2 GIT binary patch literal 3585770 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
l<46+^8EN<*O{^xrK~-!WDT}nWG#CrkCO;m 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

OXY1MC+0(p}Q&Hf9P(8*42OLZq{|TsO~!D$};V% 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�_dv}Y%uL%xN7 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

LZd2&LUzUhUPEiP4ZD z3Fu~P`2j9ZTXb!q{_$ZLFZ%!TpEl)U9IWBY71GPTKd)zvWfZRC}@Tl2${Qn$H|q|Jg2IP z5xOW^v{?5#KetElfr-#C5x@!KEXD|TJZm$)mR6P-Vb7Vmiivk%gq8Y`$Ea_7EvwYC zamM62w>FgE;Wm9AVh6+L4iZ@8r+J-Uye5mW!!dW(RA##6H;Qn_V{6!FVE*04zr*6S zk3;HAO#b1nD%XDTx@Fy}WjzADn?7_<)of{DCwJJ!j|AN+u1;w?c95-d}saLE<V=gn zGc)pt+C>`HbmmE~opICgHRWMIQ~mO(?Y=yM)YzCN4Oe6NaXmJ1rMFf3G$1$WnkqA& zUQ=OlN0j=0q!k@s*AC~kc@&|C*Em<{TS@oNNNU-@sp9}M<@il%6QCjuGKX+EG z5H4&>&o4cmy@1{GR>q(@EdUvPV0q<^hh_;Gz8Tll5NmObCF=krnC zzwdglp9UGC=hEQWM}8?jsw?yA!aSb6I}P=(@mnHI58>?)z7LFS80ykCu*DqLwnXmX zvml8#e01TyZy~L8^>?V>`Mgg^NdR17(s5aKVDy-jxN515nYDVUqY8Y2~+6Ou=*!g=k-sc%kcDe=#o)XM3>QN>e&HZ zhF6)JWT&@9m*&+TUC@nNsGv4Om+@&&XSieN(mCzWB_pAXE?wK&+Czrj&}Cw|+LHA0 z=rTZ}fG#a_p8*f@=#`;M2PNzkT@vzc$6b1-_l7RxQ>O5Q(C8Gp^trP;x}?-yLYJn@ zj8F69My#PLy`j>l(PhljC3MNiyd%0aeO=q5%kZRgn^T_VUKO~@Y1f&Cr#!l(+%a_N zlVa%7xyny2NicL7l4Xj!T$Q6s*Cw8mQ!?*v=rYhAUe8_HSLNu^GQS$x^EgQPILBVO zOCM#F(4~XwO6ZdM&K%Jtb(ZLyatcZ5I5X(dv)$jVtMcBxSMHM0Ak`nyC82(`FrrJ7 z`b+4NkT8WVU8}!+I8 z>wZLnn0geu2)fAM20A`wb&OBa2};aNhAzDzwQ-6`o8KzjGly=V^t`&=-Yyg0z}Q6V zCFJohmzkWzuD0LLh4EoDm6CVR`LkSFDiY!S2ev4z|#8Ydw^vPb=P z(69V0zAD8Ccco8!0( zNTtU;1Z5{Y1a(gOIe6!|4^YL*_~u6__oX z%k&J=1 z^7;=JHBRJ5GA6nX8v~B3+l*q_xZLi?e0TbgP!ny-V$t3S+Lpzl2{TM67l|h9U_!Y_ zG~tjkFkkK>eP^-G38]NC?QQVP?@ZCzexd-^(33`|h)K5&r_Hn1Y5C*YN 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 &A1v>Jp?Q97+>$qS28J=iH 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�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

lomI~(!7ZCg3!yv z{?jAuinew!;>K{)O%(j>Zrp;oex_C5^tDQUU!U)^m3peD`R2DdEo(xhseb1F9TBbm z9&6<@)W{H^jXLV>#CfzoY&(yKnwob(hUH#ChNgTeWohA1XhVneO%-Nk2dnd`?}2ru z=}+K%>Q2Zc=PlQ)Ih$t>a$!=-Ja>redAXuTkdoeY+t1i4PQGQU;i|Q^4Y!-H zRsV2*w;jb+aWR&y`X_c`s~kSZR=MfkY-PXrs`C_77?+CAJBhy?=&w?bNZ1~m#Q4YD z_Q|w!w5AtbjT(5gQQJbi--SD`|Ik`UE#VR`#rsprNeXEt=!2TA9+yJ8Q5eMC_;(Lj z>3c8x_j&qH>^pzx_GwKuu+VUdK2+YIZp$Z{ZG2;1(6fVof5yJ0Db=Jb2j)AqEol}% zUplWNmspUt!PQ_i(S$eBTDaa{8n(6Sg{8?A>9=3zk2#9_6tMLL0PR;EaruaOKRAc1<9zbS(mqz zj=D6!2bZ#m*wgqip2$%6|Hl3^p8wCXub*ApdBjVhw4D<61oHxLdoK7lkM7I1R^R?^ zN_&N+1Ol&u^sd|goby}z;_v9^!DfQ_m0bPJI}%pqB0a2y`W;m~&u*afWOwqcP&xFwc$wD6 zUGctX^}?XA@AVD0{gAEluFu)32KW_Q3ZvMnHQ{yxwrVZ)W~)4J7+cjSN3)gvv2103 zCR^p5^VrJ2Mz$)=+t@07?c>bDKHB1o9={_VD>1hhKcxG5dTn$$`l){5Sm&MW%U{!H zvahjFbFV)5xTn{khTYrKo1iN^tr~clr^lhIJv|A%t*57=+t>i2<_Yd)S2UDkhkkO zc!_7=H}r3J?V8j&Zj^K^8q~o%+9QJ1`a+$^q>9(FH|N$pR{FB*dw^r=Lp6ObT76@t z??Nk`nmz#?_w-rlQE1CW-Es00{&R6K?llHu=7*vEbS>?h>qWkyp8Ye?{{2v0(|51wKGOQx zIW*eRF>2v=5(bP2G{p)D;(AfDVqy6}ou2t5&sX)qSJdk1y4w{p(d- z+qW<6+gI6y3lsW&o?w)kGr=hWQyCVu?%w=t&`rgL@i0dbz@6_|7yoo1@?M$eq;SKUTY zAA_yIUVa?SGp1`YT~3_onoVm|LheoPg;p9gokMqzXxZ1#?C3t}7@siD&;z5_4wyn1 zOu-0?xbQ3KdU2)Trouh@cJC~2Fh46XSN+>`Dd+IRtsYm6rtU`EIrbs`?q7*x`eH;Aq&A{AG zM^n)L`L~OhzpzT@`|}#w58vzPQt$k4pvye{CfdKh>M>OM(9g=jXcF`rq`(bmD| zih>v0%Ddek51z}F%G^%yG1_i%`vs+=9?#B?aB!AleeXT4?KjkY3vt>)n3bPfoHwJ# zpa;Z@$F}EKDaTeMclf2ep=@lASS5^vjrkBk6Mpug?mCdI>21+!Z<#(4tvDq%M)iyL z8#O*&G}F@kN)KlDA@oR3KaW;=F!LYK^2_u;(Zf8w&gx-(#Ny(AXFg@;SkW|V<-zNO zw+HxId86soxL2A3YI+N_U!JRcQJu@oSG2sb@IHWBm4BvRVqf({(;u*}d*Ex8Kfc!e zHvMkIzO-*&+PD8!#J;p|U)r~?`0~Re?c103?Z1NV2^KzSKM#2pt@?_YOP724$%whM zZ~i5^)Uz)g_w;5fh4;_=uSBa}Z(4okYS-987Mt?i>wcJ4pS<$?<;^LJE&_6DS-3#Q zN%*O2G<~u=r)l-Ys?KFv{jtM6t-dSYTzywEk1ir&?uX;Qp2PRCr)Pat_<;R?f!X<( zV=7Bc@8#Usb?$>*`C;Yw58{Pj&kDcotgbL~HCr>`rE@dfZ3s z{~OGo`B;!W{Wu)h|CpUmB>1h2x%|**+GpU&V0Wx5QlJWD^F zOMJ<(uRuR-bnHLueC>{LdBL%7(BFdjwGjrrF*Ds0tun;)iFl+s(yT-_J(h8h8NocY zTi6t3c*I_@od1Dio!v0p6xb++`A6*NCqKkbo|_!QuId=A3I|?fEpVvo zQb&{dotv|`Ewqx8_3GmBrffR!VGzZ1xb~j>ED9WYLbmOiH3IHGzZz9no@nM8-%+2T zX|>5Fdb)w|`S&Y<_TA?q=2^7w-=PunL(uYHKZ~oCI5txs>_~M!zB0#|*+Cz^_i`du zR^hnPbKstRTloJIj!lEEoqx;waKQhTk6rv%AFiD}1ZIj`VD zmh>~bztqG0ABEOKp|qkrqCu#{Fb2T?VSU_}j9uNlE0?7*N4 zYalPD3{+`9s>>=iEKF^2r2C|npRZNBF5Rpore|O~P*1k$@$4&Y`1Y6QzOYnh*F;#V zK=~i1H^0;ay!><A(#XGCYw>di3o z2icE%`WW_md-_E74p<`RKub-L6BU)+yw=B9) zihZlOsCN1@vsJu_O+2&MQ`%G*db7U`=oyvn!~UA*H6!{DC2lJ*tPa! zzrUvku&O%Xt6VbOf|h^29~vFe zXocCi53T2FMO#$n?$6u@)jdq#iPorw=^>^X(xTndaI5@_h1s>3Qass|;ER3C6$$(Gc_E5b zggn3h7&(_(HU2fI_u7wJ^^W^t)7zka*!1@50MGx~_@`&gu0`6nuMurOy}T9iPm5l} zaj$gSQCRfKeHSfyaXHPmE1qjH*QWd9xeJPkpbV|6o6(M$h3f!k*K{-5kB24~Ps-QK zj(PxmJL-w?^gQt``7+V{#;a!zyM)lnA;fOQEJl@vI@)Qketv``MBn#>CdD5UC zr|(DNcn|#7wbhYPng8S6Ie$I;`}8$8vk8;V^XqO#FZY`JE%#{ug8y4O|M%e>WS7}I zuaO4ZflZ0##$wo8B57tWdd0%EWVs>eSnkoeg>Y$6Q9phqRE}A_;|Vf@p=kZMgn(_i zC&9Z;Q(D81K)E%O%uN#(dt;YuHn6{Dtp2_`=`p!u4dpCVxDFRANhVlrq>*WCTK1*5 zPH>Js%gH4%A|SpWzCvl<>t1r zb_+9K!)2s`XC$0>WJ4u$=S&<}YeExKl z(8YXUf|t3|@tMqgcGVe$Gw>l^){JQ)1y`vA;g*mue4y&*&J?Diu4kgQ!8giUQ^9uXME0gm4ED#( z3Y0cl%cMS+%w!5X!D5_gNf%OYw`dmlQ*emah5f+9bBdX#0@KMn@CEyrchUtLo-1d^ z9T`eGvNTuA{`R=7t64x%5OHvcjY{(xkPJ>M++&8>L&ldp`oqd?fp$ zfH^VshuqI2e8CSILWzyx7_X6Ma_!BDrE%U&Xl7n|D_tbaA?Kw_ZaT}(#mU#x`bHdy z!afAhyfpUOh?3xQ?2SBgs-?TB^XwI$m3sVlE4p?%K9=LbGZ`E$+8-zTyd~rNF`i?- zo)FO!aS&Cdhz#vUGv{N_i`qZ40!5dfrr{-V3ro_8ELkLitq(EP}#Zcob6oL5q5%|VHemH z&gNS0g4fu89o~R9;VpO@`g4wV*uD$z!Taz5{0lyWkKo_%F?<4_!e{U~d;wp=SMW7_ z1K+}T@ICwhKf*Z-l-cJG=ld!av|8co|-SS7FIYJY%2-O=FIFkTm~cRZzjWI;;h2!rIUc)`fLoeOM1P zpT7jU!v>)Fc0FKY*a$X-O<;4-*u3UTXimk}uoaX-9C|@d*akGGuP^igjn|h!f9MAT zVE}9k6)*@i?`bg9z)%!CcUs#hqYB*adb5y{ob->;b#OJor5%U_K*_h!2k_Jw_5KUfBOE^;t#W%l7^_OcR{R{uwZm{g*EdS4haRABPS& zAG7n|Lbw1fhKt|;%r0YlDICoH)oibVBiO%=?X_?e`$xk~?B58tz|EjJy|=Ty4eo}! z;6LyHJP3dBwmSAOJOU4STOE509*0N0t&TkjPry^~SNIz|4bQ?e@OO9)UV!J}AMhf) z3@^cP@K1OZUWeD!pHD$_zXUWPra>&i)j^|uYr@)~k-l|d9ndJ;dhk0a0gd8q z02;090UN_cpwT{!0B#PO!IrQEXnxIBa1LSU#kMDG1HGXy^nr5FoQ3|-4+g>j*cK|F z3Myd`R6}|I&pF%Sa2EbHqW6RSVJye$;Q)@S7v>n41QTHjOor`YJD3JjVFpZxHr%&B zI~<7n!{i4X1;@h)a3yK{WVTnaJ%#OKY>$O2;B@q9a1Hwn_;EGcv(c^W|B>yvkYfK5 zwhv%-Ios>mUc+`g=f9rq4WORUTeXkbb#Nx-*6nZ)!x4M2Z3oQ}(7XWkbS(mX&ihBu zXTCp&tKe$52Gkq*I6MJQ!ZY}DJ=+`LDYy}Cf}7z>xCL&7+u&*V0#tXgFx<;9j^7{tkbFPeHw@_rqV{0eBFegNNW@(E2}pN_h_1J_d)u5pX0N1#c4G z6WN{w3h&8q3Y-cG?`d#4oB@7#6>o~Ov)C%Ue*lG7bpiE$o&)E?d7$u~4+`&vpzvy| zuwMih!zG|_UkaDO<)Cn1!S+fx29AT{;dxMa6~_vf;!^P_KXm;%r{d|a@FKhbFTp?H z6?hr`39rKI@EW`cZ@}B|7Q74Z!29qX{0lySkKjZ282$~qe%&)&pYF*wus>M16laRd zo8fEt4}1pS!MCsv>U;|Lty0h&83fqQkH-e2}6WA0sgUw+JQ18lCps;Pt zHV&nru=QkXVe7?yZ`cOa_9#NTYt6#U?5b$wh)7rU}abZ)PuDetPX3yny?mh zgSBBDSQplV^&tWCAqj_bjs~|)vrWMQXoL(j!9v&*TA&%)pcVFlcE~{%Iv@{=VG%5a zC9n_d4a;C(*dO+T1K|KT8jgZv;TSj`j)N271UMN^f>YrXI2}%dGvN&Q1DpkagtOsX zI0w#$^WZ|b04|1$;8M5*E{DtDO1J{9hO6LOxCX9=>)=MX0d9ty;8wT=Zin08PPhZ^ zhP&WixCj0Ue}+H7U*LXt5FUVs;URbw9)ZW=Wkbzjg*Py50C zZ~z<#2f@K`2pkHBK^0WPAgF=CFa(A|EewM?7!D&~B#eU5Fb3*jER2KkFaajQB$y0S zU_00zrouFs4l`gT>;SW1Hq3#!up?;V;!3bGtOBdTYOp%20c*lq&<)mxbzogs57vhg z_#JEj-Ju6;2phr1unBAmo5AL=1#Agh!PXFmQs@c2pf_v-ePJM+KwftuoCGJsDR3&B z2B*Ura3-7ue}J>$k8lp03+KW4Z~3 zH^I$t3)~8~!R>Gd+zt1@z0iIoX$i8BgFJM=B3KMdU@7bk`@p`i4EBTl;Q%-g4uXT> z5I7VLgTvtnI1-M6qv04h7LJ4C;RHAlPJ)x+6gU-5gVW&*I1|o-Kfu}WM>q%0h4bKi zxBxDMi{N6o1TKZk;BvSEu7s=LYPbfjh3nvYxB+g2o8V@+1#X4g;C8qJ?u5JGZny{T zg|EAlSHZWycX?yq!w>KYdRrc{=h5C*`uPytm?34@>-215-Dg&{BuYGF9k z!AKYZqhS=(!x$I`V_^b}he;>(RgDiAF9u~tQSPDyE zAJ`j~!M?CR><0(J0dO!J1c$;Qa5x+WN5T90w=D32-u;1gF9&pzG2# z{*z>OKHKx)Lbw1fhKt}*xCAbT%iv150M99wxvpup8_F^I!*<4Rc{9Xo3vv z2@9baTA&r$U_K z4!9p)fEVEe>^#NxX;=h{;XQaCuEXp@wy(kKus7@jZ^QSn1eU_Sunay2_47Oe+mrkk z!UOO&OsDUs8roqm$U+YC&;g5JF)V?lus7@j`@%BV5B7)okbnkALJHE*2n(PIGO#Bs zgl1@gR%nAm;9z*FH`fe*gJ#QZ!(nhF905neQE)6A1INR0a3Y)lC&Ni_Dx3nR!)b6PoB@A;v*3?#Hk|wa zuy)6BxzG3G|BKM3ZOz)&wzh>3LI@$#A%qY@2%U2}bjUe5LI@#*M#zK^LI@#*5JCtc zgb+dq;cRQ$+4g%pormw&@ALcf_u1|CxV`UPr**E=xtw$Ax}L8mT}#(fC*4Rl&`s1u zx6sXWD|OTDbQ|44J#-h{Nq18(-Anh-ebh$}(Eaov_0z-j5IsTz^cX!#kJBJMNl(yI zG(^wP)ATG2)ARHky+9-M61_+-(N_Llg8Ky-V-YBz;I9 z&vI-L-$f2-ADJ+ z1Jq9s(nItx4bUU>C_P4l^f*01Ptp)QMbFR+G>@;f3TbEBiFTnP+KqOl-Km(G`C2T# zE{kh?jkXt+&_1*`?MtP!KkY{cP#GOW2hzb*PKVMVbQo385p+1sr%GB#3uqBl(NT0H zEv9NZhK{CVsfNy^Mmn3$qI0N;&ZBebd}^i(=>qyQwa~?M5nV#9bQxVrms1;EL4Tnu zshzH-t7u)mo?D03qb%Bh)~5|An>MD6XcNkz&1h5FlD43&D37+Gt!Z1zr|oGw+JOpa zNBR@Zqe9x5cA{OVh<2l0X?H57J!ucxi%Mu8+MD*JQre&PqXVdn4x$6;U@E6W=@2@M zD(DD0oaR#{Eu;msh^pu)I+7MsH624o)3H=TOKAz6LMKxLof_uP!85p?PG?dholR%a zIn+ew(Ye$@7t$jByt{;JD_usH(hyxif1xX>ovx;<=o;#v>*!j#o;vA9x`A$@F1m$o zrdz3-j^yX5pqQMfp`+moi6!}u9`j-I6|ZhwL62)#_B^aj07Z_+ruO>fcFiF`f6^{;d*)r% zk-F$6x|wdFZn~9jquZ&6?w~vAF6yPb=^nb5`shBopB|uodXOHXhiQNwp-1U48l=bR z33`%-=qY-do}poSmY$>MX@p*&7wIJ$rI+aydX>iLHF}-ipmBPW-lDf@g5IHb={=gH z_vr)rkf!J(`j|eUY5J5tqt9uEzMwDZD_Wfw8?8q3{>y)7v@;daF0?D{M#Z!{?Lm7| z3GGFD(>_#6`_g{2Kb6q|bRZo><#aF|LTl4Hv@T`QdbB=mK-sh*ZA2SW4sAl4(q@!P zo6{DwCFRjpv^8x*`Lr!?W=c|I|b z@7*QxTw)^MyG!JG#6+G)OyqgQM4m@XZQBs9=ezM=svoi9-w}DkRGCkX@DM~ zN9i#dq{rzAdXk3dDSDcop<#NKo}=e!gkGQ*=_MMam+2LHm9AJVF`=EVq^sy^>Y!`r zTDp!p>3X`6y67glnQozOx|MFD+o^}{pgZX<>ZQBsUh1R!=ze;D`sqP>mi|wLJf2pola*^Bb`ZS(b?2Q=g_%y9yQbXbOE){pXnmHm|E!)x|G`J zavDtG^Gr|BlQcw6(bMz{4b!vq96e7X^a8y|FVQHyOs~+ZG)Aw{>+}YV)0^}by-gGJ z4!uk7(ImZ3AJB(1MIX_}^a)MVr}PQbUocbH&PefL^snd z)J?b2ZFD>J&>eIq-9^20H{C0mm94y6h@j1H$GsFLQ>0$NB_w1@`Nc^uIb^dt?@ zQ}i@FL&NkeJx9;e2)#fr(n~Z-FVidZDvi-=^g6vkUsQxWY#yV7n{OuN$_v?rC&UbHvuL#4DY?MM4l867|e(m_;C2h$;RC{@s5bT}PB z>+k}{bt#M1qxES6%BBrzBifj9XcO9$HltkHoVK7XDUY_It!W#|r)_CF+MWt%2l^B3 zNQE?ycA}jrUTB#}tI(>HM61#2v<4;9kLbs=CZ*6%=%@5EN~NFETJ#G_qhHdm=+~4^ zzoFmK?0R)&-WAX2-SDiA*UK;0 z@w)jr9j~8Xq2qg(2@BH__$PWo2_@sW4|`FHj@QUfQPnl8oZI$m?1q2smpnR+o~D{Q#V+<8}FYI$ocjuj6(41v*}@U#R1C`$c*_F4hZhiC&0Hbrmkti*UI< z5?AP>aHX!sReCY5)<@$S9pCS*#qsN^p?YsW7B}c6xKS^~O}Z90>*H{XUWQxs@wg4g z$FHLfZ$ANd>JxF7jyZ~MU5|V8$+%aag8Ov5-mxFY#~+Nm{c${`pTNWVNj##5@TiXO zd5_`vI8W1rw?Bg?b<8bH>6l-b)-lI0qo2pKdIT@mFW@;Ha}FzX%sV7ht$eJG!XzE@ z56L>_AX4DzJ3oE z=t*3t-^WGz16-^>#3gzPm+E+qp$y08{9~%{_D^u7p2k)BQ(Ub-!!`PIT&rhro&EyX z>o0MG{t7qhS=^+*#?AU0+@in5t$I0b(|^V7`fs>H&*4t}58S2yiMusl$|m&a6}VUb z8~5q|;C{`QiU|Wc{$Lx_iFin_f`|30ctrDMK*FfzpS}rWdUZUm*T54x8BgjT;VJ!N zJgwKnGn#+4CCqC6NtCc${}j*ZpWzic6(=lO`I!GXPSR`PWc>@AqSJ7y{v}S+zryMI z*EmD-&ys{p{TrO6e~YvA?{JRJz`6SOI8Xlp=j%V>0-cEq_1d^duY-&Ay0}DV;ZnUG zF4ODda=ihr(Al_BZ-}e(Mz~sUjB9ibuGO31I=v~b*PG!6y#;R6TjD02hnw|QxJ7S` zTlF@$O>c|a^>(;JZ;v~50q)W};BNgV+@p8Iy}A(h>3O(c?}P{R&UjE4;UT>X9@e|! z5xpB8)x~&B?}5klo_Io+;7Pp~p3-~cX}u4g(WQ7+?~9k~{qUULAFt45IN`{ZkN*R3 zl0Fb8>w|ELF2||*V4S88!Rh)?oS`dlrala3>BDihJ_6_HN}Q|b<2=0p=j(;IKv&^H zy$BcSBXO}l3YX|=T&fr2GJP~I*T>)rU4tw2vA9a}&+UY2y%g8zT3oA-!*zNYuGh!o z23?06^$EC1pNO0FNw`JV<5qn#ZqujWc6}=D&<(g#pN6~i>9|{;fqQWL-Pefwy!}kv zug}5*`fNO?oA8i62M_CW@rXVTkLqSTrq9RY`T{(mFT|6&1yAXV@U*@d&*)Y>t1rRJ z^`&@DUxrucHk@$O%E$cWI7$BnC+jP4if+fL`bwOpufpm2YMh}vaHhTnXX$Hkw!RMM z=uVugug7`%2Ar>N#09zw7wVgEk-ixh>sxS%?#8A1R$QigaJjw%SLi!&rM?SS>0Vr| z@5VLy9$c&M#dW$5*X#RmgT5a(>IZO>?#IpgLENGTaI1aufzWxQO!g6H(Bc!eIr z3Dqk<=4&`fzmAjj8#qOe<5c}7PSbDUbp1BY&=WXQzk{>%yEt3Fhja8K&eiYZJpBRA z*B{~nJ%tPPN4Q9TjEnUrxI|CmQvE3|)1TpT{W-4CGq_TJfvfbFxLSXOYxLK+7RTe^ z8(goy#f^G7Zub5Eid*#GaI5}1ZqswPUH=1j=zro){V&|5SKw~_Z``B*gM0OVai5Mm z+piPxfL;X;>X<1V(lJvytYgM>M8}NjsE(P_Ff<2q(gCv?o9PU@IRozf|ITE~p) zjE))ASsgR0%XQ4G&gqz8U7=%!HDU3}$9BxLCh3@IP1Z5vnxbRIHC4yVYnuM<)LR`h zuo*gLU^8{h#AfN3iOtqABb%dRMmAT+%xs>{#QAz1T%co?wou0`ZIO=I+F~8EwIw=c zZA*2`+Lq~elL*)vePpyIZegcDF&tEN`QZ z*AzABnCWfSG2`2!cfhSWUVqf4KR4iD&sV1v&LgOW{<~pyk=@b$Lpvjb-a#hO7D-S zb@jbT8SQZ$^TiXsPt0pid3(%lPwSXRp21wcd#&%B zj``)JV^)6rt8ohEuc+_lxKq77=DE|oJ?6SIbj){W>Q0>H`^PMFj*dC+JRP&%1-^gG zd>87N+b;5bV*b0t+hY#ARLARt%Y2`h39s<>m<_MgJ-AB8e15gQ6W8dwaIKElE7$3} zalMYY@&+8A^O)an^7cO5tYe2KE@$nzV1HS(N z9`yD{@UXYX?Ei><43FwTJm&ky?D>R_x%w#`v-UGO&InkJ=!R!`zO{XVYOaYjIc zjxz%qb(|T{q(8#VI?fPi(Q&3gtBx}T+VrQmUB?*%9Xie&=+trMK$ng)2)cEgLC~Y) zOoCoLi~DeVZokF@I?f&#@_oL=!#d7S7{Oe=JNIGS_y0RLO!_`?e!-NEa}K6;oMSMf z|AlAuzwvVYA3Uf3i&yA`B!0qUSN@(R;v~HaPS&g96rF@q^=ddxua4988aP8I<4pY{ zoTYz^v-O%dN2lOi{S%z0e~R<<&v1cG#fAFkxJbv$V=<1;|1WTXF{`?U)dwV8s(QD&Y-)9}%j`^+P zwNE_ue4i}bt=GdndVSohH^6;58~5uC@qmum&OsdaXJb6N}*8`tW6aGfs2^?G02p!dU#dVk!c%W$(k0JrD^ajQNE zx9M`+t`Ei?`Vicy55--&0(a}faF0G5_v#~XpRUCHdOjY|3-BP0&(A_UtgG;-@3RPx z=_B#DJ_=9hYCNeI<0*YKp4P|U8C`>C^|5%lUV`WJQoKUf;)JCuAFIdVB)tqL>*H~X zuEVMN1e~T%#OeAZoT2M+ral>G=~HmFJ{9Na2Ar!;!+H92oUhNo1-cOz>N9bXz5o~N z3vr2V!KM1oxJ+M!%k{;$Lbu{deF?78m*Q%D8LrW7xK>||>-1l6y}klB=yu$wuf$FI zD%`BE#x1%7x9V$fo4yve>+5ib?!=w?dfcUNz}@;r+@rg2uf7TQ>6>xCz6B5HZak=O z#Y6fwJgjfWBf1BV>O1h5z7vn@yYPhW#gqDOJf-i!)B0XKqx>^}{$t58zb&2u{PT{T}YnlekmAkGu2-xLbdSd-N3U z)gR$L{W0#>pWp#KjR*Cocu0SShxO-pM9<(+{RJM=U*d876`s(ucv63jr}Q^?T7QdY z^m06_|B9FEzu`Ikcf3N+;e_K>KK}oKlk`7vvi=uN(JOGO{x?q3|H0|{zc@oDtj6PC zC*mx<3eMK6;vAiXbMP<9wwy9p@{x>o{+zLucYny*BRB>)>v^F7DA;xL2=-`}F#_UvGd1 zbez{TsN?*mAsy#84eL11X++0)PNO=`cN)`izSFpl^PVPjoUJseo{|1 zM#tGpvpUXTTCU?Pra2vFGOf^YHdDf~m5={8qbW(pSxw10&TLB2aduOxjx(Inbe!ds zt_yL7o`*Aaobi;UeMmrgWT5Hm&1~ zvKbv`mCfo#yj-7&=k!^4g+3c69KZ7M--MI&IXGFLi&J#W9H;7-JxX>~l(=h{Gu45LuLdQ&WrHLwjC*3CL*ty^@=T(|0&y>8PngWaxU7P~{oOm?S^+3YSIGuqucX0>~CoQc(|<7})x z9cN_q>o_ZGK*yO`gF4R68q#rw*07GVv_^ECsWqzOY^^aJXKan@@6OuNapu;fj zbezF8t>Y}N89j+-_4|0a{s7PE5Ag~;g%j#lKK?(#NjlE(O4gs?6dh-JrRq4_D^154 zU+Fr|`pVF8=2xcv0%z$s11wv|SztLj&IHTVaW+_6i(w)-fAgqhm(6R>!PxosOB| zdL6UF4LW9s8+FVQH|dxuZq_kd+@fQ~xK+ojahr~r<8~dh#~nImkUMqEB6sPSN$%D$ zo7|&gM!8piH><2;X1QO-?DBw)8RkJ9v&=&}W}1g}%r=kcm~kG}G3z|0W9E5W$L#Zj zjv44l9kb9=I%cA$b<9T3=$Mh7)iEo*T*u7xoQ~P)6*^|96HZw9_>WoYBpox=$vS4M zQ*_K&r|OusPSY`Sovvf{Izz_{cBYP5>?|EK+1WZ~vvYLJXy@vf)y~r~vz@PFcDq2w z40oZ9S?(eoGu_2HX1hyt%y^gTnDs8xG4oxnWA?j3#|(I-j#=<39W&w8I%dObbj*m? z>X;R;(=jt%uVZ$+LB|YvqmEhfCLJ^7%{pewTXf8rx9XTRZ__bz-mYWzyhFzfdZ&(A z^e#P%yY<(&M}LER^|!cBFUS4*uXsSu;X(ZmJf#1LhxNbkh+ct5^}q3$jx(LdaeTit z&UBvCac1+hj`Nylb)4@whvWO(aqeT%i7OpvG^gVDIB}M8x{k9&GIgB&n2qCkz&Hys zN5^@jxjN1z&C_u{X}*qgN(*$HS6Zm!+|nW)=a&}iILEX^$9bluI?gpM({a9OxsG#A zD|DQ9TB+mQ(<&Y3pH}NQ2en4Wd8oBI&PA=$aXxCjj&o8QbexyksN>w!CLQOeHtRS? zwMEBys;xTCRc+I8zG}OUb5=WaoVVJko|wCN5^@ry*kci?bC5SYrl?j zS_gET*E*=<+}0r-=eG{)ILCEF$9b-!I?i<+({aA*xQ=sPCv=?mI;rE_*C`$6j7;k| zduc|;xf`=Of%E#7>qI=KSHUavsyN}Km5;+DoTOL7$$E91qSwHwIvJ>U3PDe}l{Q zZ*hhG9j??FxJv&XSL;9E8vRFHt21$(UK`izb#Q}T7dPrG+@#mT&3b*@qBp>;Ivcm? z4RO2P2zTg>ai`9~U3wGTtvAIzdNbUsb8(;E9QW%j@POVD59&NTq_@JudTTtQx51-2 zACKv6@wna&Pw4IOq%OcydIvnM|Ac4sj(AoV;^lfCp3^(w6?$i!P`~o=UxbtNE;w25 zic|D%I8_(pG`%}c*L&a$y(iApB{)m(g|qeEI7jb;b9E`s)BECly&o>n`{P1ghKuw8 zxL6;EOY}jwRF~s2eK0Q9hu{i*D6Z5MxJn;}tM%cyMjwG|btSID@%P|-+@KfWCf{cv zZq`+}MK8jw`bgZSkHYP`8h7Z$xKkgEyYw-*Ti4(oeJt+POK_iFiu-jf9?-|(LA?wQ z>ErRRuEQhx1U#xw#AEs-Jg)2UggzNh>QnHPJ{3>v20Wur!?XHyyj-7w=X4`pq0ht# zC$D^*pM{h3**IA@;S_xiPSxk)G<_aU*UdOXpN}*31vpDzh_iJI&e4Cyx%wiUr!U6& zx)m4bOK_pS6c_2saItQ~CHit)s;|anI39=B;tFr?#FhGbT%~Wo)%r$Uqq}gez6saq zn{mCq1vlt!+^BEGP5L(6tZ&CHx(B!FJ8+x66SwQTaEI>2o%(LvrSHMr`d-|l`*5$m z5BKT&ald{559oe8s2{{b`XM~5AI2kk0FUZN@R)uSkL$YR;!6EK zuF@aiYW*Ru(Nnlqe}wDw$GBd9f*bTSZq%RRCjA+1)}P}RJ%d~I7r0G-iQDy8xI@q4 zPW?6R(%;~2{Vnd%%W<#%EAG>O!~Od2ctFqLLH!Rrr2mPB^}q0lUV%sTzwwy<4<6V5 z#S=Q=k39Z$BA(K#;Ay=op3zBoR(%j`UIVYt$vENEm5=`);UxWIoUGTxDLMtG z>Yv~={ZpK-e}*%3D$dkD$60zUoUMO>b95Tc)xX4fIvwZh-{1oMTU@Arhl_LuF4n)t zB{~zA>a}s1UI&-!b#aBx!j*bGT&35?)p`S5qqA|X-VoR6jc~o*7&qt~+^9FfO?p$@ ztT)3gIv2O<&2gLF0=Mfeafi;soq8+WrMJf2dK=uM^Kq}<7We7xaKGLj59k6ssCU3a zI?hfX);r=6U5H2ZJUpg%!sB{pJfVy5q}~Nj>0&&scgHh&4?L^)#LIOFp3{5b6?$Ks z(6I9HzdugW2jFCV5Khqt<5YbpPSc0sbbSQQ(3Ln-&&OGM0nXM7agMISxq1=K(?{Zb zeH1Rx)wobE#zp#QT&$15CAtQe>SJ-4UV_W@Qe2^Haiu;ESLtQAS|5*VbRDkMC*V3A zXQEMv(g)NoSELF<4pBt9cQbz=r~ioRiB32bR%xpXW|Zh7Vgw%<1XEVyY)G^ zN1uy(^?A5YH{*VNJ|55);6Z&M9?~s%SpON1=!@{Ez8H_`Ry?jR!4vvYJgG0kQ@RaL z>&x+s{tKSfSK#Hk9na}2@d|wvPB?Al0xL3c8`}8F4*YD#2{UILIAK@WAjfeH8ctn4ONA>4;OwZtP z{Vkr*b9hq!15fFH;%WUaJfm0OS-t++JkD`^?Y0qKp*O}!r?0$y3!H)zd7r&;s;L*PQQp(=$CN987m*# zqc};wjFa^%I7PpTQ}q~5)34!l{W{LjZ{SQlj`;7UD>tMsS1S|{Z2_}7WJRL24ay(VtgDY!%b1b6D6;x7F&+^u8JM~{wuAH8}l z+^2tm`*rLA8PLDPgZfu^NXLGVVI6xyMs(~88P%~jWK75YkZ~P*L?(3X6PeVpS7b`Z zevxUNiD&fMcvi22m+N)$oX)~4^m;gz{xrrr|1oFs@@2v>5Xx^&cPXa z6P&3x#aVhYoULMd}d-V*2QJY1l+!i9QkT%@Cje1wyq<6#3x)`_U-Ephl1Gnit zal0Y{kHP7>250DFai(5^v-DD&t!r_PUWRk^@i$PHZIdmxLluuEA+XzQlE#bbTh8j=i?fE0j|{-;yT@e>-C>;gT4qi>Wguc zZpF>|65OIM#jW}>+@{-byS^NE=)d4jeFg5)?YLWCiF@=_xL03|`*a8H*Vo_yeJvi; z*Wn@EiHG&|ctqcTNA-<(On2dNeG{J0H{(ft3!c*5cv|0zXY_4&R^N`7>mEF(@4zec zojBpFm5=|saFXuD$@*@bqVK_}`d*x-`*6Cx4`=B6ai)F%XX$>NtslfW`XQXFAI5ol z0O#vRaDjdl7wX4wksidw`f*&MpTMR1NnECfaJha8SLmm4rG5ri>0w;0pT#x$Ib5rs z$8~xH*XtK>gMJY=>X&en9>vZ2W!$1)!L9mL+@{BHyM7IK=+|+legk*uaonxn#69{g z+^gTleR=}->v!;geiskw_wbOO#KZc1Jfc6qqxwTUra#BydInGEFYu)P5>M%G@U;FG z&*<2PJ*#6c_HrHjvFCK`$zGvjUv|RTDJb9C(E&egG(J5R@c?tC44x(jsd>n_x>x4THk{_bKO zd%R0@?DH^yiUh{@OmA4 z!W(q#3vbl1H@r#5{_tiUd&FCG>>6v;v3smd$L_Iq9lOXnbP?{?-Tg zv8$|C$L_K|9XreVaeSX7_LvRo*kLy8`@~MO5gj|tMs@5s8`H7lY+T3Avk4tL&n9*3 zK%3IB18rKzPP7>vJJDu!>_}U#V@KMYj-6>MbnHw^Xj=I=j~!}BI(Dcf>)5H5qGP98 zs*W9NX*zbSrR&(amZ4+kTBeR2Y+1SrXX`~cN5@XKTpc^w@^tKI%h$29tw6`lwn7~{ z+=_JUa4Xia)2&3uPPbAWJKoB4?075JvGc7$H{nWs4zAL%1Fl-fPPiH!JK<_|?1-z= zu_LZt$IiG09XsP1b?lI9(y>FXS;tPf79Bg~T6OH0Ytyk~u3g8@xegsW=Q?%lpzG4H zgRWc0PP!f)JL!6L?5OM0v7@eE$IiL|z0NH>=JmRGNN3?;y&fLX>*Ggd2>2;=B?1NGcVzsm5=|}p_in$#>sjc zoTBq_s@@i->Fsd3-X3S@0-UL12Va){6VBE<;v8LwbM-u&r+32ndS_gqi*TXd1sCaE zak1VFm*`?#s&~g_I(Gb(>)82Mp-XV3jvatiI(7h7>(~icqhlvvt&Sambvkwg*6Y|A z*q~!)V55#5f=&8B+^i46ExH`H>Vt8cJ_NVxLve?$z@0jF5O(RqakoAK_vlL8tLNiB zy#V*?g?K<$;X%C!59uTEus#Zp=xRKw7vnJ^z*%HF#3T4#X)PI}oRJ>_nW= zC*xUt3SO>H#dEp=uh6IAgmYIu{!hnA`V5?`8*z$06Q}C4aGE|Fr|Tx1q0hmY`dpl) z&%@a|b}{DY7M!d9jPrEtXw28Kv#~(O&c;F=I~_aTpf59dC3S6q&ahbjnm+Px= zg}xeB>JD6`uff&&T3n;A!?n5-*XiqVy}kiA=o@jP?!ry_CfuxV#x435+^V~Ao4ysd z>)UXLz8!b!9^9qxz}@;z+@pJOuf7}i>3eX$j=hirx(^TP*kL)O@5jUX0X(An@u+?f zkLic-xPBN<=m9*bAHh@lQ9P|5!!vpi&+5nVa{UCJ(@)|RdI%?+xAO7-6i(7l<7E8| zPSL|SRX>Z<^m8~}KaVr?2+q_m;4B?GIJ0%^-EXFL7##f z^{Kc?H{fP{8g9|2<5qnJZqtppU7v|N^jWx5pN+e86YkdM;2wQ0?$zhvKHZG__4#-} zUw{Yog?LD};9>n|Jfbhcqxxbzrd#p2z64L`OYx+>3{UAcJgqOsGx{%hR$qaa>vlY+ zuf!|#RXCw}<>UWqoTNK&vc3kV=xcGRz7D79PMof<#~JztoT+cbS-J~n>ziU^zdZi+I=D-( zi@S9e?$PVvUcEl<(;MJ^os9?dhImkKgopITcv$D)5xof>)tllmy%`?Yxp+dyKH5pW z1)kDd;%S|SXY^KhR&R}$>uvCyjy<+3bnLTDIDh5ie>a7;2gat&ebJ2Pw$2E_1?HZ?}H0+~wPUayK9bP{gVtKlZSI&Ri$;1(Tw zds}tv?`_ku$G2U_KHm-=&NWv1fQ%$G+hior!1l z+IYEM2hZts@d}-V6E0Z!_+Jkv>Gg54-TP>K#-V|r+ z&2Wy+#kqQOoTs9uYxO)_r+32jdS~3Ai*Tdf1vlwkakJhHx9DQrs&~h2dJo*L_rx8#1b6Da zaF^a2ck6v{kB&Xiy*lDW6xtz-Z6j2^_Z`f?>)3ytqhk+tu8w`!c{=uD=j+&y zU7*Ktp?(t=>9=sPejAtQ30$h*!DaegT&~~46?zg^>i2P#{s33&4{?p2!nOJ%T&F+A z_4*Uspr>)8{uDRq&v3K;9JlBh+^WC8ZTd^xuD`+^dKP!;uW^_D26yXkagSb(d-Y#& zpZ*)}*MG+YdJYfjf8ZhgPdu#ug-3Mk5+BvEQ+!OvZt-y)JH{t;>>8icv2%P%$L{fI z9XrTpbnGIZ)v=R&xsKiBb2@gEuh6lpJfUUf<3DzmC+XN-o~&bsd5Vr*=BYY%ny2a5 zZJw@U$9aa1UFVrPcAjVH*nOU@V+VSUj$P=vI(DMx>DY~)uVY7gfsS42g*tYo7wOoY zUaVt>dWnu*>ZLk%s+Z~5tzNEU_k4wp9rTqtcF|Yq*hyclV>f+`jve*2I(F69>DXCc zuVZ(8gN_~cjrw}rq+_RjvyR>NEjo7Gx9Zq+-=<^deY@_)9r{+>sc*ww`gYu{dvK4w z1NZ7Xai6{m_v>Cfpzp?m`d&Pw`|z;750B{k@u+?PkLi9qt{=n``e8h&2k?}R-SN{p zcF51@*d;%!W2gLb9lPb{bnKX4p<~y4!kr|8&4pQ>XgeVUHl z^yxZw)Mx0}RiCM2XML8A-SyczcG&0W*kzxqW2b$dj@|b8I(FO_=-72%sAK1Sk#5Ju z`bu1)ufnDJYFwr}aJjw)SLkbTrM?bV=}ug&ug5j|23)Ie#C5t0*Xx^bgT5Iz>RWJ= z?#9jfR@|a*!>#&u+@^bQyS@W==sR(zz6*EhUfiwk#y$ET+^Yw1pMD(o>nHGlei9Gr zAv~m?!o&J$Jffe$qk0&R>1Xk{ehyFQ=kcT-!BhGLJgr~EGx{Ywt4Hy2{W6}@uizE> zRh)3q%E$j0PSUU8Wc@l$(Qn{XJ&x1#n>by+g){WqI8#sHEd377*6-pR{T|NMlQ>Vm zkMs2hxIll13-uH((jVbs{V^`lpWsqGjmz|>xLkjREA;2MQqSNj{ROVpU*a156|U8@ zxK4kK>-9IdL6`o7$G_eeH|hOwv)&)K=rY`@55R5uK-{hm!X3ICcj|+2mp%k{>qBvm zuE4$eFx;mP$Nl;UJfJJ_pq`J1^a4Dr7vd3Jg-7)wJf>^$xIPX~=w*0PACISW9iG-F z;2C`)p4BJe<+>iv>67saeF{#vc;(~&RGg$6aI!uPr|8phsy+j!=|-Hc&%_z}ES#y& z##y=vXX|rtj_yq7@vpDPdHM#NuW!T!x(gTTn{bi785iqYaEb25rTSJ}rf#)jaFf0tH|qy*i|)s*`a#^LAHwbW zVcekyaHoC*cj-rQw|)%w=t118AIE+A3EZ!r!~=Q=59+7zkbW8u>u2zY9>$~kSv;nn z!{hpSJfTPMq<#TU=@;>|ehJU$Q9P?(#>@39cuv2HSLiXE(7N*R{~Auxuj6F>22RoA zI90!i)AU<7UB8Vp^aRe-@8B%`F3#5P;T&DKgvY<0hx7DKIA8CK3v>}K)Vts!y(=!( zyWtXDj7#VX%k`ePLYLr5y%(<1d*f=o53bRrxK{6r>-2uOUhj_^bQx~c2jC`s zAa2$N;TBzvTlK-XO&@~W^`W>!SKv;481B-C<8FNf?$MRFSI@_NdI9d&3-N%i!h?Dd z9@0nRVSN-H(bafVFUDi~Xgscu!4tX$PwHdwlwN|T^-?^eYw@f;4lmcs@SHv#uh4Zk z;gXe){}XVMJ`pGDlW>Zz$Eo^coTg8~>H1Whp&M|fJ`HE-({Z*w1Lx=j7To6QM4YEr z!TEYsT%eP1pD6(uUIUltWL&C$gv<1gak*X-SLhU6segj2^iOfM{u!>(skm1E z9M|c!aJ~KoZqRACQU4M*>0jYy{cGH!({Zc*4Q|uF#qIicxI<^)PW^k_rT>7t^&fGM z&cwZXZQQ5V!Tow&JfO4ipk5CT>Gkoj-T;s2Y&@zr#AA9RJgzs!6FLV^>P_&J-V{&k z&G3xQ#j|>Iyj*XA=k%6%h0enXm#%#LZ-tZe);L*jgHv=qPSxAuG`$^8*W2R^U4S$7 z4meBy31{maagHv;xq2SX(>vjOy)!QO-Zk@&KYpi^>lPiq-~1&ywI2{Bu~hK}39as3&sNk6BbQVMZI@^@ZKr*RGERHh|tPIdfOeuMSsZ>V72rQnaxT9{dVIZvga>Gl?x(NzOid`^$G7Dd9v|l+K40;3 z4=3~7SA`_A~?*sHI+Huco4*PY$7 zxO73~{C!`#r0)3Ev#vb(n5JWwG%Ve(=EOfAcjif_-E>05(fb!KJZ#=RH-B;CGmpOi z^7Bu>`Sy#S&0YJ|fB%2}@B9DOzW+Sc^B+k3H}U=3@ABBl{=wTH@HR&={huHIh_~~8 z@b>4to%uiB=4Jl>=l#Ft$A9?y`VDXY@b~pa-!9?zJN}#Gw>e=iyf^K*YQntU!Lfuj zZ~1JkxZnG5+x*O;#mCpy%s)AE@v*fvi;i8iq;CFqe^xA8RCmI%C5x&u=P$`zv~1bZ zWtk@|SyW%UXkp!=s+yA%CJRy%_T*z6$$ty+-~TT0E?lQ}Oiifan#fPE)(_s^lDFgY z^8Jsm_dnkL_5XPPAODZH|K$5GUQ)Mc*^>D+EAP{GncUw+%ea>(ELpZ_{=(|{3u+c+ zE?io*h#&FJ29{-V|L51#i>RDfBe7r@sC=z^n}_Ud~Sa7zxc5iE?u&4eqH9V^OqgN z-#Y*I{-^#g{v7;fXD(Paf62n?|L@Q93xA&Z{M-v@Ayv^LI+Bi}YFbS3=ld}fXMn`x z`dH#qp0JeS^K%@4jOzh(ARR>IbTA!49sD|DFY+XQpFW@uX^K9gILqW? zuAk5}eM+Cv=QKlK(3kWT&C=KO4Sh??>96!RnxlWvKZ%!KC9I%-(|;(=y&UBFI6Xm6 z(hxmG@$)~;^%)wbXX!b5o<`^edXZkDQF@tPp;u{)UZdA(oZh6j=xv&ycj#TJPh9zD zQT&5wRa%938YO|JBoo%4)#*o+Olwm7xx=@k68IKn!q4cZ^m9t3Ur_wP`AbTp_%rKQ z^c&(!_=MllZ|V1xL4Tw_(Atzq>(V+DfA(e32DCnHNZGV8ZA6<;4sAx8QvBJu1#Lxn zv<+=d+tIdEK-*LN8My-$(vGwf&7&gPnRcaJsF-%6J!ucxi%Mu8+MD*JQre&PqXVdn z4x$6;U@E6W=@2@MD(DD0oaR#{Eu;msh^pu)I+7MsH624o)3H=TONlQ96ON-=I-Zu% z2~M)BXp@wD?Qn9k<5v*;XZqB3r4=6W6-h!3I`d?CF< z2lMu!bSb`sD)B=48(z${ny$p{v;&UU8879!j56s2x}G2Fq#Nl5x{11|kss^kdJCP6 z@8H@)&A6BAU33AykoxewbU)okmvY;KT>I$}8lb<^Q}i?q{ooq64b!vq%nz<{+w(L+ z&;8&Ux4lR&&?vn`uh7dhMz7NA^cs!R8}t^vNfY!oT}1EEyYxOy(uec`eMD3A34KhT z(lmWepV1dILtoLC^bLJWU;p45xBZot)8+IS{e$M{U-VDhvQ@rZwru^b<;6CDGZYK>7%^AT!P`slHC(TwI9K9ku21n}w{nfSiaWU$@$=u! z^&Z*}}Vg}<%{@!|!;*7K7xYp9~w2V%o6DfA2$8Pl4i5~mdd*}|jlkTGUn&$<2 zk>dQaySd&&qjWFz(S7t+x}P4PetMZ=r~5AS{e5@{$6ok{={_D-@%QQ@^e8<>gY-H* zPO&ro33`%-=qY-dUZZDdn4YEe*XF-NuFuoC)J*5o1r%qaUBdNJiu-#RwbA7i_xCS! z1+~);?{9qG;&XNt*SNn|Q{3P9x4<=YEnP>Q6!-Ufiu-#b#r=(I-1jcJiEgI2-?vaV z-AZx4Z{vD9wa`U$F}*=?f8%o;_bWb^@p+7o5x@TUIpg#661_>|^ftXk@6ZIjNAJ@6 zG)W)Q2lNq5(I@mVeM-~xIekW7&;0wV%N)-T=OV) zy==vGYubkLX@sC_0iBQ#Bn!N7J!XLrZB19Y?ivJT0RWsE$se6X|5C zr&H+^I*l6W3_6|8q(-`sE}%bC3tdbX(IwPMm(itkIknLh^cT94+UaV#imss!x{j`; z>#37&q#Nia>Y`idX1bNS>2|t}?w}sJi|(Ymsh94hd+0vuqX+1IdXW0*VS0!jp#ge~ z9;KJ)33{A{=t+8-o}yuThMuEmX@s7q7wH8Wq?c)wUZq#)H5#Kg=yiIN#_4T(i{7CL zdXL_v_i2(oqz~vLnxaqWWBQb)>2vywzMvWUioT?;X_mgFZ|JYIoc>OKqkqsG{fqud z|E3l6U-}OvuEt}PR;5*FHA=}*yqOn&r_KC(G(byjvdqZPiXzU4% z{h+ZIH1>hU9?;nT8GAot-)HRkjQyUm*E9Bc#vaeu-x+&5V_#<@ok?fW+0;a_fAd`0 zoVK7XDUY_Ittq~r8hdPGe{JlojeWJTr#AM}#$MXkM_WkqXeZj4if9+wm3E_I+MV{G zJ*kBDqP=M!iaoIV(tfl*mC*roAjMfKafV8qof2oJ#91kEMoOHG5@({sStxM^N}PQX zXP(4aCvnC}oNW?kn#5TqafV5pT@q)O#91YAMoFAa5@(XcStM}=Nt`_rXO6^KBXPz^ zoGlV(io{tWafV2o9TI1T#91M6Mo63u5@&+MF0a_(6}!7)XIJd%iXC0Cn=5v5#V)Sc z!4nV0;#m=nQl@&X(Zl>6Y6}zxv2UhI9ik(-n>ne6! z#cr$EX%)MyVuw}iu8N&iv8yU}RK;$p*hv+;sA30I?4F99Q?Y9*c1*<#X3Sp3%w^14 z#*AgmR>n+a%u>b-Wz0^-%w)_;#*AdlM#fBJ%tFQtWXwLs%wx|V_5#jIY;=*4Va%;d!^Ud-Ud>|M;< z#jIV-*u`vJ%+$p!UChwM>|D&u#jIS+$i-}2%*4ekTl7yIsF z&t2@di@kQS&o1`Zt;L^RTTmM1(I4nfv^LG7b!aDwe_wp>_&a?gZrg(vQ2gB*XTZeS zFR@Q9_RGZ{)!3gJdsAayYV1jk{iv}QHTI##9@N->8hcN_+jq(}_M66D)7WPkdrV`0 zY3wbHeWkIdH1?CmUeee{8hc1%|7h$TjeVoBXEgSU#$M6bCmMT1V}EGu4UK)Fu_rY4 zgT`La*asSWKx6-B?EQ>=pRwmN_It)z01NqAC1#%!4RQ4*~|tJ9AtnbxEq z(@!Xcenvl~pHnLRg4Uv6QX2i5enr2bbow3rmVQqe^hf#wtxcJ(hpm zO&iljv>B(jK%ImC!!4H|3CX3Cr}-oL?_b8R8ObUDRde&&>3_(ok@*!Hl0Q1 zP!pX;=hFGqOc&Ax^k-_Ji|Hb|gj(q`x|A-bHi} zPw}(^?MORO3hhs`=>STl1L+_-n38Bu+Kcw4WZH-JrTr*_4yPmNNXn$6D2?XOAvBlL zX&#+Sr_yOOpN^&D=>$57im8Oopff2%i>Z{#D39`K0Toao712UkL{HLF)Jv=AWqO6) zqxVUB+_k^`EBcy#rhif`T~1ffl~hMp(baSfRntXuF)gPWx`ZyJ%czlVq?_nwYNA`{ zR=SPq=~}vuuBQh23+X(B8>p4;rTgf9YNH3}L3)Uq>2|t58l^9(otKSqIZPkZxpW?V zMpINt%czRZryoiG&a;Y+Z{#sD_qPe>}fudXwIw0eYL>p?7JJR?~a* zJ`K?a^dWsj!}KwILZ8wIeMXSTl1L+_-n9^tt9YS*{ zo#xS@bQopO;dBHYNttvM9Zknj79C5+(eac`C(wy>66MgzbPAnHxpW$xPV*^1vuGV! zmm+9ATAwzcNZOD#qKzqvHla;vGm56)(dM)T#n6`Yd-?;#(pI!JZ9{SNNBR@}nS!(} zZAaTvJncX`(oU2>JJT+-D<#ryv^(uV`IJXz^6$|)-}ZbiXVXDc%? zva=|Qj-w^qRzYXeQaYI1(&!>wP0Q(Gx`b-zGP;y5r&_v_uAr-^j;^7r=~}9%>*+fB z3pLOU^jEr(8tG=biEg1Lx{Yq7+o_rEq&w&?YN31RZn~FR>3+J89-uaQh#sVeshu9B zN9Zx?peN{YT0x!k6g^2Rsf(VWr|DVhrswH7dVzZAC3=xoQ7^qhFVm~kN3YXs^al0Q zTl6NqO#}2Uy+f;Mklv^F=mQ#}kLW}Cn1<<7`h>>lYxVTC$-RB zbT{2Yt#mKlNB2`3JwOlAL)1Kio($n+|bpYaSpHurfb?&$RUZzX^9Zh>UwU<+SH?@aTdp5Oq zQ+qYFXH$DLwO3PnGqp!kdor~*Q+qMBCsTVcwHH%+FSQ3#doH#2QhP16=dy?jNqZ|7 zlJ-<;Z>9E9YEPy1P--uw_D*UKrS?o}@8l&^L)s&GDQRz{_DE_^r1nN?FQoQFY7eCL zLTc}$_CRXSqxL>(ucP)nYLBD#I%;pD_Bd)!qxLp#&)?^^qa7%ocA_0=XG)-5X&2g! z5=na#cPH&h+>5jqQF{{iqkUeS z&ZIMFF@;Eb^h)VmT1HiLp3K+53%R_2E~08$P8ZW9R7021rBp{(QW0P8uH~|xw3qHW z>Y*FxuXH0d(#>=e-9k-t8{JB`Q#0L3chFtbLifr{}1FF6MRVjPqXn61_~TsF2%V<+6{o z$4q<8-lcbFH4W1H^d8+ji@%R>seNSHA=k{m!Q4)F(4EvmchTK+54F<0bRXSMZS(*= zNDomvJxq_#qtro<(c|<4bZdp8O?rz4=xut3-laiWP4ChBG(;cJhx8E*)5r7)eM%$r8GTM)&?tRLU(wez zM&Ho4^c`u>llDH%`GwCjnoH?4j}E27D1#2CBj`xVq@(C)I)<`HyMm6R<0+d?pcCmN z($1fg=@iX4}ilR+uQ`(H8>36g_Z9y@#CHg%XcvZdU}*P6J3UN~(4*8rkJ01w z1a;C1dXk=^E?P-X(=*gf&(d@BJoV5E^dh}Py|jv6rdOzsUZvOQb?T=#=uLWywBJE{ z9kkCudmOaCL36%N|Ji6x4HGi(TbIqG;&Rp~5 znk&~lx#q|3);zc7xHZ46xoypB zYffA9*_zANJhtYrHGi$SYt370&RX-;)pQYEOv|Z;E}={5GODG^=?c1%>gX!Eny#UG zx|XgZ?P1XV1?^qXz6I@B(0&E&RnR^K?NQMF1no`Gz69+_Xr|lg4!V2k9Ydr-$hg(rmP5qBRSx8EDNuYvx(A&YE%7Y_n#XHOs6SX3Z{ZW?8e! zno-tlvSyMsi>w)B%^qv!ShMGvIoGVYX3RBPu9*Q~f^#5EhPnQ+a5 zYX)4i-takxvwp%mZnxWO~tY&64E2|k<&BkgbR{)sG335?5So>HEXIFQ_YrYrc|?}nxWS0v}UI7B+W=` zHd-^$nuXR3v}T_*^Q>8C%{XheSu@R=W!4O{W|uXytXXBvC~G!ZGs&7o)(o;{k2Q0w zS!2x@YqnT3#hN9~E9K)tnwiwBq-G>F8>yK{%|dDhQnQbmdDN_g8#&BAF0PP1>CdDE<$X52K}rkOU)vT24*vum1J)2y0i)HIu> znKaF!X$DQRXPPc#i^yP>MYlr`qW_&7OzT?L%>feHhNP_4D#swtj9t+t$y| z=h*tU%UsM;^gt#R`u3x6v8|u2583(|`*J%Ahi(1LeWk6Ry|1#5$JJP`Uq6Rm>)TJj zb+&#kzuwl*=Qr5;IsHakKd;|p>*w~H?R?x~FTkyK0dBJkal2iFJM4wH(_VzT>|)$) zm*5`z4BTt$-+TM8eqSLP@a>E7pk0cG>@qxTm*WxpEIevg;4ym%9>;q9VVd;qOYxL_ zHV(wkJZ3aU5n)&2NP8KMvd_iQwtn6*2J7{AQ=D&q76CIPOy7$qOE`PPQrRU zFH(wce+j4Bnp;S-HNTK4IZ$+#e?>D zc*q{d!}j-h#Qp(~+CSnkdjgN!f5Q{@-|?h9iKpzJaA1d-$M(-K!sf5Cfk=A_N7?_v z(e}S_jLlya1F^QgxW?JDaL`@{$J^`T1e?DG1QKnY`UaBh^>MPj0Zy?aajLx`PO~?{ z>GsAr!{%vQAk*e4Q6S6S6ldF;;T$^}=i0x+dG_YG(B1+U+c7v~Z;8w8-{Y|T2V80M zv?NevZ-uMvt#OUL4X(B0aGm`}TyOsgH`ss1jdl<>+1uh~dpq1>Z;xB;c-&_1fZOdI zafiJV?z9tdm%TIYws*lj_O7_sPQ-ooZn)px9S_)h;6ZyYJY?^UhwWrMV()`T?S1i> zy&oR8_s0|VY&>ZnfT!$K9N2N@@qZwWun)qK_Q5#HPQ%gm92{dGf@AHuIL=PTL3$#| z_7Xg3hw+fT6c5{H;}QEDJZe|sF?$&vx6j2B_IY^HuEJCH`8crC%;Wz89ARIGBeA~s zRpV&iei4qbFUGOBhD{iyz#qD+*?yw)go%Vyc z%YF!V+wHi=ei--KkKjK0QQU8L-~szFJZL|ThwLZtu-%DA>=k&_?!sgCN<3~qgD31B zJc;!fegOv({QMb5+ArZ~yBEjWt8mbM87J7U;3T^br`WIJG|a{H{9?NOIyYq4{W#Np z183Q9;%xgZoMR8*T>EXDXTO6B?RRmpJ%~g0YFuu=hr{;!xY8cNRrUwC+WrvN*dO6q zdl=W*ALDxa6Wm~biW}__++=@-o9)kWi~R*|wMTKA{UvUb!INH`b8)MJHvGzJR&elw6(AG?8ysa721Y0wviMD1=lWfhLCfk}p zO|dnDnrdq%HO-E~>9%H6Gi=SMX4;xr&9XJKnr&-_HOJNrYp$)C);wD?t%bH`T#IeZ zxQ1-ayq4RVc@5i|fvvPP16yTlCbrtvOl*y<8QEG}GqQEIW@hW{Aa1a?!;Q9PX`5`# z(l*TR(p^ZtLfXChRmkY0tq^_8~a1%gp0{ zE{?D@a~o-E<~GXKtZ=lg+2I&lv%|5rW{Kl$%@PM~%@)Vonk`PSHEWz`Yt}f)*6eYz zt)H1nvGsFQskVNOD$PC~r`wv}&#*PWpJ{83Kg-q(f3|%p&aw4#0=ae`&a?AzpzRNMMlvKm`Iqfl#?;W}GCKUQy7;09a!1R8Dq zELxLYjhpR@af`hix7zv{h&H^j_SUx#~a{Y*u#t)H{#v-Pv8 z{g{jCS?wX;eik?w?DUPr; zOC4!nj-zbNR!7^KU5>Fe!yIdCmO0MW&(#L)YjM1-Ip+k-hhTa(JIS|eMmyQod~u5J zqj~K#->$jsbX)Vt8JLUdpY_eQHNTvP_4;qd#lFAhxI?~O^W0(IuDR|?Tl3vjb~CQ_ z{WS|+YirKC-qx&lqwlYo?= z`91c7xYvFN_u2Y+<$n8NJYZ|Cd=TqnqWS${-`;^oY|V3z`aX~2ao_#~p0GRdB<5oJ zXR9L;XRLYgXsp-&6pqC_EtsD5kMr#-xjo*uYxY0Eeg-Gn-8jkj*X((Ut-1O%TeJ2V zwsr($VZE&vaJH?P`5fOzdjs-(doM1u^)uSVzR%0J+_!6|K-liXmA3XFRN1fLYFjh; zHFiI)#rimCPQD&K@M{Mm77`3%iV9eG|fpPmwJYj3cz@)96 z15>tk4g_|a`MqlgL4>Ux1d+CO5=7bKI2!9?`#p}ewR<4w`}~OGZS7A;z+6o4eMt8G z|G^EZzK`}7q}keYkZx;_L5BTLoN50HXW9S8+4e6u#|}jBz0#hA^XzqSp}j6Hwj*%J zUJsYs>*KJ!0j{(oah1IxuC_PAHTK51){eq;_9nRA-V`_3o8d+~8aLU$!_Bs49$Twui9dVSs6OOhMaE!e(jJ-cf*PH?l{Tb11H-_IK|!*r`nn~O~ZQqd*ck>uKCkU-@Xsd_U-%P9D6^U zYp38mdw*PL&&I{}0XSr*;&S^y9JV#@T8Z`k9E_`ddm65>=ipl3=MY?v_3@vJn|z;i z+-%RoE%u?f)jkZj*%`RqJ{))0nyc-^dVh|@-M&2&_t;0_Ui)a=XCH(6?JPWCABzX= z7W+!vYS-a5`zqXSUyVELYjCGskGt$^akqUP?y;}O zy>B0Kw7YSY{VcAwpTjlw^SIXT!FBcvxZZvdH`p)XM!Od`*{g7~{W5N`U%{<*A8xZ> z#qIWMxWj%OciR29%YFlQ+i&6?`z_pS58yugZQO6ag9q$)@t{43hwRmO*nSU>*ze;} zdkBx&AK-EOLp))BgeUD`JY|231AERq{y)JH_NO?~9>G!eXE@sa9LLyS;8=SU$Jt-v zp#2q&x4*^-_83mIzrjiNw>a7U4yV}TIMx0hr`bQ?bo)n~VNc*p`)@eQ{yWaL|ABMt zNt|o{g!Am5aiRTBTx?I_ko_-QZvPvH?O$-E9axXYzdZ|A+w0&OdtF>>N8mbpJzQ_E zj~na_aHFk#MNPK$7d6}3U({l2pHZu=eMW7z_8Ya^+HcfhYu{0)t$jybw)P)&+uDEB zV{0E$udRJZeYW-^_1oHyG+=9A(x9z#-lsAgNcqFQY2jB2&DJF3mr4ykrqyQDg7?Ud@YwOgvo z){d!eTf3%uZ0(%twY7Vy&(;pAemfrz*bDHWU4Vz|LOg62;SqZw9<>+YF}oO#+a-9y zJ_AqMXW}V4gadoeJpLEs2)h(V+GRM(*3PhK`z#z|SKwHC368VFIA|}$@%Gs`!Pc&^ zL|Z$@l5FiBOSZLxEXCF?vQ%3;$ZnZV@+-7U`x!u+bbcd~3=uTTR(OtG?qq}X*NcY&9 zmF~4QGu>xvcDmoz4E2DmS?WPsGu1=3W~+y7%~+4vnzbIaHFG^?Yxa8F)(rN9ty%0z zTQk{Hwq~;f$up0C&1gs1n$?c9wG%7K)^4n5TRXC1Z0*X5wY4)V&era%psgKR@wRqp zCD_`jm1t|XR+6n9TgkR|ZKc>lIMvqftu$LZxYBLy;>xgxai;w-&aywj+4iS6#~#7C z_GdWH)()>i`wLubYo}Mp)^4wITRXnOwsw70+S>V5Wq*UKZS4T7v9$}V*49q2I$OKJ z>TT@^Yp}H|tkKrauqIo(!^ z@r13}<4IdH$Wyjvkpuh8JpMJ49ARrVInvgQa+IxE?v^85@Y-`3kWNX&C+}6x>*w*ZIrL7t4DqFMI)wX7`Yi!MC z*V>xVuCq0(U2kh)mc^=DWkz?02WF z8SpM!v*6vfX2N@H&4%~dni21_H7nk4Yi4}F*6jG8tr_wmTeIZDwr0vlY|WOB+L|#R zvo&izZfoXz!q)8hq^%kBDO``Uvs9d{f^mK|Gurgk9oFsG>3d2 z?NScg+AUILYxiRf)_(`oF34J2`$+3-?Io?ZwV$-X)}GQvTl-3zZ0#*=wza>s#nv9v zR$Kc_+idMMZMU`Gw8Pe((@tCaPP=UFJ?*x&|Fp-}9@Ji2`%wFA?M3akwI6lB)}GWs zTl-RnZ0$`QwzWTX#MU0wQCs^|$87CY9k;b#b;8!3)k$0XR;O(3T@CCv^D)={)d*XA zSR-xiV~w)4mo?hfe%2UUds<^{?Q4y*wYN2BYkzCJtv#*@w)VLu+S==yWNW``vaLO@ zDYo{#rrO&3nr3UyNV=`vOBuHIZe-d4_Vs1ivv9V(4$iUH#kqC_&a>CUh4%Wm*xmq# z>_}X0Z-~S8M!3@67+2X*xZ2(X*VvolT6;5GXGi0D`**m(-W)gDTi_-;1~=PV;uib& zxYhmxZnI-?yS)|eu(!sY_BOc7j>FydA90WUC){iQ8TZ*i+;4A-2khTss}-+4FFreJC!r55pll1DD%}wvWO!_R+Z3J_gs> zS-9Rl7B|?(;YRy-++=6tX8Q!(VxNdx?UQhuorBx$lW~WA3huN|#a(tT?zT_EJ@)Ci z*Pf62>^$6$_5Cy-584axu=2H$7vm_q6i3@-IL0o=vG!Rw&aS{gdkK!W!#KfSiWBX#agu!wPPQv?ioFb{+UMdl z`#hX(SK$o%e4J@tfV1oiakgEJbL@+7u6;4ivzOySy9O8Am*9|nDK57!!(qD?SK623 zD*FmtZC{CN>^fX)Uxn-Jt8u-34Q{aOaie`LZnCe#&Gz-U#csf@_Fr(DeKT&ydK})0 zJAHdI?y_&k-S!>0$G#Ky+AX-xz6<93; z{UDyOAHtJ%JD##1#(~*0kNHP%g#9Rvv^#K={TPn6AICBF6FAoH#Buft9JHUr@%B?V z!S2F|_DY;&KaG>^XK;$$jZ^Jsahm-cPPd=O8FmlOv|qqk_KP^%ehKH;y*Srih4bu} zaiRSRF1Gt{$bJ=<+ppoU{W`9+`*D^12ClZ>#5ML?xYi!Pb@to1-hKx+*ze*-dk{C- zt8uga9&WMU$F24dZnHnY?e>Sb!~O_&+QYcZ{up=LpWq(*Q`~Eh;6D2^+;4x52kbBK zpgoF*>@V@K{S_Xuzs95X7#_2~!Q=L~c*6b;Puk;n%Kjb)4w!lT|9~UxA918Tfurod z;b{BsIL7`5jZ3kpLzV-vv8Wd4o68{tBGV_a-U;gG!vF1I(uVS6)NX-DHK`**n7 z-W=E1Ti{wd2G`kJ;(9w4H`rU@Mtf`AWN(9;?Ks?G{}H#^LEL67?SV5i|k zdk#*r55dXyT%2O3<5YVdPO~#`x_vm#u#do*_K`Tt&cxaFQ8>pw7U$Z><2?HWTxg$! zi|vzf$UYU9+o$2MJs(%vdAQ2X$JO=%Tw@pDTDuU}*+sbCUWgm)MYz!}#!Yq!Znn?B zE%uqX)ehk{dogaeOL2!?hCA(Y+-0AIyX^|xV=uwIb{O~BOL4!g9qI%2Ie5_4uJj>W zJJW}4?NlGJwOf7E)=u>?`+PiZSK|r$B0OndjHm47IB?+1Z zc-*eR6ZYfrJhts8@RZ$&0|(DMwpZW?`$-&WKZT?0E*x#I#4+~MIM#j!$JyODXg`bN z?dNcU{X9;zdvKEd0#3GH#3}YmIMwdOY4$3dZoiB(>{oE6-G{U6S8=xe8qTp_$GLVt z&a>aZh4!1c*nSI#>;YVEzm3E8JGjz*7gyPXxY}NgYwY)Mt^Gc(vxjiK{Q+*UKg5mp zN4Uuz#?AJ}xW)bix7wfLHhToO+n?bM`*YlBe}TK~QQU2RiF@ooB9DK27Vfjx!Tt8S zc)*UpgZ6rO$X*{0+Z*5!I}(rD8{#p0BRpZJisEWb6EpWLxKmq}V!7 zB-PfrB5AhH7fH8+IK$o+XWHB0EPH#LZO7vrdk36r?}+p4op7O@fQ#*&amd~Um)pDI zu$_o2?cH#dy*sY9_rNuF60WuP#C7&wxZd6yH`vLz(cT9)+56&Vdq3P_r{Gq5f81uz z#_je2xWi7xo%Vsa%RUHq+Xv$wI}P{Rb8w%12=2G%;sHAy58CtakbNi~whzN2b_O1` z565Hn5qR7_5>MEfc+x%!PuWM~z?_-K|1mhi&cc!Qu{g>;4oBO^;}|;|$J!_0IQv8# zv`@nEb`DOkPsWM%DLBbK6(`%dIK@5o&asPd zuDuZF*^6+YU5tzE5*)J6z~%OtIBbV-rM(ze*`>JJF2gl;Ij*%UaGkvb*V{{RgMBt` zv@gI-_Jz3FuEs6)MYz?z7`NHWal2iEJM2qvr+q2zvM+!hVfG6y~;7R+hc*?#32M(Ee{5RqV`$imT z--M&=n{l+=gk$VmaIAeRj)h>XTjy`r*gA*1*4BC4b+*ps zuD5kQcZ02Sx*Khs*WG06-0o&u=XbZ*I>)=!)_LA-w$Al#w{^aEhpltIJ8hl!-DT_C z?`~V?fA`or2fWwTdEkAv&IRwcbw2ojt#iT$ZJifBWb54UVO!^ikJvg#eAL!iV`H|? z9vin0!4vjeJZY!nDSI9cq|ZG5bv9Xqt+UD^ZJkvXW$Wy+Xj^BN#bEtAiOw;Lvvr19 zyziqk%@S;#X_jc~jI$(LXPhP5I`b^W)|qFiw$4CHvvmeqx~((OGHjiRmTBvZv@Ba^ zq-ERFXQtUYGcDKF8ESd9&QL3~b*5Uetuxg^w$4~9w{^x^*w&eAmG%N$Wf$OTyAapd zMYz`1nQV2o&SkPROTW89R z+B#Ei%+?umHq5CS8=RGwPykolzHK z>&&`Xd%Jsh%-h@JpdF9n?HzD}y(3Pvcfv__0#3Gf#woVWyi2up240$-h|_JIiI-vP zOuS56XXItsIwLRJ)|q)Zw$9AUwRMJGp1m(FwD-fsb_x#J`{QzZHV)ed;7U6cSJ^s) zui8Ec*VqT+T00Hb*>iBceF$!_=i){?9XHwYaI<|VZm|!;t#$@(vk%AZw$AwLuyy8N zr=5wrY@GqvZR-rc9$RMu_S!lVu+P>Rf&I452pq6=X5gT$GXsZgogp}EpNL27lkljW zgU9TX@wj~op0H2FlXfnivULVw;Lw@J|LHiwo{uB#JRD``<7j&Uj>?br z7vgw(5l*m+aiU#)Aq zvCqf3_60c4z7QAM)wtNc2#4&8ak;%5hwU0%X`QUAeHpH?brxf-U5D%Jt8l%o zGa4Igo!QuE>&(U`TW2^n+d2=i#r`X9wQs;}b|Y@LZ^Rw;O}Nv(8F$%DxZA!3_t>}M zUi&uOXE)=1`*u8F-+>41JMoa+f`{$9@Q8gk9<}emV|FVZx9`Oh_I-HLz8_E7Z8&h) z%;Wz79AQ6*Bkgt^Wj~Cg?MHBot#ct`?G7Ag>kP}F{Wy-dpTG%rCr-3i;3WG=oNPaZ zQ|vCBYOlm;_R~1segJ7H8Sd;cWYPoMZRkT>Ax_XTOLG?U!(|-HSu^DqL>A zjKlUTxYF*!Rrag6+SVDIHMY*=thL|4b@scs-X6pa_G;W{zlWRb_i?j5gj;N#<=JZg z9ky%hJ_XX8Hm9NceL;sJXZ9<fkK%5-1NYdE;a>Z3 z+-E<5`|VCVV6VV~_LF$XehLrUU3kP^iAU|H@tFM#9=CPI?1Zf|XD97#f8p_OZ-)bi z&piIO#}Rfsj&!_)ge5&v(++xxQ1j&i4%*G4uG>IlmFM&ijqDb?$GJ zt@D4QZJh%gW9vNNSX<`;$Jsg`IB4sf;CNf-1t-`#H#pJO`N2uH&Jj+wb)ImFt#gG_ zZJjTiX6u~cbX(^QXV^iUX>W_OY@I`#ZRn zm)pDGu)Qm;v=ecay&JB!cgHpM9=O&{!gcnZxZd6iH`sgQMmrfd+56yTdtcmQ?}uCM z6x?R-kK66pxWhgGciO4A%RUfy+Xvwu`(WH_r{O+(4(_)P!2|YOJZPumA$uMkwhzT4 z_F;I`&cI{#;dtCW0#DdS;z>IbPuWM|z>zbL|D$n)eGHDYbq;itt@EIxZJi4pW9xkA zSX<{r$JshBI%w`iM>^5gdD2O?&XrEKb-r|pt#hVRZJjrrX6xMPbX(_7 zXV~31(|#6b**cdx+t&HiIkwKJ&b4)3b)Kzrs|#(NUtMhL9P5y+^Q_BloogMob-s0_ zt#hucY@K&qZR_0Y8e8XI*V;MRWx7hFFR(lAy z*&pC``$ODee}p^jVccbZjJxemaF6{d?zKm7pZyu`w?D@N_7`~29>qiUmw4Fz3Xj-d z<57DIkJ;bgar;|5VSk4w?QuM1e~$y1GmrltaD@FMjIjxZT}s|*#E$>_9Tw8 zf5JigXB=<;6DQa@OFYrmnc_*d&K6I$b;fv#t+U2cZJjxuX6x+nbX#YTXV^N6Jk!>h z+JGETW6RT+d9iUWa~`xa$9Gchi#p4UTN#B^D0|s zo>$vC`@F{18R)gP&O)!VbtZbft+UY^Y@LzbXzQ%>CR=BwH`_Wpy~WlU>aDiUQg5?$ zrh2=rv(-Cnoju=a>kRrXTW8UC+d7lJ$JW{Oy|&J%@3VDQeZQ?U>j!L|T|a2+4ErJb zc06qBO#2aAXWNh3I^%xK)>-%Cw$8ktuv_t@eJ`G}@56zkW*-0d;|RMAN7@hIDEmPi zZ9jx#>~n!<9TW88=**aT3+twNLIkwK4&$V^te4eed=L>C}L0@d^Ec%eGGwI81olPIMbw+)q zt+VQ@Y@JzOZR_m%8e3=B*V;PEzRuQ}_Vu>Twr{X?#(kr$v+kR0oq6AEH{uriM%-%O zgxl`_8=~|SL3k#9~u#?JseM{T1%Czs6nm81A;e!9Di3xYzy; z_u1pP-~JvC*gxPwJ8Kgj|MszX*gg)A*vI2hI~$MLC*X1WL_A@igeUDBJY}DZ1INrf z{!hUX_Nh41&c#voX*k+G9mm-7ajcz($Ob`>tP&&S2~1vq41h|BG29JVjQ zmG;HB%3hAE?HXKTUxI7x=2#y8_U*Xdz5_Sdcj8971vlAu;b!}8++yE@TkTfdX5Wk3 z?fYID@wx7c>_VYN_?!j^P3pi-M zh~w>-aDv^76YW(v$$l9p+ppjhyAP+@ui`ZOHJon0jx+3joN2#-v+OrR?6ewo`dV{LvVvV z7dP7JxXGS}o9#n!i+vbwwKH&=eK>BnkH8)Fk+{> j7LxZ6G&_t?kaUONl-*~j93 z`#3ycACCv^Y&>M2fQRi9@rZpA9<_7un0+!Hw@<+n_NjQ%&c##qX*h7~%;W!b9AVGL zk#-)Avh#7Yy#UA91vu6&#Bp{J4%!QGyuAn~*u^-}F2PCm893QK6Q|fAoN6z|X?7`2 zx65#bU5+#Dvv8JOfwS!;IL8j-Tze_bv(Ltb_BpuNuEZgG87{Za#bNtATxnO~D*Jp~ zZC`+E>W;8r^lx7i!wc6%e-VQ-8( z?I_%3Z-Tq+O>vLC8Sb^Cai9G=+;4A=2kb5IpdEvU>@D%I{d+uO{{fHMv3Shh3Xj`c z;|Y5kJZZ<_Df^E&aNNw}|4%r={xgoWgE-3G7DwCL;TU^+9BaqpIC}>iw0Feu_D(p# zPQZ!w&N#{51t;6P;uJd(r`o&WG<$cPZtsCJ>?E9N?}@YQy>Pa@H_ow>ajv}&&a?N$ zh4y~9*iOMAdw*PR&&FZ<09^ZpJJ_I+|b8(|xQW`F* zD9sNAiz+J0DrN_ZbiJrBxU{sQD8HaMe?h1ySWs42#7ip6iweTL2vh{iD!93{AU~WK zTvQego={q%dj$(Z`Ae3J92^}8@t;aR^H#cT=OP`1=3$Z7ixNTUx&6{r~p=_I2ln!okJ)6=xPzto8nX|9}5B7F6Vy78LtU zt@*u7`0elzD5}uMFt{+kBve#5JGkwVqR_(K7l!f|ElJpU_oXurmV}+xdLK`S2n06d z`v3g3|NAdp^EMCmuUm8dUET-QjsE)h==ja`SGmqu!>=!Y#@CbfpL0t7xhinsh8qTh zfj?h(VbcEFUXXuo@Pcjkn4NZN-gy^nxZy?{ZM<<*)Fzt*gL6*Nub4kS|6DE)&0o0Y z?YHtJa`&}f|82jy{wUXXTI=N`%4~u--mU$mK>{mU0=x<;A{U$K?iGzn)9I?L+l- zfJ?nQ{P9e`Z@OILHSe!3b^rB!A6dU9_oFQX3uqw~Q;5o`g2Hq*RZ=z8(be=;O*ABz5(xu?!V^cU*K)ly8bQJ_qjDMpTq~Rb^S@a zA(W0WtV0nJUk|KZm-RRfXQR@5X<9YHP(Sc*Qe3kcOKQ3$e{(35x$I`uW#<%ClvnVbxO{18L3l}d zenHXF^75jJ%IW(A0>ALTlG3yDLnVBJUs8}?UKCtXbk@?M(t@Jk!m_2Mg~5{2AkPOX z@_7!x_kKN$*WCX%HwSs(Eh- z^CmusWefT94(ro3SYA=Yr`OVoqR=uu*(xYoR9bSb?)Kjw{X#yNd^#=)>JvU#TC^yC z`a5eGe|GudvWmi`<)IRuhViGw%m4TL@E(*GahJkhpTbSwZ^6>=^m8}AU(=7q|9Ve! zum8M$9us5z@!T)*tnvc?dzvS0H!2kS_{*TxA>x-t}$kI}NmwX|b zd6R2i>wli2@eFinY54!k!)>i!bJo)Q(s0Sb5+1}eAC4vbSi;OX<_{paxI~``i>99z7s0a9B|K3s;jwuRe>}fFwuAq9X2V0QsD#gs3Z7;A(LM8Y zI-Ji};$VI$pKCMk(OMs~wH_h=FRwq*zny~OvXX)#US9>z-lsni6ZIHOobhhO`Jsh+ z8qZDBp7|{IJEqUw1x1TWN=x-y<58O*{NLXyuONTs_xN8Qs31@N@`Jexg6HrX)$d4u zl6qAVl%;lIeTRe6IicDw6ix zYwzTJ_T4XK|NI37g+&Yb`ugMnGv70c@vgK}P|qItc~8>!qXp~gduWJfxxu{Sik9%* zbN1||rRVT9H(}?z>5oEbFmGN(Mc&L8kY8V)zTX^3`k!8pD&TeLe`~H6a{Ywx!W4da zS;h1NV*b+d`QftZzpBj-6_sw6o3u`DGmS^NHrxW4?v=s*EC>N%>u@2t807}xc&S#w>_X&Ej3^?I1=JFIn`f3BH+ z4z~O52L=<0DvR^^_E1!~bD)^F5yk!VK9=A!=wMnsFFK$qC4Ub=WeQN>Bce3zPkyuO>}moA(B?#r)V^Zx#e-)9=v=Nv!x z@WbcurC||Y%;uCXTl4ZY&&|)|_o(Mf`hAD+|DVUxn%A|AU#GuEthwICb^Tt}Tz}v< z*W0-8?B=MGJXH%jk3Zju!Hyr;I+Q?`Yx1 zT&K_JJ6gztq>MhN?`R?Kco}_8-%-}4JZGYQT1`QIqdQX?Pf`!3db*K@dD8zSMf1tH z6&=cxvSX;9R#WxXfxzWdPd8E)pHwGPJFTEJKH!H_7M)DNyLmg*-^#D2z`gt#P(Q7v zar%j}?&JP6em~bKnxFsOikkU3r+X=h|DLr!rP1NEFnU&?jK=9F+V^*}0tZt+t)}tK zxt+3NW(7{Bep*dgzvnu2(<SzB>G8sCQ3Ls@ZLr>sA6NzHUG zW&N4!l$6h}r@S*}1xl!!R#DcOyqwAx&k8J~@jhN3z4q>`z%P{cF~1)g|AgCVe1uE- z{x z&nT*#pROmyzdkPKaF;_VpBB;_J(XU-zXKIuuAkzUoy#SEY}4s$g?iF;bNLPp(%)&4 zp5=@3i}VH!(+G_@{kxBv$LE>S*Zwe_P3O?LbUt0^F6C0y(iK$auIBP~x|9A!|DcQb zLUIM^EKr>Rsz_ zdW+tsA^Mm`=^Ofvex@n<#YOXZe=r?I57W!^6;06J=x3*Iw11$jDUs4Bhw|tQDyPfn za=MysaLrtJx#e;e7#$j)}xJRGm54yD1mmNB-)GirhRB% zN}>JfAUcE&qYOHdGU-@%GMBk@x+~{$DP2U%=@Pn%uAyt`dTOQnsGT06N9i$IK`ZG6 zdWlxiE7V8*ZkWqY=_i_^S$zFom)4^w+Ki%U3re6}D2eu>y=foXpAMvSI*c;tNXn!W z=_Jaf(`Y^w&{^(cE|=3KbOl{a^>iKmg>IyqsL9>RgZ~! zr|YPd?xRQPFgKT)s%J(*V8W2D$u*exM&|7T?!r zQyLvgN4bl*yqId-rCeS?b#y1)};S{2? zXgSr=4Rj-Qk^Vt!UrKTOH6p-2+XS-c8oG&Yp=Q$AqB>Jl={!-TvqW{S

FW&c~UK zqAWU*a@;9go<@08OIOfUR8Q^n2t7uf^fYz5=eT@ltc7W8M@o6_ib%A*jKQaM%75~`+0 z>2d0%cij+|D#-J+N~)&&sGa^s`UkZ?QIK|}Bub$yT1@2>rfRyM+G!O9cwV;+1?hCk zr!d{)p5d~a`sg*%U##|~eP}MtqfDx%d#Q~cq9^Gy`hvbEJvrZ(j-q4e6gr=(N$2S4 z{5+kd_W!VV=kYaO>)*$BsG6s$4phZFRTJ|R#5|J@s;Zg{S%>x52(9<5b)L1R^B!oe<^*UR<+C`CU!nDod;6ytK*|_QLb^gJGLn)7 zd63uKPZmH?qxF=fq$y37MF6TH2({4wO`!FZB@Dx`q$odAXfWjnPD1NmX}v40bEO+r zt&>#3Xl*13L>ELFFZm8)Faxvj31YDX%di@8*oe*8hIs73H~0YwNJ7BFDKZ4|b3h@K zLOE1IRRp09-oa!{!BkwvRU{!pIX(}{VH9Gp28l?5ry`GAkS#eEe#G~KYw%3xJU@fK zeH27#l!4ZR>V;^$i~%@MqhaG zIX0NHQ=npRz;!~`_c9TG!!DU>BF4ij}7%dQn=kO9%BhIWN z<$LT$0?yzpF2HXt;}FP<9LSA(;E&=ciH8x0r|>koAqqdi^D(bKdwHH6r@lXXxJ_0bRuunRS>@pq5Wcnh15h%1P?&hHk_ z;VLxGxjHm&_bGJ7YOKR1e1YxQiM{v^`@m1elNH%f93@d5L8yt^Xn_#4hZmO->_@)? zyy@t_K@8&IN$=+=h_Yyk5WEC0CL;!)V>7m62X@25ee+~!{+;G`X)q&f@|+nf*L@;g4$Y zVkuT*4Ln)=xR2m#;!b2k9^}QnxF3}ehW_wk65_B4TW|!Ptb81T(Hdds124wHla1aP zc%j~Z_57ydz8;h{d#0KL%VOCgaV^*Tpid#y8jx5A~{A2sZUe@nSKS84vZWd?5 zb!9f$$UMl4dvG5rp$e*^27*uL!S+iQ1@xdZr=S2w{jo z7j#8;jKUa<#W=i!_e{cr{GGu=9WWQ}LUq(aFk+3z-_J9l2p?C}&(jND)GNm44WPaU zPoSSCpd#NB8X^pr>+$ybJZ?ya`*|LQrz<~;?tE@MgD9*)Im;RXEeO$hlYTANN}7ewL8LOy;aKXXK(KfD-*F_?f4jOT0m5Ag&h;R8&; zhh{oC1GDilKEZOVFssPVu>l!&`*|`V3$o*G+=B=3AgZATY9Sc)(aSTScmoa5}pHmFDQo6@Feg&M<(2d{3wJX zD2n1JjX?CoXyZ9ZzbLApCR&;?hx|PA5Qme9KSCn@D9KpL`oCWjFc8=g-7rx z9ye`BX=~b%(%yuU5{?e&WV(>u(F1)Djpy+q`r}pOC5PipOvF@7!*tBXT&zIgFMQ7k zK{rHUIMnrXUTmd+E41R5|C(Ow1fi@g6b=}GTtnkPN4 zZ|Obri=_9|?bfMVDD6iZFCAoycd=6C*GhZ{a=jAvp~*uneoQ23xQd z@z{YqIE_RkAyW}97vYaWD23AKT7nug;>_pdMr_6we2J~tg+17ZA8-g~FqmJ?dzgqA ze2Dp2X5z>V*kZPkJMlGk;~VV5L35ZqisLwe^SFeoxP~mHdH&!*6hcu`oRm_g4EZoB zq7s5o3vKWuIw1nx(G!t~LSIDVMNGpC%)@-_!9Mc?DTih*ncv7OxMr@G;hq=i zs3~MXW@JG&WXA(20DqK1Ydnoi)DLpwZsbQ>?gyViCqy6<_j#G|fO(LV8m1;G?M!=8 zLJ@`z=!oxmO_02t-=&oqPRi$|o_Z3SbmBRoL!`#Mt{aVYr9+UZ zL#7_PYQfvw*p}%=)|k#fvyzlGMq@Uj@tUnT1dY*X zY{m~Y5QI9=m`n@Pfz;T`K=TDDJK;N~QZ5JeLR5stQZ$az5(~_y|!83#B|Jp#xmw&9*&vgmgwBXWZ!>_DF_?sSB%=RA{J(Gpzrc+N3@FRTBLS&v`l{=fMp?L; zehrRg0zQCh_}7s)CdI{%_`g7Pd5J_Hs22YUREw8Mn1V$70?$mYR}f`XpML|Y!Jo%P zTtd28DefdCt0_hn$3td4srq~Zeu3)oQhYZ5A2h-vP%VBC7MUgFa;(HExZ3Nhw`Wd)#&S)=A=ZK{-ng3h2*DLie*q8e+||e)$ipLPU9TT<5$yeF6RTNKL0F^ zn&YILHVlebkxb<{RT$zv!=Jyx~amPWPOo=~k;T#fc> z4(cChn3MZB48jojQBResXox7&myE^$48$TV!E$_tRmRn3xAIt2n@xujD1)-7h`vU( z*@0Ms)!2fsp!%!?P)98X)nlbHRF_pv*41TIn>}C-lRrVVS3lH15Q0r-vIn9NjTKOB zbeoAMWv4kv9zxZ-`B|eb>Z74~hLlBEhR@6zG7jtTITq$ksfn&6S78m}un($@R=9`X zCu*A7r0S$|%{)?Kp<3xuqZ+9cG=<4xD1kBvphj8+)leO-23m`{rqnZEldcB(J;w>g zkGf_SR6teKfNG$P%p>FzXp44u1MlEHOhDiR|EPi1SSO!eXcvT88lg2F45yBRvIsz8 zcRn8isY6y)EfT6xswP<%&qB3H)gt9awa6p9J*`^fo_g9I)VCVim2;eT;OEJa%%2^7{@*0cu> zC9Zeme{;`B#X{U?m>{w?8lVYUnlN$z2IDpS)gBV{QfLn)FD6616GNfiiBTAXoApp= z-vM2}UB-=i478Sc>fV9WWBQ&uIL{#U82P_CCay7W8Jx!TNb0d+t=Xk9VXaxEv0yhg z_djDaU;pnL>&Se7u{-#VdAP9*H@1*g4ZU7hO}OkE+NNtnFD9+@jp)n-Va|wkcuMGe z=+1v}9Phz5H~>zj$?jRPBT|~6 zDVm#>q=cA9NqO8nLCTZnDN>#`&yW&kI*`)IbS9;%=}t-y(~FcS(}$F3^BgHJ;6=P_ zULj?G8AuMoYvy%wD2C%rjKWxq!`pZV?_m-qV+vyMq4|iE8JLOL=3`Pm!F(*hA}lsb z$z{;%uB^ufY{F)IfiJPua7m*}91oW+$##*l+w3LfTk}0BKbQnk4w)mQ95csB`N^Cj z}@kj})!d zAP*XUQVN@*q!c$=%Rx$;he&zY1d>wTR3~eoCTgLMsYfxjF5?;k7(WOz9Z2b9I+N1XbSI^U=|xJE=|f7id5)A9%uA&7H?NZ7HJTG7 zBg`mL#+bKAdE2~0%6sO0QYM)XNQp5YlJb$6LCP#Mhm?=aC#1xhg`|9HmXNZ{d`8Mj zvznARti|VM11X!#7E-=6TS>=eF^BpPs%nzg_m_wu-F~>+bZhj)=l=+#I zM01vu^X6AlE}F}vTs7B8@o;Y->C7FZ+-WkAlEq{rC5OpH%3bDeQtmPLk&@3mK+1#0 zpOnI;C@IBFNm5Fihe&zYxVdRVc`Rw&=eRisx}O=2)V=b$kCAld4pQzknMlcEvXPR* z?7p|lR(NLbA*&*<~S)onNy_vY!XR1YtEDMtGP(ZWpkC3>n2k{>hExKTuO2rfU2ks zH`k>t$D;Wy(%xu}i*!XKyqJ%L(43d0SP3`RWfRAm>+%i0$8q@1aruqMS5drBiqd2m zlsBp$L}IW}{a`yZ2PFVurUTgtT}(Gpo;5wmDD*M?NO=`r3^K2g^12yD${S_`DWl97 zQrYzGulgBI+@O-bT!>c>0wl_l0oJ* zQeHR1NO{AIAZ3&pL&{s`ZBn#%wrHm6Ylx zh?H6;n3TGvJ}C`NV^W%$=A^VVA*4KN9w+4q^CT%xnWss4#)Og5!E_>}v*}7ochiHE zUgkwov^TM6FXC6>HG@cb&Ad*E>W(tfsQxH#nRiHe&%95{B=Z3&G3G;3J~A^%nPujX zpCA^WVu@Ks%4cRJDXUE!DeKI7auc*~tbB>D5O4O7@{Re9lzrv`DVme@NA*$_!Aii@ zNpDskb@feG*Hk@IYoe>384A_!v=;6^)#-YMvjp2e>U80}G-%x7M)kU1dHY3F;nS(E zH3FlcT8nBd%b^;|Dy%WTGl~=s*DI;78~+>U=B9Psax3E>QM|78L0{-vbivZvpZJcO=x<+t>-ro26_4?EE;svo zcXJ;9ZQ~=^em^(PohQ;9|IoQ2_4%T?R&eZ?JknW*rfzgo|~UB~Czo8R9NbGwe8Qp;BjU;bTneAVv%&icLT_VVwp*Q-u1 zs?p!B)8DSs->%bhf6cY=t=8$&s?WQ=Bh}__*XL7e^FiDL)H1=O)HU@eL9h6zsi|!GTQb!A?T;^MEKfq&GXHQZo zjkJ*0eNz9VHH z_Tzv#NXlVzl$0OM2~tj))1;iiFF0o|kaEdfA?2D$BE^pym83TrNXck2lakeBCncxJ zO-df4z0BlZb3ZBhO#xC0nj)kWGbKnVWy+9J)&!7J&S*?cf=q2P7 zH_b>=Mw_vuj5Fg&dDl!JWulo($`mt|lxb!b;wvpSh!|Wnux7ka|x8{3N_L~Ew95jbXIck0+<%Bs&%4u_k zlwZs_QZAU^NV#OLkaEo=k>W>fOwyYSq+~RiNy%!mlakZqCMA!_OUk|Gep2$A0;Ci) zg-9u4ijh*nlp>{!DNBmRz9k&$tM%=l9Y&2#>rG2qjZ70#nwb`)v@(y7@|bB&N*mLbly;^)DWN8ul#V8XlrE+lDbJdoq(qwDr1UlY zNO|78NXpCR6;cM6fusyJLr58FhLiH98A-}$GnSNbW;{6&Q_VC|rkk0h%rO=8I2?U}Ff}yqIL(m3c z=z=J`0`eM$v`uhlp$s)DZ|a1q>MD9 zNf~R#kuu)AOUeYJ9x5q9%}0uv5~P$eWk@M&)N>^jOeIpPm};cdFf~c3ZR(Ix&om&V zk!eCoGt+{UR^|~>9y6^;X=B=w($2IeCDeqI($Pea(#3QmQ8&uOdw^VnM}$QGnJHSW;!V|&1_N@o28^IH!Db4W!8|g)_hLN zX7dFpTg?tq_L^@=`QE69?pFHfT>o6jJ5tscaBJ`1bS?dCDQm^MKDan~X0=9lSg(|| znhR5G_@_R&*4nkWV{#u{`0e^#at-fx{qDcJez(CdrFOTORPF9dsCM_?P`69u`_Pvp55|BN-`NEvV5C1rw{NXle0g_PTMyW4d;)$aak-7fXKl-qT@ z+jYEt)N-CTs^Q7YMm0PcU{u4C!A3Pa8ERC+lQ)fOcrx0kh9~39cyc19nrWm=H#13@ zZRV0P&&(%ffmuY#VzZQ#+BYWwM{x{4;S>ThGRFop5Q~$zfcrAhkAU~! z_QBc7@nKwt_P`O}{cj%UvG%+X?R6t=pBuNIjrOh)w?B>BkLDV0(>^qA|Ctt9`8a65 z8QE%rvhgu!VOEl|)wum%+`cbvpBL@rB8|`-+S5foGup@HE8J`!ms&hWYGV+5_i=Ii zwrH;w-~C!T^0*Vap(lnyd$MT1d$;HPM2_8lEZU1DFDe?h&x+e$#qE>g_Ce{FkMS9} zeNVLC$!e^{mvH-?)Xz`9D%}1ib2!#sCT<^-vmBqpjrJ?K(f%aA(JSM-KgoL5c-W2$ z_$&L9oOy_Q00caoLi>XRK>LAAg7yQE$Qdd6ldr&c-;c>WPQCBPu$i1waS@l`_V@7J z&qI59xcxlJ%;vm<$Bf&*BaX+S{W|33IedL+kBxOmYafkMbGg@n+c(3X^HuOGXx+P|VO=jR*kUvZ6d_Ko(d&>j`O`&797C@SRs{XP?MJeDt@{Us{h z#X9*o0qqyz_K9ebhy53kdY=gG58?KO(B8OiUkL37A#Ohix8H-?-$DC0$P#GJ2JOip zZa;>a_y2w$2Dk4*#e97KaQiH1F9mV?C)6##*F}A3KLoe$L7jrU9d2I(x1WLbFu2h^ z25#R1w_kzVD>bcs3ewt_pyv+umc+}r(f$N({cG(TP#LNB4Y<*M0Sy^5Y>cL8&@-}o zH(rN|n9`*1r{$>zp4!PiAtlH^MH5mA7fMl$l(#VfvoQzx_{8~9(rhQ?1kT|iE@NHM z6myDk9>Nk6N6Hmkho?B}bs&eyP0HQKi~CFgQv6L}vIvTs(xg0$08~YF1e>~~G{$2H zMHo7o2(mM}nwLp=6$9`V-o*qnk(`7WOvOwyhn$O8EWj$P#(HePX0wgljvZzf`87`9 zCnVwme#2#4GwDjO)(JA0Ok{TCG*8B*vKWqSHKoW#=3vhmGzP#QnbAzA3SM4~yV$`=+FP z{uYs)x^?ar(TDR7zd!A-^82@k)}_fJ`8=a@%_WnC=d%9BhVb#S4(qYWd_jJNx;z)^ zp&>%h884u}8AuMs5Ddj=GnSM&CYs+>Kj?WQsh=wi_&qd2Gw63Z&3sBOL7e%D6#b4Q zr@4UW(L?)-SO^PoHbr9SVab)HLo9{Z#7md;%_I&W3x?NyQb{N>Mcuq-N}3i{(!=zJCf zJx{k|7ZRZJ*?Du3ti|&$*yy=@74H1jjOU^6`OQ5yea~Myhh2g1dB!~l<9QyYKHnVR zZSFjCp5uS(`Q?S^h+b?E5*pI2V{~MfKH*Valke~U?(3mpJeTF~xGu`Tb2KCFg8nXs zU<~wJ)$9I$>UF*gU&}qu|J|?i9$w#*ke%1=oCq*I$Ul0$pU3-;LVq(k)A+m5-%Ai` zqX{naoY%${di`$b^Sn*sxfsps+W_oF60%+7^P(|Y;VFb-7)Ik0B;kgyhnyR=NyarM z05(W@9`;eaNaCp%?LhFIDK2N^yaes}D_4xGlW4zMar@I|p>8N{KUTLds_ygUWurYg z#qGyAnd2Mn!%_zDU#Yz-#qCS!_L+41OGZ(XlY!j34uacHu{-yt;`US2UWC#< zPYUfDsQbf>dHp<_p?&bAE)!g}Ut9tcTMy!}3F2O;CbUo+jMj3TE(`)drM9+!GOP1WaAza5Fua5daG zj^%T+k(7A+gfq~7*mv^#&58V`0NE5_h(vGf#t+8T@lNnqenxhl7rD$`WB^)VIu@8X z@+X{!o=4Y_mwH}4Qc6Q5c07Xs_(_nYk}S4O5d0MiVqgON8J_ zgrgI@7=*zXf)N;vF&Kwgn1fg>G)u_kSY_6baoB{-_!3`Xo7qS1#{nF~F{(d9_ zvLGjNArDHTGy+i`6;KJ4Q5Drt3&CiMr}2#GOh%#)qVb#=Ov(_9#AuAgILyKv#9|>9 zVKJ6t72>ePd`W(Vc#}XL#4-GWOD0`b{(s1TY{-dR$b*t7jX;z~1yn*c)HK1QG(uxE zLvuWh_6S8dI^%f^HbclaFbZSv7RF-&-p3^K0XYTJ@DXNV4nDzhtTAiJb=Zi__yS)c z-W($@!!H~EUt~ZwAsVA8nxiFJ;c+~H zClQX$7=S?-j3Iaj?_&WLVFgy1IC3N6u>;@W2OPs0oW*&t#iS&Ok*j6L`UxwP*)^5Q-`g)sDo z7Zc#tuXFu%8i$;84{ygsco?6^je;nLN~nxrJc2OvKrckWi$z#sR+AgB37hdX_8|c$ zkcdn0*!4>;@_zW^1$glqhGG`xm{{@xJnSX^Ac~+kN}&t_Q4SSQ6~U%H*%MKSh8J@Y zi!F%9clZJKFs^bx^5H?WMjI1ON=I};PxOHo!!ZUE5QBNRgE5y1sD(OcfaYk4?ufPVhg)x|f7{tL-h;eg_ zK`Cm{!Dxyw^ew~dHOAvzXda&Stk7J%OSsWIyuh;bWFQhz@ZufBUaDv;+jYNHO`!9*k>1LNiaD2GuPgQGZu z2g~#0!-$V~J2oO7WoGd6Kri$)uaX*Hi@_P3#c%M;Wb763*nwSUH>q{U&%$pOugS=O zjL3p)D2fs&gFsY6FrJ4OpJN-o#aUd31}BO^V{{Gis0k(eV=xxtQ!K`3Sb^18gSFTS z-M@T`A8-V^hq(@Ij$9G}2t)-`L@?^2KANG02_f6!X}B@L`5Z4Wi^(Nej#Y>=8Z(sd zaS}h{0{rH3FM!O*f!w$U{wR);co>0r7Ew5YWB3s#pfSfpT!L9WQNr*A=wGL1m42i7>}FIJLF@|!E-0$ zirl9Mqcy_N1zy}}{8<~~W#+U^GSuo zl|UdG;1RS%6b9mT3`Z=!L;`+=+kiM-E`A4Sgcf)dk?4&+=w}9z3$YZ-umUTw8fy`c z<4D9Mq|eRY4<0g=$wml4A4KCh48mfpF>A@q*otk4#{nF~d1$lb+{lB6Q63dg6*W;C z!SLdB3^Q+#BQYA2F$J>`iyx4HLrBCWq@$*k9vP4gIgtx_P!gpPi1Mg_N~ngKrZy>c zP#=xZ7|qZeAx3qqj__hQ-ZY~~8H2@GYL=6q;S2K>xfMH%YGJ#v7vDe|OIJZK>Y#yX zM7BeF6H11|i}_f9g;;J@kSnp;tR-bVHX$D0!b=VA6U1TxmSF`}o3-Tk&?eXAQ3FA! zW$KXi5rVb|Ll1Z{2OpbH$oW`?<%q);#N#luP+&ehX#B}SC~gADhR`P452LE7L5lVv zI*TOSdB2}0v&ly0L0;U0`w)O~sDvu0irT1)`e=v{v_%YNVh(m;9}eIkjv#rnZ|av> zQ6AM$9ktOAA*K!aB%a1_yldVkKSV4pLJK5jMjQ?z5tpD1#WNub0#M5YlMN7p9*Dwd z%r*;1`P699#XFG+nUNKNXlO#nwg^K6x}Yn%V-&{WZMFiQ z$6CBG+|N@0rST8~Q4QK~ylQv;zVHmf&<(w?8gbZyc$~%sqXifPPz4PTg0^UfaCF4; zcm<;o+|$qVBD62o`_O`oO%Z~j7>6lPy<4?zZFK(IP;waOgAx23kZB~p|M|Rr;{vYW z8m>bND;8eBbIyd2kD|5dM0P9vF<*Faopj34VfSC%-E+FmdEAB;Xvhx%m?a!wb-Yj*sIB zOu`44f)CAfat3DOV|;?;SYcL?pJM|u?B+TTS&$uf;~qSK2T=_*Pz%ARkA|ix8G=VK zeGh#a_;N3=bx8V_=fijWy`v|h@f-$Y2;PJioO}?)P#Uh!ON&oFgeuVZMlhP7C0b$3 zA+8}1hm%OeB_x^nBfK4nxPr7(^o;5qk?z8%-6 zqw#akZ#?(#GQLIXejU$6&h^NJMhHP$gkdPgU>;(z0&!RiEo}POWj+o)@n`#cv>57J zcpH~MCERmh1_N_5(|M{bP3H+lfo17D{+PNgohKFvC)0Tn(f(&X?jrBMOnTCLn&wH* zby#}O{37Z9G5(h_u&Q@^BB8$e;ZQ$)T7C2zc;6rP(6(F~!8GJD8Mo3-S6xW4_p9Lpgb#&zSDg|CYsQ-`dJMre#?P@n%JCW`Eher6y! z2rJE6asxJDGu*s@LmVH*WoUkYU)B_EoQClM-j#yn?+v z7EiVmcaY-d8`R=B7!A=FO`$mmt?>jppd$tvH!oogkK?e;Y$P}13uw;5ZtTG!90mmn zk00DThFTm;9n^=L*U*Mz>41(HXxw~iQMn=6}Rq(YIDF@GY~Zn* z&ymEj6ras`6pio*-24tN$AjSJc`V_0IaXp7;>=M}O3k7EigGBAN~nx_ra3A7O)M!3 z@hO&K8CFAcN7kBCY1;}z4#8_!_Cw2%g22eDxfNApcdS` zokuu+0&UR_Z{QuMCrtBs0w17mjjE^#H^1jCj%Q*HVzCg5uoz2Fj#@-zR5w9nP1J_w z12r;Z$gvo2+&rOk)Gp3L8&vqAGO8mOzVnBIEAlqDc|;F}bFYK4xY2x~R*~GtK=X;- z!V%-<6-{2ry)IJEBZ}BTodP$TM^tww&o^k(gUYCZ9_VLYBV{6{U@GRrlfd}{nQ$NS zqY#RqD2k&rMw_(eDV^e8^bBq^UrFtyKxL%9J&98LxD&6a!d;Ri# zz0&+c_j=@BZ`|vEJMY)#TrE1c`kr5PUKO2B#m(1q=SR)Y6P@eCozL9)Nar2V`9pM` z5a0QBnsetn-%fwyZoZxS`@PvbyR_!lx%qUBBVGut->plxXnwa`4kXV-t3x(KI65O2 zuW$E5d*c*`*4S)_#xK(1*(+rZJ(m{A^UddxZa%&5{Q2DeDRbjBNB#<5NK(&lkKl7k zllqT^*6r3Syw8iFtyo|)JUX&Z@_73%0rWuO8Z?eB`q;<&{QiT_^8Rzs`&$40(|E4) z_N3(ZB~NMzj}C1S9^IAWUeVop^^5Q<nTh!0+D!dqlbcIu7B;`S~b`SUE z_}*M0CGXx8l}Kr2B1su;W|Q){X;S}p-{)h|;eDe2qhH&8F22u=r##$?8$Cx}0+&z8 z7L&5nd`3zf_TU@*ii=pAj_ZG@&pH7|aLTB(AgUW^j{b9SeZsGBtX^Sx9clFoYoCta zFpzqKo6mov{$ceHhhZ3QwJzb?M|_rl=js&xcQWT3y|4@F9d>mJSD(1b+mej>hP4iW z`i0di90#of;QGy7ox+nTr5+JXsvZ#r*9Sb5!0ucReeSE6yLsIy{5K?>MBpe z_5Z5AqW<4V^fs!u494Hp2dtXSI{5bg>b2eV|GN5(`hd?sb(}xy|5aT_eZOhdb8gfR ztolx8s2|vi!5D&D=?7LlNd3QQ)qi~Zf>j4P2H(D5)rC^`1*;y^5UvkcJ;3V!Rb40) zsta{SBwoS*s7~}}`hb1wNxpR?^#!YrlZ8CD)UJN!61=&=v!6tNp<00Z!fj z>*`Q9>H}6Uu&Yn`b6g6QOche98Li*p+ZU|5m8)0Xs7|Fm;3f!xYD_UmtAF=0@4Jfs zn|-{l{?&~h-ri6@?`Wj%=k=qXw+DT^kr;r1cpvKT{RuzA_4(?0SAD*!qXk2Cv@rPg z_qw{8m$&c2UZb8~tzD7;_4WGJ(^B{Is)sjq|E}t5u5Y&n#|?2SeY&1}DK$5L($(2q zJd%cS$8!*gNP?##k6Vx}Q~Gq(pL-3S>HMx{aJ>iDud5oWtDg?wSas8T zXY#j;!Wf1(akGA1_2jzyQ}yHah5B(-SB;1IaaCXa4Oh%HQuWn9=w3Dq>c{m$_q49x zHi2W;XREqtFw{#Mg0=|5b9f1^KUQ-J6L1D+p?l*$(ay<{$`Bsk)ML@ zXK$r{mY?ij>XQxjqs|LgfA&&;_U(gp^=J>Z=z{R=gH?Un3-!Uq!1cjy=XeMHN-u0N>yrVf(|2Nl;(x zCTzhmxW3rntSNo5VWj$Ey-;6lT79tE>{shfrS5}u;|QAXtA1E7;|S`1b>j-L9Q*da zYMkMLoO~`5NQNK^LlBGg@a=n5U92>Ssry(xj2CEpLH(<>Q6H|4Rbvk7 zVHGdd!;LejclA5$GahPcu5ZQQy$8XjtiO%Z~&&{#$|yx0KsmZt76)p&*a zO5^YiG*02UCuLkhy`#SUqv{(~k7!!`p&GAH%~JiK)esEV7h0YArTRcm;8yxTefvK( zo}saf8})sfw zGckbgJ20hBQ)48p5r))#nt#-n8P)y9eVK{8{XEo{SsB5o2iKR`k>k|;m_2%Oo`LJj z9MFq@ADPmZsWBP#Wolf;^<}zs2sB3H#%KO-_i4KEp+wi8xt-Ts1fn7S^f=Mi|Gj;d zaeFw=<2&rbWn9JGd+FaqMN~#hgrFCqFbr>C7Up0b*5iNrHaY&&<6{SY-^Y2Y<7KYj z(~XeD1)Ae!Q?$@+_ z&A+)H(T!&^o{~Ipz^zR(H-7OMk0lO!@Mp&@w64j`#w|2zVkDS7@B#kJdHO z_=VOpNo)KfhWBm39hs>^pr+Bp#X1GhiIC{LR+s@Liunb@|{_^>(-Jh9?&_6KEX`QGLBNoPg>ujk0{zvO;_}1N3d-q*04Y z{cl_^Pgm$aUl;dXzv5Qw*ZR{BFpTQ^(<63Z-_9cZvGk;!mYEX zy7>_t!x>zLtD~2klTt^oOV)?hrwD_qqpOzwD*o)c6t3?66aQ9q_w)Ey>h6cAyL&$V z*Vm)?chuWc*VENwraHQ-pLhNb)z4Gc%{|n=Q`gIV*Nuqb{eM(1zuCGG|C{RMs+Fg; zUc?{O!?j+7CoBDO2!_^)2*a(`!?i9%Q)oSi)b;Pwb#G73f3ACL{Rh>(weCaex_5eN z+*;=$^|}s&dE0!ry0=@mL3M6d>vr{St=r)0-Gez^h_z7NTea@A>fL3iTmPAL8C<oWY+^%q<{TXpPk+)CYAYb^M#qo6vq>eCg`2&z-3UME58ANba(-TDWrOS^Rr0`5tv zNvkfcdbHLtP)%CgIt9LU=Q37z)_(4{Qg_z+16prD>KNa32I6^}YR#_RteSJ`bq2J? zfT->)Ze4-2>d(IG2RuwYSv6;I_2wJZmjkH{yLAC>v>w24s~xL;?B@MzzQ5c7S3j=6 z@t>_1*Qv1#-$5Rv5ynQ!c-_?cFst0R+zHc2^^YdjKQrCh18|LZ% zH_wazchqZdb^g3+r>=hLJ8$02llPq;uQ~F!T1QPiAO3dzG^KvZ-Ok@KkGn~yi2qrY z{Z8%;T(6DpDb!Gx}#xj8gxjm`Ye8W?}q_uQ*qT@Q8D{~za@=grK| z96_cInR>o?C~tG~&0pYn00x@zKe1eLVke7Um!psn=;%pSG;U2BbBg-M2qmbK3KwB+^=s`Bvw<`_@xK z`Fw8vyKi5%db9uRJovoSDt*^azSVj0u8#V5&yUYb4KxU~Oday}{P^4R|$7iQ5 zDDgRQ3mqe(k~dw`7;t^KxmJrA16+#F%;Gu!Si5>T$1AWB z%_E1t! zYJMc;ggHsdX>*1=2dx<(7tIy&Dgs$UAQa)IBPkK43n|^qv!wJik)-rCeM#wOo+sr+ z^D-%~m;s~=G;fkJ(u^i$tQkkjc=IkP6U;u+l}M>#s*zH|)Fh?0sY6OV(}0vlrU@y{Obb$4nMX)@%(Nz@jcH3tJJX(&P!mo{ zM-xFx7t@WDXH8F1B28~n`kH>EJa1kkG&J8{^Xy9?5LFNi&AWH=?ZY_kf+)E8^+P!xgLe^wnTUm(cfXY5)n*;(_OIH+ zaXj2UR(m;4z>n~qcmErYd;6ytK*|_QLY6`)a*#QZ#{`g4(NrTP2sP0VP0-Rrkpu9W zi7(2}8-Wk;H;8Z(L3T!0)18zarZ*{l5sl~Y3I>|Nqzo}bNf~b5BxR%-P0Cm^j+F7{ zT~a2PiKI+6Q%IR=rjat;%p_&DnM=w%GoO?NW)Ufi&C>tF-g|&YRc(L&6Pk#K*Z>QP z=(ShuU9n@whS;(3vx5c2%K!77 zvsM`9g6011`~L6qyqAYhzI&a0>OTAIb7q}=_Cm!y#(k)Gz<3B14;zo7;&J0iR6J!o zgNo;j7f|t{@iHo2HC{u->&Ba?c-wdv74I1zpc)V1b3=VU#W%*5`hWJNKcvVv2B2b) zF$5LEj1j09WgL!*F~&Gl9AQjE#gWEjR1_LvR78v@DoTwQD$0#YR2*;2L&bdKWK^7L zoQ{e!jfJQ<%lIoQ{$`wqit~*NQS}$yhw&4{UyS`xae#3kDh@I_pdF#J(G?Zljh?9J zWgLo%K1N?uzJ>3M z_2`d~dp&*UA#*&7hp@Bbw|T$Swhb8L4?J$zc?}uM6aE3Wz-@33+z0nV?N$Nv(9OmB z@_1KO+Xmn9FKxw`x-c~!^pDyVM@eTG2_BcDl=KO3A>0XDiofv!d7nc4SA%#P-BHEU zD2J2aQn(jhhA&|&95H)CFBlIAI1LnkBlCOE_pmd+2i@(pO}_^nhn@L7=tAtw??Io! z);FO-4xX)H8`xaDj=gc}C@zLZb3BmKB6`DNFvU0q6~`GjpyC$eHB@|W$oKFP$oC-D z!dLJud7Jwi_oj#TDS?8z%6hm+y(c; zoA9>rA^H(~3mf*P4EEvo8MJ}D;27gV^bWYoSdNOf;C)#97upE83GRaX;bC|Jo`k32 z8F&F+hWCvRQSm?UIjn~b&~QJ_3FI05P%#xEPzecGxd*%G702@i_;o`)v>sX?t&cW98=wu*hG-+S5xNz+ z71|hWjBbr?jW$7>pxdC^piR-H=(gy#Xfw1Kx*fV5+8k{j8kH(z2m4l3m4%CC2}6b-my)7!D(06pVu-!28yzPu)CFU%Bit zQlDj-kCEzq<8qp?e%Ra?ro);3TQOTScIkuQecOC2(r1~L8LQ=IZ1roa4~IeaSfaz3 zHXbyVsP|D*zclZg_6X_Bu|A*0_Ax#~O@r7hhoSvpAPk0~FdQ})lSN~7J_wJ&6R-@P zhG!u=2Fo{06B=`~zV$E59&2+r(>E7`MPq9!?#kxI%KVz?8Y441_R0v}!HUe-EB9dE z2a3V+oT0HQ=RtN%l>_l_c7x0q^@m}Phs+o%McBnq3YCx<+F;Eo$L~+tJ7Ng>$r$A#ZE`?{o$6Rc{x1wDk zA2imY$34H6^bMd`CW?9f73_=uR`E(+Zp||Q+-W|IRR_^NfyTl+8a$SW#}M(@A^Tjz zZ#U4`cE`i*pqSH-8=0{~+Fi?i8Ad}bD9-flpqSE`u|YJZU1ls0jcs={91DsAA~qKb zMDair2U=s?tusEjJ{YUcV}ATzERW2X9U5=T$JWwVT0*g5>w#i)3;>VKQA_#+SOSUx z>tkl=MZ3r3=tOz|37PEwgvex02DjpVNg5_A6rWCN<9WfZVUDS z@(jhkxC1nHR6A(T?;6DqRUC`#F`#-gEzeLqQ1K%87*LA+sqvqL$F}IYD`QcC$F@*R z3y)=?IG>8w>0>=9ZfEw`PQMkaqHk-C+whnbr(r7=XXY4AipQy#6+U*8Vph~Qx}ZLW zlj2t>M#aIPF^|OI;A0;tCWVi6q&O7mSQM-NTx^Iz{7w?NUlGR-3Lpkma4H1%_x{n6 za7{(3a7bx9kqj4AM0xC~dn5^s;yy15x99m9Jg!re-z%cHW58mbSHxOa4@6f_QxDw} zYGDJcWuSx&+cmRo4@!m!El?Sy(@ZKFFJ=kvkM8$W-P?rjW5WAY`@L!@_Yv`k@g(Z^ zo@Yq=y~q18`#r_ucWI1ep)q(f<4&lJ6uk_^f)Z*sJ^qAZPH zo4ABBQT(8#+jFgf$BpoKI372`uT778v$<xg1V88N??%z`0d8|5hqh0gpYyz2KOMLGT0V=;`oKe#1wVwN{`61 z@qX5d-<9HE<3g6X2!i=H_JX3hPWOGf7ZpqBXYgBn59Y9MLhmL;d+uG+V3u(q`VdTK zU&UNw5qc3+u|M+VyAS`E_JI%nBJOqaQC3|Y;65bzj(!07j0!>Hpo-t~_4t@n!STwY zvC)U|TRsW(TWG<4ifms*m}$juEF1@C!oS1!unXnU8vcy$p%3#90Qn&P2Is>?a4B2{ zm%|lsCCD$~zKI)2FM(Si(>L)P_HuX;UN&Au--Ndf_gT2F;`V(u@0*ZcBHK4{=U)Qf z#8ULn`X>H}Pa?h_&p!LJZdeU#VBP_t(BEMtya_+UFCd?U@YpHto5=P>{3rVu{!e^| zn2z`RTF!st-Qusg4}!L1Tov(iBI+?ZmFpk@dRBh{wsh|=2&eEq#0$sFj;F%2@aKiN zZ^0pu2S>sbm}(r29tW4f)o`srGne+Q-h_%Ja0}dN+=q&XjMq@{z0tf4zY!o84uifh z2FAe@Sj3JMavUM9$r`Sgb6~@P*ay=_LryNgA)zs}fn4LTUwFp@1Gt6;f*+8Fau(ToY(L0dQg3X;((o=&30>i8Q8^Q011|K7kU)Chkhylrf^ z70be+#=K8~_l*a5?ibG)hu0)h8EXmQUQNT{g@npgc=@$zLthr?35P&Gj$Jh6c(;Sr zuqX88So=f04FOxBq6i`|I$W&2%As18Js&QFZ$KyiRTv#D<bDBm8WsI{E*SvV@EiDg7`YqI7cdEq zgeg!6$HH9b#qZtTa2(8qecJ@|Mh}HSFa&bw8?Fdwb`|Fd zzA?T>#f)p{Lj%vl3((=(fMw`YFqwy+LRbr5!Dmzou>n+hxjz!OTjv$dpY|A{f&4f`SAC6z@_)|o(oQSBVbITBvsfyL1S1PiiLPigbq0Y z-Uqgf=S^|3aVsj+k5r6r5HJB1MXdwQMa31yHK;gfj{xrrG@be+26G|lSxL{EV((Xo z`v>FU2sjN+hX>&y_!_=}{a$4pZB^=qT`ZM)yCpGrw9pvn_3kw==)hzC4-L zzPwA@B7U!(DX?~CY*stdly*gUd$TL)-5|T&DQ23uv_97%EH{p5OdW?kw+`_3X)SHk zIyht-#%Y1`;Ud^vyEWoZwp&|juSV>|wFF0k+O5aoUv0N8qwTuf+OK@tujxj1J65$X z@f~1u?OD(Ae{Rpt%WBU~rae0i#>MsOs<^OjJO{4F>~R~K{YV{w?TsDLonTL6FI4OU z`@;Tk08rEZ+*lK#`k|pa)@O|T`k|ZmsUO<-luDguZIfUrtbmp94uo<7>Y<{6(Fhe( zku+2Z4L7AQ32B<4f+~=P+mJ#BXc(e2El`2GF%73AJ(LfpBP6(`q-leSy$w!DNbF~{ zMMXQKJt_`1a#7LA=z@xFMo(1qG7d#WAEPfS@{Iwg7-S4Z#c*RJDhiCzs2FREN5uqV z5-N@|rl4Y~QG|+OqXZRY#xzt^7;#io8A(*6j2Wny1+(F3<5*N24=2Eh#!2YOa4MV* z3*apHE1U!8!r$Q{xEL;l#c;WC1uCwBtKnMX22|VxH^VJ(8{A>sh29PK8;_ylN#ki$ zJZHRsiWiNSQNe9Cjeeqv*Nrz(@s6sAys|MMX2CIVyHAc0xr9qZKN4HFihE9!48f>}~9eiv5hX zsAy-jN5#QLE-E@1hoHUSP&f?w8u{oz7;Fqh#c*RJDyn!k5lKUFN5x!2V|H(8-0p?s zoduV{Kj3_1}fe%-a*AG<9$?oXskxX$Hu3q_}uss73!NL6!%p806)Sn z(1B;rsYa2WN1@m#K}DG{4HXqe92HeY5)~<91}bJ5b5L=NaU3dY4UK0m&M+3BVv%t+ zD$X&^MaAEZ3s7;9aS19G8<(Tv3gaqNTw`2^iW`iZP_e|g6&1G|ccS8M<6czUZ#;;K zrSLF3YCMjLCyl32@r>~tDwZ2Bq2d)|1u9k=Z=m8W;~iA2GTukUhsJ7Dd~AG*iqDNN zQL)ze8WrCf-=Si?@gpjJHhx7#h-Y_E&uD;(Mn+>)G%=c@qM6Yg6+0L^p`wM+3KhE= zyQ5+cqYWzdHugouenwkVv@_bH;$WjAIv%z(uC>Q;Je6m5u?X&k2S9NKL;Q9V^^69n zXk;`-MH8bbDw-M1QL%%u6DnF5tx&P6u{$dEFxsGEZ)0Cn>}Rw^MLVNCDh@VsQPIih zf{JcN4^$jt^hU*DMjk5q8U0Z)&=`!0p~i4jj5G>RG1?f5it)w-R7^6CLd6tgDk_SM zVpNnEWvG~DRG=bmRG}hiq);)#n1zZt#xbZk&ZtGj3C4-2ILSB#6{i_zpkjfs2o+}= z=b+*eV=*c&H?Ba%RmL@_xX!o%6*n16P;skqJ1Xup?ncGE#{H;x&{&F!M~uf%@r1Dq z6;B(_qT+dDIVxTGU` zF(^LhdiV+I?G>;UDz<@bp*idTI~%*8tzlndKUB0e+Mx$QE_8;&pbrc%rlJX$XZU*p zIdeL|RHFzjhEgMjigKe8t%9UcgNoyz7EUluM8!$QDX2KjI0F?6j76w8+c*am=Nf-U z#RbMisJO&fjEc*RD^PKjaSbZ2Gj2e|O~w*b+-ls8iaU+FQE{(vKPnzHmZIVj<1th` zVJt(%)5f!?c-~l!ikFO6P_e>TiHbLjw@~qpu?iLM8=s-#3*&24MlmW%j51VAGb&I~Yn*_J6OEHlaf)#o zD$Xz#pkk46HY(0B&PB!FjSEnrxUOPfV?R{1HQJ$~y>T!qIvHJ1(aq?AibIUvs5s2X zLq$KMKPmQt zmH)l*<7=BTo;VcHA5r6X7^1@%=am*fv=%?BYwj`8;C(1JT95OnRpjIhEL&V*kCl@ina|#z%8&8 z*1?a)FQ^Fd-sd35gCk)oOoJ*o8BT=-a2~t|>iZwrnsy8lptxe{(?1{nOk6RInVbC$ zfMSe!f5pu4az9}DYRHT;mN{Ooz7c2$|4Q7k-Yh3J_l>~_ru#Pr6G`R{U^T3P%yD@2t-_y;W2SL=v%hT^!L)Ip{-BxT z@kX#qAOV@<@%}sGoT>k5_O}zyG0o$jdB4=vOj`r`mZB*%gXXXUw1sxi6M94THx?t9 zHV($a1egSqjj3n^N+1EXFc0R#8L$8r!P#&PTnD$o9dHla582;nJjb+GVFkPm@4zbf z09L~q_zJ!Ob(m=i&7e8#0NLMecsw=rwJn4Qlt2PJuG;aW^)1IAjj#4J^NKBf`>~q5 zHQ?WX&|HTOfjk%q1uzkghZEpL<0SMnI0OCxR~lEN55Q7*44yESq0hr|cpb9iv9;n| z^DfW^4uGykcU1H=4nqgQ5U2osdvYS21n0r|a6dd@gqkxiD2|)H9odrqDsx<(!8_2F z!U!mU@i4)dgieO3a0;9TXTl;_0=L2)a5p>%ON~d+$6*<)fR)gkcj`O9&d>@b!DJ`| z?<4&0h|{M2*?U44P@Fb>D>D@;AP!aF-_F#Mei<_3wY`nK3O<3%d;Kol>oeoHU5C8{ z)x&1h0T%y=i1h{lf8cXo9fN^Q+l#YZ*V`#5Yi(J`BP4TPQ6Q%V7nqgm+*S=$ov}cyRg-VN3Dg&L{5zxEMSx+`lUx z+<{kd&L9E$M(kKnJh-o*<<(rnus56n`rW7T8}xfgV>o1v-=N<}UxU6OYj1emH+@s4 z@5q+J>#z#4#zzu&YQk1%L9E=Rsa)WDtMf?M@YX3 z9=A>3k|}Q6cksW7+xF@8Jm@oD41?k zqhh8p8x=x*^o2>F??@hmN8m|#8eV{x;5B#y-U4+X*#@?S z{h%!z0=?l-=mR650475%{0MnD^uK{$jM{qqMux?(999`2`YUC}i<`r=TDTY%!*9il zTg-3!Ycqb|`?w*YhWze_T!_H${qFz0aYmN1j&DGnX1Z;~@xeHl3Z+mBn;U;boogCG zW1|V$6}m$Y=xy{t$H7#X0kv=mtb(uMTUZAgYK~vZf zc7~R)3v`7Za0v73h)K zx8s}|xo81Y!F*T(kHISV4%BIBAe2B2%!PZwzZLa3b8DIQ1BAB6{{h{g5A+9*H&;#C zHF9IMgckzYC&=Amcmo896kV# zYo~8y4}@Ik37K*34#B@CKi?AAJ4zd?YAfEg-P&daqYqX zv){?RLA`-qPysc@iKw^`E``hBX2_27r%sBEpfR+9-C!@+2lj>ipdI+PtP4pC4bI*k za^X8gg+V=aQVkMp%oy1|1c{t~`nf|Z5^H4v{-+Sk= zrM{Y%v8?)N>YHixlRW+pyz|I@m(ivXel*ZKj08*vf0ywp>5pJFdh93V`tda*cTOT4ZZuA09$(Zv6#H4puyJo9pO-;02LD; z40;z*3-jU6ybF1N`Gwwph|G5%?_qn4z@JHrhE4vpcOBX9Fp{h%1@qz0yt{aS`9Xz~2dsC#`n^VeoeWfAk%IeEPZ2$&hb< zAp9Ah{u1WD)sTOGb3XoTpMD-b_)K5@DcEO#eDdv}k0IauIG6;JA#6m^5{N?;)WGqu z!1z!1<^MZ;_uID&eD@vEJUAStLZ$r1 z^1Hk5UE`31_V~~A!B1~PTLyCt_qEsCYtz1pO|W-_osCv#YuMM=4;5{VcIcn=sejp? zwg&!;Z@u=Qe~)iH)2FU@$XoKMXZq5AWWJx_-{n)^^D5dJaNl~Iw0!Csk7hBffq%uf zo^uUdN}wTZ1x=tS><#W~KY{dZ@HJ%n*neeOlWQ5C0px2R2vb46_7mY&kgr|H*Zv`_ zhBfdbxbMB~b%F1_AKD*=!BlYH`yA58!Od`skr_Yj0j4cAB z_f>yDI{iWSuDt()PH>1JpS3s&PK7P`t}}hs2k*|gHQZOdIp1_HzT|<%=6uknk|)2j zkk9#RsE1!!GywNKcm5ZA&3(JDZP=WzxpkQGDC4~uzT-TY0`6mW-?Dtl9pp2HeAtpN zIopR^kf1!_uaNCS{(x!!fBTOAU-R{5`)u78>ps}-_+90L&GfzAXuj9a%=h}4`Ch-k z_qx{jqdr*qUKNu;{#Wr|-)rD|{df6X^VaMflDnY*#f2FvLz|!}bR90*-M4BH!VME@ zi{jo44MuUVgeIU#^y4NiLby6Y>(R$JJ*{?W5u%GWecD=tE=61I(IUjpY`zO+e%80N zV_>gD=P`Y4*T8PvtwpGW{2oIBy8x}hUVl_zH=o=hG(*c*1^e+BsxEXVPH&-~&Y{KV z_GsH=i}e0?K^tSI(5=y0RQ}=I*}?wxK+nbg_}CWd<6n>JxCb8>9M1%l!wF4A>1r5C zp>5II=e7vZEitqVEkFmK&?2-mIu#v>E^3I_<&}$S%%V1z2iwaFg~2-W^xfolKmHhU?m@?UAw z%WetgKL*u#{1C;J7+Q<&!V2$xI@tfE=#`ZB$L|LD-=aFsi&h2YzZhM>2Aea$k?P0p zsJ6c^s_pegaXE)lXuAB-f3Uv4*K3)sM;D=|lmBg_mg)JMZq+h9-&j=3SD-qMpV8)M z)5b07OM@SHyOyE7(NOc2>HVI7YQL(`j_7)vL8=E$cW9a3et%T;b1bU*n?hCJPefI3 zig#?8F4rpbB<#g4gZw3^>hVfc%YTe&{$;INrpx~=RQU~d38uF}b-WW$&0mJ9e3#qw zm8j0wT2#l?VAq!E@@k4|f7_rF&{ew!$Mrd?t z>})>C!hu0rlVd)yyfj)pvy4#=ZAGkd(}|T~ z#@fuBSmDvyGbhGN$|DQMItA2O*KBWXK^GJ znN}W-L=rU`k-0QpQyERhBISMSri=`xFc(Eu#n(+mv5Ht~_6&XM6i=1wkn1LQ(?$;}95g1K4l>FzG6rX6Ov}g^nwe2vm60>7V3VxO zoXm{MjEoVP8PypXV=^;R85v_UGiu5+a>fnYBr7u~Gh;?Z#`wC7go2@XnWslx-B{dJ z$yjALIoop!0&`=2vbu(v%&6++qsK5nmr^=I(OCm)Dk@ZuH&YciPK?%7&zX^u$jnG( zWM;V%6_J^#$jqAJaCKR*KC92Fq12E5>1}u&9}!I4WJX<+o6e=Hu{anHe&glB-c~6- z4Z?rw2qT~t7t;tZlxR4T zDk~GyV(C9Bi9}pOi)s>C>DW7)80jUI%hs!zGyUP7cBMKxy(U&1O$uNt(J~~e~XgQaJf$lcEYWSSe%?-8FEUKnxF=(rlNXw zMTH^+sNxJxPhtGvU{bmv=kDV-pt9;z8TX24JVv`!tUV5=DjDHC!mTG3uZd<(qn0F7 zn&4T{MBO=xv2->6xuHOut1Q7##~PQG2`psGR;QBLnN$oeyUYdRk)rgdwi?EFnufIG zZbdP~G}0{_Pfto0OnQo6lN-x3Sh&D0DaOdnw}MX39~2I2vWdamLHWcY8S_>}VsY-( z)sZ1%M(N_Oq}omkS0<{<63J9NTp1mTQ8-3c;YiGBr9-*=(zoAaqNZvZMkM_wxQi=E zW~t|q*7@;ebV*OEj!#Q%=GGCMmaN-Ew2UJtA23*ZTpp!qsgB6%FO8O!mC6`Ah-9oJ zoRBeOVBb-g)2gG@WwM8kQ6gFvPXx~unl>^KJVc}?CpGkOG?+X(NZU;)l!fvhG%(^v319wcn(D&uY-?+V6^@;jwr$s5W)+2^a@D z-QaSaMAOx$A`z`flQ0LQ__FcnuE;h52RCNV%rTiUdZn zX6V1^48@rhvUk zPGU-WkA`LK5>q#>Fe7xDZlmcNQ#@t2+H@micVS%vmZbHsiTW(#WyEJB(htrFN?Dg5 zHyv7JT00t^2vjH1XD6X^lCBsVAG6cu7VnYiTyIH(b~Qa|W9w#Sy4^~r>*_(;s@r1S zb03#HEgsEh_3Su*HEKI425mQErbaZc)_~?rm|0yFspQ5Oj8{&hrq(DJu3YtKdiswK zJuV{|j0c{yVZYNYnOfImth$IZmvPekS-P5AepM>?n?6E4IagOlW>pvK-mC$_(^r8T z>~MOp@amGR^G!n)RDik?uq(kfI@}+u{Q?W-u6s(}bndbK@Vx2Vb;Y>p+~fSIx^C`@ zNHs%27pF&pPM2nNDxy1OWpzy?75S&NE60zlYUA+8**jMg`KK+VA6R%4QT6SptJl(Y zCb*L&$~A41N0szp)E!G*!Van?S)G2!S0htx!x_woa!*Y+K{3us`iW`0O)4CfteZ9? zF{65B(Z)J7lO`*D`lv}%saaH9VYg5H6|6SPp5AsQ2A(foEH3c-xrk+r#mX&#c))KobQDN%#bj$bk zrOfvA%{1HBHwRn3l(SHME_xlR^}3JlW^5hLy{Pv42~_3dKE0Q*wLiZ63T&0vN>uxO z9KHqFzWf(9-F<%b%7gjb=hxC~_xZKQ)_x5@|=Lb7*8W$$J7!Db(V%9k_PrjIi%vi!K& zN1J`J+2@$O*z6n4z6aI%p0w$&n7(KEUzq))*^Md#U)0X1_H%DkzM{@Hy&tOm9*L@+ zPeA1}oPyE?DKraJ`S|%d16$XNpPxl$`}sKsTlK@w$NAW4pOyJ&FEZQD&!uMj`MDfh z>vtdRRoL48y{OK|3#j&g6{_>~HLCOPKHP2i&|2GbA8s>j9hcj!uyy`@{#|W;_wlyI z*7cl%Oo)#IyBT`!NII?ryug{}JVF{Y4%`L-o*&0n{Y#-*|2$ONb9)iC+BvVE z*I?^>meG!={IA2-_D`XGZ-L&3t@U{R{n$D__o*+#*8chYZ(-}W-N*i^&F?<;@36Ih zzWmSFDqo*Jrz*(z`M1JWJ>3P>b`Cizui6oTl?oe{P{M&zcV-$TkCiG0?YSz2$x{% zeERZNV(a)l|1O)~-!a^Wt@GygGnW4Xs^j_q)$(qy!&dv;bb4^z{{>aMa0sgDhod?^ z&mU*D=TF4e@g0TgxJ%J={X*0A4OM-bZ`034b$5O&cbIdb2I6{o4W6e63K;x2NUr zZ`uJ>yVe8M{^z6G?@?w?GP?xT@_xUow0ytc%`)5Xck|5l``rR;t=I2&7g)aE@2)i4 z?{`bg_WRv^X8Zl_32d#;?{_a*zTfZOHrwxaA7kr$`u%Plw#wb_cMYn8>%s4L&9HSo zn%ndf?0IBYY}NAvQI(tLcfr>A^mkOcQgsuAS>z{_L`s(kr z;@DchztftIt@XQo61MjD6kF~Ln|~pycI#rB?)jHtYyYo9)ehW_YXAHl**#`Ih^m~P zLsfomzhU|BTK<=o@AgmFIzL;bg5`EXRS(_X)$BH?jyo4kx36X&hN`{|Ky|%OM0Gv5 zU5>5wO-Hr-@u-$}dm*;U$B*X=bM-|bV(_IH>IuvKnu zUx=;i#NTP&fUVGMjy_GbgCa@=7?aJ-)13S0GTCd+F(ZLu}K+XrH6d;X5~ zAZ+cgZ|@LW-rva%wdH+#Be1nzx2It1IVFYax#kSBFE{&MvzMFwF{=IX`9H(fb?y7J z4qN5#?`(gx`F(xASibLHy_v!KeEkivb$nZ)+Rs*~>a)K?-W^-z=5_~cm6y-o2V2Yc zMYa5BRQu!aoR7d({q*)Kg01V`+vAzoTA$BH&7o`&a1JdUcPIwwLhN!1Geg!=WoDHKaX?| zj=TP>pgr<;=*_T|@9)rez*c+X_O93}KYt$I(`jRpHO33fP zL8_j0JhB>CaG^JZ%u9jxuPOP3qwImC6#_BAq6Vgd*VI^Id*rhPND%R8$i}iG6mac`Jv^G}O zjfvd~S$8LdiJg(o-O1}-nA-#CQJC8k=~YC%bE>8O+eF|9 z|LHb;q1k7feXiN(n|-m_i_N~m?5oYb-t3#qzSZnI%)ZC$`^{cz_M>J$Y4+1*KX3Mn zX1{9oO0(ZG`(3j?FnhJxpPK!J*f~AUfO`I>vrqY0(E;wY@J6xe=V_9 zetv#;wR}IHdzkI#b8oZ#eC}sC98V9xo4F>Rw#nLpZAYrd)X-h2 zl=VeO@V;So_3X-`L`A+?ypxuxei0d~?2nnbHhMzPX`_NyL`BhLy3Z7A;sAInq4y#K z+~5U4vb;pmPBT_EP>t8#>Oo3ImAkw~A$I%{TdN^P5|jc+q-`I?PyDS|1LDg(WX z3W|0FDJ#~>$QWJ>P)g~7sf<>}NAl7kbCT^!urYs~Y3uRb3{FuzIM#S^ydrLUY*Xr1 zsr?9whxh*Rj8iZQGqYIJZ_m8gK`UYuc~0R|nKtEyW;b$K=Kv4hu7e!5lM zL@ajGidyAD=aAq!2zI^h-BVBibuWnmbIzQKIaPD2*Pa>lY5WRR`}rNJ-)}h!g6F4g zQ9ZA1hw68MzdvY!t>>WKQ9VDlNA=uyD609rz3+pq_4@MtEq@@Y?HrEkd43A2`$7?_ z=foMPerKMJYP-Jt+1OhDIjEikFGlsd<9bxTr|&g=3e|qSj%xiU@_R({t;W{=xc!;s zuSb>NXkoBi3slFmKdR&O<2?vlznA-S>v_B!)qc$~ zosVk!e?@hCe?ztZSDJk_s^h!U?7LB|=P{e^^S^BQucBK1BeVa_wAjCt@TVXJq^`t$OF>caPb={>N;&S5Te* zk1T&Js_p-bYX5(+>5b0{>cg(6>cc^(j>qe72eZ9Cb~M|sm(FH;ed}tr*RSqo`~LLA z*7@=4C*Sh@cn4tXczyqdV(WO_9*3>{ACIcs{P((FKSwcL*HzRsj_P>){8gFl^&@Gv zmrn{?=jQ}e=iw|=+xPl&5w_Ov*YB0s+7I8K>uou&zuC`^_gcQ!=cllBJifnAV{3o? zdV1DuKR?f#?fVx==8ujR4JhoV&WPzwZs9qBRXC{cq$pkJDhCw$-IPv<)*ErwfS~hU z`fq7?&LBFG6!tCQ`KWNx%xR@qVHtB~P8(iPGJIggjN#)eW~7FXA6r#b5cI~dP8n*= zxq0fLA~kl#_*t`9WYQ5s>)KIo_p;l;<>v;+`I6}?rYlgDr@set`z@yHckYL%>d%*` zo^##)3R~s&jphG>>O8sK=)54mF{<@9Gj)3>Y^|>)s`LLBRM(5!-cEL8y3SW8RNL!f z+Re0w=^?1rcc^Lhb)0AO^+R=k7-H)7@A<8~9v85j>ZjLJw~u7H_VXyy$);0G3sLRA zw<}?6?QgMZxVR!**;ju^RfbE;it@uXJVvWCY~PBaaGXTAEK%7PNTm{V)QXqIqTImM zr@p$cPb(a}aUxF`MSX#O9QK#aN-Wnm8EBZEHACn}O#kkRLT0QCYtG7ect(^i8u7k? zglANzis&NN5A;x}bfA?r{lb+zZU%p8Kfd*$!c{SOT_cj zeb&rVV> zu}HotHlGSq)0HqqH%v)!bVj&8#KWZ=mn=)g!sY#AocF@M%;WEuCF80QeOX&#Z`=u4x$+Hc9~wfa-8u$+XO_98fV^l`v|O zDvJ$(1bv&MrtEKc5X@F$c4;(`90aATTZ1oc@ z8${9Z17}!Slq)&dBHLnvHOWe{nLkkM8WAro*Q|7srdPDON(Y^zm8z-WZ%mZLl8G{! z{@G!2u?k0J;BbmvE(`v0jSN<=I=)Ov|BWTXgQ1kOUgla+GqbER zURuCz%q%M$Ox-NSt{OR;D#6vt?;WZ+cda0Y+s`mv*Q|l=V4Q1P8^JUiRGk*Do%PPV%VnZ^g6|zT~m^EXP(-e+p&lyaO zrNR~3iyTh2_w!n4C=g~MYy9zQP9v=W$UDYv6_O(ebK z%EL2RekRMZj*1w4-IK$B{@83nmZ#XQcr`wQir|Qc(eaYYWQ?X1j!73nc^Tj24AUP{ zkeD_M%2`YBmyb1O(r^tcvjiX8=mf`xNef5Qn8s4o$L5RNOQzs1;UYLyDdRmrDOeMgvLPphOBjQ}o0CDT$tS#mEN!Jl-3 zdtUJfpb9A&2y3AmWLY?>^=?chBRn0^`ZCcZeTk>9z{>RJDY0UD`;XX|WNJxeG@6Ry z(U~1BACXStpCHYRvUr3(yC@vS2`;aRX+o4U5~SG{t-RWqLfl8yG?$#aMBTKEd$Fc# zK739-o6L+Bky`}4+{1}V8b3Wa>M2rJ;Rs0I?qviCHbGmTOeE+-8mp|SNR0rBKuHNr zG6z2*kjmMWN$zyiUkYlZCur|0M~3mj)KHxI_@T7YQ}N=Fl(8nIGcuCNB3)J^`Ldu) z&kIGI(KsuPM`wmd0-EApOlRrn%tBSW;dGTQPmC;2@E4a%S0ONtX-)Jnw7Hj z!Ig$9N0m}l6X`z{lumhU6yHfm6BUtiymBlav@E1`ozoAtqByQSqBd%WFlllsW06tp zYC$>`OwzNIO;eJI)rnG7N=+OSB-0aX>edzHVEfUMpQ=fg2P+?&PBE!wc4=8nQZtWB zr|A7nW5$k;LP#cf%9tId*X-!DtQTmgp7M0;q5LZSZHKp{~R#TiVnW}I_ zWdY2_Ux_EDE>ROH2-g(m$GF>uYpQrSp@AjAQS)tQX#rHzekzUMr;64IstT&Z75e32 z4Qo|dd{#kOf+s^=u~i#W70F_rJ7QJA?AA6<4~HYb=bK!|rK8h-lhfjSK2lc7oh%j^ ztv{ra)wKAu_2Kv!PcVh4$)f6TO>zw2Ql<5hWvSBm%rU$zIzk_X(Ysrxv^YE_5Ud&O zAC?4bW_4Lo-}V%b0V<7>X<;q40=lE)kS!adQsLuI6Hc|AZmR%DqMB#3F+fe=mc_>P ztmetti7|=UIG&j+5H6K5x?FTG;VYrKL=97GW`^~_M_OiAB=~|Sk&5xXMJava(`ha& zC6kdcJfDRlr1+cSYU8Vqv4LO}k>t65CfBWNtRkAes-j$F)X_?0Ml71rwDBmn7^^>|)I6{ao-3G}gXHF*ze;P$3_SJ~HDduY_*=sKJZ-SgWvSAN zQZ^eN3;f*hzcFmi7atLa<6{HCN~L_MSh8#^up=pxI9p5rNKv#M)m&5q8AO@!i@Qv8iggjj42$6pkl z!+D-w6HZ1axmh?SZIfLzhsri*_Uzen_{ZvpX(O0J^v1D{Vu-W^ij)q`$@B( zLABnOP2GOe^4~?}Px{c*?N2QK3sioB?@+DB?O$#F`WFPtH%7I;ZZ|c%Ija3^Y3lYK z*jn%Yrn#t=ce{((Jy2~o&(!U~mOmU-d5$)9dxGU3g=+f|Q@5vCejL^MXPCNuoaLW@ zs(em1b^8pu4KV7G9gTYeZ{z6M+SeXQwxRQu=lsn}ZYBGdCM|3Xy$tt(C4zS;6`L$#d;E#K{B zmj5iO^ZBBw+bb;JxA%tG@1WYx)uwKLY58BHy3QM26r6Xrcfr>2v_^Ft`D^4-KGgF2qT2otQ@0Pd{Bfv`XOgMgg_a*dwS2j$+trpo6IFR0Z|e5xmcJ0ydyI?B zUTpS_X5WIU9^GZ?_5+sxFskEUX6p6}*xK(`OkYP;UT(jQt^NMU^b5;(`zy28p{kEL z7YFM5yDhes-`TV^s`b0Q7q;q&FW(+p{=E*SooxPYsE)6V9x(f1 zRQ;Gh^7xe;2Ct+;8gk!=(^`9o6~p{8eUq{{PtgpP8;P{RY+k{9x+# z2FtI%ILP1H)a~uCwI3}__e53RZtr9E{;2lrU{kldV(a`JW;zJf^22Pt(WY)swEW4a z>Q||$+tV$-2G#bCF?D+$wytAuj~8OAJ-fj4N>tl-`&yfRJF4ZDTK;3GuJ0FZy4!DC z{(GpNKff}29jfbm>&t@n!1G&S>pJlK1F^OJ4yK(=y?nZx-OIF(X+ElQ9B%6NIBeC| z38qJ)TEE+cX8Z9)%q~S$esNQ`Ys@~zbRMepxqULW_G6Lh`Idh%s&c*t)p>LKR?ENB z@*g&J`&r9hj;h^w&um}+M`nLw`UR@(e}`&&IhO~=-@tS$RQv1pHfC>!>U!JB)a_lc zb>6(aKgj0qX!CV5b-Nd~%B>%&>tZOX?YTV?TlL8A50kL9zuvw_uyr5w<4s!r(WuI8 zzUe|VU2o04!t9$-E&m{@@_GT)`d6Y_{(ZAQGkYDX>;5NH`(5uJ!T!442wUZ{jcIes z_x0^$w&%C9`C6OqZTW8RXLdVO+v{lRb`Q(<{p*dbbS<5x;@$Q!>E?4 zuza^`EZ@s>w%Ny`I$!fq?U&nUSiaw%7nywys&f8^*;k_~-&;)GzR&XgdVa`kzrR0< zt>+(K-;0*-zaL&T+n*O+$JY6J*YqRHcl#5w{dwvOY@NTaO~1E%w|~M`IX1W=&~4H5 z^w&(UyX8Zh8%`Ue2%T3)* zVrx6Ty<=^De;zpA?D@9b8K!Rk)$-4?>6e(geWm65^>wY;H=??Z??JVFw;!|oWvGt( z1yi?ISpFNR%KZaVw?DW1wWyZ=-qh`1Ex+EC!S+P>SnV5>Y^qpBzSn7Vxcw$__# z+8x#Wy-?Nvd{eiFVXOWWpjzK}RLlGG&}6fVQ7vDAYJF9xma8#!dyeJ%`i?W(+v^i- z{*z75uza@{nSBnb{kgz&vFTN&o__zjZiJOt*P5PS-u}{D{Sq@9;W+R zzT0ihZf}~4s^0cS_53o#rn^1D?88y**F;md!`RxdGSdXA=ZmCi4XW~Xd$!rfqFUd4 zQ@78=*8cz1^n6syUyQ0=UxTWhar;)w_xbNM+wX_>n(h9S2hDy2)pnMdy8S%1`l~EA zeF@d}-ClvMcK#z&&vWZ6-|ZjF_V)P~v)w1V{3=%TI^uzb{EUi7CO<=OhYPw4*inN*p(-Ouv-qpCyM zeVx1y=P=t3|Ay7=0$YBxEkDuJ?Wtz_`m_5+d7r*g=2P2SW$N~9Y}JLMQPt_=Ox-@- z^5>b(H$53u`T93)Zl7WK3oPHiA#?km`bq`oxNlGmiW4;qAvc{th@$<|NrsOiT|7PL zVn_90zF_Di>IjPleI9~!1ic`vUwc_adAPD@M65VirZQF>%)}H{p_&*gW);B%A)^+!8smgnq8MhGhNsB zWK``@3{}~?{eP?9Ub$^QyWieSo9_9)SGRw!pWi%N-$FF)7esZuZeL=y`(3jAFn;ZL zd1hZbi*5PKQPu71O>Z}S0M)hlsOeKS-RFM^Tl?eld;evh{}u9e&Aw^s{gK`Ny=yc3 zTKv6!i0`u<)sHVw)sG)g?VsB}VW*#49}4uJuBEJghd$0y72omnU_Cw#$8!3;7GV3h z8)Yn~@ksnT+{U!uqv`PI-`%?H-`SqSwXKj>{@rDB_U8a>|K72Tot7VOPYPe;8Kc@T z<^l9QI3PPN=M=_=FVqK_K7b97y&na{+<62P=RPy8{R_mj7m9Dc0jh{apMn{nxb&;)5$6`B63_cMcmy5; z#rNI-{~hbz;*5To6Z#4obAu5bxp9n#iEtX62@7FI%D*MtMcom()RT@7+9rtC-V^Nu zs(gyYHWKE7VqAR>9@D~OSSUX7I#|j)-@wnX0q&=Mio>~>Mnf?~p%&)BpN(~SKg&D@ zPr@>I1{Cx1H6t_jEHSA~z+_aY?uf-)qsyTIbx(9Orl2CXA@NNhVd(s*cWm^`>+@%=sH*rzd+UXlpiRT(KDcb zd2l35g`?qGV3yFGa5vlo_rXK(n(;jOoSuhD3}7pPy$tu zg5#hT7QkXy3ZcFDrU3Sb1E4*0gw8MmMnNH*3a7&&IACAO5{AN5*swqAIUp3OK9Ket z{s!m41_)7ST0kr40G*&0913~R&*+a%h7i|*XkhGsiZ(_!R1EIKe!*Ph7W5%_7G8kq zor!x2weT)%FqV!W4UMnn(BTv~4UW7%U>aHu&AH}wfn4YhgJ3j_g%T)(a@b(xaBa4M zUXTYz!crPhgkH`GjfW)6g8$^$J|L|DBgDsybo)jwmn4vKfnfP$u%kb`7G2XCv^TkY7p7B}>%msg z8M;Fs2sI`i8#FeWpk1Lm^nl(*A5>^PIk2b$vAn>aGjt4@_k%{*!k>q9e-PUnp$4=& zJP*}!Z$AwVY#lHQ73+;v2XVZR&#{U;o`EifgSoytK<+Be4=gl74RS)Gpl-jo$LaZJ z9Lxnhizo)|diVj>wh73+hM26d3N}D!x17+{5F)NxBiPz#itY$ILknmHU7fC%L#o4&6pTj%*HghE^~MCc`mM3+GEY*XP1wxC*X;n_vmt33tPTuoRwvW$-*K zhZV3A-hn?F|^IeEz_zUcB9E1vg-t+C$=Nt+@&nI$SiIWZAkDu6HP@!0o5h#HQsDczMCm!L8@Ur2@t9C92{JA%~ zo!gN-(a#uwiYk~1bKqE*Yn+IRlZ;c))8Gta0eTty1KxwRumSd?eQXDlAq*uj4HQrN zVF>NXbq1}VHMD^NFc?Na0UQAnjU!Pp*(gMhg<7~B?u5tS33wS+z?<+ktbwoLTlfxs zg~@FKJoa^zXE%|@y<-6^HbO7uga$x%JvqKfC^Qe|!J@2d(d}7it5S@#Ap` ztio}y7AAkmeCx^o5v3s*%7tD4H|wUoJ^KY-UfKSIgDD&N7P9>c9VwRu5aRgvfT?ht z^x7bX_?BXAXCLR{4cr&u5qJ`wh8N%^cn#iww_uC+GwyGB@QM-QUba8vLQiPZGVoKZ z;u-L3_!ic|Pp|>}Ip!?xc~8P}_!QQ_x1hM+-Jl2bhQo|Jv@hgCe;5d(U`yqwGVGdB zj=f1A3Vq>RI3E^+>Y?J#XO~kIWgsqrOCe_oF}80ZUanDqj)sux2IO&UbYnyVfg9We% z&W3B?I=Bt)fP3J6cnqF^W$-jS2d}~kcpKh7ZXXAhzM z?h5`qrAu4<+4`t@coC>BZh*C1;~QW(*Y>XvqD?yjGV7=6h=ekf4l@Wn@h(Ze-@9yKh z5#;R|!F%4svR^oiBz%u#TvnS&^HZSD*|UD1L*DH{-fhT*8gQSpZhML6z8{c`%ZTh2 zU&`Gq9L&uRi{|biAiQREyD7Qu1Tw#>N191JREx0YN zU$+CdyJIlN`>(^jzufV@$3CMlN}x5`<7srkOL!Tp;Lf)-8E^_ph5Ga$rJos1jz_X7 zR)F(%lrfD+iN;W63BDJuzruZP-^XY75WInHNW@O;GJD8FIENHGz&0%5978^V)_4jX z@eDjZGcuq6@1e@5fhQ1~k$oM8ARhDa83Nag*2TdJsDk=vh{n({lV}l$dl8D_2uBq} znp$LIxc(I{1AXcIo=7x9G&+Gj3D-Y^xK_-$6v9v$RZ$HQXox7ZK`gGoW1oJb{u|fN z;kLId>}#?jaSG2H;@Jnt6TDs$%Qb@WaND=rUx#Mqa~=`KJs#M95p^5=ZO~fom*BQH z_deD|@NCF|VBC&csDpZV7>&^s9ncZ|5V$|q{-6wWOp+=S=O=j5xcd{>H+_p!_!%*I zIS|HpqJt(Rc>Wp*wV*&>gYtYhTAuGn^cWQJ8>)vt412S<4gB!(aJ`*I0?|B7rSclEn11~4X z`H1Fc^@IESbX{6Jes?{%_uDzXMq>D$VF-Nx2W92YKzd|DP6Q(t!cYw1D1)*nk4mVD zTBwV9Xn=-jhURFEHfW0u=!lmPxZeok|1Pe7#`Qb9&&_!HhIe5mj{Z^6h zky!TeN8q-vD4v^sh`lq&TZE-J3~xW@5nly)<1i7EFc)t7@6Wz{AO_=oe295ifaO?e z63C7C-0UECW3Smy9>KRbi*vZ39F~B7p0-7Ie(d`BL%C0G zbeyMSJ^%exUOoeV>vy)#!v%r~4d??1|}*;nB9L+5$TC5S#`QQx(wKe{RsI2QW}DJJIGAa4~C zum!H)&GnZhb?2A^UQCep%MfxX-#eTf$uSH9p9c-9%Z3~X#_b40F;qfT)IuH9!^3EZ zW_TPe@C4eJXtD!3qB~wfKe+#|d;i^RdyQuMdi}P@f&sMo^-0`bBPjc@+_dW~C z!SOsI(Fz*0T^IGy6+Q3)#$p9lVJo&{HxA${xZ@#RqZIe~pzT;PoA8p<9-=#9(9Z-u z&+h;I+xE#Z#wH}<00KXU-0#u3p8xrtJC94?+T3}#=VSCYTtA09PIA95u%E(>i;892 z8iqH_o1~1!A}m1y)|w5ZY{KW*iapqe{Wywm5X&*b1WYvERL*}s;kn^&eFc3m93${H z-o<9CX%t1Wn!Tr7e}7~=S8Ej5$!lfOdY?)XF^@L`AkCB`o_h&`Ab^R=B4{>{*oBlybC=y zUrBG;6==KpNW$0q#*VxBM_SP4FwArFjr69iZU8sG$WUv$`9#K8+sz*`-P&%xkfpTw z`1);rkkK1_Ki|y<5>K1W-gEPRgl+Ww{cgUGNZR`Q-TWT)>~S}rM>K8yeQv&v7<=5! z&oPuX-MYWc&k=8JH$TUI+WP;x`8h6G+s(%jvdLFB;^yCIL0f;1tFMTrJ(0Gnmus=r zS1;n~Kc>^x&v)}_Y^Kd&&TsQ+1aI^G{ciq@P};ZixSP)+p0<9Un=fN2ZGFF+AH&=3 z`}^E{7?HH~`n&lqTF}ly+s$t=owlAYH=o5)`}$JjecMqYZT-F)wD~yp_R}s*HlwZQ z(M$A=<972=gwxK>-ERJgF|_%3_2%*QydAudoxbl|V?RHVHXpa1n=c~Mm$|(XwB7s= zop<@_M%{c6$+Y!%xcMK#cU!$OKabtJx0$y7KW;vU{j`hGcJn=i?e)!T;OY?*X|sFx z+gY>&Ho zOYea1>)m__!L;@JT)lr7Z9UIxKeG2VZOzNz#^qn4t;1?J|H1UHeBbZpKS-dh*U!y& zu$i`=KR5qCrh~q(FH2p$eorWEZJ%yFgGg(;`o(B#yZH%XY3t{^`38p4=CIA+WL8}9zTq>{$5vaU(p_S_4ZNrxU0{Nw#Qw4eQ#^Kdiv3{wf(yK`OWsYtB+5j zt@oX)hYvpLd;VO#dPUm$dtCi{J=*&FUA=o0ZS7xNJ>(eLdVO4d`%?S@3xr$^D&|JT*052dZY-_@s& zvF~^F)N!=+_qckzMEiPIKbvG<@9K$9THDo=C)3vNclFh4d&W%l?23n$ao^ApAQ>vakK&X=xUIFh!W-=}z7zo#>8J-;!ub$@T#`hHjMJBGGC zuUx%r^htX??B~bO*6(rkyK%Jj`QYkt!?@U_=jk|Kub&%DTVL<$Z%5PC-?85Qo<#e4 zS8to?2jADbdfJM#_48akZ47Pw{jPpCmbN~BUA?S#%J;adhYhB!=ik-8hS1jUclE3- z?CV{v_4{3YYP_{ieB%4PCu!^Fb13UoLJd5Dwx%8V3TB!`qWjG1_@!GJw{(&3{RRDbq0|?tai9M6F{+V? z#!zVdz)Gw(Ysj@&j}6e+g23?w=eRGJ7yllFLg$;$VHfs5^;1W15Z}eJISBjj?Ei`7=MThS{5!^N z+{*RDMw}?=dSY|5g}biUo!hTK*BAdg`=QVC^Zom&8qrS`g_h`#|Bi7BsRsufAcWv< zgrX?Qn+l{-j)LxjUyk0 zz`C;_>gu|3g4Z3Yuj`Kwq3bC>;76ohSD}yF^^2F|b|h4n7mXYBhsSb1r_vs$uc;1^ z{^Mb?ay=+Ja^gnUZC#z84u)TjRM*N7Wu=ITtN z=uB#fF6aqeA5lH28y6AD$+sI9(U;q?P~Ar0_;ro5`VzaL>$nh>TUXh=EUbB{T z>I}!fllapwlhX45FYqYb4`o_^kkdbI=dXN%0-X)RyH0C8u0iTSdWI-<6Y3?TT zp^&+slrU3_EQwO6gsO-@ZPZ626HN}q;zFDwLY+CsaSEyfx>IWpRk*P`lD4B^gMc@FZ$sp@Sx5<0W*U{vaaZUtb$d`$fD0cRlPd zx07%d=b-T?w_4v4K8y1NXuOohNyXp?oW>a>BX#`BY_5gvW50ln_ySiEIKJAAvvPIp z8rK_!Vz|}uz4Q25%|lR)Yd}%(pN~NE5L|`-xK`D9l|?x;L}LWbQxKfO{uOTgR|L1k zjRWh*?OPci%`^K?jn9eSNrv40oL+j{DsB zj2+zGiPUi#TzmH)rw}-f!Q+~W>bqQ>_rH97hM%SDQ8ydM7Ry++8;+}EOvJ6$6KY(w z#!&ETwP`y|z*Q(t0tJ&Ok*RTBN*T~EG z1&z%Sjc160#@!4?Jl4b2^J)HpI_L;D|G;P5*4S$a90%cF?;pXqiCR$IzsC3VgvR)Z z#(}KI7Hq|Ke1${Ce>`sm#)nmh#`WIHc(UnyUEp}%|5Ux#Uvd3(m)~_$jX!%BQD})L zp>b%j*Z^HC_P<{2KdvT$aW(th_!`DKL_%W#{l@`nJj7DC@epp@-Hqmzsg#?afz|{-R&{+<<8Q`dg3K&nM z#LK7s>Vt+0->Yv>T|;0U zPGFtGZ{smn{C-{Z1Rnng$y*s`fWUf~r+515VY-pe<7Ra+4}Hn|4*!$qWk}e|J|17; z5U$`F?$}3-I?CZeG(r@fLkxyuIHqGJ)?z*U=XvnH;(JjAUGah$L`vYezyC6>K8g1u z{-~ZfoUi$ZI{u?KA8)HMw{Col8%N^C7rXJce^l4)#%m{@^o`dJoTuyWd98f&T800_ zIA=uR8N^^1lCSc<0%ya2P5mStXsSQs)G}3}P|l&Dxm_d&$M2Gz$K^g#ge;0yrVS~t zn!coPnv-fdDV6Ets)lj&`)J&DNGQ8|2U?6wDZG_Q_szF6N2(^ z^WoIvc1t{oOgv|qq4{s5nrTH!8`GB5yg2RA0Wbbc4IsR!eH z3pY-6FSp(GnB(034(__l8E)T}(I=eLb(v2Pk5f1gU5k;sGI73#JSd35D1xHUb()sY zbsAldnTXHf=EqB$nb#OqQ5}t;@qNwF9=dMRAG%(%!mJ|K!+-v>ZM5C|XWwx97y_@i z+-m)HOcwf`plc=m*Gp8-E~~HsfpzWQaG&bguRwL|?z)G@(@S;y-njbqJg)Kdx^5vi z8~5tQyXyKvI%piJRLAd)CvDH;8b8_}x^AF4PFaQZ*oYg|bAH49$DrCx(VIRks-P;W zBe1ThA@}JTfV79M1Gs+wKN?rA@#N~qFP+1u9I0`qb)o+Jd1fKG0aW+lD(VlvJ-4qv zy9}xR>_?&g?B~%F3!(mN^;wI5f3^Co2jg|jFroA{``5qawtnYkWZ*b&jrI2LXHJ)g zzX7%2-_JaN_9V=~w@|-xA^MJ0kLTZ?e3G`CAJC11{e}B9k558Awtr+}ADtbpzxHei z`T^m_@w$FY&G)B%OV#PBe^PUw`1c=vL|gL=B}4s)X{P&RASJ6QNc#5|s-Lhw7GeX` zPpC1vno~&bpW*8#tV^n&Q2m1gu>k5PJYkB?^z{$cB;^sPpYT=mMZB3$F2oWn#VV}E z8gq(Nzu`rw-|*P1f9(Ie_bS&N5ZK@5>f>F1mg~QIk^U&v5d~#oTs!>hiF4BSuOC)F z%L%AIrBHVIF`)T!)DNO@yXyCF^N7~T$uR~7K>Zu)&q#xcP`^fu=}Gp2=2jelc=-2o zs9z%uia_%j)nSckdv7r43{^&cFv{)6zlIETY5 zEP>IVqtJUwv!s_NVqX&xeVzP}T${w|5zs=dxE?yD2qy{0{`>deJ|(PrQpt+!#O|Jd9&&>r3qY}=G)xXIj{eDuRHJjm(Mr9`jh8foIl;l zd6t_eO?8Y9LNx|*8fTTqN&I+%ggZZ~^*#Mr2=#pP*Xe?{j@Rd~>k!o_iRzCe2cH*` zm3^_~Ku#3H1Bk{`=!ouc^EGN7#;XYDwTM6*=kS`}tmjVlJ8<*pW%20xMLWELnI>@D z(-H3f8JED1RT*_Ec46v@SGRd8y0bk|m$GCv?5fnIt1`({>>{*_(QY6WZ!=GF8{QJ0 z(3O>nO;TM_>LyB6fRuu!Feyb$QBsPVlBAR}rAaAk%9Bz76;at#C8fHFB;_GfiBNQWlj^)kKhyc*xWxrM_uEN<-6_d1+Ct(%-y6%1AScl()<~q`YT7AZ4r> zN6G{B zjvd%(c9F8j>?7rXIY`Q3bA*(m<`^j_%y*=GZ%&bN#+)VPCv%>Zi{=+nE}N^QTsJAC z1f};$OG30aK8a!lno*MNM&1N}5unls08aDQ_x}Qpr>yrJ9K#rG}|VN^Mh@l=`LtDGg0y zQks~@NNHx8lhV?(BBhOKOG-P_ft06BCsLjx|7nw^d#j4^Aag9n^#HcYxWHXhNX=Vl~v&IFQ9Rcns>Db!chT{&^)YBXpU%fLJayM7DF%^ zA0Q6X5DzyG>k@9?X#C?Q?oWgp|G1CaN%#)_;~#&a-6PbeA1R|T9$5v`l7!XNXlR{ zgp^_C4N^v$QKY;p z%gl08R+`nMtTF3I*@W!@p>J@Wx6W6d~n0t!y^DNITcQFnjoS8t%L^Fw$$!01k z)65J~=9)#MEHTSSS#DO6vf8X6Wu4hf%I9VqDLak-e2ROxZ=X3p%0Z)f7BApubBVly z8;u{<`aOZ;fZaITuypj3!p*PsNArNhW(-Q5qj4a4qw%C}9<-S3zHyTYA@s!~`Z?dY zqX87rc&%_zb)7BQnzYav!ST zadgLUOojjWo1?V-$KT}HM_()4_?u?j_8)&Uinjmwn=Q0821nGPlNniYFAAd=+<2M$ z=)|cBE@7qCg?bq{mq0XB2iXN(;npuo=JsVIWaKjfZv8m7u92%(bn{rb`2oMBvsLwV zns-h0ZkqQ<^=2Kj(Z;tp3(e=Kx+^zNm#c$HBd>QdB)uMM>j8JTt5CzXuM%dgtzmJ6Lj-Dx_PDC zct1C;&y9<7>-o6(43oJApm}+ckCXU`PD9OK7{xZ$5^mhjayCs#z&gB3-aH<<1Ec9eqVL7NKI z_R8n@0T(zTYC0s*^mRlxE*0A2F<5d&D?0- zw01leYi_k(b|qgghw(L%a1@%y{2bD;Zw;JZw=(xtGpdDk^{|g~TlKK*;Oby+bsk18 z?RnuSgR;>4Yjw~cw_48{&)3e!0%%U|8_mn@=Hd1j4>7CQ`MW^1=X82g{vz~&u4L2)P~kC9f&x5in;g< zC*biJT@Y@b?I*acy3)XUQq2u~8b9JZv>vF|?^124lrO+_PsCyX24g4!>mXxG{xx-w zH>!Uu8qRBi8`VGlch)`T|AhAhisL!ckCZr^Meb>AGf?fLj55EFauq?->4QdkWJDHZ z!+nT^>K_MS0nQgy24x-TqgD@Yef0QH~$G13(E71JWx_}>sNIZmE zXn<(AdPvnozJ|G&XBLr*u?#DbU{pI9SU>p#_o;sJ0&cZ_GGP{L@WGqSIo&?qC)kLa z)kmrxQu5=!qb@S$S3ZyNBCbJojT3adihoCaV{Dp#tZVer{?~fO7q~ALnl~~IH>zjU ze8Q?{^wKj{3$AW4f!n`Vci5lv!~yU!{rl?-RcjcGTnJn@jZ0apXvnrBd|^|E$1y2&;!pywSqDbbK&X)({k=|KU5d! zY6D$;;Pc$)>H`OIdp_1cb%Lr5yjguiOnkJ^btXV((;J6;#J}5FY1xrJx!HOR+K?yqxw8)jbXT1ot}Sv z-UE4gO^vI|)1aroI=pc1t7D?cr_l+W@hpZxYpIFq>&_t!=d_Xz!MGh|@n`GmYLw%5 zBN|s~@_(;ITZ5lCU(ScXy1JNWee*IWlB%QAprlf8^>a6?n{#z?QQdhS@eZ_}gMXcz zYUTdZ^>JB_Fm4lWU4sfoed`*iw#wC4&7mJa^;M^!`l?e8}>ZVF?Xu_c_Ysk>254Vna8~RctTL#7s;8I2(ty3VGOs-INZ3yD{Rf0LDxDB~* z2TG$1qR<3Q(F`q22U4RQH#$c(b~!K5T89YF%IKVgU^?T@C%;_T6d@>p8>Vt*0H(B zK3XcUkFJPX=DBVhKVb~l3uNL7pP^q-|BAsL=ZpyBH7ttE+?K4!hENkniq?4%J&*;Z zOj}Y?JK}jC)!^n6NWfm~$Jg+JeA1AjLtx2ZIIPv7tqwI)Wg{hr;U!UNgvV2yilZ9f~B^pOUlFM5mFkNC{i9ZO-Xs&v>@dP)0&hgO*AR(%~PawG@VId6H3*U6gHVu zF{C_idXe&?=}o?jS5041`eOhFnb*l77=}0SCf>q3co*+u48~&uCL#_Wn<=Dxf@zpx zW|Q(M=3*WeV3AouF2xG7p4@;<*o@Ed1-6+Tr0g`iNZDidk#fKsB;{+9M9MejI4R$n zlcfA$PLuMZ`H4J-3+89?60VqQr2J|;t~p2=la7=OCKD-HOg2(-m|#+FH+PV7mkA-| z9+Q`pdrc@Q_nAVZ+;752DP~HL@_-2^rHrXeRzWpXM-5Yxtb=;yVNxD3jYx^%8jCz{ zG=Hn~Gru=)>nOhFElk2>%)$=yCAk~>%~zxxGGCLDWWFKgxcQcplja9fPMaS|xnMMJ ztX#$wTt}&Nyq8UTQl2s$N$G5!C8eu*j+7YlJSn}*i=^~6uaMHmyhci_8BWRw^Cl^y z&D*5BYu+bijQNn1@#Z5^;>^dSOfjF3GTqE1Ww!a0lz20rl!az7DND^~q^vNjNJ+pN ztTP)(*<`km@`c$(N}~Cal-*`8Df`V=q#QC|lage3caUP*kTS?h&5=r^e>?UQe*-y$><`5}gn>y z)|@2e2XmT~A5AhT=gb9Cem0j#xni!7@~g>|pYu$FARod|3KbE7dT5B2rWGk|Oj}Yq zqdSIT6vkj8reiLaVg)us^RVv6L7ar5-6Pt0^uW}4Zgd}`uJnQs=7ve+yo z>YZd#D?glSF6lO~#!_U0*4I-1U;JZrj=5^DyK zGRVA6%1|?$lo94lQbwD%NqN`2Ps$kcAt{<4R|=W?NeMH>NGV|+Af=2cN6LeyA}N(k zRZ^;(NKzg$wMeOB>XGuWd4!ZkCW@3tO;b`HH!Vnc!n7vkNfS*2BA?@098?^AH_D+QI-@_vn~%te_}EM(Kfw&l#-~_>M0}5QbabRg zMr1*D+=0807Zp(nRZty~sD(P_VKNF`F&J@JhTS-WOnZa80;q~+h`}&ShvxJ92Aan& zFP$u!zwdEq-oDY$e0`rA6>%59&E{z{#sk8Ce5}p`H8$3NJ&nJ|$1+Yb7h{wWhGGau z8I(nNRKowd@v)riYdoyZ`&Iw@_qf>qUE^ZaPvgIi#2=22WuVHlh(RC3VkkyqEY#oQ z>b=#+b1VHjH>(5xy?!3mh2Kg)kLt!%2k!cB)^hu=T#q4eT?JSF{qGvTt9~Zcng2bG zmp;QEnNJtXakGB6`#9tjb!PoNe?I-nbl&|ve?HqoHoCr1)l?^Ip$_WdVKhWDJdXD0 zfc_YW6=oH=9viV4pJN;LU@yMGF`PGl&!5lronWr>;_vzM8AHI>AGy)|`Po7_??p1s zmSCJY{+>UdF&CU`|2=>H-}C1e&&@gkoP+#5e?Hee%lZ60fBvn_pMUi{=dK71m`A@Y zhX&&6Ng~+yM#8O2UG`VTSD+ypBZ59OnZx%;-V8o&-u)bWZ%!1$1Bk{`=!ot};b+LL z&bRMBPtQ57RsJh=?v3d~bn_*QqYrmH;^4n7v|IljzfmN68X1gyVB*%l}C(m?EL{Z6g=Yku)>+@SF=DiK(iP;_B{PeVePh)7)F) z>hEgtGez}uqIx<}{hX+FP9ETAN(f(jHwu|Y`C7@y*N9sejZ1c^^-6uzrs)8_vP?nk%HtPGADlp zf8_sb{Tyj{!L?4HTPv_Cw`-st8k!re8`z)6Rv7hr$Qr2sLu&^9(Yk?Yvd}+ZYLE}1 zF6yBH8ls7bAp_S99Kd~AGf>uG12$nZwwW8P8>qDd{nrhQpj`u6Kd_-`MmEQd)(zC! zfeB_CDgNsQYC~7wM_~U)B=_A)|A+cOT>r;vZYN-^`J;Xiz3GGCzkZeY%@I=m>h%M)Zs2Q(#jUI#STdORF3O++Dxor}LF)>(fd9IJ z{_6;8Ey2Nf9a>XRCYV37p5P+t?U!IBHkvKupIvA0KI-#}APi+pC9(>%?qCS=n8!(J z0k;leG`HKEr^&A9i9XQUgn{c5rp?3tAJy;>0@o?*&wU?bDyGA&SEw}$PvU!=F=t7w zV_1Sdma=#df$JG2ao;z%(Yl70xIb`R!))xQ|6Tnug_(Qcev~ll$qo3u^$eTLV7>zr zOAdh6HI&6zh80+e1apEEt#|kUN}~+Q<3aeZf2cJO`G$#cvDpNbrQ8!Vx(zEid!eKBe%OE2ECy55oI|Nu-0rKWfQhw zI}#DNPGZG7m=g&Pp%&^G|8*1Nxo-iM;xn_7l+{SUTDbKUwZ`InXr09sSc%n0fLm{| z>|OK=p_+*xBcb&dWsZp_-Fl2#lQF-!k1UKLP(M>C`k5-Al3#z5)@-Z-t<$Kr8D%%z z`iuv;tu-3Oe|^S^ObT(M^%)=M{+4j-G``R6G0=LA;dz<68Wm9uTC>rA-Nu=;<1rr# zun3EBtLr$9&KKmph4+lsaCGZ9UbvS7dgl1hI*t!Q>o-Q?kJfK2+K%lUzqgL#sP3#i ziT~f$Z@gLmlXn~EWN`B~db2$W#^_Tr6-jAoVn`WbrjxSXB$0B>gv{ad8s$tBDP7G_ zQl^*$QVy9*q}=hTPdF)$n9igOGI6A=F#AclV1nl|E*vFHJyM=Bv80SQOG(*nl1a%H z?-NE!EfY;jA2WuOg(i`d(YK5pEtKrL!4CN}O3i z%6@Z!l;D*vQtFwf zNQpJ$Nm*)klag$*ZQ%7sn5jidwCO|27_*R+M01*yOdEX)krHWIlhWI~OG>=iO3F!- zZWFIRLQPdtT9{s>j5f1L*=&xJ;%)ZHOG-u4l$01Vf|TiIJt;}%8Yv-Le9Dm$WxA3w z)J!2I!5kvxlDXq^UVns}M@Z>x29XkHR*n(}$EXW+5qw<}@jpw)qqyCDODerMG#Plz6k1l#?dic3yvknyRFsj)&Sltu$IL?=9h zff$U5n1tn6iG4VL^SFqdbD3Ke#ZeMSB{56Pz}w|5 zjkaiqSJ4+AU@R735q4lFPT>qPa?X$$1yL9gsDV~!gO~6!-obmAi+T70+wdK}M_SGo z(jz|#pbDy?Ia;D8Uce~4g;|(`P1u5CIDr%dajuXD`A`9s@EDq*J9^*^jKnm|z&dQe z5gf%;Tt{xs8SX||lt*JUK^Jtx5Ddd)OvP%f!9g6xFSv|coG;voQYeiEXoyaD1_Ln| z6EO+Pu@d`m0OxTLIXP#z4aHFsbx|K3@HG0NKgMAKmS7onVGqvYCuHS(Av=noC~BfM z+M*p^MPGb?u~>jb*nyomg)_*=IYVX?L}5gr23nyFUc$?G2k&7n=HUx$!*}=|X%l$; zksk$61=Y|TEzuJ%U=-fMEX=_sY{4;{Knj95SIC2WsDMg%49(CTJ@5ubVj5;(9X8+y zj^Zk=BRA&^ccU!IqcNJG3%X$lhG8VlXCR z5|(2n_Td1|<05i$&Tt!wqa^C0K04rO^h1A)!vrkBGVH=0oW)Pbx|P=-MNkwqQ5$X1 z4zHpwKEPNkz#{CxPMpFSWZcHfo=E>-y`jIUVr3A z0aQUXG)GJH#0waOw=fHHunAjm3@4C+pdGya$cGB3gvZbf-O&SYU?iqt2G(H%j^HS+ z;yQ9C^7^AJ%A+xwpbNTT2!>%YreZbL;2;j;7hFcJoxJ`ih05a1f@Ro+JvfV>kaZWYKZ>9zYN9sUq8(mE zUwnYESb#;?ft@&oGsw7`*B=E@7!jy}R%nBl@G{=Pdzg!P_yXJT9ll4}J-q(Nj{>NI zYG{s@=!q9F3U6T+=3o=H;22II1wngx{gDq9PzjHr8M>nf-oQvq!wjs$1{}drT*Y2h9MXRt?T4v;Qs(O9#Zq@NZ|UYT3b&7*Z*A0HPUr(>&67G$Kuvk z8FY_tT@|+uid)|#ZDyWFR58`bNYuw8XoSWXfPq+z1Z=`)e1WY0Iplp0UYM>SdKy^y0Pm(oe9l0K^9w`ma zVOm5W5_M1y591LGz(6EoC-&oOoWpr&O+wMyf>J#vKMVa#>0sWgsDi3^9L+JvEY8iC z1Tg&0+kj2jjDmMF?g2$n9N{R9vZ#o=?_vBenwjRLbi?yVm&d0%Spx&iBvL-XG<;`% zAW!2*Qz$RL7v)eMM~&)qq~LV=2T;VslKrs|>+t9dpMj(-#3Fo#_ z8k$q2{D`x-XjJ!d9N*$Qe2*V++N3T@z}SN{W&kPin2#k`iW0m>q&DhcfLTB;!fLaf zloE_5cmQQk7D@O9X}IQ}77?ZfSqpVh4-N1L+M@%O;WK=0wvyXWp6mM+5Q!S7ZRU~l zvCJ$dS74P{LrOf?{^wySmSdF(=lXsbR6$i#H?v9k6mxMe*ZAdrqq>p@P|=j;8h&|H zKt)8Fhe+9pT{wgzIBqJjpONNhfe%b6uFXqzGlP_QW+5rVxeos(-od+g-(2LH{Le_s zb$BU<@~Dmo6yv&k2{hr_`VdUNjr}^@dU?^@o`(2+>`TyrF~`yg&mwTVZ_YP;<7r37 zhIqNyO}p{FVf{nA-a))K86Qh{Cr9|^iwhjTTam}p@c1PjAH^3|qn(y^%vfLhA=>Qb zy^~WzJa!HLWqfWFk7won&Yy&M?V!2nUcf8H)fWt+Jscy=Amu@_&N->b9)(z;-0!3|w79P-dQDq(>!aEU(7!MxiOR zK64B-c2}RTgYjq9XZ9cO`+IfHhxoZ}-R5K5);jA~kS2>ydNK?C?7Veuys$p^A41@G z;lO$Aw643>b?y%xBMinH7->e4Z{ZzG$4tayJ{DjRmO*2TH$dZyb!?&I3XL&NG)bhm z_2YwhGwFEaR@Z-ikgu%-jZ3Zx|KpQ}v>%7YBL}Vv-I4oZFaQHF7{l=+)1z3b-&@q{g!#3hZb>m-iza-%(zQtL%$wL?dA2jv4^WkjGA`eOhFnIYs*3^yZ5c^4mG zEGA+SCS$6ZM#@ag!W=Baa;!uG)?=gDOm0IW4nXTtABLOfPxJcyjH^cDrCLH`rap!~ z=PpC@%6*79T!xA>{_1(=*7GwrVi)#8^Q<4nS)9WK{ET1Wh5G6|!pS;#7BT3BHxY-K zNW@Wi1vt*dV;F$Z_yOL1oO{A6=#z$gMYjv_50Q8n(f9#gVcuVe!&!Lua~_R*&>cZV zI8H_eWJWd=K~Xe7L(`ai6px!0>>y3)7 z+&b^ia9ec_Z(uau!v|(8IS2Ew1k230d+8^^tWY0sw(mUt*A(h&@hg-1rr_6$RDNhZsIr)WIXGf|Ab&(1j=>tCz1c^~L35atBjzY6sRx_s=m#=Uq_ixo!?);v%JpozWJ1l$5QhdxdN-O6+4U$;tQZ4il8Wpp#)SD z^B`0c6A9J9s2DE;GNBGMXX~xb+xj|RJJbv(M`AQSMZB3$F2Yi*LV{UKZop=2M|(SExe&v!#Ij%|MmuLmY! z3Kn1y60jEQvC+7Cc2^It^~WwEk$vh}cxgFLM<@y+91p`|PRPOtLqm9ptV0PcoOeHp z;V}M+`N|S@Q;&dk*nq!k-m=Miee;%W*+-uXQos?PxAzlvP?yqp`L3k#f~fVBQ1nys zkTm8wk`7S)r`Cl#fS--#L4N~UJ8UDi;B#oLu}$GX9{Uveh43CJbI#Ts81vEQ8YJg$qwjY;>me9jvr910LLG=fE1j&k3^q> zKI6#kI8})KBi=8}@d7R(1$VIx=f?Bsi&zXp=OUcXBN3;Nj1+i9$zt?VhV#4e9^S`9 z#39AF`4F0v;g}Qiuo@pv;d2iQ%^FfRm~f6cp2an`Ve$Bk&xzWogPx`>pIy-?z-uby z@E|_LT$}|Tr(P7VYjd6O;s`@Z)G$@W2EEUS5}%J z&K1S=V~^mr9K|vGWXf}HB|Xe}@(NTRx)O)k1|%7m;n8=S7ol+dx~e0LG+Gb18)DE4 zNl1a_i|&HQLOF&)6}Ac4QIOXXDTRFQxS#(whT|>7VG_LJJSWJVap8eksYBD>G-5GU$+j~C@z{by9KhE&0?mW2+SPlJA6?nT z)}dJ_?;W(jlNgP6F&~R?%2X}D`2rp>I}38mh>-hzUL*VAZH&jqn1_TS?1zzqZ88_U z5}Y3*98V$^KS1kQYku!=JdN%qmV6&^_yp7ODdMphOR)+G*oe*8jzsLmetZp&&-C2L zi+o7nvwH_#E93LYM2;WfO=F)5k82yn5p#v-5y89%?nWfr?r_Ah-LAuC?12_fPK)%& zfNaQxJCPfAqbw?-G9pkHQD_10ORfcA3ZIRd*YhE^)y8<0ZL}|Tu#Jk=kmR%?b;5GEaH`&;a;U}Dfmxs?AM4=DXvkiQXUy*{-p=@_($m`q)gUlgb z>+dk1*HktY;rnn0ujxGqML|TDVB113yoB7-cpRZ9fJmNGtvBvv<~c!rqeY^hE6DRu zh-)Z_K~F^UUhV;{Kl25&Zc0zMbyIe5TZZtQh}OO=hzuEcNpKhLK@~*cxr{t7=)rUI zJesh7mlurY9+39v0JknhwQPJ|q6J!_JvyK_`k`8OAJz6tdvrhyUck%fhc4_Bx?;Qe zlH85^*f&U+DNagRlt*Pm;0cVyN0^A295YKSujNd9ie>P)cBlGpts`F_4WV`9zu-0g z7US>b`=NFGQt%Y7xg?v$yzVj>Lowlgp9SO!Bw!u37V$Yvo<*MG>|am_k01(7(X9mU zY4ku(^hRGKmE`v$g!g0~+>3COr#~+AhRbmMc3b@nR%If1y{`;wwe9- zkZnM7COmN)`%_GYu6JF5u7jm6dc?WeOPq`KLpuf`^IFx-bqW%wi_W@p2wXS=7(tA_s3PF%A3B4zw3j&FSUJ{fh zEddl!N(0v_c39@H!}nP>%5tI?iX|`X#EP1zMvY z1|k9uJ?Ec6X!cajP(I&FOkGkMnkHm(v@#*2ykQ2B zgArlIlH)PS+}j-eBL82MM)9v0R|qMA8JTBCM^hsc$0Vq> zL|UR1`r~!<%R-_Q$4aST+&Y+XyyhojANE6iLOLRbW1jk7+=fTVYg0btwK*9}%_&}! zm$0?C*HKcA;Wwn?^(UE;1tm>WQkt6=$QB4eC_co;m~Wy<*@{?%bBvP+v!pzq-3XoT zIGv!q`6gfz-bEB<;-*Q(Yc4%9AvLZ%rd4$2~&bdbqaz5+Z z5tT$u02W{sRwEYM5D)d4mI|l^e-lX7K|M4;BQ!=3TB0>NA{4J690T#D8A1+4B*tI@ zCgNRuh7<506|b$-sDK&>#&d8kag2o@Dx)d}BNFc;3Tv?*n~;DcIG6by5NPU>*Kh;3 z;c(HsHiFR&x8Ol4CRlUg5j=)GCLbvU%;RJs_~0p&L>WA7{K$%^j6gI%5F)V-&Na?= z5XgJ!i6yC>iM*F2ZF;XL-aqmszQZxxMN($3!`V4bVFRB9vc=pXnKpK2^PW)um}Q7Y z49D;dxP+_trG(cOQZ90gy@V3HUPXKDNLO@21&+Nnv6*A8yvl2M5T=^`%< z0|^{Uuc92sN?$~BY+Q_0h(=t_RL)5x;Rc*s-u@v~$a;vxM#N#C?&tCLwTK~qhC>ZV zeW>66P^j<1R5<53KSw$gMiD%TVx|NsrBDHtP!-ipO;YNbMx-=0&yvy%L3j?&<3-bo zls2XvDIH7*DV^{VI-71}5A;Gmyo%TH1_ooOi6qD19ej>y_zK@3dH?t%?q5KU3#pu* z2;?qk=KEj4ImzcB zHeffRle`khE68$z#}`E|@!mxhGlY~6Fcs^}FXUG2L_99w8UikR)gk4&xkKKCKgX5; z)JGF^#~T=guka0SqRv&0tq4X0)*}`PIEy4)LL{G&JK2%)@ZUq(2hQI7YnFA_5H`oU#f!7X^Og3rE{h(Rp2!-JIjQQc&0;K9$lmp0=7 z;t|Pv=PkT##**VP5mPV~GvPey6->&e+*~h$lb7Q=)Ei2Dp!^VkPkBvCB(LXsPw{j0 z8B;V&W z?R<#DNW>T)&W)yRP3%5Iy9P97l7=IV_ zI9AukT%JQ&H^XZ@$Jq%;xeuE^kEJ+|@w!7h(}9%GJbY%ud7QnMkr{4Zs|MT-MlXb8 zBHqKdP;IRGStW4JB2GB3|Iy^zyl%#l3Cu4dBl4jjil8Wpp*TuI`{y)4FxsFaLh$(o z>VZ-7qSu=|_VTsa#^b*omvI&OdE5)Z2PNQVDw6&P#Ip!SM~uR|2<18Hf!lme-@#4Z zbCfr5al*^(i|N*xU*-9@foR@y;^8@w?Pa_g@Z2;;ImS$~oA=;pJe`Ku8Jq$f2M~-A zcng#91-^tsJ#l(uL?&cG71S`b$l3@%BLt%jj_@2v>iIkl3wXY8YazcMk6#z;;4#{X zYq$=F-#rToo06n2%A*3Bnh>%l-owX;!wJmiwViM#wG+y@kZ8|lNi=sd@VH-v9$)?X#O;$;fMbq0`S?1f@Z3o# z&qWt>LwEFm>c!oDZmJvq1W}lY1Zu{wL;HYzhI71!E+An$pCjnEgK;VPo~8aAzPu;o z2G61Fx|Yh>i)K70LFk2W^v3|aX$F%K_yk{KK9*uN*5EgI5PCBe^Fw@=^SsDg*}cY) zGR{mO-^V8=ij*0ciSNuZQf~5G%FjG^;xR$xI1XYN&s8+mU_H9dX8eW(o{Osp;aDY0 z@_0q%=QxB}*n|C0jlb3rjY14H_ZQ$X>f2lm4Z=9yAjm|Js>eTyUvZJg{u+XL|2&V* z=mvK`F~1|c{}71AXpSJn9Oe0d$GH1}r8>vYqt^wmU3$)N(p2u?DbJ1ATj6@Rez1!HpbGHdsa20N!)b2c&Jux{I$2&x3=k<@-n1lIP zpv=Mb6Ew=@wUtz#&9*%E5{gc6@^hR-CXsN@Z#mE#VVGlf^Zf0>E!@U@&fyjy>kY4dq`Z!S_zGWRHs;_L^D57U zjKEv?2s1Drix7h~h{J9;w>TE#18hPPZeR~JDTh>-;-qn!JetONB0V1^2mk#C-DcPtIkldy)DLFV+%W7U5ThWxc8X1D2xXEXv#PAs@zGb~a zNO^(RPzT)MHRC}Hua(t^!#3#|^}qyQByI)qQ3oGjRMs%6(+R zc}3Br3YXM`C1j0f${QFwuOUk)dhb5i)B zA%gJ}PHkiS33tE4NgQY9BH=eak8u)ba1Q5@gu6JzYcn269Ao4SUU#zD4B|C47&Gx5 z7GoKH!aD51J|y5bB;hI!^ID5XW#$2^!Ck+&H9M~d+~K|KLBJ!7ncx)Uy$ba$&51{# zzNK0p)ds$mysDEeP=Uuo+sdXO80+UgKM^9|sY`e8?pPX5+j9uR#0yPQXO0 z;W1u|+a{88lreb6Odw?ve#BxtsBf^=0BZf;F6_Zx9Klh<<>B)YF+7Jykc1m(%X258 zJZCrS@%(n;u|Z&OUT5%dEEQ)nKM!XMW8JO%eaHEEc+5hMoy!q})fmHLEECNtQr4S; zq{N$3r2KM={f1C+OkO7~N5jDH@;N^IZ{Kn6|CmpgoSpaVzRx1>dbLmOz90AB;QLW_ z|N7E=4o{Est=-SJJfBmO`*ZDn(u#c46LCDX`>mt%IW4)r!tQ5Wlh0vz;QVCweSXU4 zwBi0HyMJ;fqSB zZfcPMXn@9OZbpzJ;c)IS2)fRG47$#K9`1D@=V@Mp|27o+hG z-0PY;{@(9AM8{+Iyw<(msrm1=&^(&Xaou^elE;e+{%(C0=t^tqvVVeJ$CANx-4{NJ}-1d>wMXswv2wpiMl_M~() znRri2ZPS4i)sD-{Cd6Uz+|>%(tkVd@V7*}V=hmXjzS?>Md63?3i2b@8w8Z<4eguLSZ4jzjC( z4i#o>0C(PF{#lM`;4plTyRK>#|3-1^ywWpvl$`v3b3-++Qoz(8b=^MDXsjrY^W2J` z(OLj0&%dz(TAP&=I_FFAPb#2v5ent^C7l4RlknFFO!4x#9b zt_Xv>PSIVjld>PrgZ3{=xsHX8GDq_9cS=D#j>4uoDXICrB(2FrN>-yfX7Mp~9Nt6d zgf}tExaWJzxGynCdEU30^Skxfh6EhLS;J84-nv1Z|EWiWTX*{=w^f(?cb)&W;WaGo zd7#^;LG#|)|I>%(unF9CJAJvm1G~&|@&w%VA6id%8y=IB=UyIxFPh;SEHInM)3}T) zxM>_-Be_w)6eFdi2_##?z22dDq0txv%@0N4XK2kyb<{TM10m`I(Fv+YR!zew{FOcs zEBSeG*C8C__94XM2$FCCx(*}hxJK~L^m}N-pKFhfrXQ((4x^wR4u7_P!%BWulJ{%S zS{wJeY&wpiS&;)d@hD27H2hEj6;T=0QQM^K$KbBh8Nv5u6#lFI7?$#Pxb@)avhwdl zcI3n(D2dWgUj@~Qi|WO7ow$g=u|29+$s`a;8Z>!pP2}TRFMF(^;UC6HJgK)ftVVGe4 zXxyo_JAZbauGZ)#U!Oal`+sI#uDc#rYjBgVztwtMt@D|Pl;d8lyY0pKau`(KJq({g z>u*oPt$WhC#$3=Gb9rbz<8w&4o-vZIeUCjxYj;KKbafq3>vTtAG-kkEf8f@YJNdo! zRl#KP^=(?8q$;n} z?p2d{y8h-g=Q#5<$9>#^1_xQEbJ#&)l!m(=r4P3wpnAV397o=7`8jA_mDQl z$8Z9PxCzxE>IAYR0#O(B@hn0y0B@S1Qou?$JQsU$0ID z`_<+7QNQK(E52Xd*BHL9S}#$Z*G0H}jngt`=3WP{$ZfYCMHefR*RiUOAPHJmr)%VO z&=CJ|y|q5~8}fawxjq4R{ghkJ?baW}_3+kltA5)TfvAU@KdujidF!RL zPDS2_)~TrGQ}u?bnG)51s%}d4pQ@kHHDA@wJgDA5>${#@@Q>^KZoQRzz2B|7a_boX zsGj`q=p*xY_m9!~_!)@78tlhG+{A4>wuf3JR6-RrM=<&z9B*SRW?&Z9U@f%1+^qv~ zuV1+J5N@4X)g#_IHPxqy>P6;2b!umzdWkd8b@+2gGJjN0;@0cC*Gt?ww}Zrzq!Pja3yvHDVl7V-8Q97Vp342%h+2ui{2 z_jH1D_(TMzqV@%KI2RK2Vv=pR*Z-lIcil%xAI>AuiGT5%aOYp+xqTJa!6~1^Uv&?E z+>vx911X$(+>?bAKH~4mL5e;)MISw)j}Xagbm$fxf`vonJsc8MD&!O~MM-(elpv*) zDMQNB#+Q`xrXneoO;xfQYM5H2_?tjd>YDnb=uj)qpfR2`%}5C{&yn(iX+cUW(}t9G zrUNMAukv&h+)WB3@*M}hN$SwzZGEW=7fW4-yAl+9)lN-C~bNE(xllnf>l zDOpT5QgWDFq&#YJlakluC#9fyf)w>$lp>}mDNmUaq?9scNO{`$l2YENhhufrG67^D z)E7n?nZ~3%YnqV~gyi)*eYsX6>YXC58@G;U68GghxP861aeEi`Kt0yvfH_1;yg5S3 zujV)@znN2{oH6G}NyH_nHb}0UTcmn4`K9H(i%#ZcQo5LKq`YE!lG59RkMbYZ%|ue(HSd%1q4}7UPtE6~OfgeQnP$Es zq%1Jslk%fkOv+NToRpO&nv^wWEh*}qC+fj2>Y*p<#V+cl7mICX2PwPE9#Zz11Ed@> z@uVCvzmjs?{6@+tbB2_2CXtj2<`OAa%r#POm|LXWF&N?}ukl%nP- zQc9Roq?9pFlj3X2lTy)CCZ(#WPD)Kvo0I@khm?Az0V$14V^W?q%}5C{&yn(iX+cUW z(}t9GrUNM-R8DU0|GTMwG zk zukLjNUyp-Z_qvDM3HS}k>t3&MKXVbU>|_o+YJ5qlWU7-=3$@V@jnUkUB*m{R?=5sP zUC6HJZhDZSUUj0rWNvRV^{yKL)x!=mBS;x#Mw2qeyhF-(Gm(^c&HJQ$Xg((8Q}a0~ zQ_NISrkSru`Nn)p%1kqxlsRS|DGSW^r2J?Wld{w-CuOCHCS|qxiIjC_11Ue7Ur5>*{JIY7!G6Hm$!^DC+Aj%ST(ljV|mP8I&Y8hrmkTS}QCS{Cyhm`SVA}Q~h z_euHCs7IcBYE-i=MY--MPni;=lrm*VdD{4rg6N+l%Bxn<=DBHPcA>%6vo0w`L|O^URN=EH+C?S#DO6 z5^YwK@{`#}iq@ja7PF0%;2t2fAv3Co&R3k!pG_8J%O*V z0N-ONmSY9nx_!4^KPI2IUO%)C>)23$iH(YAju+7q-7p-VV-c2OxmiiN^V+f8K8-ZH zsC`FOJdd7u3sbQSJ8&Kum^gV7HPI4b7z@p7C!fzg!u{m)*#-Cf=lSdw+)qBAJ(2s# z=d;ycU31#*y!QR-^Pgn$rJg2W7;A@N1Y@Exc$YE7N<^F0ya;E3<5T1ql z{e_#|>qN2t-$TJj30gy*6C3f%n(e&F^FxP9ugP`j56 z?t1f4+oo>L0FsNK^KSjo@qQr>6Dl>MyN5Nh_f~dZItnpICd7 zPJ{Xoo`CvwYX4F7DOO+E?bwNvIA<=CqCPP<5JQcg`c%jHFh7jMvW$!1_SH;yn(w2u zAL9mS|E13mHr>1KKz#~_K)su$A_*6edWKheQnDEBe_8@%jrs@=gZ4jN2lbV`0QEwV z;xjoep%K(yI1<_y^?StNxG6Qu+i$oYDNUii!-Fsc^UXr?2Q0=CtU@$a8||H%h$~QE zMeUpF?vtv1wc77VoVz^N@PYbJsdup?r1lz+#@jb86}2g8ki3t14(=!KTdv;a$DzJ( z#j<((y=eV(Z>aCYchI_Nty6E9gKMuCj!{rwQtjDV4Gp1n|I#0?LOtZ%eO#Au+wBLS zi(RQv0+rzI=h~m!qP~#Bp?zIr;P%II`&?*W*Q#*)Hfim=#6$h(bP-K`=hTZvz2yAy zd;R2I;`{gOC%1&J$6$?FN6H4c>%ilsk~3 zXk?xv+hHs|h4y%L`&$KYJ7qts@=rXt-%DK6zAAA0)wuh|s$b}PNZG$+$_nbl zkg|_Nmu>V8KyUQJAPmPSyn|VogSy*!JwX@As-Px%;Waaol+Q60)1W?Tf41M3+pj@= zbgDo-EaWT_mB&b&KTaa>4h$C41l-Fuf-2HXJiu2ilm=c`FU;~aL2_875_*}!M*n@+(g}d;S zW*&+MvpyQ3DN1oHmX|mNOJ{UN7LV8CWFfRS9Z5NAPLXHf_NiFCo7y@YFtnK7iyG(VBz_J`Ge!K?8{>%z1qOtc zP@=UZ;;svE_fc`zC)DFyMcnlR135>~I)JjABlN&P^Es*d{=U5CB*IK0Cu1<@5JTYB zsVA>5SB-h{`f}BntFHVDsGj^Taz}Yx|C-NMs772=4=$6Ty70W;atK4XQBAnGeR!^O z`v%=QG+wb|i(wu@?~9#G#c^;=&9e~(unDZiRqmpBiC!@tQLUyuGDGQLjD`%~jE#`jXYwcC-j<4%*`>&3#hx2FL@%3tMyW{JP+}7UFa=-Dl#@O!o zI)K|!2O4KLGa6sFM9T4X3}2HiM&oIBOr3IE9mx0o%(z-(Yj<27&27=RS~f%DYIi)X zadaxU+_c&SOx;1x>&?&PUmZ_B$(XtX zN}__PPHJB`jj!`TV{B<@T9fX0JCxfmnJ#26^oP4&i#rZq$=B3h&>fGbDd-)KYfN4R zHBigcB_;VdeHiz@#5b6MnQ-?H(70Vr;uOxAMDha4^4VJvRgiLApTO6S;(p_Mw-0;r z@%=#`&dtnm@{h**Py7An@xI3Ve|5b76dy*#;g0v$a{G_Q`OnStj`N3;8t2O*EX4|} zMDlTexmlb~paLqR3X;zQXf9x|`Lpu?XZiVa&>VmqpY3&$6wL+vJI)8BVvH}pHy<#J z?|+X)Sc(VD3zW%4e++1TAo;w&FzzqHD!B6k>U}A`jQz`_lBq&IXr4fG1;4_bFG$50 z-kmQ9jFTb3xX+B`9(b)ffX@XGoSnsnp1G+6*RX{*gQ!-g%VJoa9`#cs-n8h zJE$LMEoiPmG{+!2;m$K0;I`%(B>6l;wF38_XK2aS+rXV~_=ww|K=TfM$>tqub6ax{ z$>$$taeqD*;(PoE_1FHh^AYYm#D~m5h~^^P`H0KO<|C@uJVYQVnv3|O`G``Tc)jBH z<|R_jM?7dAqT4p_JjDO+^A8-to$6SK@3GXZAXgzYJ>wiC;Ra$dFkVF0Oq^fi1QKx> zH_$aRU&jd~qH7lJ!`)}<1h+4uE9XvO7>J=bfke3dq)N!uU}`{2X* zOhp88ZqXQ%@F`wlZeIIjyXy`TIBz%wcb`~yAMA#l0|Y_)c4|+yNIt)l@4u$~8rxt# zw7*{FBokQ?&I|;`352}2EojK496&pL1;0?I5-XMB|D%5^#Qn3*6Ts*Al@s_ zb!qs}+qe{-f%aW<_Xm#T_87SP1p7?q=isiN&^~OH5eIkwy-YK?k9|nO4Fu2P_d(KZ z?jtATsQk!~in&MxVj#2!r}jcQlA8Gr_%MI1eX<|4J|ikEa~)`%k+pev0}*idJ8}16 z$dk#tU)zKBV+dr^pO}U>*ICBc>UmDqmp3F#M!GZdhx_xNf{_LSUcnsn05AOB_PdduaBk354 z3(RGz-|2>ve4fMI??8RsXJZcLVFA?VU46r!hA-4V+_~W02gU98T+-qE9PP{?Qflzt zmRja>)(}YnAFo2BG%!O*8E-NcWj+*{O({~k^WKvlrWYxFOgJh1%&VlVGbcznX-<=J z)|@A0L@BRPq>MIWNO{MMCuO2}mz4L-hopRL_L8#S+$QD8a$dzqDQ-%VQrEN~rIl$z zN;{L$kH-y}O;%E}o1COPX7Z4d&lDi#2@`OKaXj+g^{PxtRa2dmnx-}>0j3Tq^-LpD z+L(5vbTAn?c1casjuh>GE-x8}{|X}lQ!&R3OvCXUkr;t@%y?41G=AwAC!-Zw;~k8{ zB(sr>#TlH(6{O?y^Ks+$Nz0yr>x6g~O|cNsxP{v&myzp-2r%u*4hS(l$uLaBM{xVB zjm*S&ALB6r@8UhoGz&=i9zS9kmSY{(<7aF_EOuir4&bmkMjnR;4xjUBO%^gca^Vq_ zGUZ9BWU7)<12s|G)FT_BF`A$`g7G|Bqk{<{yWn+1Vx*Zs%6n!eDGSUGq%6a7tT&rT z*@{?fLp+Y*I4lrrT>sbp%9HPHYK(HKq89513Z+M%QAOm@LQ z48utC4mlq0nvcj&@VS{nN)*1tH~1E_F$c@A5??8R~1f(O|+HShCSO2jbU~yUNy^9g6bsD?QdS`v8}KuJ!B*@tdq_#ZaU|ga zuE5F8V+en=MfmuW@MzmQ?%6e?T9+Qi6dC7ykXovO~ zf(U$uskn-3xC;-aaIP>FH{d}Y#sGy-6#;k=A?R)TlJY7da2WA8jYQmp2X6n$0$c+t zj5iR0*_el`@Sreb3MmU;)ItF2pdR`l46h*q-(em$Ar=R42#+%^c>*D32sspEF%h3( zD&}GyV&Orvf?k)&Td2mEr3RXyDc-?EEXN9LL@aK>gFJjV=0zbCMng10a|EHaX-i6b z(~*>+h`^6#9Vt7p3kOXSc>!09hm1q8xnD9evOjL-8@D;#)J1l*J~Rlno}9lszV% zl#b9XYxB>2qLi6>?aSwW2(;L??H0}p)K0s zC+x>HII|gVA|rAjC-R~&N*G^KdLazwk%*h{;Ojj+57>ZBxDC&Bp1Yg;Jodwb47d24 zMm{`_s-`w60j4e~4a`sEc1+@2_FZhmR>UC@1vvjKj2BEdQhFf_ubDffHD($y>M!53)Lpqfo-sB*ot}Cxg%t5x4~p(lCZkk4mV5iDn8p71I!l zyNF<%KLt~<4e_`Q4~jANFN4?KC-&erJSdrtF(Nvn z4+fccNO|9UM9P z8-ySV(fAFgaSa|+VQ!=vTA~&D<8{1;PcQ{DFdrT?&dR?J-y<5Aa04Z?@%*3$0?-xR z@fOBo5<-|)i7>NBnTvT?h}Bq!TPVp~i!a(D3}Z15n-Py|@Sr(!FwbEChQjRw{S&ui zaSDmJ2@fhWHzUs=2(Kdo3FZpv!6RH(kh+M#XfuYC3FZq@W?>%AAQ3m=L0YaaNH%0g zERpdlKg37R7a&!Ht+qdhvK3wk3AuOR|s%{X#ACYnX0tTsQ9Yq8$^ zLdtHlk4(U?@Sr_&Sn?7guo1D?ulro%ScJtm3=bMGw-to82tjW|U>TyZ39&c^4+=5| z_BhJI7meUSE#}0g;u7v61J^1tA~Uk!F_V{+DyBMF1C0=bwwQ_;n2EjEhvV?z8LnXj z;VaC;4S0~bApc$*MIvs(gG^kzkgBF38HC;l!z8?m8D=r*K?dgTB(teXR!2?aPs%e0 zLR*BOt9gZ#iRL|0KE+hbLOj<)Zoq?F%neFS)J8kZ!vaL(BJSd|qWnCCV*;WOkK;(hMR;(1G>P5g_`Q*7Jl~(k z=YqLSipLaP!21*x5rh};B3j~QbVnF&FXYcGr(SCX_b~(!7=wxU44)$ko?mz!Z6@)< zRubi6dEKKCg0L1IT#X}9VjIUs^v9bx0}mQ*=P|`j#N#qNXtjgK9&f;d7CXJBkP?My z_zGX+Tg<>5vy7A#W-Te{cX?$Yvm&>7f|MF2fRqNN5!o2end!Uve`50<_IAX${X9m9 zGV@8#VXk+^b54OW@E}8iSAMbpo-|L9QU<>0g9(@f51u~4*Wr%MLDQcb~i=(8eNJ=$RgOpmRgL-I)XG{}PnwnrzUN9}lmS}C-lG5IEBqh|m zOiCAYMNiY8l!0alDG_EYDU%U}ugxq{Rv-}<;YsB4Ac^M3J>;PrDhlBkcd0*;Pq>~&#)iyIEzGFfCpKx^Y`N!1feZL z@HQr5F6LncqOk@Zym*tJLmz};2qG{R6R-hWa0rKS8i}|858l7!b(8dX_>5+cLJw-t zi!A_!*q6I7zGVO6c{oCmW+FPWfrRH8-@i#xsQE1W`UPP=d;58qXiB2y+(W|>4ZCES z;gIG?41U4~)OgDM_Js&Y&pZa2pbx^3a({^Pd@T_-aT|YiUkE27^}PthAMN+Bk)KJM ziR%ccZM4^ev_>cN!^8a^xCW7hu_JQe;eHRyPcbLF6#vfqJv7M9H30k_`#t=t_jzz~ zG2hHwZWA;^Fj}IuX-jrMDE>S5arp1rw;}m{4Rx9Kt&jiCeH+phr0xX`@K^V1c%6CO zKiZd}auMc=;qD_4$z0_}h{ANtz+BA7A}qlw#9%!(Vk_dX8+&mW+A~0EnL4EQ3z%xA zk=if7WB$s10gpv7UyX6hcgEowoNt&zp3X52h2icSpgjY`-7jDwbDna|+#>%K`vD}( z^zH-j8~JDV0SMy*yDtXdP4my}2XK%-n*et|fQ#Ht#T;sSWI}f2LLT^_I7*@%V(?e` z|NpD|{j0x!82VxgqOb~UumPJ8i|yEh{Wu670WR$_kAvbUi5jSd+6X{11fv5YaZ{Q4 z@9Fm+oR;w#oOFx<;fI$I1MQp4q^(mW1M`PyflzdVlktCMAO7Th_nT$o+}k|tyU&>9 zQN|?5iAPZqrQwGPsEEp_j{hlr_aFA#_x9ZXf8B3CWuN_ey;C_opoYy&;P%&lP#^uj zyI+20=8DAa7yo;G;!iWj^H2AQXPzPr(xEVl;7JrSB}gfS3aEstsBUVKQr9#hrLlRI zlx7IRb9f#vnpUK=G3`j{U_waggqP6SbR&D97y98CMRnkA-M3rkt(tBL z_wl-4opwkO>Ql@g)oK6LdTh7;+O4C0EfsTRcu*bn|LZ#G(CmL)7u_Z2KkA=r$|yL8 zqqYhG2t<1`jTBDz?^#4HMzk49ou`a8ZK>Z3!59-m%1>rJDVJ~=nbK1hiLA(mg60Xb zFnXXjb{Z!GKZk3$0YB!n{L#^LX8x)R!p$9024wb1BIR}FGGwH=%=<)wm_LxVXos}C zXCA?0W)vxL*ol4Ek0v?!bGT(fsjcdcKGamn8Jt7qysWFkPVB~B?1#g6I2|$|GwSo6 zY=A-qcpMOg>6n2zXwJAc2yGFHA&9_jcu+euA&!IDx^n7WHH&vJjjRqC};|ig;5&i;D_p{g#gqs z^~fMRj~9{3kEQFVZElfrmocpe*`_mhhyG?LDHm}Kug>84$5zDRI&R{&DL0e%1wzbf zatjV49_?rGJsd_nl5hcM823p|>R0k0zwslb0UDw)nj#p_<3+SW2s)v==|T2HDi6Oe z(jfyfo2;Z{M-CJ~K@^4$YMD-?bVe6A9Ai^sY8tONQo3KcjusKD_9o)rLj=gd-lUF$BA94xTannR(<@kdj9b55+NyRZU4IVYQ$-F3l z!l-1bkW$U8BG+L9He)Mdu?u_gMNa0*Fo|RDr|8WwR{}Yf%3*lWiDP6Byo$kaitv^| z8l*=?WWr-651AK*P!vy@5~P$eTV7=RD)F+4cVXT@m*a}0kDk@ys!;}Uc-vI|M@ zAg!O*Bjls-F;&Q_@J9e9m8aeiA7LtDa2$!oslaoG(rAQW6G}#4EaoEyo{D5M5|h5> zd<7->TquJosEX?5b&mOOAduR|AjFzGqzA`1*2+n9jy#XsxPz)3g9Gpe#$X&KU=k)H z%EXbk@jA!kf!LVYD}ZB_?BaNG5JzwUwK!e`pn;jpu|c$vP9mHw)UIvicpl3-ZD>QC zD{!_kuZL3Tj2`HP5g3Van2EVK4QD&YQZz8m4z8O+8}NAcF}CAaR0F;7Dh6N#M&T_4 z9r60^EdBXV?wpr4*(n1*ypJf%#R5cQHDa+1SCH)jwHi2q)EAlaK}`hW83f}wgrW&$~9CmJCbZ4ipln1nf)kL8HLYG|XN z7jE)%=#6j;MkK~yBGzLo4k8|>kc8{d=0fk`10ur7S+@H7Jeb4vX@%0V}F@s1MVy2Put(i^AA}q#o6HUtRjSI%6V+?Elr;QJ^ z7PB_~>Nvr9j0X+wctLA8C*#kI8~zpJg`7VB7$<04&;ZZj1$4v^48?d%fYy{|(Ps=w zLu*N2gVu+xht`HBLhC<2f!1msfYxZ~KHeT@OvqI}XHEz(DL1P7XT%hs5%jWmS1sW4*EO5VZKux}08v&*rDIH7*`L7rk z^vT9KF6LzSdN@w__Zlbg)^#MxL~;xgeK9jiLZ3IjCWI7+_mt?SM46O-{y~2(O(xF0 zQPZd|dLSC3DVjrl(uZRN)DJxd8?X_-U^DiZG@1GP;EzCzFssNI{A_+9HzRcxejffN zkd)+o%bRjvJM*Q7>#jA-v4_t_to=TDw##3tin2Mz(y2hELI$);P&+{&+Uq+hWyNR z6@dDCODoffl$X&Nz0nWq@hz22O;T#34(dVuzlWP?q)f-Rm}Pz=W zx!u0pgSb7!oFU~r5^=@+I-79_PT)73!fBi}>VNI_z*Zk@^}2TZT`%PJVk|+~TwZRU z>*3rN^|$^J(NLdj^|u!Fw=RbYsEEoYfjo-Tk8-^T>T4ZxEcqmXoWn+NjU<0xZFDtTKLi_?=J_wcu~QBV{h; zVUa16m-S8XK@k);>Wf_t)lAC%*tMB=l0c*W*rNW}J8%&3aQkCdFTh+JTA?*QHtK^d z{$?gA3(OCsxP7kQXWhgH_{dyg?n-^GllQl-%sA5@0jOh2cj7sR+qXI?jPWSckGd<| ze$<+3kTRwg>5q;kl$60{C@EiJI(X~co5%W&l(|>{^=OqPW)CUX%s<<=)$Jdhe4cC~ zV;Hxebe8m-@8ZwSo88U8cn#_WD;G0yT!H4(Zs9^^ujKP;np1nwd|E(u&h7B8o>x1- zF%XlYwpYGwMnES#W9K@=(@BOR0{?7Zr!I_bq#ycYqM1TY#cIUj0z4R3grC8~K2D5-nIQOI*~e)Q*AH(} zVvc{OK2CQTf3c|go@nx~_H(+0v*o|IPiJ)W>Nvw&GzwC+d)x*MHd0iR&cH z{XgvI#B~_1Kl~m2oF4XZ`seyMeZ7KtJ0_U^**;DW`!_x8-&FDZ!~RVV`#1g9`!_L@ z?4(9vMB*R)oU${H$U$GH9AwUW{hjJCENP1v?8aUkhQmC$q&8_uNpC2@R!aegGVFV@ zl0sSAJ)EZ9E2*Hw!4b*{?x7sO5ia-N!{vELxb%Jxm)ITgF;9|G%oHc3q$y2GSyPS_ zKU0B}N~Q`a)lE%OYMTI3>X>?@G%$@wX=0j^(%b}-^1OMGl$NG7DQ!)AQaYMYQeHBh zN$G03lhVWVBBhTBC#9cxm6QQyAo&IcnIWVM!*Gl=Z;_)h2Jc`3-o^X)03YEKOvV&U zMHId?Uz0K&-(sfuj+D8WhXwc^Kbpnl609(5N!egFk+Q|8bYCc~xMv3`yUZR^_L&2u z95xB095u&CIblwca@w3F<-EB-%4KtvypEgZHYs-vZ%i$Xc2b+Pq@*_)Ny%)ol9Juz zB;^tF7%6#7K2i#p$4Mzf|R$++vHe`GZV;(co);~6=oyWY$tbOuh~z^L35at1ap*>W99@Y zC(UV6&YJV2TsGH8xq+Lw1K+f~m(5G0bT(Z{>27+E(#!NACEWBQM8YNSS2bBjp405h~O^jFjT0Bq^m$SyIZG@?=Xy<>dLo2D62fs7I;Y#29KxWfGQQC8FUJ@=8rg zT9clXj3zTFSxt6Qa+*g-dCcS?C7&rk%HyUGDL&>&Qi_@4q?9zJNhxc}k>Y16kW$H1 zA*GtBK}s#-PfDPvOG1t^Fh@x_W=@cD(wrvctT|6glDSCAWpkC3>*gjYx6NHrGIH%O2lC+w zl!Py;App;y8QPe3q;xPLq;y9ZmS8zH;uq}20i48HT*ob>F5;Delq|@GoOlGeO@8tT z6f?z1DQQZRPs0xt;g0|`Fe6A&6B1v9nwQAV=w@CarKjmlhNGW(jg+B?#Bei`l()>= zq>MG=NSRWxqK{%3+g0%29KMlyl}HDS=#@ zmAa-rDGkjtq%<*2Noj6^NqOG9NJ>l7nv}MtJt-YcC@C+Q&ZKlT-AU;p%ghQ=R+$)5)|j>A2K;P(AvYt=>?UQe*-y$rbA^;59$pjBpH#}0(2qu)CQ zV=TtuJ$!%<5t)^BGYF=JxeKE5vGxanOvHr1*_q18k4k8U?ihy2<_mHvzBJ#E(=ij@ zVJ?0|98MuE6B_A|0hy5vk0B2pM>SMOP52`a_0iBYA%oEiqY#Cq*okw2JAq?a6ya-0n=7Ffv-AL(nROc-Sd+d!lGFEwMrR6{t6vsc+LZTT)>j@zz}WSDFal}{1MgX$#% zG(5_{Y(RXZOF`E|XaVuz(_+jROiT!$8Dj!Lqw;WHW!l=0w7B$5Kv%;57r~Coqj`e~ z^9#auT>TZ^WZK$4n_&!FAts0k(*xxh#o4=3nJ^KcQM*zFcIJ`Z@#}*UB?QnoBsBhr z0$>Kv{JDn!EFcZY0%#tBi+~g00`vmNzt1M1360MWaE8J}1F=9HkOX`OhJj5$a}CZx zz*j&D##^9q7%{+YpaIzNe=-ZpXgr4VU%0mct^(`8j{m$GN|-+dSO+!%^gxjSAOimX z*>B{|_=cV51Nv|rEG4kxcMHwgfW}1!1Cc-s5DVM^@_@%c zA@Cf>O9;z=a-bIYcN}#y=$&!Yy|CN|3;@Hx2=Et}fHn!!Xkd2yk7o$Ma|r+gV{i`u zJAUhA;2TpdAOj!H<-m@=<{dv{7#cXA0%-ntC1B^d#|oUBHUQ^*NEbjq8Q>CN0$c|k z0mxJayaC<<@Cn@iHr}rc@;Cte1jd1108ICRafgE%vE!#C7?u$`ehi7=m_Q)Egoqu# zgoj}nA%mk2Ld4E|(mVbKcgExG_@&zM3%J{#2R``vBLI-^Kg5oIzMb*J|Ct|pG`{!` z4h$BW0ze6v1D1d@fc$v+0{%cWkO5QyXuKQ;zy7T7zF+uN45%j1Hj;I`{CR1f4buj zYRCW6j^C&6aO|uBXuhm00QqrR1^zpJoY1&i6V$6^TAz8io)fczN#-!;F;e|P?h!BOy~28;odz!WeI%mRM_ z8Mx;|_kA`%Ft9V8_5bufqlFr-S-?5~pI-c5-)F!+=K#2H@I#2eK$|m0?GE-kF+d71 z0tWzA;0VADa00x5AOZMS2QakTekF(?{GZGNAPMpRGyfBs@IPY54}~Etn*o-9J>U$u zqY#c6H^2k%1iS$sVCQ{q5G*79tM|G)?{mLHyjfrq;Dlp?7cc}&0ZYIZc#8wwM9~3^ z0D4}G1r>=fs+@tPA{C&x?J)?hljzFM(R19{37$0O)yfA20*V0Smwq@E71@-Nphs zWC$6!t|32$890!iK;$DZ0B%N+FP>l^3Wx#XfIC1Q@E9lro&&|e3!n@r2kL+Z0Qv4g zetSLvEjR`t90o=JmnQ=pg!%HYz=LLdOd&7`9sOCra2n#RfF0({gIa?5cnRQ`AixyBoO$Tx zdK1|3dm{w>w`gF;?>=oKxe%Ws0Tg*Ye2>(Jo5r-fCk_L@EQ2O z%tHg`94%naZU`wscRZUMdlJN~f! zslgWy@Ck?iUbqhhqJdc8HjoEA28w|fKp9XDApckOz>fc`Pq5q$bO3!oKQIUk10%o; z@Ee#19zdD@02{z2Fbi#N6KH|9_7}hi!+8&|gf`>^?96vGTLAL~0gJ#IumSu9(7YQ6 zY!S>`0qEc`htLW@H=XYcl^vC|M(gJ z`XKW^o$m?r|JgiMXkN5Upztu{5AcU$CJn%n!FdMw4?pNM;2#!14@vg|lmIob50D4` z_0NX+RPBNO7BC4Qf9e>x77+ua02x3Ihyf>YNJ1zDNCQfM zCZG@aLmuw~=p$2kKoigh(EI{;03i-y2$=vZurm+eV_4qthwcw;Hw3taBOJmgAO=VW z?gPjNJBAw0kH8=t3x5F3$bj)Fxxizf6X*tzuc|5%IBtOrU=u*|&HMp& z{Fd*$U#Qv(_Yc4yU=z@UzMVJf-@&pn;7qmcUmlMfu1Ek8uow96&f6&oapi%3{rstc z)&Y>8zsrCjU<{Z6mVhU)^PZ#&-j%EYGH}m<<`eLTXL51CjvxF-uv`FSfDgq9U>aBf z&_iQ>U}ydce`rg{zdf4Y%nt~FHiG>41p|pdDo_Lz18;x|990n310Qf8zkh8&2aX;8 ze{Z$9RcQh~ytOCfv)=>Zh`-TFb0?qylgA$+u*aI#=5|9Fv1ISPQj(_}r=P427hi@wY zCjiaY;fKS2Kg_iZv;g0LD!2zm^XbJ7!MixXANmYoKm?9x2obTs3*Z${1^ie3`2L-z z;XA|~0{kiAJObnc$R}(ePy}Eyp#K2p;T`|${3+Y-d;E*G-^XZzhHe%{uZ95w-7btZ zX!M@U88obo2>=aUFHADTKLud|Xw+Pti|Z zaC!}3=ixLpXp~+Cq=$A77ibhe7Mxw8d`f^u+ovws&i^^kD1Y4b+xfqY zTVDn=%D*EnJ~zZi`3nS%@*@En+4DfdV*!jaZvA(lQF<~s`$@>}KG4dz^!WZEG|Hbf*in7%y}SKBN)H@$qU~WpqxAj3{tQB1oSrS)j&A@Ol{c?xJH4}@ zQGJlUX4+csBxq>P7zxlQJs;3$dorNWZBHyNe&MI>?cD{v^*`8Axr;%=VG5n+?e&^K zqyI~B>Ggv~=~dz4&w&Pa+L%0uztxRO+s@AzF1`Rxw}2hxM;0_%e-`ZQ5bA(N=~I_) zm(L7m=LU`P2X(Vr~eZ)+MaUdc6*5d zO#!+TG)jjqecL_;8ZNJxMX;m#vwpjsz5v+KesTtlE+=B3(R$db?ew%kqwU6mM&-8x zz12QJqx^Z{;!}5SrxS+Ld0^9%;>XeWrun$}eb?UJYoJKS9u_9*S}ClR=~7X%sYSr+MAm z`OU@IN#AX+zXTfXkN03l+c|K5`}iR3*^Vy^8r44*G)hMXG}=BRZhallsNCE*ZHd$V z5Fgc7G-y=cw?LzIm@cdp%TzjdHdzLG(sbiUwpA!ttBcU(f+#y@lpCQpi%i+aPhNodJr_SSAs_CkKuF|XtaJTZv9D|PR42S ztnKn;fJVpPL7b*;*e*XWXq5lK;qCktLH<#Dm<5gMMHTE@?eE9-_Dw;f{9$q02Q;b= zETo6>mkS!@M-%L*yz!vX`HLIuX#Wg=M(w~KXP*O&wj+bf4`KH9_B3&t2{cNt5EuUp z=&kz3ZSOozTjR7jPE-Hf-o6m%t^9&U+YiRsogqHjPf0l4g2n zeBGc?eRSdMvpD-8tdGiz{}5MyxbzN!-a7t4qjo3=8s(qy{dW9Qpi%vCgGTw&#Ko7v z*>A%61KDLpx9iCq7vCB*+MY9LRDYVd_@Ov$0vh!jGH~gcjN$eNPS1iJ<);LvsT;TJ zqYbC8fkx&10UE{g2aUEj0~+N&7BmWLL8JV=2aWPioP%pmxcG-aqw>#!M(G^|jnZ4e zX-Uv%KVUvEZSAM?piz35$?g2Qf=205gGTH7;OvZ`QM@~#x6UiL`01e0{|5^+%uMa=EzGed7cAU7?A=eE^lfCXj#$ z_NuA9hXrO`nHpmW>s7%@Q;2B%ZLBbXdENzPwm8~-K7OUEB#|fTIwH-#x5c|dIz=B9?^F$=(p1r z&VyD#RSf%7%ffxT>Mfn@%`MEg-dpXghsGkRJ2_ftIXPJTyS^3t&&WZ&^<7;N7|?ak z)ZHCbF4o-%YwKj=h=pC~gf(-5#=Nx`v7R>W)>vpV*wa`KHydw@lPA?=^3s*~fCr@Q`YfdCrScct-*>16@ zh@P%C?iN^Rk=QF9mX;Q-aKxIMx|>2A!f#9%RtQmE(fdDmbicJd|!b@~}6@I$A)zY#ncK{)CB2QN11oP#Mv0Cr{{GC^;KViXznTFfTUY{TvKIuTjpg%JBV@Lxaz6wGKeKwnw-W!?b>30(x7b1BlZzS; zzXXmv^}9fM{;>UNzDR4LyLJ__Yx&=99`<7OrDggwca8c} zJ+MVVK*Q0@0-BebyD3_*Hg&@~yINeeaq@7p_rhMWfF|bbWa9?S)*Rq>w{bwRZQO0( z{N-)Bb>?v}^};$jxkF^EGc*_{R|nXCt`=qS$wj6zgnf>}(3V&kJkgh84s*xnhN29d-Kc8ibc?82+tP{#QEwkPfc> zYHqE0aqFax$=Oehv4OboFn{X`qqudRM6J%u2}R5Q2uXvNNfMIzWgpb(sKXU6?WN?{&#&eSpDDhmHrcrIvYFXQQ2h|f-@v)c02at zyR`5wEwW3C?$TnrwD>M9u}h!WrBCkCpFpD%-cJ6SciBJh(k;96mtDGbm;Sm-x9!sK zz1sg)KOMXD0BCfQ-N_$3bN%1+k6n6Xmqtz+{#}1!m;SX&Pw&#RyY$>HeF-$Wf!xWT z@h+_lwtx4(A!u~txDy}gf9*!Q>`4D>H{NAO`d_=rE<4iy+D&)ak^a|yWtSc4f9+`4D>H{WGP`d>RbCI4G~r2n;}W9eTz(*N3%K>vHbN#3PXc4^ds`ZxaFT{>--PT!^P z?b7Jd_iuVHL8AvaJNxt1E?v4ym+jK8cj|gua6NpH$&aQmD5p2kYuu2ugePgc43#Gu~Uj(x%CknAJ9mC>`F2kNyN z8{H2I=5?$N3>EQ@_0tjw>$$GrkH`L{!e<8ruAzch37-u-x0Nb zX^7zV_*UZ4F zzBE6Rdek~mm^5yE-YlLtpGMC9l7xh*g@-$r!&v9!XWLmX6%F~#%QJUc&txa%W~lRd z->v$o{oeV7SrVt_-X%O{+7K3lQ>15#?-<65SKS>8Zr88mnAsx|;6lCPg5Q>UP*8aI zsPLaV8W;EVojd!MPc$+m;B$mjg;g3sk;}1D2hJWo-JQ&Bd94Qr;izaiRJ|c!Kx`zDU@qQD+KR`S5Ak<(`sL=DfB3%lROqe_#70VH<^) z7F~us*3|v@`^6O&JNJID8FEb+43d)MyxBcvS@?)GKdPgI>@Jt`ZG4fBNzKR4{@mQ> zb&I#ZN_w*>v;ROYvtj>Zk-6(mcy2tQ(^B#dDZW*7ORD=RbpWm- zG1aZZQW?wkQzoA?w_skd=B6~JbHz9B$%D4BWP6{p&FMKkqijB7FS14o1Liiyzx|?# zyeEjhJ9+af##Hy(!?h+>P!a?g*Z}EKG_It{-P%lD?6%nM9v>0mQ8qhHK^UdcUO6mnln#J+_hUA*F0+XleCst^-_N~7ZqX4o_c@pcJeb94`(n>vO8Cvn=;CA78vz= zYB$13^{$RZT2O*z?LEPt!hEB2LZz$~rwW!`vs%PX|p^Nv0D zBJt(7U)=4&DKe}tEJTRQDK1==Q8-iXXt5E%IA@u%`cq7ZL-zBunSRL%DdUk)+K;|x zjc6<{v~>R(+rP*$u}@^-MYi)D!ql|*eY`|kFU_qky(yS~r_I|TaK11=FhXvsqd-3rEWWDHg_3xqN{gj6S4&Iu202=8{uN64|r9 zWOARW{*!E%qj%E zc(n?f2#rEi_Yj&(Ed3{Nbv62II|Gfp-s&vn9TI zq+zUU^5dbj`GM@YMbQ}(MWv5eR#K<;*Hzf7J3~H_q-DrQq$iOvP#La-lpW<({ea<= zQS~)Y8Yfp>pft{RudFvPEa~|qU3e#_<5IO&XepDd=#OL@_gwt?_dXg!!6CJH?f3&1>WY!!MRCg83%nRB*}da; zPH<;Fd?}eKuJ^b~#%VM@>&;-J{$$SC*;o6L>h#9y_J$Z5N3 zR4$kXH_HFC4=u}aP9I=ke?51(wv-_=eFn?LrdxD2{hi@8z7XS2_G(=P{F6FoT$)9U z&y5(SblnTm(7BMmGT7Trmv=+Od+fYq&E-BL>%0`VeBy>rL_FSKsw^d|TTEg6gB+w?#sOE5g+Na(4+6@CwSJL)u=1di^(h1tywOE?525h zjyjcKxiN$MQ<1vT(2YpEdj6M^qY2C|zUF;-+2ihqY>WiO6(p$>x=;R=a$D@aD|?MZ zx5mSkc}T_P_+b&!_o{ErM%2EmmoP|tKYHPo0iI^C^2>qOj#V~{-RC}})n!`AIOMe zJ#R>bhaY#Q`$PU@@f_Ql_%Hmxn39Gtdiw@VdD$yo;v%K#&mR_;=sqDlOysS(&(3K^ zxccyAimN4?wUnmh)E|_7iJvF!E4&_5%Hf(sZ=g)~O`e$kQjxZ5qR2JU{h~C&JpCDT zKE4s+HFP&dPnfK81w_|gppTX(xLU6Yhte8U zPb=F!6>R#NJvgOas8(Dc7$O>brHxne8EHaH<#=6K6c<+)Tex@x_0^ySs@EPTRF-JV zqyl;PA_iyPu3uwmHsN;jSL$M?_Xs8-%pM|cdjErud-0le*oU@n_L1`Y$xg?1zg%Up zux?|iH{K{&cIYOVGf-8!eLk6YMEGJOzD;JH&LfI3NwLYC4$Q5-WVBQC6Db(UfGOTNAlW?}wpt{JbrPyQPn1<8+@ z@i*e@!S!#OUt^Tdc*>T#U8h|XaXqbQLtgCIF5~6Wk`he&%Z{}B zUV4nA|C(EGdBBsCRDFVzwkpDP|EC|Ik2u znSHGPb!_f547&*2$tO1+j046 z{-xkO#g9HKvMG?s(BJYFXyA6hca;@2)F%OJR{SfQN25P)2G@SHJ9>a!G~_dz_dn zDOXN;toBK5&VGfMo|{WWkJs|tsoYCDPw8h*&=DMxEmo=eYScrw>Fd(wElh>?{aE8S z?tnzkKX2Ldn908WxX&Hmmw)`zrKd*1SznWHIIU1R#R#ymd_8VTe@wA-e-w@BIH%LS zCl1HDzn9T@NqtHizQ`K3cwErSf*JPDLR}L5O%GN}^$Vq=q zAF{#MkbW*yXxMOM89Q=Jkny_W?9E?FKkodZSFQA&k)yM;+vaJFs4YLZ@XmmPU-L2O`>#O#tnjsNPyiC&Ukb$nU>BEK9* z-}I26PIkoa*G; z@sT7YeOd9pJzid6S0k3xt2q3}+9*{kK}n`P`0k`loY3I>LtSp?Z`UkbZ`C__KYI_4 zODCAmNObkmJLf)N8dB9zIeL-emQdk>j^mV7r(iS3D(`DCBND&YC*~jCyq(C)F85;m z@MX(G=iXB0{?VJD32aq)sJ?%3uEEZ}D~Ez0FZrRJdI*1o13tCwis+@6X6r|OdArHD zoK^J|JQ^6}WT=Ww(%08J-TPXNagXjkD*PDiuYyW`V*w^IL%uf#V)RV4v?+h|?8fP* zs@{rFDXe~I4^v6zE>>t&`QuC4a{kP3!T@gf{W>Qbetfpg8f+cRynU&hpqo(9)j;V_ z$U`%egF)J+QOtu5S)*z6=iEE4aEv62X*WDrC1e`YCr(?mk|1fvQg+tz(oCsUa+3uJ z^KlFG-(69%!N2;|#U}N{n*<{ZZal??AX@r}tO%c})U-z);z9v54R5C}k&;=9Nza|I z6qv~(|cNEV8sa4Vtw}tI$qdjDOr1 zT*xIyU#ecod_YyMm2=svu7)fBnMNEXgPer5wK@&wC4Br z&Ql)xM7=+MIZoK_=Sv<|j+Dyp#`@N*Uncrbx7j(%B?Z;ST2FCMUn2nEN#?`%E2ps>?v3R0R*wCqdIv`6GKT9)R>W_q3C*Xl}x@Jm#+=RSu= z-zmgCUQfBLCL$c*S=XqT`&;;^v+Wz5<0oYYjA)f|~E5Mk_gwTsToVfeZJi(LPW; zP5ZofAf+S$Kgf5(xY--mzzb}my}h#9U>xW z+*v=L$_jf`!@;${M244YeN}T0sg1yghJZB#r@P;k2IbGTX2nbtFx2)RRbwv=wN8=7 zvtglPp?V=zALFEWK)=1zsZI1$bo4mk`RlJ<=X3WR!UQFhJ^4IvpS>^5-rLp$ZzAf^ z>2Ssi9iK7cfi8{ zR!;CL4kdkU&NCvxzr`^%FP(xnJpARabjlKoYl@VR&hR1q#4kTpnPbMMD>5&)Y8B2N zj%_f}_N=AKsT7o?3D=n@4B~mAbA0v&iGm90^&dgOe@wf(7~LMF{#H5na6`x81WmT? z#GQ%jSL=RU=QvO(wy5D=Qkg5Pm(Gp%MB!7Odt{3DV}?OpJZ&O#RS#?JjZabJwS$ck zB$!wRgS4yzyoQpxtq0y`r!AXWQgQX&kGM-!%DA5B*59@|Bw~=_CCB|-uu9VF!HSXG zwW_m)1qtug-i^+J~NeayLk_YXry!IflM0^$a@7tJPF2~`Ei|%l2ucvC@gkM;N zsLBB%H%r64)<18|Ub~lj%{rgXs!WB3W->-KrM*ni#lkSYgX7nzLz;8wScwwbn#yzzHeEEn;lqA)#8QA zQ+2hee?GO8^go+}ZTumc?XA8R*Y8za--T3naWqtWEFA}d;)lE|C z2Iq%@ngtyal~Wlqj;!)atxIvXX-8ps_o>rA^ZVSf=PK9tuZ!mx?^=BpImNLZt&pei_UAm^vC{`-W&+D|Jr=Tq`W-L@MhTjcX?@D zN%5649z{#O4%GZEA1Ihqm*4pF-%ZG1tt)@@S9kA&nSqe7GotS(6+Ru-CUjgfm@^&vF<6zLzzRpJCO&?@w^Soa) zS(YNHN+D!S;Zb|%^@iWutm(8zEVKB0Ki)RHH0t^@E;^eYPBTxk*){v6Ik`nfsc&j% zKWltzb>Hiz=yx);53}^f2s*?9&OG3JF(eu3SY2rpNO5neEW1+gfG$cA?qVpN2Wyp~-)2;S=q!vH$wVMS(xeOf8-<@5ww8N>YlivQG&5{rcc-wy8Sf zpM0A7`pfH^-QzT7#;Fo?r_MDBJ#Sk!`hf8!_ctZjQ=fXU??K5csu}56`|dx~nTl)s z?;kw0nXFmW$FOm{=;0NuzZ4xZ2d0aOvD%~c;%cNT?+1$-;$`{f zrrP}<32ke3KL?A3S7 zPA>L{28$W77sZSSiSW~rI_8##YI~CD$?(6|`gYJX1YUj_9!hTMRQoNID3tVFz0*0p zy9D_0rMKFy$f|G#XZ-Zet}q-g3E~rQt1ieYHLhWE^1RP2c0Bepy_J-;@!Ra|QySKq zr+;~0HDp-V{>;B|cV$+Ds^DCn^iye0#*u+_%1r5ptu3RjjLUo7!d-5df0%uKU8d>f zjq)#h?edDA3251{#CSQ=z71NdrYAKVyuloK5r$o7VK_Cc9!gN$tN(RxP@j#Fyj!=& znOu+1nd8*LRI#wM>?&(IPt5GNQ3a3B%4b!V+w~oRQkRuQBehr?}47q`c?F?gEe>?P%ly6zc=8e-=1wC3_ zF?~m!V68LGBR>SM_uQJ)f0$5D;qKfm8Wp;ysPPRgo@h#tS#q*z^IZYOq}C5@ga?v- zlj|KSr2Zu3H?2k~OvqzRDA;sf5_1JxSzgw}-x;mbo)LI4HkP`+NT>e0dw82$u-s46 z^x6oz$zhB}x9Jt4aDKvW)!`=GHa$RpVxXX;|w4&dK4R?vG~{IyuluWk}icWacdclR0(cz^9ux-2al-CjHbC`epW}`t)MG7151- z8ymr11XIWTE>=7w2z9QfJj64_K9$Pd|K0fc+_8{v^WFO-O~wg4yU);Vwo~#;m8R9X z-&<{%ppIwnd!9ag)!6Ro19#G%!Prhew|3#kWAWBxr^zxZ518GQV(O5rZ)BX&HEqgr z5O|(QdN9|_-QD$Q$?HbHyAMD%y^JcOM!d94Lk1TsBS)La;(bJKngw!~gx_)0TB zdLqXDPYGk;65(kb-5DECk?N5{e2eDneBSC7NeQ_#GjZbfbL~}~vwE!e+-_ocINu7~ z)08lnkG`>S|Jc>s!^&9%v9nsS2m03cky!d1ubkKAK0dl$J8b#WHK0a<1Dl4QJ^8uu zOlmTxBg4C*?8E17DqWu@n^r&kbtbj?Oz$;iaxS0HNgmaf#>lBWHF3?zYlO}RG}fg~ z+-Cgj>;9BBwKU(_@sMZMU&l6&uF9Mc3)gH(W=E0ptTi*8)_EuRHbTfZysm1d>^X5E znN`c{wkJoZaY{_)$jo2sTXiD~4i`!IoApFEM`yAIqSVRr z@2T=kzNE;D9f|uaFn;x@d_ZEw_2-&{Ms|0GzA4bmg+~3>PP!i<>2Y_$PF%^b#=%j0 z|5+k2r_+=oCRB? zzvZuS_p+W~)f`EUFCbUCUURYXsouj%H%)~P#X>&vDaw;|J?ig2={3-IP`1^W>35dS zMfJXaGiFyQN&A~>@xs!b(l>iU>Am|*PF7Hxwp&FxT-mQH{hWhMiG5wSDy;Gn1ED$< z5yy}Dw>DDJ0dFi~8^Xf;u2tX(dz>as2ox!f&z9D2a+b8C8@#PP{X@n%SF(XYah&4I z=;fZXLG>P&%g+!}Uvc~P-mJL6I>f9XC9Ty_*U01ItB*Q2W0^Cx*#(ZZdJ}PN%Bzw{ zi01nHT;X5~^%M|w)N!;|wCGfRsWM+VuQpq9aK6s$Fn{=czi)p?-9jF>pZQAeE^xa} zx#PNHyyT+inRB*B_1dllXa7{M8J6zph;#A#F+DtO> zD#m{_?Vfh-3VywKpRn-L0~hS4*_5uF^uOT%%F=30NwhcUU%xAA>`XKI!% zkB3ja_xoG^J$~+oLZ#dOgv+_{b5!$dVM0$z7=)>_YFNS@Le9nf#!^nSv<5s|KNGg- z=5qhS7}aQ{xD@m?;gNZCOQWuJR7C2_&a1NWUuI63YilXa^QTAf8d;y4%%E>*ly5vj zujXIL5O(Y4qV_d`gsJueCVYt^zY^`S^0hE=6B<%VUjT zrLbTzI|^=op8T<%LcB-m;XF!|BQ1EvW`#L}b#^Z1&qhsq37rZ|nKf>HALWvEPF7Hi>*LvvL^WRl0G9>6ygdLg`eZHo3 zzqZBx_WY4@O^UfmgTlvwGui2m+T28bB@(fFO;F;!6Id1_X1 z*J$|+7tyu8hc_tJ{=`udI?JKE!;dC&j$fXTJLca9qjkDtn22sbZigEhIwtk>@ zy3KWNh>|k#A*&*1yvSjRv$5aq%dNH6I38X2#t`OYqQp$_guJ3S+`HKI@r_0TH^Yv; z(3#)Mfy9R@Vm39%@Saz842wkd|Mbn*(!0dmb?1a{8GXN$%5j~BD~7jUMJ>ED=Be`X z@Cqcme|PSf772~8x3JvZu>>Cp_RWHf{S6CttG-%$axR5_Q;WA(S@9D}sua0=&sJUZ z*M)H&nR=s@ z{F*zcszC3YY)~|cWqKvndVWOy#l2JJ#~5F7K1|Ehtk&tXzH{uH^iYD@u& z*u!vB>zCEdg`ub^_V@h+AMUK*Hf>8eKI)6jWOWyCGvT}b_}N9H1r24k$V9HqC$k;I z#bcz5#97_z{=c0bnWiiqnwV#6Dh-}slZmp=G!-X)s>ZQCTTnBr-9hgoW^|%=;(hr_ zZSc|w9lp57H>{>*4lkCR&Zwctpi!70NatvDs~0U~Pp*xYI(Y+yv@XVj_uLK z^%;EQt2}p9u*bf7IQkv_`!RyjuOab)Zbb1b6`$h_vlm;4b8HN#-yWF`QV4a&489Zi zOMl|+_{)mB8V5%=ejL1*=fiT{KVj*3YEx2c{X3R;#?ukOuT*v48V3CmolxA5S2*UF z-m@>lb4=-u*yB%E@yZCbtKG_eJ-*DNQ{*kM-qL-z-e0d&WjN>8SK~Ctd?li#)_QsU zJ=Lc_WpF1fy2`EhPc`<;J_?CcB{vZ{cs_7mw7uy?i|Ub^&z@2678UVbJ(K()@w318 z{L;?{elts=c|2#!j=H)WX`25;gD3rDyyg2PX&*gKU;GD~uV@I8p1U7BL{h`OTy1YM zG~1B=ETvbJqJELO^z*4#gZqE$Mtr`0nVV1{IXp*Xb>t3R?W->y8pm9Jm5Gz!lV4n| zC!3GY(43C;ym^S~k@kxRsUa^N-iOK02H3uy2us}9`+b0IC?xZhR6SQmPGJgBK*|1Z z<^0@{?~J&P{r)v@gN}z4u0?lm39&Jj-wD28u|fJ&<{Y`@wea!tvn`2Ddg4}W1t>VA&~v)t@`Ku2S*;FvLRcwJs0f-^j&FFXSpVvgyQvY_4Mb|)PSj$l&$!dB zG+RV9SLokibmh^T)X#=-r-~OkIhH#N<*-$2%EU+gYwPczyBv+j{B8K$h*LtlNumZP`q1Z)~m}Q75Fx;btv= z(sHEY-s*ggzx)fKvS|^S)wILKr?98|8@_Neut@yWexz8Y^0uk*Z2@17-{rl}_4Sus z=Az2O1ykMe3I2w;w)f^GME8H^|GCfYWJbkL%{Nb*7wbyWY&m_O4JxiXNklw8b>qa3OKf8NL?3@N zybD~ve{q6Y@mvKXmEYSw!Utw5mbSuF)p>z?`+g^c?)%GFeU0!_o6uz=mzORdSu|rK zxLjwdGJoB08|a|Zcod{mM_>2w(yKXjd(OQ%L;_!KU=o&3MZf%_d3U3$@8he#SKY3S zD)Dn|O3QGzGivZ|5VUk%jeA8Fwa$AyYVftOKBJZY$H3{%vfff#qOSpLdBZ+`kCeRc zyBRC3mm4#;Zp<`vm9`1%;I|x*!J1JJJ2m(y?%?^23)QqA3;gKk)JeYd{2_1GCuTU( z_|cM6zhY_TVrDhNban9Mh6^Y0Wo&+TCk8hyx6y~&R75Q(ao)~r@<^846CpWD}Ikx7f9LI`iMg7+xXfClfrmUcR#r~d+^->uOv$0 z=xEixQ=dHd=rXvZ`0HHqJO5gzw0bTnVCHNT!SR<}EI#4nXV)i68>Z=eRc6zU zA35@y`Tob2GdJ)aIHVgW@tKEAr;?>;dM#Yh{c9VjHgzrf$MW?9S}pEu^7^TfUA5_P z4dJ()c-~JxERe1YaEd&eM*T@Kd!HdXYnL1N)^H-Slk#40&InlReH@futCVfs1tD>1xp=t532I)4@^ z$&G*0mDl#+ozc}mSBa@SeXdK-e;*U4lzTAT8#sK_9c!NSG?J@QWl6%KLi=pAp3XgH zeKFl*tlxe;I^9h1<$Co(&IifcMZ-g z`_rvu7w`2^+Y>F1omFM@928OAk9YcTzzx-q)EimihJEQ{b+rfS;-nrt*?ja~H(uZ% zo6+c?2yw|;@7LmHtjo3VTBn1)G6|V(?RR38lg~}Y*Zh6uSSxs)i$!bZCgDDl;i&I3 zkxIiXfpot!N{`Qf)nO%n^PTSa@%tLIGqDkg?`3(!)9_ddzL;KfF??R;F%ic{7kzl( zT&l0Y3(JrmDdSFudB?7GR?(*hg%V#$MHnMlW$DFrh7HM*ReqeqQnIq&YQ!EMx;tNg zcEAxEoMNdi4kv|+C!|9DUjRQqz`sUQ!q)%#A*YGY`41nDx>H^hv0dyxDE|I3yn?6(>-^j2*h$hmLHazD zPYPG(3?0;Ui_ZBre2`P%gNa*SyMGr~X@A4d%P4;;=tChDRDfm==F((2-k`(Ra&oe%4!( zc*knZ!{K}vazX=F&+jbQ^e? zXt~58AIn7@UbslEh12f9X&WRr+m1h6cp7B**(K% zes*%G7-oXf!QaAWTmRrx)pAtpNmS3+656i(Cx__=bbBTjB59QvIF1+4n}!iMAc%&q zub0JGui1mOnXCA}y+qa0+c;kAm=5=~u6sg+H5c4^E(KaI4|53{X(8k`lah9e@C~P2 z(y-QxVJ-y)B_Wu4a5{CZcFK8nRVu)#XFMKuggcZ$=>MK53oMy==ntLy3^N{GUO3kd zQ!Geg+?DvWQ>bDX!tjBq2OKFG_Eysy_y7`4J$~?e#*)Yfd&L}m2+Wy|-b+YVzd)zBslH{lap6xoBkK@1w=Xj5DO+ED6SK8QQ1pGa2~ zAx&!Cnjqm2jlZe9HDfAD$LYc3Qos+z^;lTPf;Up!3yJYGXf^~?SUz&q!8-!~64NR5 z`?~KG;%Ihbbokk^tB25<)n1 z$(b7|w7WYGL!L=zM~Co+odc$UZ%+r31scnph2*t3ePH zesab)O16{cY@;Ad1vjdr#dh1HI77f$2iB&CVeh1*Qe$3)EY0}FT{uW@PDTNTyAOYA zF7@^44>X7!e7wQ%6TC7>Htqxl4D$<1Be{?zI1 z!OLfT+AYXomYnwC%D^VTk?6c4nZi;zRcI>Y0eHAy*&Hb`VFAA|Ed;?&IEg!R6M2-l zLbx*Kii!EuS=28y6C4~47Ewvc(eb>3x4#2W+NmmD{GNb_7pT9f(2_=Wwng~FOYl** z5d1*g?>u<1f5oT7WCiSYI{#I$<5beaxyvmHhu>$uqRMWLX&)deSY2C&Qe^Xm$@Rba zDc|Y7d!m4-MZ5Y{c%v&56Shw2j%(C0s18}Z+7y>(@9}HowWy{^{-pBsN(~wx^3wnn zvXxYRhtWj=B6@_@WQGiUF*s_1Y7<3Y;D=vC6)bWfybC|L_IkAD=HL`B-(!Nw{7#i2 zMX4idHZ+PpVPD5=eBNN#i*n`M2^*@&Z0Yw^@&;u!74r)b0318z_7`%%$_s%Iw100(en|YhRx|^{x`U^H&Mr7zw3} zHZk!>@?ViYFs(NSdNvRJLGlqU>ub~0&(sfGGnayLZ*wz6SnmrmB1v{Qi}7xv_co;j z`fZFneu=^N(S#CL73qJ@h)pS>wl)GhFbhC3Gi@`cGPM@!a@c7Dtq4Yh*dub`)|;zC zY5rAF*p|j&!NOlxpwGXI8Lsy{6(%c}^1?=Xf|OYy1LvZ9{to_Gz9J-*FpDPU)#&B0 zuTT@~I@TWxc&dC9S`E30kO({&B3ko|wux>99=S3+=!Fi6-FB{sKn!=8czwqy}Hb}hR9KlO91qU9O#Qa{l zam<9)@5U_j3Zs8>ny{5NA5pyP!z^_K!|rOWZdD-a3eOXs$$Xi6LRR_Jg`x zqW|dg$<`~}DX&b0LxF6ZJb*-t{WiZGT&2myG+6Z{dS@}-jW1)D2zF66RwA+|)bi}Y zMPYe|`;htXwuI1M4Rf1}aGakG2^apY0`1qUQ?%KJOwCYfz#y1I#1e_p%q8T?BF5Qm zU0^ZJwfWYmCxSj6MK z_2)&!uSyw+H$)$&c!M-OldGn{&Me~wJz&c0eXeG)syBx;VHZ-thJjj{%EF_Gn=%q} z=ZcKFfD}|aRM3O!%Y(p5A}~mNy%I}ur~x;9DzfS65k{5=$?dY(o-+hXI4dVb+@QJQ z2szi;=T~&yWDZ9>g2RxKvW55#c*h+vPMMf#Hgbw!?H2A7;;Q(N>TDOHZ+&((YYJ6= z974LQAcq{cPI3Jw(`$TSzAzJ{-d#`4@SDI0KZNdL$n~?5O1i|)S51g1fQu8}&!Jgg+#9`dXF0pdnmum`$a+)>B(v-pi@r0czL^@#}VSN|1PZIKk1)TDJZoB_<_6f*1u3q zy<__)hI323b0c%Uhos?@e)u7T&WJ){b$wIi8d@a|?6O42|FyYC@oyNZ_V-|&W#K0$ z0F|sXuV&QG(oK@cwMtRxg>*PJ$YC8|LneYOO>rn@o{ltSL>2w<)|90GgPsk$Kru;d_y`)&a-@87Y$nz zfx?e1>6~54V^skYSVC`UlRt3y{4Vu0c&K5{F|B2BFu_HhB$&E@OqJxpiLC6SEJ(<+ z<6#`;WXv$sT9L<5lIrYytiC_O8g5^$o?N)7#e<-HF}xF8P+*{A=%ZQ0=5K`42G($M(dJTvZ1_>lmG2(}|rh3YkCiJWel?LRD* zbj%x;IYPlaqFeql1YRxennQL5QoXY48bKb|%GTp?bPg zhBC}-Vf0}=94!uE%)dspdShA((PKxC`DxtVDG`z85rtLR>Gz}=YO#)uNRB|# zQ*Rz(ZW$WtJW&0$OO8Y=wJchcd%VX&lXuh_G%>N^bMlT9dpqchC)HF%+O{ePj|$?t zW{_GrigoH&n`w0ITVz+S>!-WVzu>tFWhh`0U`jC-+2-S(IF#xsUNbOdY~b`qST7h5 zGd1>aYI?yq6rqfx`qC9E1;1UjBrRhbadC?H!2fmz%}(T597s|c6quMU`}=}`Kx8{i7}Jh$B(+{Pj)CcjT4#+a11gcxj_T^-+leGCzWUViCn zTZ|Xm7=_GKyF?bgN-P#DFCBx9G92OpPVh-gWfnk?Rh4yp<+oEhGR740)M;+*HxD+^ z(N12`ZItsN6>2MzY}9DFZUC{UKopc!ls~n}#*^xPVlfv%?#rB(RttmwX!-2!4MzW*jK-3zl4)Bz5?}u`UC3IM#U^H()bp?Sfcic} zB^Va#NbyY|LuH_=j+_e`E%Zl(Mu2k0+Pko+F&$a%;K+({5W^UoR3Fpa$JDH>c~g3gHn>N3jzn{MwWfku zzZ)jv3A%L&lD%!TtT=W~L(9EI)l1T6V=)j^=~^Em2@O@Rfd~a&>14|82Qu;eGyj0W zI}#%kInX6fE9l&8l3lgjZ{#XlfpN*WN&d8G$r4raRfk(BnYkEIh9)i^k91>*ea1KT zVs5eE_f*8=4JH{Q+9iO>Cw@3hdO3#bFuK$zj>4w78T-~LkpZzjg@=lM}k zO@c2D4riIfpDQ0Ds?$M0pM^gGH4V@*rHUmW8>zRPE>-B-#^&WC?OIj8afH(V4WxJO zJ3IGOG~SKT*i!kZBahNRKRSaZnZxb92CBT}KaU>Y&qfHsl7^ZNBYZJg`~u(YK!*1G z9Wa1WtrjMX8%}Frqsa$&Hs;E1!4jkdgA^Jl05AE({mYd=5=^1n1Ly3!qAx!JA1n46 zAVFEWtO-f{bwMS#0TsAJ3~%6c6R-A>n8W?VjvHT2@AqtV6H%AKU(b66{`i>31LdIH zgNN9{%H_(&En}j1k!r9hheEixQBj4U|9_ME<&iH`6!|1uOl?ZSTyms+`_I)G+L+7R zJ*ZWU%Ko9BK~9RZzaJV?fi;HOv7eq<<4ycDks&I@P*5shlF|)<+H6W>slx?1z$RIc zgPI6Ndd1)%&lcXrUb9b;WWXw&p%2FtJ=wy&KkdCH-QISc+*5lxH`@3`Yg$K&5F9a zrDKxk;a|Au5ANRs_`Hztd)ULG8t3Gq1;2m4_YNx$BDF-LS5DBUv72LVR}jy57Cai^ zsg)|HQxl(zF@ed^_-7$YOo>)fH zf&d6jT$)7E3kdNHgQ~KhA@V5OJo4}y48L8GDhZ> z!YL=S3Go%^Ke9@h!kfrGb035MpL`cnisTK@qv^9HM|kJ>xryef)DrG_Da|KAGE%#O z6m;8P6c4~S-bZ&ktUfE(K}O^0yJ-b(r(U);ut(z)a2VN6Ip=aLNw%-k(DVKRj<+xL zmJ>hr0t+jZybRA`%qW0Lo+*h-v)=?TQaD9oTMza=966yHcF z>-a9JndZ!?V-G-%Q$D1hW?X+S3p}rwyJ-k7wOYOhi5G5RyI8nyr;Hqei)wr2pv-u) z=SoGqRU~UxBuKQE0Xq5N!Q}UZ6TnhIBg3Z;m+7fA>jSUm9^u^-hRpMFd(6{RUZHEc z*j0X9P7cH{(poE`D{yF;tfD0mD*7CZlQ#*%+p@~gS?dThi_pCw4;UQhcw25?Vy-tT zm<$c1wwf^I7~EHE-7B7GD!*`03*t!CXmMOib z3m_SDAem|bRInD&HnWJqe11rjhJin$c&J-wuW zABNGpToP1#nJu0UF1FiFa5Sa$O_Ecr7*kJgc##gEdt%-i-ryl1uAT1xOOBe*;pPL- zsXu4HL0Z9W{QEod3&n=?exSgZGjG#&)NK|4yqE)WGuPpO`&~w!pFtdQv3#XCH}xV6 zw|Gj05&cV&QfyY=Ls~e5ttqA`ZEdk)7P4FN;a!MM4F&beEqzn=R>y{jPU|Mo#m=slNof!p4a*NL)-e~#w?{I(I?9u8k1|RZ4;a}w4 zxKa`8iAS`TwtTStL0j4TW2ggX%Wy}$^4FQ{Y1QL_F~m2c_!ivInoX7-z0GjmXzO0t zNvRo7MIMhmCrzY|^z$>;Q~pI3%{$ZoNUvl5NbdBHj^?**F7xJpKO4_YmUitX8*0AU z*kAehk{Yd;gG<}vY-HQcxh74iSq2e_Nf2oe-ZDM3UNe!MTYEnE+~%ZchloHu(gr<> zR~DVw+d&IthoZjqYCLyg_sV0TL3^rg%n;fMc$%6RtVQCU3vV9nKrVYB{Ncg8P}_PL zr!MHaf&{EE6yJO6c$)i|asd_X|G^cyXVx3Bqxx;~DWkJ`8_X%Co^jEHH<}BgS?;R( zRb@&q7~efLH(W>Mrv)f~4O|9CjvaT@UgJ}&Qk#?bsr&Pa`YX^orOW&@@CU|PsSs_I zBp1qnA+LzfAx`EUwI2Al18g{phr}9-q!|E&o2JBOZXchyM!zm)9B`Xm7elcJdwZF0 zRdGRw&FCkIdqB@;lfE^wOM)KRyxg!>QQVQtAoxqK!rs`h%aGa%)NKJL5gF}W=08lG zq7QsU9X-}<3634%0L^O~c?LY0@uxxLh*hi~7IR4p267$sJ4r2a^rYzOV<>w!bs%oD;7{NMH+)CAPE22fI70X?K|km9b11p*lUY!F3+}bKE17VjQ7 z#AEZiYXM2s>G`tUklj@oe2u9gm%{~9OK3FI7~_SuCArUAVPtA5(oHbj z18!7Z!n0YAzJ7bQpv6hWsw~~t;2+Q)?&z&hc6^CKU3`hpQ75!Ec>U+E`!r7f`FNt*j*JQ zku60>cnXJFI~{3SnK;<{x}%b<2z@?@PKSn^gVpo}Pq4Kh5K?~*`|c@7$@PiIx z-={ZDthVSdpu&fN%Z?|%jAn>_iv7FM@-5^dzB6Pj@4DJu8z>)1eeLMq^rm~FzWFN1 z>&HN_DE_iw_oE&-%4P{Ra2*yH%AUjc&3o__U}3p=P?e={ZFxzbYFwGZhB^`{pEKIb zF=d~$=ua*jRvCJLys#!_H}cV7@SloOnXDi7?F)UfuDSAOy^v7hL2O-HLSl8Z#{(dfF$-ISj(X@$Og5#@^SUi?gvoRj-qIrUX+NaBV0#7cacDTp{NFAk)+YE4?AOOE*4D&5tYeR%Skd>jDe`jkHl5(& zvY_wU6OJ}+L}#|^r=~umNYZ#Ma#)lo$N>B}H>Km&vY7I~A%i0Z-``*cvZ6HeL5q=R2*Va)tUFp4FNqG9qTlg zL$0omZ$0DX2OPgsRE%Ae6EGT^hYa}unH8a@)ir15DBQ72Phq7~cU*1aVo{-jh0&MF z0N$RdkAQ|qS8sg5FS#A6>mDoHl{D_Vvy`O4PQ~oN+~DmOaapLn-db^ym&mPepM2mP z9MhC>V4vQLObmh^PWs>BOw%;oww=s5iXmlqaR4#|I#lI{6wk+-1j!EEDl^pu6^FUO%mqWPC&5*s{g_c=pJ zv?j06{ccKA-Ad*c4O#juYh}y|CY>n|n>n%v+jA%Y!=U5_kyDe=Sm-og#aj>MFy3PE z5!#Jw!TaHlnl$^);(wo%axS8^bksPXeXZ=cRw5T)40R>-w$c`y^Cz~V#8QMmo5g{N z(~?2tYMluSe-)QKU}3GM?Ht}=`g2K+Y1&RYBn1_LOIr_Gakkflsj&?E5O3K)sc7xFViCJ$xmof`YOt80L&6$!V0fh z@kb40>awI#581(hGsUKCr$T1>C~$_v>M;{XNCYPophs<3TTO9VaFlxl#r0vk7%@7K z`yAl?lSYN=v=@0;!le>m)P~NuzIpxLa&b%2L$|8`Ou#YcnmMdx1xTyAn1Lz4dDlQs z{fS9t6h@Ys;Orkk{OU1K)TL^*-V01Im|O^_>T~zYZIqBynfx+Z41EEOYJDqgJGD4S zmX`|?{a&1}Y%eMV`kvfxtarV3?%*D$$WH@A>^z^ZE!BwY#2zoMN_>d#0uBG0ZxoAE zt}Rl7or?#Jdyv`yyi&2hG%=w0}+S5B4d`G|?UMWpmr&`4RolYoxxX+pASn z2OSanC$lREq6}4DpRU+F@eH5%09E)|8Y9R6b_$0K6~Z;-;&yI+=Lp4R3R7I-$^Wfj z)Ij^9eq_hYPNkTI*xGNJC!+=@MI=yZMPh+a)N1^{(;HzsdPOlKGSV8VXwxv)q1Fr2 zgR0X>yepr=CcMVDv@B(eK@!cka0ZX*&YwG$w zXJy|ml^4=_ChtF?5xW(2kZoQ_pts39Z~;p73p0C)XkK2Oe!x6gcj$*^f8k!BZxE|~ z${REd4n-mJrR>ajX~>zIBP`Z#>p`NxQvCZVW;@eikhp4YDpiNAgC(*l&giK2P$Hg* zty`W7Lrn>h2(hP(_?xANP)}@VK|J$L3r`_E;C%61%ITb#(9=4W`96SGa)42j;h6&J z$b;tk&$@L#N9#`H7kn@1QC=a(nlJCOpeB)RUXTuw|fFS*eBZM({dDl(P3KLL1Q1FQ& zwCT9YSG?lcpQ?&Ee9F==ltqjLEAE>v=Y+Vhr#&ZeW*Ac_=M+&NI@kh-2GX7t%PZ z4jLO+*j8xMD544%G}7JAJ={n$4JvftgRH3#!2POrJcM@Aoa%UML=ea=D! z>qrYZ$z4_hgbJ`~{FgE&x@smAI&z`i=sh!fS`ml0ndO3u*5&`s-av)G#qkxv?^4JD z+{P(vU-kNDBf3e2%iQ=iilWNQ*se~0%0lQGjyhT9C=>;WGsIW{E1HX!pzFwXK)lAH{ATbz*(WC* zv8(bVG0%|sEI5n^&)%jr)DH}iG#zXJ^Wy4B$pmTBf}73Xh-_*B_-FE5Bk{VPqEUY~ zs`V*$0Jjr!9#@k~dGqixNd(BbvDQCaGCm5Q5@}Yy2R$JBd=JJe=(Jm;f;lZ1XZ{GT zlN|PYNtCGV9PJqXx3BgK@s<@2yn?=jaR536lxnHsCzU4CT2M z7L9)W4zgIR2e0UQU~ zf+t+ffk;8NpHVV_(LTW=&YQ4yoJUX{(Q_P6z!l|nUqUxg8dOxm1SN}AQMPcv!a^0Q z2G}ZH>rD$*GUA=n5LwjY1HZo80kNG6E$5tjhjti)X;H2Yl%Y&W*FSZXL6GE>E*$4* z?Dw^6q(2HFS|MH-BQJTcAm(ImM7R0nuJN z^b`^FR8x}XNR?PT)QWeQttuX z?DjcW=^*SL)1B4#0@|)o3IlnB*T9khAKfh3fY8SwW~&%zOpmcRJu8O$liz1aa9wo4 zY9mbMs(PMC`){+n_=y9sbGLEp^+wB~b3SQ+$#mrUwphSSC)8_j0Pi2Nv*@O~Z{<@M zcl&;8{*Hh%`nyfFEV$LE?&Fy8PO172Rn z8zTNY7U1DKD4JfoRla#TZ8lFrnu$OtZNx7m`{fpM=H#)MsZbt&kGzf+=Be}2#=Q4+ zngN~`zgaO4)W3Imc*AbLIa=e#k8W(xI;y$&-{yF<3?yQ1i=%N1(!c@uwtODCe&ln` zm3=2j+vl?j+Zq$Hb~+|`nUW-(_p(O}68Ktd88>$*&E__q3R~r1@7g>r1L1@dT(d$d z^Jw0<-bPH!&4ZMvJ;|0|^&OYRPGN(IAwH~a5?^ab)|afw*-EAD#X*;LM9(qqUUh%y0g<%>zijp48%56F>h+U?B2C75Z^Ph%( zOHh!*h|+1QpoEgVF6&ii9kxDUz`BftC&d#&{t0Z;@EaVHDV-?URc49$N-oH?C*>OU za@&Ox^9Y}F>!$}pQe(djuCT5bam3gUJf;Y`V3_}A>(#~Ghgwm`RTk!S2lHY!eY*5O zPPyL&i>~s#RLVjz3>}6_?C=()akv$16%}h7s2I;N9DJWd9K zp(YaFX4m|Cm56?R!M?ST0kW$c1OhFt+FzacxC4})lvqi0PV+As>MUO%dvSB_Gtp@= z$XGgl(I6U&VKV>6S|U)&fw}y3ElJZAZTk8Tl8f2pX?g903#)7M|Amuh_tf^v znEv7zCcg|d6z#bC&XOqO)|g^rvb`P%2p$5y?Yx#@mzX4PHB~Ez2f$trzAi>}adq$i z3i#dChLK{bldj0!f(F2j^MWCcZmt07VE;*tF|spb24;bXsWFHszU#x>2ym+Q{n$_K z!A)U(-6!mqZboCzm_&guT734_Xe;M+z`d)5wXUU(ria9TNN*y)6t*n~B;(H2scV;wgl*fo_o^{T2&OVV@hQ9!-N7^T^cbzs^xLBz{iZ^T&5 zN_^8K1!<*UGuQDc_oA2a0{kwoNKM)Hb0cpZW+Jw>_oSb`WB!1|qGmrlkoijtTaFin3-0v`bAX&ua;%nnoCSTA`SWG0S zx|NQGdAh1iKN)(u53=1gGGSD`bZn#~JiL@5H9alpIy$*+ic2uN zZl)-yu`71Q9bFm`ccYU9naYJDRujo#iJav5a-(`kwK(J?^@SHlmDc<+pSG^bhuOj( zuFue;;zlsZ6gSg?N!v*Km;>DR5mMxgFjU)qHH>ib>;*!?oa)O9mh2%sD|)))V?Jfl z&uFglma%fvc9p@BSwjr747AY9iPO!8Nj*qvCRi|N`-&S$OQFljtjRcoaJe;C_G+}~ z5P?II{w-aZd~2p`DWm4IZ?XTFV(tqu)|K3@ABj+MxKGl%=g!h4M9%QpCT6$TD+7%; zN$KheSHD_YM+rn>^cq)>S`cgv2&SOp@!-XOs1+&S&-6~@4K94#`;rI*9F={S8;7$-+_ zGG#5K36Lbfa=S9+!%KMT!PTdA)N-)L)C=~*Sc$ye!hV8s)syq$Oie%A=OWz(nQ)>o z*_FU(z!IWW2pFfK7F=Kz(ImH)Az((gs1`8qvEBFR%QXY&Z0o5DvrE>A)0TB;BhU02 zrs)E7O8D!s?vQR4c7{u7GjUboT@+2fv_cZmyAk}t`rG4*rD2KFH z2V^%%l5(l&AA<;*=X~Y&j}7Nf^+z8svu4v4`P|>tM5HVn3~!LG4)Q)hpYc}GilHI2QT*VA?_l5#<_=88sH;0 z@$t1){`%t6jj)W!UqAUvOAD4}x*W7EkH$uvUAD&8Reo`6eWcPOs`k*c1YLSpj%S)p zRTnwI13BrirvckEtgkSRDkz@)M9^UxkrvEANDe8n%m#gu7~wG!Ht^81auBOpzS z;DBFQEL>}SQigN?D)$mULiovEmnr0-g z;sA$ssj|r3*(8t34}P&Kb(*taLW=Vgd2Y9?e4(Ze$i zhk2*KJ3`}A+C?97eRiV(`RuL+sfUOw$PX}aqxdO-JS zie4>UIbw0INcUV#w>Gm$=<9vOqdv;deX8FmS3^bmN+X(HgIW74Gu!>ewS9wNHF6sz zSKK~3W9|~X>8ZXTsS`VU8m`GTnDyTCMtkNA6=*)yk;?8h5FEFUf$S6lhj(eJH_N$> zE*~y?SaQ{8cDK)TSGL#{8KmnBrI`Y@%h&W#-e?Iw>-`usjkq0VtXdHTodY6E4>;Yk z=*P5Y55T9Ls$ztq77&@|&JcWWtrGH_QqTKjczZJRFghh?>vE=`cwK1_MF|hfm@~5q zDz8@k2`^KA1yPOL4JCC{TdE8&=nwg1jAuuObRqXpqT@biOH zO8j-83`|}Gmj1c{axqdZk8X?vrQ-v=ZtdUIdr$Hax=}$RlKr?R^)O(}nQHYra6YM! zS>?0z!(o?qt(UJb~|Ztt-1xz5scjUp7-0?gE_G3|*LdlraEM#7cRQw2m41PvN?& z7DQk&rM=}1v;XMpwe(o{NcknAfYQlP%qd2?*$RU&<^wJg;N3tSTOz--D8S0|EG2HE zPL*d4vHVZps(UE_<7-S)N=-q#n2BL^B=;}v##~0o7NEYc$2MGc%wLKU#!EC)obz4P zeFpLv@MeCh$*Q@RC zB5MI5iAj0Tpji=~+xIB(XvddX~4SCwJuvYaj{rLOWLlrF4Lz zW9`Dou-DHGN5|-e6W#P69flRF)x3aWMh^w$#jLNygwt6X8q5T^wmH-xWxJS%i41MB z3uk$?IYFO-GSZ=krYVc((Tew@Rfpd6+i!SeFh}aIgtvGPwHFLn~ha48jw5mozD|U#vt= z4=A>)gD~@3G)+VP;e$;~cL!UkS$coXEi4^=xw$=947-YEDiwGVl98~5s!JcI2>H^sf~ zLo2o8(<#S2kiYvz08=?yV}o8D7LtO;O^%l|)>M2cvHX**N~u@5%>A2f_pW&$a8f&X zT0#cF$bw(F#6>!!GP&Kx-~ytv(^4GR@{7QON%gx|zAo-_-Jr=lQMugHKH_*o+so)r z@6O?!j?vUOMiAjA%OLM}&xanBr9cO@48At{QTJ1bmS!-_MKa(XR{U!?JJ}-p?8`X> zk$^~!**T!l<6hih)!wbFU$;)P?o52;rb#0l!t_ed(K`0n>698V9E{so1&rM51^+y< z^2$Xl#h!&$TwYiAJ!Fgu_c@Nf&+vWF!4opizU9X92c5{aBHlp0cbeD{vhHS`&r%+R zjU)ux53ZeY8NitYl}9$^BLg#Hg@F&1Y7YtOJQlF{)MOCh_k7aD9wKMQZq}n|t^*fK zm{d~NTA+KX(EY??@X*KZ$T{c)msiIFn||s|Ql$9lnN+W`#d>f`w9RLaH?V~90m@zt zGM)DJm;#!%@+MU8c}*nAc-^B^$~wbq1^zRWmt%GVdp&FKCXnMtTLsTyDX-U_Eog=? zEy-{JjG3%=U3M(ESVi<6&%+UgNk;Vjz9W4(HrQJ<^yu%e_4C+bhsO?x`vo1$i|7Y$ zjG=(SH>!0AT7oOKnt1b+1;NFP_%3gv?@<=u5b~XOxjs;>j|z<92cumOgP5v{c-t)d zFg0U$AK?{hE=uk`>1KIC1z4I35=9C53NSI4MAvuyZkr&^LEtY=xkIG9$t@HI9q^!b zCyo1Ss15OLblx4yUG+`2viZ&7PHbN63i@r;WW%~ZT5;yBt9cu6zZvQ#sYnw z&!;Rc4Tb+c;Z6*;;k)8fsA>6lIEsbCyKj~Y523j3g0hR$OaGcvZ8r2$;44p#-!!@O z-0K*fF_Am1lqozq+LHm?(UF>FB~(w__U$qaUSnp+zUR*zgLota#8cM!C;`Fl@vtYl z)KDbl(8-mcpfDeU()`I3*^4)TD;Ow&tFvZi0$$W46psfC+$!9LA_~~C`)W4MJ=S(e zCxXSR1$vjn<@X2_gR7L^_-EPe@Kaotz>!1N)uqY;zoLR$>N%4=|LD9ZU97Bqi9XdB zCFY2@2L#pKtTzZU51E4gfuaxR`@D}^sVt54eZlIAF)1zDLrV{F=%m%5MgFDQMP$ch1dyH z^v=qCZMINs_j1hhZ4el}(}v$5cSr#Qqq7Hpsgo`ayg*SIuyk7meSHollUdo*_A;B- zE088JK@mELj)AKtK1%bunu`^)wwY6dE4co9ZoYSII z9Gyu9`i*@58WPt@2_zbSLsX98y)vVi8*7vf7@u)ItyHz~0zR$0g2?iseBTN&?_JMAl1sR%jUh&2XznzF`7kZ_D_bkNCHGILl(PMQ$i&Gf zFn-Zq>q4nu2<)^}JFdf-)xVKS-_sh#6r$1Sn{m{1kF)&$Io+k;EL;<;dulCLry*t^ z`)Smyb%0JkV$7Heit-)7xp-oyKt;tKIUdR{PND|2Ua31PX~VF7GVhfu)Od>eTU<-$ z>kKibs2rk6Jed;@_6P*pZUzx%{#oLyfJ1Q6?oijDBDYnXVT6DDxLkVgm+6WKE}uVe>0|VFqml*Y*t&P^`4R?N1>) zuT$bg8!bUN2Doynj<;S4bQYZf(dc(L)Cl$CItex0Yf1j3$M5S8mPD5dqx+UwXN!|C zXEpb@bOt1O=rD2nm8cS18$TUHvPgqsr7s0fw`O5nwh6>YyetraKJUc&=sfuO&u{Kh znxWWhy)bD(~@PBax4ul4HO2)wXcLv zsZL5TUM*7f*lRQz2JE>E;4l-b_e5b{-y0CIYliRCoul^fE@?eKZ}i?+uT%;(iBZT( zT^Q!nZ%l|$cr0l@!Q4&S&?%T~cw0>xjCi*LBN;YQ6A^` z&@#DQVtV*#Wks;B+LEiJ&MRshZR|uhM^UI}ert zv3$hLe@~+OGt~z@f&(G#jVKoZz-&?(`_w9EDv_h%eTPT*uqxipyL=XA zK&LB9hDn~oVmpg)u!7fLUxwCzbA|E%OouB?rI(ZnB>2wI*H1APu9b9mV(PJ``-`pGdT(^8EU z5wzFDi9kp%^_)p0-jEhD2eZ;sFaQ^6Jago&!PXLcBnNzQRwf7M+Bigc9RI)VNv0Gdv1539tPF*{pthbbaA; zjXG;~QU9x3f2`YS;c|re0p_v{jgp(ZfNFCe4+<8ZiK{ki@DaP}ENG+7CHIr(x%E3) z(X&l)G4&@$tI9=7NItaVG?A7B$fEOd+vI|b7*q#BTc160q!Y~ci-U++cUx|w80|*H94^KIpS9o*fO2Yujg}pDl^u5Dk#fhDD=;O2 zCCBSM)4*6dw^i?%nVvZFD0YMRmg8ZowN*wMT%6JcThpr80v``<0V)N)3P@Eiobu&& z+=B}^F+D(&WhVY}5Fp#38oYBMv78sp2Xg;vLZnKp2AP~(M`8jYi zq8-|b8Q;k;))Rv8v$Hkwd!D%7o+%GB;J0rQV#&FBC?rR(xA_>9iH=z*;Nlr#&oqHB z3CNwWnb8p#Juy&o2IUI7%l@C)6Ta+uh zK#6BVp=*kEE`?ARM9LmNG8w<SeI8(ck9N7L zIwhgw zcc51r@9l6F-CG_Io2 zfjCUhuLM$flTo>_3=^vkF6KWIfJO({7Q5T<5S;8E)sNPZhwW&(TJsX$;Rs17_GYd% z#_1_}z#}`9^1*ekWa|D)P5k{u0BFWyA}<9IYijv^ADP8ot&_;Mb~EM+H^8m}cH#Wb z{d#SJ9yL+sWA@Du&vJy>oO2#V@;wI2lEwlJ@W~(W>VBogUcIW?8VIoNlr`+Y**>%U zNM5&sD%SJC7*+kVV_PR9@lb{RV5|G=#PrpYi}@(k)6{lbecH~_kOVGTuv9w*R3!<# zgxQXR8ky!@LxoUnNn~py2@(Q*?z0F{A`VALWUZ$I|6>zDdK!;5qe`1O*z6NhHFYC# z^DwVb$^?(tDaN%dz;j_9H4Z5plBfF#5-uW#_st0|GmPWfTzGIAZ9!R0H2X?5GXtp& zYJTMlnbj0{p?eWo{O-=4my^hIk0%HaL^O>Vc@RBs_j8NQqOu!HH;^g>?}bm-dnk#J zezhKe9cFl0J+A=mj2&gGm~~I^C~OV34YokSOpk}I+J5foBCyoUz`6giW|StxpIGOV z_Ce1g34VRf>zMtF2)-LI#bLKdAcZk4EwL9A2mNEiGQK0)WR^vX?^tw?ebm@UwU(V{ z-zt+k<__^woGlK@aw`GOR$kG#!ppxC<+1Wdla8!$)zONEkm8U@TUu!O>+hHu7Uk7N zG3e)oLPC9h=|+^+HDR)I22Y z-jmD6Ex#pS=+$j=2N_wYziRYJLG?v}_hA+~nYq3h`G~fH-$s6s$@K!J6Lx;=o18h+ zXfVkHk(OuKTBdu^B$8z>qZrTo&Q%acTF?8DRvSzPvF=o!XvgTJ!YkvLY&4F;c{@W< z1rLdlRc<#H$1zC&lH^h-6WCB8ih4)5gyEG%vCz!@G$WU(k)ipNzCXc1w+Fe z(pd1lS=p9N>MUOeaVrv%ACnTM@b3_nf<*5Deh9@8!M6hwZ2$H_NPD5~a8q=Zm0JJM znSNeSCAq#iq714~&wIa{@Fc+6Uqd#=OKQ-mOixb%)epApw#Xi}KSLe8=T-38JMv(A zZKdv%A)ThZAn|>Xx+O<+TuW!{(G!0xrbINXE)N+h$kQ``P}5WDS(NVSp110x#bR4L5*0 zlUClZ6)9nvdq8})lw;@B_0Qz*l$7e^r&u_z^@M>6KmEAuhW#%$Lf*1uc>>JgUdT9p z46BA3E|m&k;oE33K$ls2 zEvb!SCp7xyHnF2@VIz!<=x9(>{h)c#bR|K2p@wsN?B#Vuh83o<5Cdu@e3$0i2)DCkFd~&o7`wx+g;Icrt8|MF1zkK-% zrhhZnlnx0ydu|`-czNw_DSoCl_opU%-2J$R(}druvDIce6<{-T=kbh*?+#sol!6uc z7ip&W?RUK1?ePxFQ=ZQpv_^k{kL{v&RsNhwgGmX#zPRzmq`9G@{$TRjSW_AC);dy^ z<}sEY$&QY31QftBLp9Y(w3&Ct7REs~`K_M+LVi1;;@=sD(^^4t!Hp`!YFuGwU-jR! z&*ZOWJld#CPDi%vCYKCvZ#l$5Vp~gJ;VavHXs~CqT}bTX0SAMgJ1vocEpL?16FtwP z8fkX}bTI0Fp900<+!J>Cm=OH_%=i%5z^a6v6b4>o6V(b(QY-|1nw|x!?9-)N{Md>; zOM8iMS;8RMc;$ocmfr^7qJ!DAlyusZ><&#!a&nG2asNK3?#bM^GfJJy0Lctrs``eZ zSO&NMd4igc$a{QBp$}$Ym8!6TRUe9&wqphK>pIn zZYKMjI2%;3C&8$~ulVk-=ZCIA!zb~j76R&$Vlk*}#~*sutY?!?GiqBIe)t9N zK-9T8iiz)1&KNtSEd0aw)GOwI+rav(PjuS~E={}qdX3bl*P~2l&-4Oga-VYAa50)xhok=z8ajf5lv-L{B zM?f||+=d+lXC^kXZJT0R(FsQwL>2BZVac>hH*76SX zE+{(m(Bs@Cc*Jk$SRcckPg@_!KYC0>SWAx#u*GD|IyJn|eh;@%*8bKp)$LyQ}--+oKbwGN~fktDnu9oK9LJ1VFd~gf+6S{<_7uCA( zImAW#s-w;ZYimDyzKDvx2;vqkIf$!e1YzNz4&jta<|9bC9_QQSID)`V8B)2TrntfW zrOQ!0woJ!WwZZhh$23^tJ2b9Xr*}W@<+w4Q0{9^OXb8eT$PC#Qq!+~MU-7m~Vd{gh z{jv82?xATjZKG1J@OI-TL+KD73SZzV&8igFpK4Kdds}_-K>qpHtK=QpjR-?t@9V&f zQ1ocM18>#TZ=IXS%>U*ZaXknDqfQg$qg>UK*Y1PtRnA}P`9RZVK^4zSRR&2}9E*CH z>48<;|0+&GFV0>UYCw+>?hg{TC*)!-bY#bg92^#hA|SCf`e$Z$fxIXz&0Y-u>XDkz z;X!05jY9LMCeL1$H+T%vaA4@St@TWJX7Q4czLg_kAYm!gkXK;wOOE_g67Mm-chvEW**Lxj9mT~i9{oxGmC7n``A*knHmK^Ur z`;otb?w97Nhi%pgK~Hr7l!ONBHs?r76xx>K(j;ypa--SM*LEJr=O1-khw2j2y6v1i z9^KC`uq1NldAnY!qM4g3p0qm65jnE+X5c zxO79>81_ejU5< z(58s{@lWw3oOgW_R55yADU$m+4OSC7nXwrRn88j+WRfZojyZ}K37j6;JL{K~RAH0L zAqQ2Hp_DDY5cg$z9UVN&Iv&WM-`^h|g81x{iG5qdwDhCGug3)pcg0$c^4z&Kwo!so z;K68kP`g#8RD(YD)NQac1Bb6~UF_I84h4{^*rKHb6jC}y353);+u^=fxRK8unkFS> ziW@hpw}WOI%sHhj356>~napv-I{;=7B=-rPB537+LouFRbTzduqHVQs(-ILRfR;Fq zT_{HRmGm!3yAuP))+YnemSvqmp#K5F1AjLytlh|II-)=P`O}kA%4mP+g%2K;a6u#} zc3hzqSD);<8lB(DC_jtRniSo8hM4CNuyHswLMi5nj3XSj+fV@K9`fdT9~9O?C-*YC zSy-UfhL~|fu%xy$a>GWivyG8vxgU9RAJl?Xov_MIKp=Qkd!brFnr=eG^!Jhdejv;~ z!Hc-Z9-g)xBJP0_cv|pOZ9$5TLf|9IiwUbuC%I(f*&=;F*aBXLMiIRXyU>F``#t| zZJWWdtRzca%G2GEIe1ciuix4V^^@VN8n?~8ii%-?4k0zuDfd;iTK6n4!84yTTe_AQ zZEQQ+_q*dLqw~}-ov8z8h0_1lk_OtziB{hacs_|rfh#4qK^wn|$zq3FaAZxHNtO!! zwM>}2pimow$2*THwU5|e9*6IhUa^E|8J%UGQh<23vk-4buIc7&=ya&GbPH&*rNzHc z-tVZsYD2IMcXVBgqKb01<3l4WO#7RkxC|&IVf;+02k$<^}QW~EhzWguV zm)${ro$ib#aym*EY*Z;AH_&sYs{y?1DJ*7*3~jeBO=N9Wv?-CX%-l?8#7Op8=?I0$ zGJTkq(*{BV;AZGk^)a5QUWbNrT;{m1QOW533$^T&4%xrI8ZF})h`&s?o~{2U7asw? z(Yt=;Y*)zak&?h+x$>3wCNTnWZ~-I*4Actj3hg-dR)!#g!$vl09$HCQ{_AdszJb5L zTlaRRm`)etN^7!#afxzjEtiopD3yuEpxHv8zs7oue=Cv=HM^6W1L+9^KTVfSR?(Wg zte}SIYSRine0+h_ExwuMxpqsJfO$pyf$^%eN#(bh;I zvjRyiOKSpSn0YOYL=M;em=cCsnB-3(1cSs1{>Nk_4P-i2zfGVuWd^*{WKf{jTw@=u zMo|q6Gxy9VdX(6{urR*9=TWK=3 z^*1Hz?Kn?j+68$Ra>{YnAfg3ju{R=!!boleF6Ledtdp8U7B) zb}5V}1LLJ5Ty}tP` zQ!w4Bu0uQfP=-|&pDtpxm#zRk8B19a5c_}hM`gIa+#NU(;GqvLm$jmrn{0jJbz(T6 zBo;euM`yB*=cd|QAe|3AQoho0OpP4b39r63aSTCaV_wCT z+&qBDp`r==BTg-w>vO^{LJS%%E`W8h)KCpU<^MqNI5rPg&%`GLWvk^kgvzPN@*u7& z5EEu|iAWHyr8L&eVaZT8JqAdUGmb?7XKkQAIdSkM5%QrzhiTl9-g0)Dvve|3L5E7v zy;8DZQ6CPIwi&;D$-GR_MOgdjQwmjrLgZ!+2aU~sNSWQJeMz!Q@6M3#%}656bMcu# zh{*&`D^G%q$xFS+kxDE5TNhRoHhbUH^W%?Y!3>o{0kw+&UoNLs{_*m4^7U?pEWWZ= zivC}!oS|ohXwxb%9?+$IdgZ?UU%nwrRdfEKc62q?>{^{U612y>bq19hr<(bkr zEP!6Ta%U4RLbvZn5WdMoGt3U04>x^M=4NTmNA)Hk6GB$olN3uJ7{^7Yc=4poB%PF{ z$E(ey@Bkw1Y@NWiv6UULt+vz&koMgp%QhV|vL_8B&!*|+jI0(t15<%E6ue#I?WU%K zWG$T*Yu9d|d3*69aN(pXI~cA``2i`_t`4(V)m^!NvYd~9teJc_ZoKfi);jtgtlgZ6 z#gTTh)l+cSC!ASxd#t|ddo~VfZIJW#^KM&6>vD`lZ=dB)#CQDy5&P>dGK14e%=(|4 zV&*t&Jx*W)&n$osL~J5Z*SrP;3gr9c+WJnE5mb3%8v%%Flg$Dkb+$$d5Afo$W9VNx zBxgk6Z?jl~0A_uY?ZT~&9%KK?xdj)WqHUv_$F-61`0g&}At&tZ-1D@pgE*Kl+Dh8( z{<6?<-;?iKZz9777j(`uGQqshT-S>SX89O~MdYmg~DWx+A|-=;cz8iG0f$|27M z5d><<{^9Xdmm`AOHWJK&MEL;~dpWxxQry!{?UA|=Es@{?nXIwwS9W&0!o40L_HBMk4VT5wr1Xo}?&qZBIlfNICw_Ls zO!=9}6;`BFt};nl&$Oc124lCU{1fryvDk)JEp;#4`_nN-^nBzJDIBQy!-h5}Fwi}W zH#5#Jryg#QNH>VM(5}hHe}J&!whVY{Q2rVw|I8HK9R65E58?)B1KRpx#yUc>O}7!C z3@w(!EA!?!#^`XY6h6<6*HFJ#-a$@%F$pknUKY&2IY6y9 z59q=SM+`@F3h`9VHqbtvi*s7JuN>dl@uiU#m{DOOm&IbH8q;L<9!K1(KhQ<+mu|x2 zW(S!n&u2%F`w6|BhM0L->=rP8)x5d64Y`(il3)4f3u}XyrFVr^I`0Qwd>f2Cta8&N zwM#Y;zWRelAFjrNmz17#BL7$9&rua*8LtfnJW?V`Fa?5Wrg<}DJZ`bz>3+I}I*g%G z#_y%F_f)e-baP3az?dB8&X0p|nDv+>+X3?$`OXw ze1S#W9N;H^-%~?E=6BkqkO2?v6#3PVedsA&zf;ND zuqBlTrM_{bpHl}&xO7g7YW0iTmcaW_0mVpKkrNyspN}N!rdGy*xH=N%SK0{KR#bpn zmKO%w&rSp?@l`Bk^E$+UYq6q^?;mosYe6pvzWJTb_8LQDN5r~rZBD`zEWdh)B+|fK5T}q zi|5zAwvw_6$uYJ#F;CKN39|T(=hU*_8iiLo(!KXZTZ}8Q=K*~ zco-#tcz3QBip!lV$=10E-YTyI0iJsx!j2?{)(%Tu>>7x!u$Om(QInu&lij^)R%QM0 z&QvJlTBivj2zxJp-(<=`#zxi?i+y`N|M{5g-ZEfWPRPg+hoLB)Cb`iO*h3;PBKMUb z86TcuSghdH$dYc4Qp4dCO@n`SPJh*YgF+yw2?F=va5}mju04Nw4=7d8vB;v;(9lkv>6?+w9v}OyA6IK{g1G&Di0I>znpxN%x?uz1Sgk6 z`X7&JiqO<*D8%&v*t>OX9cCmq4I=*iBy3b_b`c`|-XLDqkh^6_oMcwTBp`vhFD7+B zL(T4BGHm%@+4(Izp%=U+uq4_YTN+B$i3$sI1cSOVrhpL?bdUY_%Qqhar^Urrt4I_A zncKUD3jgN&Y_`?L*#7Bf5BV71=mhm4rt;c9DWaZogF5}Kn+`mLG&>tBIzS&47e<36 z?JPO|c&0JBLE;@sALoI{mlZjyMKbGg1Osb9zFFJX_6P{D^bC|_pV*Gnpt5`J0;F#;(YZ#{~|Xc zy%{(dH0}<{(6dDcekH4^L`0}Tq;Vs0(?kZrzl8Djo+x`5!r@vY&K@E3*ROjSbc6JJswG!wD2^w@$H1R2JqR z0LX<6vBhyfN0O@;4w{8$gYyb=7)6|dZa3N14P9pD=FbkrfwyW{jb*bFUiEuvYk z23+W>B12jhNRZ+yUP7_&`$4aoW^4`D#;E;e!tv=#Ye&z$w(+w?Z7sh7M#ymuPxQN< z^LkY4z_df{qk+a*a(7hsJNt*>{UW;SWA&UXbk=7^gG^CK#O{iPfmBmBor*$eCP7dP zg5x|WW(UN$bOGK(0!@oDj9a-@=Ejeo#O`C1yUE#_u9oGMjT{*2fE z4YX|a_0I1yUma22>Q~OkREoxi1zYF1tbs*Yls_M|gikjwgT*6HT{u;6=;EBgpY_LR-1`&}1fr25lSGW>fSK7Yii z?S5AkiR>ce+Y4BP-KaRjCmLVnNUo%IgsUG#K$54weoKXrwS_*|V~m7SDCE~7CczTe zeyz_V$`AH6k@)Fgvfn7bFCSI)M~{6>(L0@188Mx4XAGW!wWFz$V4i>nospD)J%oeu z%FF#E4x`l51i~0$jR~bMyX-6v*LL`73(9!zaEvz9JvlJU+AzIP8hhlM5)L-LUeS@)TVaAKr2+1@UW zqF#*>B`wIyjfKqCwaL(wOj-Cy7)akPj6&Y+BAUG8^{?M zL@(aZ89E#TzTmxY6dP{nXoRPQ(+L@YB-+1>G(czXIc;XzEFHEO)CEU;vl$U3#`5m= zc3*pme83)~pq_^(TDV8|d6Eo{0NE+eLx+5FJzx0`m;hsZ}WV*xa|kKGZ3L%b_c~ z3w3%jN_IQStN&W?&}~ChSkD3z3btI9k;k-@>7dAh6_`$kDU>X z5iqrSTgeP1RngT_%j+`ycw13zW)E3boD1?iBTQfY@ub?I`hgtQW5ZG{*@-1Xbu-5q zQVjkXL_}B;YI232(UA(fTLC2I!@ih2o6tX{UXlFD;ENfSDIj=rz7eMz$tW0V<9Cmfnq$UK5y-l==FwNaLi=XGW_ zJ|Nkk>nu04(vHJ*ibx7XtH!onfVYUjcWsKO@Il_sLhy$E!qf?HD?g%!8|e@pq{hpU zBaxVCgS2>i<%^=M-E1%!i>uFaK{rr_5;X%Vi8fKzzIq0NWO|`;gq^OT`+3}}yZw~2 z6&eN8uxriQq6%GbNx^IKIGMG=>Q}Kq@gFHLb^_*3H%Y7n6{&UD?1p)iHC3QoFU2?r zWc1>>+&C(;w!+1D{K~bS$83)6WsJ~2aGoU5oj#M-k$+54!5qEq(IWm{sK9tu<^_8H zcq73=IjI&niXh5Q0uw>!I;HOCQ*F6t=iO+Y4Ex4=0qKa>c-D z*l@)#?Dn|JT@hCn6P$Du)cB~w!br%jdttPX=ZrF~{7Xj`8+o`+qSSrKw`;&TknJeF zm)gt?_GE%rjoRKtTcVHKL#o(l9R7U_11}!&2J>X5Lrhg=H!@b)D*b~=*pIj*5Ib~= z$~n)ab-5J!cRp_hH)l43qgoAoBb#i^KZ4-hBt*3qj~Q}Z#?ebYL(xS;ZM&l@oax>2 zq$y3Lk>(7I6J>YhQ{L z2}M>2P%jkw7W_7PAKV1^yjZWUGHXs)CqU<4xSge~^bk6?0)Fx)la7I+#f63>DUNs@ zAoKyQ?COKMewgss6_IXlL>H%?uzf3Z6~ZUuGbd#Drp0F={ds=TFTt&{HuqgcZ9?vx zMznsV*`$=bPgc0F?8o)W_dUkb__5k=r9K?*x+wJM;2 zRkdi7jXM-wcfK4khGUY?;gM&UdB0I%z1L8 z2#&stU{pBpK*b=Qc+34-&~bJr+?y->n9Px1>_{H?-ax#Sb_(nxn2-%v-DE~>8BW>( zqUdsIwIfw&PBzs14F!n}npMMb+~`t(Zp5^wrUonHK~_^)e+XQS+s=@SQr4~E_J)9>5&;aeRL6)N+7Bgc=A$XTLp*>uLbBVMccRhkxdrW$XFK zDQG*9BFaT+Q0fTTPcXCmM`jE2pI#y*=u`#VGJ^_JH650LWfMVNv)g(O(Lz8aTH-hI zDsB@yIg`_$E;3r+KT1qj0eOr8NAaPq-hM^g+jw=c3h&uKJgGr;Qq=fCnuU~4q?!TY zr6q#%cLBoQou0ycMyAzzR>3aob*9M|Sl*-~_sn`$HthAvk4zU{v~dFQOKm0Q7vCH) z6I9UaP(TQwVpi*=T@`x%Q5&xo-PBjq<7Xin34?>nywtM$&ni2ad znb5bj98EA>Wyk&f9p^26LM{ylxlz8bNTb1d-mn~Nm`mI+x6Q(0fr&@4v5F*F_w^5gQ0NWqmfY3a%l{8<`^|{-UWWXW-V!+CjvDu zCY;!p9iiQ6D%IP@G5v9iNa=Ttc0^^7h^zicF5ecgZ{4H#jnPpC^7SD?FOrAXSp5i6 ztEDN-=i2y7)$MM;{?2tjZm})v(54!8Sf?GhImM8!GXjyAkQRv<{B-RyZd$bd`&Y6k zM#qF#vc8`^qeQbgbAzNu@%qAKwVrP3b3Y1z-ZxM{CFT?CK`)@-D*9~6KjYV`mNn(K zmH`7;rJY%lGg(!D*2_4=?wj$UC6lm!{u#cQ6L zN0Eq9FPs`(lkZCQ5&VN zcR?O}9*hWwtTx}Uri;{`t72LB7p=O5ns^)kotRa}dKZemDw5(A)#(m$Yw65q)hT<+ zs`Q@hkhXsA>fe&i6xQ>QpXK&vZO0aKe8}| zS&QA^dPNcVNn?H}EQ-R01Hq-$$1Jb2m7a2Ei=(8%X(xB95DKXzRJSg{re|cW&z38o z!J@WRemEoN(uD)lFuZsGGVe;$O`7d4`6ZZK5J zXD5m6UI~lOWke4(fIvb(&qAxFg>SV_44#f&nt#)b3+EcM3~TD@d5!s1@`=g?s+lasD?@bftu$e5Oc1te9}J>toC&v=Wr z%^h1YQ_FdNwNhjYs;GtUT)()A%>dBLQ*57{kxiL%px3v9#t!pKM~h)E8uvdpBhv0*(0o}ME)x`(?VorX-@&tp9$XRN+*Krx zJJ*R_4+V-b#}e;(Y=~0Q_FjRq+ZFFoC9Rb(vhLd*x)Ga&*=MXyIGutIs8*2sd_I;q z4D09&fw`0$r_me2w^S==qUXTlA>=lMnu(k0{%%w5zEtA(y;pnQres@nv?p)LK+iYT z@Z*rt8W?Z<0x2ynKn%)HG%jwFCuDN~C(ObEpLcD9>^w#N2ZFc&=TTm*8XP~bZP(6r zMxH{R+{;T(*V#CXMeEE;{BKKyid`8{WdyAdb{&Dog;sM^WQ|#~G|}Zl$Zj>pgB^Q} zLKGwJ;C7*FVSp$S?v+$PzoVYw5`ClNZVVF*rb%&3C7XB>2v`S9kwIik<9n?ZW&8t7 z{*bxAldK!Kjkl+#pIFL!R#p+2drls&0UXSWKk#!=b{1) zU`oLP4_0Vv#VZLoWc;Cg|Q} zi@cc`ja@}h=PKY9tLUUtef(`PxjOW5`GQz(Mmon6UJ;11htm>u)<1iwINiJ!n{I3w z&yB>jldlfn)XvOwi`K?s1d)DO-Oh1Bb&TN=&6zOC^0dmG6x}v~@e%lsQjP56k zA>eJ}Wq?ohINyQ+A}ile>WC-pRrY^v-pI zGnd~mcw30#o*Y)uVL-qzpzEXdL33sc=6_20{sMIDT?0Oon|N68p{ra3k4 zugF@4Uprw8{C@z!-rQ9rIZorvJk-F<=p@^_x-0KDW#GY^&Wp?)N62s3pxZ|K@vQH_;TM=_d5!Gn5Rnu84vC7M1~dXptE`av7rm|2bMGFx;7OpTa2b=hx@2Ld|S=XSMG|Q;*8} zKB5+iv6vs!yJ&6ZM*NDwL#7oca1GUIkL)pmBcQn`OiGIL+Ebl`_^aQdLW>jJr?VL5 zor+_5{H~a5n?JD!IVxVx?gw~zjTNxb8mExI2=AfhbwlcA3g|>!{LIp~xj|&8IOSx- zR;g|1*KaxshVf{3(+-V-9o19Cr(s#I#$Z>OyVrlFbzt*_Az z?}8nK^u*bHP?>0&X?Xeq7%H>y$>6_!x{hw$-Xl3lrKDH#7;q&r8EIAaSp(l~yq*;UqT)3k;r62x+pQ~BDbbv1Vo+&w= zu1_3`P_r}S6STP%>_7w_O3beWy%n+$__&dY#fPTJzErfL8Q z1)rlmMa?xXYc^JP8B~5TCpnhA|1Tr1kq{H!@zfAzQW%>|{ZG zw1PL=fS%re@v*XgI5soEhYLly!p@1v{Bc!8u7T?C<|HPg*}Xr18*9dWeX$IZ*E+>1HgRT+@4 zv2cFzJ_b_dt@RO2G+MOQJt9m3+&+O$o7z!tfhN|gN-1D^03tB`%)5UZVP%)-1ZHOm zC|9FrYaJbqCq^Tv-mgT2o{(Bn=Sa!iM;#9fl$Z7tyX;8uK-R!h7GB4auuRX)Ma_oX z?r+JQNscJRy^_(APy+=yq4y5NJy{^(xag1B&lYP)IY>#$3f(c|?+7KXN?(sO^jM0=bH zD*{U$gSdxhfMXx<9ts}79*^brH$H)&;?WldKo2tdaoS_CDMwf<>FB-<{#O+;BZ^Sz z%&u0Dh?8Dl!(l1CeJ0D8cfEA&p{@mWjJp~~Uat+(QD|+a`I)|4Xqozrewo%>0SDl4 z5EX+)KeQ|gygPmQw0s*i4!d}Q`j$fo6#Wq~2)2lhmbpMo@uiOY9h&PM9g#c}9)W}r zLpeAPIAyuC2b8Rx#ptVpEeL_v1dOyj3QP+oWlF2gm~oikqrfzk1BgHq^86Mfvi+0f zbWI;Apw`x;a97Ca=gAfM*&akT;9|t53g6x=F>($~eMU0Qp>Q4AO%42kIv7CW7x7wF z9r4{H#xP2i!q=%l+k=eUqeYBKU)7btn&B<3bIww|9F&Fu2CD&~RgTSIFSbGN6te-t zj6(1H_WQU9QA!Kaj1>v(uRP*ZG6H-0E5b}$Z~6n$XQ4i``eccFd_=go&<)%(@5KB zhg8gWiS?e$(r7D$$LIu2bcl?@xsRe)KRLi#2$7R1ofNi^d|W~f3tAq?#Ux&A4rroyTx?#TxP_A(nu3r3iZG zb!6^!@hQm|)K9P0HpIRm>@?B>`z>og8*S^A=)66m-m(Ypxj5zTSMdV2=hN1c29Ga} zx}9iNl(=JgO=LOszK8W4!gTk)7Xy}S+yEzMM@G&7o<#edyGjRSZuq@eES%)nMRlmV zZB3XQuZe~S*eaXG7QnaihG6E-4`n*GjUP7R4*jIQvoFe{gjIR3>gN1)3C|ynFu$R+s(MuSvp{^^vzsv&}-mT3g%ZDj2N zUZxpIX3)HCZ>|CI^24FFZ?_x${`K{;yTvXL`5Ac=lMw`TuK2DF=c^}TU(?7s-DBDx z#rk5J2lQ~4{1>Tl2fZ*KGRv3iqpr3&ziLLV@dhQe7DS;%frsDUhoS^G6Y0ejg*g^9 zrMA8^B842v8wKqhi9QBgH97b?!S+rg_krF}9dXb2$&mHGAvDM#{?{H=0je&;(iek= zHGxvp)AC7{@fdhl*$Civ*@leml@#J&0+OprmHqyXv^3t_C{;uQ9joQ+*IKY?h4%wX z0dUwuc(Fv3tYYA{Mm*_s^1iEMJS;mF@-3Q;(mRe$gtr`nidcQFfE}z1s}t_i<`(cS zl#VPey0)}`?;E$>RR|qW3(!;a>!M&0Bz*>J8&KchBl$H77(spW^?!86q!YxPfX1m+ zm3f?4guGDHz50D@qPxkPKz_02$$97ABjgMN{uwl|W?owBAd%&#KN+^hu-XV!(bjGWUfS zlizOuTl|d6Y=|n2Ga-xZ`5HUef>fODv6Nn*TXfj=8Xg65u*iEI!RJtpT-V-GNXL24 ze|bG<)M}|UFBz(0ko+F2jDnNW#Qn_+)syf5fXNpkfR0_Lu^Bb(ZFjO~8ym1(G5>pF z{ta{I`Bmo_XFum&JyA*!Y?bD}s5b-;T)iF$nuD>{Q`&Q30tWe{A-$3vBU~19n5K}CrtJ_&#RD$CjZbEpt5t@F{5VZisogk?O$^Ze?R%kj zulS}F2WgQ-ojm1MRW=3gFBeGwt!~~@PYtl}l$qcdS!-T6P2XtK83fX;+*-?*4su(8 zW32Xrd6};+b|${&Ct8gdk|#;!s&>}E@Fo2qR=(-tO9H%28{v#Z^?`Z2hx5(!M5)=+ z(2{lW6zUUhsNMBXHN#Tj81CoFNO6s^5F_5S+>>Q9=hO}n*4XcY_Knx-=>t~1$PzzC|ebB46pe?tf!jB z(m+x{jY`gocE2&xQ;#)X@Y)s&O}u0a7v zOHVQ~Pmi|$Jl2co^AuBvcB?EIf6s3NI$hvdd=){M|H*+A|JM#-GYr9N+14}2aT+eu zJDwahK9#BEB}>`})67}e4$OyCH~11!*Lv_b6l5{6sey>2!_2TI!-P=DE`4H#06(Z3 z5A|v^RkG&ySUk&upl3;TN}CHu`zp4ddIODtKL zXEVG{X-Q)N*B`2N_FQ6J5*OZl^1R=x)sBH~*LmonhD7;lBb z$|#moYp_?!G%9VugyD0)#o|5Sg@4BhwMI0}M%Gu~W{haCYVl2+?@@cf|9u(M6=a0S zCJv9rxbN2HY)|9CAexZrjk{Hyv@aHYsrW__214Y*)ZV9bXofndAYW|g@?l}&l9U0; zzfDuj(>#G!M-uAbEwfIRajgc#&nQ#e(>M~=ZPX#yYHTm6ww{^7MQlgoGs~|8!u#ms z-%}`?K^ip9WHt#d(|Lm$P!x)00yaE)h+jf>y3SuQKzsqzKQcfkDh@7JD}X>+I+9 zDQ8{(E(lDK-N(3BGBNXk`@RW-f4G>UZmIpZ?cOlPRm{TSrR^K+3%EbBf57X@Cmj&WUN=sn}YscOB6^2+cv)UsVfpWbuK9vbI1InMwPvq zoOj21GV3*zj8Tx0LyVwhg(GG2yDS4p=hl?PGK@IQFO7vPtRZ~>Z7dzjpxbH=;~E%L zquK}$ebfC1E2^i=EGOc}UI||-p)19Y_jNN5bWeVsSS^r<3&9h~DpgPbLqNR0VBcBq zhBtH3yA1qkd^Y^`m0>I?N)VB8bMb#&gnaUVpihgKW_nAHTc~3jScH;%AVGpnNm7pF zDVy2UkF$poR$!yhI|Pfe=0c+}z1m0TC1w1QHzTRQCy-%^vMM#-f%R>R#j=SjI`!8O zS_BaEfsTmlKLwk-bUPsG?PcOy=2_G<8w)V;Jj9z6f!cZi$nc3LW0D+)#9p@z|EJ{8 zC~BWwn+ZYX%3^xA6LrL(HD;Q!mUB?U2*sXc{II+R)(1K>X>=@H{(CLCO=c5E<{}BM5;|k0yhj=E|9*uc2ZO=^B&^vU)OhQR08?5|1`Kc-tZ>X=&69h;G%0TVWpdh+qi%%$|& z^Y6tRdb!+8mL&9N9Y0Q=5|j%4!XhFppvV~9gZU;j7U47}`#RP0jmrVl*J zuV{mE4wvr5uJN zi+w1@fzv}GgAucD^v3PhOhZ(1Z8%B$*Mlc;T>8g2ZZWA50dawJg~sH0ocJgvP{iZF zYJdxI@~Wfr0*WmUv($ zJ-^<5DKn`)Ia{i*jNz7I)ld>4qhY8a-Bir>9Y*-1pNYkJKvZ##5Uh9F>_92w%+kUM z8CvjL=xv^I+c4;=o{PTw;-ou>V!zOz_lB(^+dh@o!1k8 zhV-DN<2PV}EgW)cJRu+VUpgP`oTinmumQ@Vo1e3F(4FOCxP5WP#sfQ;R*F@mvH#S^ z#_W<;)qjX-=sNyj{6(NxgmWQ_wjtY6#|M6-OyLkvRjZt1!q)iL*}|s^4ju79nKH$w zXoe@l-zT|@I3u^hm4{1G^_rPf*z|HGQgC-);~=zqB2<|rH|RX5Z4OV&j`^ldr^pYRgRk+mOvgv}Wv@fHMzBi+Bk-;_zjADJvy7Xpvyz4a)}T zP&38Q$9JE5J5i+tTBW5^z1tLzEn>{sgVMpS3FH;M^6W_RpL#zfGW4KnQl!;?%b!RaKQn(gS9QBLVS#PVOV%bsrSA?^B1h;e0CMUTE!k+-!)grfzQ!;1D&I5X5y=mVA)T$zpWh z$8ozL`hVssk1sRmRH#QlLCkrq^)1AiA}sL5LHbWXPt7QX$~avHg<6(GRoLG&@_A~z zHjb~om89PDl_=EpoDH?$D#=;Bn+>QBaUqy&NVt0-n}+8?9HA2!>+LVxia1T7nVrIE zR;G4s9x3P&J@tOFG&J#wScT4FYn$&ck-wYZt{B^jleR@w5+;Dk2Nda5d64a5$?%%b zU!N5+pS=CZ2Ky>GKWQp{e20?%ua>;Mw_o3{on^eB@dH5l{$Y8wUTEscd~m|1udaVx zhQ4&m9sek>@K|)A%Kz(&n!svm1J}OZXGj3q;hL(=^@eothKFQP*aK^eNRUH%@PdY8 zYS&$Ey`U+<0U$+_^W7nexHTMWwGE-=oicc#-ukO&Kv!V7hX45%?sQ;5i~n6#Yyh@q z`=g%Hplz*aK$IrWlimfmE6a|&w zLRka$2IvG*R>rp>M`4)XdH8t78YnnzDOIOv9M*`_su&~3T)6+YVYd1U=!!>-<&;4I ze#u{M`O@tj9UOZo;8FwJRfB`fQO(xIut85{Lui0uB({?4Gax2KTpl}qyhe4WDPIE( z8WbK*8^#kqA`FXcMu$rXIm-nQaCw|GSv&Zu(3c%)5&drTb=gm!olq%(+Rz4Sx(vt4N`W@e{{*Nu3dB1K!S3ORgI>s~pG8GIja-2Ow z6df7ZEIM%AwB+grm+WP>$K$2#PKc3%&t7z`akaJy1khWkRRJ4WvH0uZ0kS)I%ufKE}I|(1-t+Z<-0XukCjwvMeJkZho{=pZdUN>U@Ai_Q)&I zJ7rB6z!pU<&~EAY5`vCPQAbm6(^i(Sw`f&|4dzfdhAoQ`i4vrnMPNw=WTSo!qrE@G zZG%*%>qJ`v=tZ$!>^NU;{d2$})O||$GFw@zfsLM~M4o`);DlS4(-W=l(?iQcLX-Z$ z31NO!5ksyb75Z}R9C`ZCqGcL#rr*BmWD1bpj?9ums9R?cDbpC5QQ=2%5G37e#X|3_ zb^nXgyywY0PDe4K7^Ws`zuihD3?5;3nKd&<7Zq@0>sD4N!MBo3>FS5=#xfwlVXb@Z~X!XFiCwZQ37z zGyQYkTro>ww|wp+w|q(=RsP%F72K6d37(Lgf%|c>xy@OkQG@6kux)x6%8=yQI4ysj z0D>^*`19;zN(*Na!de9w+byl$2r&fk=p2rMe}Zeol$p7CxJ?tQSb8-IjpJMv_m?}_ z6k2q_$%znWjC7P6#k}1!OZdWW*umKXVu4=Tub5LCp(H5CC~?qQO{c*o`DzQ4dg8FV z`(|`%8G^}GACOReV*&8CMnz5~xsNT|Gr^%qWX`#-I7H^^`H^}U$ex2KQ(tm1J;;N? zyuV-%(3W>89jM&w8|Hb0usk>($=-Pn85-OFM24*Lm`MaXKKjJPP@5r9Nedy#QU@zg3YSCr;G^>$5$GaMV7hz6H$$Q;N-3+u_+ z-M(HPaQsn%Anh>scA2}z#DnsuSo$RL2?!-Ar(zP)Xdxj|lX;K2aR4og{T*KyuyV)) zn{cJ^7{Sb)2LK2}Rg@O-b4X4BY0Axhk{$pek93WR*EfW)!Zq5tcbI4JHP4a1Pq$@P zlq<-h)?Wnj*%OmJQ?WTJ4|=r+kF1)meFc8}Yp@H^O;9eT@Vj*=W6NVFLOT1R?NlZi z-8bj$HPQa5A*_BbOd6bj8R-!IjsPHFF52lvX6t|kT6>!)k!&JZ9QP7zOB3@bn{17K z!YXPzbyqDm3KyICd<*DB){E^TGHJYIZ=-;KiG}kslmp^z=*54pb4qM1 z+?L{+)ME`ReUXd$0(hoB!dkz2F$!h{o?+lBpYkJ75xj{5+8$X z9U{xf8AtR`xwf4OuLP|5UhmEbr7u;ii1jaGXkj%q`+SLqjB@dHDe0IZj5B)Hh4U^n z!;~{jM;HKY;EbDc4WvQ^>MU^`bEBkJht3B_H}%29P}+P1KHRt<0+e=DxWzxGH-R3@ zr~eJDZ15BmKEFZ`Bo|=GD~+jZkqY;sbpj~+|Cs+j0>ndvZ9=v4hF_AhyLM7^qmlnmi-gtq$^ly!} zzk^x(YipuL0l@jaNm3&yYOeGH)5%6F8>bdzYPB|!rsgIQFaQ?H0QUhvnboZ_obP9T zx)RWKyKuBz*-v3|BFrag`un1S@O2l5Y0_BnHXny!m=}HElhF6hDc<5g6Bqt?KieE3 znW)o2A@DG>j@7%V+SmkQIcj*e1pOU9D)m;$DT?w(D#)HR=_*- zCFc^w{#opUB0h-f5TfRtxXU$*CKB~7ZKwhSI(o;V`y3P8?#Yc5=}BASv>k1;0@jX_ z<%i{epz-Z%)x0iA6R`s|(+UQkj-w3(Ro@ZltHyC1KYCSh&lLBe?=21~@^;0k2nl@rLz8!My#v`=NG^(W ze5KG;{BUimcq}mRnplMyJPtq_^MIjhcI7FmAD@U711$UsfL*9w$bPvEu=oh2GTl;o z%3A+=TZWQBdqbq4c07>u*C}*G!tte_R!EiHoONL9gJzx5I&ms(eIv_J8ECfPYz~=R*jcEU!J@;W9JWs_F zJ;4jrAXG7OIBactrgiX^TPYI9XF1KhG31)cXj(u1Rf#D5Pl!dn0;^8Fp+#n`&xE@Y z&CD=o3k4))D3HHQEa~ttOYJDsP9`1sc^@O6FSFF>9=$MMM-PXn^O$Hi-iH;df)pc& zZZRxv9w<&MU}eC8b?*@nNq+Oy2=~JlG~CT%fcNFyo)H|#t&H?GQLjqyPSyMZ&NAfF z_qtC5Vy4IYe?0M@9^{r3WFvPN(k&!(FbIH*GJj>D$G(`C_5hIbOH2D6z-$e40WKn7 zSkw)7*)gx(>$Ufv0IL{47$UI@2d1rAct(v(a4SEG*iAdAuAjA^>IMCatG43bqG4Sj z-8hV1>uMCGXK|!PL9OhPo(p7ATTHIdth0pMgZVY^aJw!M*hA7V!A^Ni=zGwrcL&IE z-oV(^Estef?|PGeQ_AjqT*8&U?CnXTYN?eJmW+V91&bVMye3kI4L59jplqs7skCMa6Za$>eB`!!=}L4TVp2s9UNrOn}o~4db2-y zsSPW+seZN9-m%ggZEz`af6&AUyn@Ik3FLFtJGgCL$(R9^X2$i4tz(a^cqFkZVp#-- zIyBno8p8fa!c_OYu~J}?d9ssIuDddN%2wcXM^u02*hsi`hn!!ccKa+G#YUP>Ek?rP z$Uzgs7BvtS%4>1k?34JI2R}SMN7?uSPLkJ>z6G9!MjPQfy;EE@cvQ#Q6tgBe{vxDb z2Jlruw@!5p1uZp|L%hGVT6{05{V7`_`gNMf%aqbWnPUh|9?|Ei*m-9u9Jow_s2z0A z*FM|5n%6d3<6T55>JvG_)s?$=8clg&>^ca7a)ky;8>h7}l5z2iIBIZgj94m?b;N8- zEQFQ-8@s=*SoC3+AK|Bd@CRhs_Es8q?Io|a3dqH1iiGulOBEqr5bEloc75m$pFSsj$CrV7`{~WUE8fyFz8lg=yWpYf zUz-mqEUy!BBNdlCF^0xP16W36?~?54jyeiauxp`?-r9aDOmDWG$NMY$pE9<4UA%QO z(i=Hs@6}d?DkvM)lkWmW^=iVA#4ni5TCcBCk`zjX;?H1@*Hb&1`N4bTvt6=T*E)=N z=A83K^{NHkob^-$nf~d{cH&eBQ0@=&@cbeOW3@-%Z}US8|Ha7~n(_zwwj>aGK8+l^%QT`MK8Ok3Xo9JMFHa5iDm5BZDooBTF| zW`pOW~-1ayW34+foxzXY^?EiIDCkUwvn5t@=dzUx@BISR9q7-_9+|$ zEluHUL-`DA;xTTn=g_Q(VTpx>nwrpuufdcti+6hW+4r@oyiJAbV4<0Mxim$o)k-6u}H96Mb>Jmga-f z0w!%J%9(2H1gPxh5mLlV=(4%H2cWfM>8QQcL_G0vK9dTn4eET!S;`8aLAx@E|fpWp$t2lZ_gZ7LROt)a<8dd9jtXeoyR)8obKPwJSm33b3lHs z4S3B<%?lNeU^}!UtfZ{uDhEBb*=2sxRsE7zINE0v1jhL%c8vgI#gD1@$szYcZ7$y;Mv(xyQ&?kps%t$HTF93sbT^jRK6#uj9&!0qH7$IVZ}A56Gp zX|M}U{g%Yh2MCygM1usxw5QJLIvn(}w0_;IGJREXQVSbF2DtxT559!RgIbRPkv%O7 zwKHPHyj_JE?-6;K1Ek$6I!Xhvh=np9@^DweD&7Ait@@3%nxRtMw=|UBmEyf#<|o8! zADDhb<+LZ_Wpd(T0ibN*%v2F&e)Zs7Iu#BUi9R9+I=i};;y zW@yc`1!0Sl*~!)x%jbNqDAT}QjVfKL1roqM9fJ;87|=RJyQ%-Hh$+v0y7+2uZ@uA_ zfb_(fUtYFV;o#cRcneOuN^DA(rML$<4+U5m`_^I0XkreNQguPJsI>0^sklCN6!B7B0ohoqi(7z|> zJ!HHb8|)7`PYK!Z)1Sn^=L_V#z_1y;uFB|OYvCgBqLy!XOp7mObb90EQZ~?l+DF#}FC(O?~AU4*7PGB`Q~x z;vGWQK>> z1#DB*@NL^AlSoSw@2MZ|-Gu$c2s+3^E4*kJ-Y3`q;Y)uja^Io4a|>m?B$}hKFWw1R zsK`RoKJGVm+s4E`5-3Ag2&7}_*U6L>TU`$jAK^~*hEE%(FQVpCcP9br0>FV6Un&u3 z+E5h;nhw=6{Do@4h4}zB<*9~InNs-vR^ju~l8CgL&|O`T&=_>iLG+?ixMIVDe%57g z4*ynb*8h>oY(82PP!j)hoSU>Pv&sS;(13tkd3W2R|e7e#Rg0G?Fg8G5T(Wp24eEssCO(&70tr zmNYVOaKE=$C{N+ri{RYk70vTuSBXjuzl_fY|J8scygZ0G{qxhEuVKpQ@oIodg2y)!4?e0l8!o&nUmEo-zqi8ZXtjQ za}mb?)>SN9i+OuhlLPpfGfJYN+AW%uy_^hE{BKNej_5TiKLI- z(OPC|8<$*WAB$f)Y5c^dIV~`IO^vGA0lGr>FY^j-ufjK&^>Ixo;<-i&x6g%WM(6cPHUW@|8m-H4qR?=9__fM6?0ifn{fOm2=+{ zX^CVk41i1}=f=AAW@wc04=)(&qheoEBY2E|sP(mEJCXReW~X!23J`&F44~<7L5tGK zsc@LOxUa_5*&PLaj|QEY2wO64!OBt(5|!(FG;)7H?%m~HpyS?cArz{^SmSC&ffhkg z1v>q=<&N6ZyvO8Fa?V%>#-kA+OW?PNdz-i_vCc&e^YSYBUqj~a!#_^?n9-{;pwV{1 z)))G1Tkt>n?(C;nTcsCIO;@>bznQ#1V&GS#HIG3y1s~^f?%WT-XRV`HIVaa`n|M2k zK%2xn0M}jx&_8)1i(cWbb6kv|UdrOQw+x4)dgdDh?y#rEoKUUo+qwj)L?+_Asn;g2 z9B_L;i#)@p_;F4f%u-aBNDkOGe82yvpbVvnJjJa5??&AG#ZmcR$&$x72NHEi=8{*E zTX4Zyp5G*WO@=Te%t?45_~L5u%Al4kkmNC8?Kc)GgS~7&+KQnDyAiH-#*#aK2e_^^ z9?Y*EE+gRm%r^^tZHjFF7xRm`U+0uCq}25t9rP*rcsns)1Jbz+=3QBfw}OPjhlO2! ziqQsGE-zh|O>fljl4Ix^NmCF!;}%1i;RN?W?jHm1RAD)G5!^eff!CD*vMG8TUph~( zZpU+%3xTi0o}0uu{}qW>oWqxCdJ8EJI*|bV4SD&M3H! zg`bpSOayMvXE>%iML?4`r*79TIAA6IIFb?Ek)K9jX4WkKx8>odr2|jxH|W)Unz2&a zttZo3J}PV3##D;VOYkCk<=5zC(oQu+>8TxHWit=@g0u!EMV~Kus$D}|G{F4CeM#4M zulwbSKJng7lMt)APa%GbxQHdcTSLVZ!Rt}sHM*=%WXfUMQ5x?o6n~9OZMxG7`CLAe z8dcu;&-KsCKMcY~*yH3%KmiK0c!B!wE`^dtK}gx8)uxt z5=uiS#3<%}{jk;l;tf0M#Oa^w<<4h#9?V=+M{k=POSTM$ATK)HANX8-4ZIbM`*<4@ z@!9|-G5_arG{;^5$KCf`j=T08tFYjwdFb09Gl!bG2>8LaMEw5ZKBBCgA^W&Wo3dJ(&+2`60KJ8wWg3QT&) zPC$l{7Tu`gk@i6>SM5Wi9Z33fAWi+lx~~nBu%eK6)Z}}syR2(81GJF1;kmcteK{LO zjx!uWu3zXuD{_HemGJ^5wM#LkhA<)-3IR@{U#9CPniZzRZp3ioL^~*qyU;s(ZihtJ zUPl8Q@zd~Y^AYYZMBPCmUNwCxUExK9&Fz6+IJ`~FYsi1QoM5wPU!2^?kYNtum=>xU zkqEyD+PB90Uqmnh?>1N{L-&vbf4_vOAw)^PJxpIbOuLYZi zda0SCT5G0t=n=%Op1%)htjeu<9JcRjN7x{>YOB5Iab=?I05cQjzA_&dT|oLd4zn^R1Ux)+2xf&rIR^8HHeOs##3m6K1SxNLknUs+&;M~z zgqouO=3xf~`Z!zyv~F1xd3#4_IXY;7GizMW z%<7bennGo$f&+VfN7m&q=@!$gX4@$tL1@Ztcs)BcpswJ&IrS?{EQhm&;sFVe&?F@J z^w1)4964EGLEWhz?KeAb$jIcc1kMM0&^4Lf2DI}CiQl4hUI_*m#Pms)O+hZJ<5rR1 zZ?)1tvg7XnwZpBdQWZC^GitD3j%t)8NlU0!jAmyWEIdTZx_|Sj726eops-^7h=NYD zL7(j5GCz`K$8->WhG`EL%0EHI1qIDm4&86(n{a3=!Wq|YOyHarr4cG6ZfyOCN#?nV z4QFC`Wm{F4IO59e%#Ucuc!#aQ5v!@RFc`dnJTAh-TG_Uxp4$@3&6SSw$k6lppm`ZH zVZ`%^KqR*Ox{dQkOI}2`Lm#3Z`fL)C`_(+?yTq8hBT)omdI{L{SS*hr#&NfP-zOkGU@VK|c| zXOnEB4`UsbZGes|@>ia5t)@iPt@BSj7D2&k$&Wqw2mPl0gGveVM*-6$Lkik%7;Ef~ zYgAbvD8z+dEiuI}nbJjUfUoTvWm~i8m?$$eM^ue0;X6`R2fBGGZm#%Oumke7fP__u zbE*+25j(d*F9O<4T(@mNFU3-pB#)rwvOX_G$6bWX%)~b(dL0?c(u3&8Q(I|8(p=J3vhFc0aA4WxpYPy?;I0RVjeOBQ$hHp+!#II*Sh|$i zh1h*;116*Qo69n1&67w|T3*NDY-&XpnrP?EugWo1p&2)6&SkWvckg~$3(~Ph$)<#< z=hgF5#ihT8$gpvFeq$MaK~y74z4R%I^l2eY?esiT0CegJ^faIO`&6>a)9SV%ms)|! zZ_c-i%m*u<-__k2ctASW5I6#BblO}`7gPLgZ8V(*$aa@kvl4~5=?LEgn;A+`1?lnm zk6NW%J}G2tz-*fV-AMf~Gg`Z3g-`{wIHtP~A->)U0AKmHr$fe$E68&cwgm`j6aQZa zZw=pE&nkV|E6ao%_BH-tT!^5VR`LJHih2CMoU_TVk)mwBDJ>6`Yfy-C7L(7>)v}<~ zX(W*3t-~LQ-edaIu;{DXt$5A<15o|x6F}TV ziJO7@I#N^ch73CUpm656F$*T&S@xR>CCi=QS0yL!S$@!?wS5(`+!M`f6KM#Q!v%_4 zJ*~O?MU{l*5r4JGocjzXj`pzTfn`!{@c#2t^|%>CRX6|ilCT8PQU_PP`=#%8QN+aT zAVd_G>9R7t1!_4tUCMB*EFDLjz(VblxL`9EIFz%;yd1GXGl_Paua;Ur%gj6&MOGbu=sgSm9`|)5{2nE)G;9`;_6y z`etlXd@dcxik907inOY8T27*A#}xgJo)-jhax|v!N^7hum)Uu%S6odP)2gUv(?y{* zB*&Ne)Ll@rHSNJDPZ4p0O*$=k7S1Xq_9iwz=ZMTXHLjuWumuFs_J#I`JI2oBbZ8_h zF%(k>;krGqlP`sSCu1cT+8?{bCntsgMvB|*4LJ;H4%jjWeB5BESJlf19iKfCJ{-K; zd>lrjnO_rB65K*Wr}GgmMWV>d}qN=SjZoE+rd~#@2x5G zJ6>t7|WqyW4G{0S9LdmRu}>ZkiNYrhs)cF*!n#%U1YwW>ZKJP+7%k zIM&s|*4cO85y52-SRa|`04y205jDdOl5_5-!~YK>juLG9lI@;5yKA+FCYCWOxe9AG%3#d?fCccZ{RRNCy~letb6LD2b^wl}MMXe6#4- z@yoEK2BKVdVf$ayAnuqD#&cq2UbqUaM$P+d}H$tn@9P7yjMu z)C%lI!mRZ{ycbjx9^Jl`{@gKIklw6U%9cl{XQS|;V)>6>fj>s0WyM=L!eo`@H+HiE zI9fR(^%Hae5;Pj!i^c{(-MgALRn^a*-^W({C$`nNu&p>`$Y--rx{ofNNh1B7bj8W_ zY?!nHhbD4m^MZL6=$Q*dM>fDIO_7MF^hc+L(<`hvbUH7NeP<#`Vl2F>GuubF_B(^zJbs zSmdZHAsqJ@7?)++1UBJRchF4RbpyvSC~8s}5q1+fe+WC%P%|}=XJ0{D*6U!$%DntI z6B?F3kW-M^Z0na}Di}ht^r#a$>-6%dobL$!%20W3%R4$h8-WOHnk4yewV6P3IPN}MO8f^T@>8m~YA;-Su z3&*2lvXL>Cit}BWAA50;MCVf{d#}f^x;*N{hngzKn|d6~l94ky0*8@LhnI_EloLGV z2=o#ln}c2_e$qk^p+pgD@1hF~z)(vdBHD6d>^@&Hc3-A;I53&Lxo#44}x#k{Xl%Cw+5RE^+ zvY^zvbI+ZHC?!Uq$fMEq?)mTR50QLorv{H%7X9SwTqrP?p1vAzNYF!kjWPvS8LYy& zBb>3AgQGWtvPCCJij2^FU)gdi+sSo5vX~kNlyXuuIaHBpt87_zduh^ zq-NsvhzNYbU(=qS+aNsE#QR(0P>Fr&iS*31!6%avS{_PTfe`jO<|#jv!aBQ&L+UQY zBDwYyfX)c~pQ7(Xf-?;SS?ffeZgjM|%^dx1@Qs=>AgGr>!1fSQ8kTeGlSCY$}5(E^duN^HfBjT+FMcQ7vknf1ylt9BiCFB+^K_vr>@~J`Q0Xo_rXhP z$^g>M&!l5<#8N73qS!X8*-LXS`pb;~8{Cz)GHaI9Ht)}o6c_1 z_wYcAONN|#;?pBtu)vCx$2J?srjjVT@87dg4Hc}`LqW`ZqJZ}67e>Co31B{yNZwYf z8f?pvFi}dtTzf}}3U2gpJIxf(%dIE@7UTTREUEO`PwhR&4Fn}j{)}L>Q1Up+OdxeQ zs7ZVXouV9{A#cbG>P4k{>{9ArPuOs{N(7}N2ydvkgkX2uU>sO7MT5{R3s+cja`E2V zXXQyayb!cd(nt`?zPn&hBab3|9{$w(^=j?8l-uJ`Nd(4wX4#cU?=t-lF5g9!@akh2 zdHr*gIlE}fRpCvTOBU2_2jpo6{)`$+Mlz@B*L}X>@M(X({ycc-yXlJjqLajc|4XMI z{iQ~0mjr2KJ}k z?;YR|n1GI4fZnKe(0BPLhn<8d^jof!74z-?Msn<$-9ms3od&$Et=GAOVu)JGVFZE{~vgbh@x(p7VlkLg^N_yl>xOxOf z7t-Nqwz7Txs)4U#FUgu_+9vw}flA_|D3|S{z)Pwqwy+o2@ow1M=ctu{3@MFE+kIWI zO)J$c+KDlhXZZMv0idXhQ6^}8x{CZ4OskyNC%Gj)f?$(=44B^@inxSqV7ZI!|8H}D zVvWu8IP*Q>z~JOy+UrojSGw9nUf^zV#)EU<@QIFWiLC^n%ORCW{pvWc+IReOxr}3U zN)}&6x!gPbEjO(T`B(@Z%pe8yYNH%ufQ2A2WWJV{tjLQTe)?fOqwB+lL}QHy!myOE zM)sxP9fZgUc_=cJ=EF83Axz^B3 zY@Jw#q$-i+_j2I@#H0<2ee=;4 zhHA}t9Fr}R-Z=QHB72J@{4O$$x`uf)HlY$|$?N7G;J4G$r642>{wWPab(=Ag1$9g! zt3GLi1K{CY#^?h^or-GHwF^Kqu{Mp^rT}(xc5+HML0P(2u$&wvDT8wLH|XcwE`e= zX+7-AmHdZ>E>cg}XK@1I$q*o}<053g^(2#z)^5SW?30>(YFF8$tqai9Zf59$!f|n+ zO?pT*p4Yn4S9^HeP;Gi3sW^}qH5FUb4BL?sE}$`_gt6}~dN~fCbVr%Dly;7e2<||lY6A}ad1`Ex8@8c^EVJMi z8)oT&?}$ys0K32Hc&{_S)6dgsj0D&zM(+iP88a0NU4;xpme<6Vr#A(!dOmT`J6K5| z$DsK=)|UsQ-zF2obk>%0RcR?RJwI9$(1^wQ%~Pyq98)*fV6TiMaCCom&C<`0s;jH5 z&1Y=U&%m{w(l~%4wJI-K-3}ijKO&bKG)cx1??`;cLN~eX)w7mPOysZ(>|vRz)+kF? z{w2TdwC7Cbq8T?`prbgdTu0l-@I+RBr!A&}XDC`iI_e&rDrOW5unha=PKiBkOD{qG zcBb}*uQ~D7@dJ#BK2WGBM2C|T=>5M1$eXJ+_D-l$GFIgJ;gmN?ki&_@{rxhHK`f&k zLh({4Fto>or|>1b;Vpqd{5D!CU`nWTBf3MHfgLM_PjeaTW%?bRkDxGDG?KS>c zNNvPbL(O3R(TvVDvZk8805e-kytDL_wC0Q7&h7GcS+ixq|4QToCMI2CyF@%SCA>Vp z!k!1Y2lpSx=22& z9W6CWgTXy*Agf>`NAZseA5|aYrWV0Iqt5IydzDbOdb#{G?kj+SPn6q8vB;zbJS8MP zGta@bYpZ&w!>%fGA8H`PsP&%_Lo+c4gzzUFPAuLH7nOnH&!xq2S}n^e$|jPHN%}#K zO8+rB&Hg~4JAvF1R;d`l#7m_hR_%(>OZCCUEFUTA`X`oiB6Oz zP28r+uwc(a7Sdr;5W&Dr=@|3nq(9pO253`rd)I&b@LdQEWp=v|x_;gCrmmw=91iNn zcI(Gg_FLZ)cl74qQ!A)BN>2*%F2j309K-`E35d7X!Qoo%iK@t$I)SuT*cpPi$5I-) zzY=4P1kPkzi|4nZ1r^8!XbIoI-_?iuN3xcGz9Pas1D{2{NgiGi;%sd~DBDK(J5YF@ z>lX^iaoh_M!`}A@HLQaT{{@HD!}%3eQrF5E*K2Mp!5J;Zw6-PX8zTl`O^##7-O}ur z+s}3aYO^vW-Auj>kPgSIKU0EbJb&@n6>EK@sO(lSek`<>W@FYjLscEA#&F=vsBD-k;-;_|?sq01BEy&-o%AoblJU;ytUTwF5X zm?YNjQfXcNvZ{d`ulWq4F;AQq*?Hc)9EUHcwrS_|DTZ>{F^YZqx5?kD%+p6(GGh zevDvnlmbn7ap5@&zKpZ!t^Rt-RH{R@W)A)v2|#j$M0re5-Yl8DN$<$cn~bh^n-TUY z7t#yDOI=k|dqaQB83EH3gHNUZQjlz?v_4ruX{anS9#Uzzz0S;Xi2e_I2%l#o*pkNV zU@$*LJ#x`AIP*euG};-Qn{qQS{4`ul)~mDt$m`b!@WT2;fct9&REX;Y_Btp}YD=jR z-0=0RVWNFooH5Oo#aBoJPN04L4B1h8p5z9uTmfaEBg~-1 z?E-MSbKAo(;$z!&Y5as%d&GDZVf`7d($acZs<#HcMJR8D)JSg&-x_@8id}NZTg>zi zMb&WypBAzWVLeFHlrkr=LfL0ahiG!sw)-5xJRYZ_nj;tkpgEx6$^H+bL9&@?nvCg> zUNf+Rj?%;`#}EfyDur58YSQ{Zv{f*I&+Hrg?23Co;Qiu>v?N{@w_Pl(9!CwN;Ea4A z?hdSGwK@-Aff7@a;pqC8A&GY*BaopiXa2~poRnQtJp)hA?&RBVR;tx})YD%diV7SC z$Zv_o50)fy93)m-4u6uz3-z-g9=$nA&ps0|Ca$oA^!LjDbH!bHh>=BU4A{PP{6l8t zSdE8YT#FxiJ3J|z=E08RCQ962hrzm&e606{5^w||DnbSRLSs=BKc>7k*%|NWAox>& zf)xi|%^lC)3;CJ-)SS6_Ee#kd9{DpFcl}(}>g$V!3ONN^Vf<|{{Y{`VG~o&I!(wKU#(OGR0a^T4(e+mXglUAbQub6s8&Ei^-|8G&&VDWEC-0rlO z!S%1+G#>!%)wO+foDVe>wD{z#5EQ>v6CYj4{9T_+{xR}K+5$IQ<8P&@eJIAF@^>AO zCjG8rx~&OeL9nY+@g+!pZrMRYjc_jAODz4bCUF3pHA>4x>{z-jK%x|?;=oeY_1x)T z0NJ(v4Z(6nsZPyE+}yh!q)s3>t~RU-c%OI)n7}?Vo(uc>rX-n)+r_dxFO{LJi70y_ zy2xLb&Z>fHX+r3b@wBA6CJn+SXj&o^F-{4>j1(j2J%_C-$laazDBTw zB}7$%4OmF2F;I|zqMgxVL7bvaEx&zhc3mhKCj(Ldo9RQryW;dJ8f9Iv@T-1_x?UhY z>40r-Ld|f0D{?NY4l~>UIY7q0^^i&B|Nl7+@idVD*xFxfMo(#S3Km>|b#i==j3v^> zU#g>8F_r2_00vBdN@NGin5srG!VG6$E9gVGrLTTra3R+s@8{xs2(UiBgG0kb>M@$0 zJY#qpy{xmwnn}OX`7d=e_yiFwN86^6-M$8csXW&?yU1rhcF^}xhS>8gbfZ4CCvyZR zW>a%fYppBWVsMv;#o=jCn@pPx_eAOfBqmVSEpM?({84d?C@kBCAwvP!esy!TKif3G zzNqr@n#uK2$xI&sFg#hbtg>D0snit-y_)l};GksDUjjW<#;&tc$@t>*7k4T{qPyqd zycn-{*CiX1gBC!YyRsJ?0(4YS%K3hRepH!F7n@JIZtS4y5}dba7=&^XB$Ai+erLOk z@`C{cm=9U58P4s$m`|6IzF-?c#tx*m5)*!~xCtnud(<)2<0Kb*;4mu+3iT@i~^q{7Pa^k?C3-We6PKcqKaJA zEfjmZw_~Jxy7n=MxBlN3J5OGgbdRr@y_Y4A6g;i$q`QezupP&lZ$;?Hgr?iN0LGs9*1``@j~#3 zUNQKZD|0QEi_%Z3+w=1qPx80{(z%EhdWHVx>JELOezL$M<-7_(=I}< z?YxNRz7$j#m7+R>@t8@vG>bPqqsYYasG;qXaDjExI8r@40bKVfPVo zhcH|@Er`E%<56UN@^C$|Vzc9`iLx^Nso#z1rUdTroOjfr>#+9b1m_1KSsz zyO!%rDmG%orDn*NaRhpYkKPn+ex$XpxBXrz#3qg54G<4$3USC69RsGjiffDgLN$-hN_n6~VcF zg`x;YNu*E8k!#~nHH>-)W;8&BR?m_eV5{J=kU4iQWSL*{FQ!PC`0`|9YAm)k%O@nL zZtc#q+yjZ&bhz|ymw-T%Z#-Y=WBWY+u3)^FNKN+I_p1vE{?xLXWM|^kVrg39n%@m_ zyq%Q;th{U`-6Rd3BW6}Qsa+Z4$^n9bpev;Gh7SM=;3xfHYWXm7j!eA}g%UaEuawbs z@bBXb%x}_<3?!!GX0cJ6kqH~L@2nhomkNFv_MY<$K+Rj`7N)Jm!?1q%;G7DSCEyh9qXkEtS=Rn4Q0O2aix&jeaNcyqprKMp|F2>i(8`<&G!#){& z%{+&ft(>(cIx|ZhXyCX5g*K%KG5-MM^9U4CmH2$j!_ynBumWJ&@fOD(Rb#gz860Xp zDOMITDDixbLnTyqe-qM+0QkG!#D~EEGTHa-`3i;z!tMqczBeo(ofbzok_p)-_K=x7 zTC7dwL;py-sL`vCe-B*xhUazqnN!`8y0;NOAxY&1r0Fu5F)~T+NK_we3$pX5tOtwQ<%e^RDpHI5lHk75EwH;)~O%WjDUDtoc@CRS8IXDAp2H9d$#eDh^inb~6o3 zbswTR1>iM6o$9jSy)i{Pu~13xNwizl#E8K=p4WdWr6lt_$RRGYjwjhj>1k!99}24& zZGXm6sg%>9@?GNC4E7J9k?Hvj0`=6tH?l17H7osza}{6z$}mCHAfK*C{~sm;9hNc0Y0LPXoqm47Ozf;L+H{&{jeK$jJ8FJR^^Vj1l*azz-AI@NzuHgPcSfeZPs;khNQ%QZG8wU*x zLoITg7p$Ag9cCs9GxoJ3abH?RfJqeyJ!x5#3$zFVHo-#(cp&leM&Go_-VS$$BTvWB zLZ#a=4T90qK>U@EjlH$ipb?EgBF9_c1Kjy?%Rh>6@76}E4DO`fpdKu6-?RyldQjY! zi_A{XLb5xN$LUCOBrq&Yl~FOZ9DwDE!J@i#JQ0yuJnx<|vh61~E>%&Eoy7yf1OKfO zyQyHw_0bIRT1Jds@e4nX8x@vE#se;$EN1SHiAGlzrrKq1;mAs;s7L1zt>&*D2fA3_ z(AMAzIrXKeX?q8)FJROEJaGq~dxq|hTwcvs{tA~@I_k8`!HzF@HP^$c`HKXeKZ^G_ASqHv@XzV|hn!H3OK$BWxdoa>H+ z`8fCg>^LkhbMxPO^<4-TnwJ|Ppjce=+%$M06nMzeHDQ8)cMyL)UCuS>jbREag!2DF8vm9I{Q}tN#oTn7{ zeTFTgbw7bI+=A=viq3HYMLi$=LJY_wvb0FPmHZh2VEaPpC1jou$bOOU`&WL~1=A|- z`zxkh+wnIXM*ZlOliT75Dljmh2~BG-{;}25xmdJdG0s}5q0QUh9*e@=cOICh=&;)2 zN#Qp1z+6smCJ4gM1O{@v7Kq_T{6l5HK@grrhH$x}$^l@#P_Wex;e_qI7SR++`mPo?TiJt2d7|(KEUwLf0voJvrU~Zt z{JzucyhlAV6wU9VZ9;PstLCphSjpTU_CB}f?NorR4~5_*3C*HAmrLl9#$3IkE6%0n zXD16!PO6ocm)F=cO#=9t8v$8i9vc+-isz=x8gy-IPmO86V5=7~CQ|sggwSWRfno=h zb54(;F_Ot)<-crh6bLk(DVfw~ux*I18Ndh%2^NNAFdcuMmrF5%1VgiG{R`GUx6Ny8 zFDeJr8Zr}k{1kCInNr0v@6TFF$pZ|UR!sCw%j%=Oi6EsRd+_bLI+NXZiQyx~f z5Eqce@*_9NduQ{%4wdf;bh-KM96r?aQxejPyX@usxm@wlB-y;;FKyYd*SBKo46^wE zg=t3;1Rzo?ZQ(8BLU`Rn@=zH+3!FH#RSgmRB*Yq*xZa!cD0?4DZQ=$1ia z?uuyer&m!M+O+1O1U-$s>dn%DJt0LUg$?;Y7{8TQ^`(2GGJDJBnijP8^K2u6unm<@A#NUzRR7rkETCn zh8M(xrh2mSQTZ^dqL(G4AoS6Zidlu&BfUEx`Yz5oAwyhA-tmQC1n>+9u5}iCC5q#bc8EuG?3-zFN1VaXPkCHot;{5wJ-J z@%+%X+-6slJ@1>`9%d(&CfZ>{Q_C5{+__%h`@gVC(W6Donl}aZng!>#A}^Ersm#cD zZinnJd6PSU4|(NPM(`@NQW4D;-O-TCag>I)(8vD9!qEa!95k|hEGfm(5xSW92!3RV z4*Ph^0;@mw^j{VcpRTqFDX~qOoZS25h|e-ixB)fMZ+7y#beYcEZ#_7at&;{LgXdo^M=u0K*qe0 zOV;eYGLTt1X{PN^pD8zSGLb6HA;|@nv$w5N1&h_Hon%_l^}UaIYXH%2wCnC4{~<`Z z1$+njt61D}S~kS)uFqWb&98LDP}#%BqLRCLpqp4B9cZ8ppNIIEfgjeB-V`rG$UK%> zdJPV@c6@(HMr1=qUpmN1jbJ{CIg;$N9j?LTI19T1 z2o0)R7wJ2_@eIp*TNqhMz7XP~##)ZO8Tzp;stDgsslYyb8u!L&rijSyrE_=MRhP_d zd9DXrqf~pC{>u zk<7|94U_gOoggLVX`nA|v<+RuF!}S)7LLj|IOYC7u#2iXLrpD;*T{EhaB2o>YK5f( zS_o~UBw2OV^ab#c{jSBFC3k9ekdXvPGaeil#Jxbj1Z}jC@Q#yS(fV8P=i=E8n&miSdGF8B)nOC-875NmwF!$V3EQgh3WiEr`MvbDU2V+ ziXf%pFbKyzTb~VxO3r_GC(cr#gX54+J4m$51d4D;6uRgQu?6B1-%5l&rFo{5?~Hw?k)%fTm#Q=kK5{dHkpMr-dsN5G`NrF&5@jo$ z@JmJNTlbZ?vqLdFDjYjMfP^9|RZeJ1Q3?;T$pQ`NmfG#$G3-Rmg;mM-e4s%Y!?3^! z6b)@>fU`Zk?9(X>YH9kMNr`m1$;*P3Z^?QKL(KxzjtgT1N z-vNh8P|*59c++V)OhwqtTK#3=g;N7Wf-`si1T z?C!Lm?&4abYW7^t^ zo`f^zQOGpt`Y_L-0lEMQ0MGms(#d^xIYvNaULoV2)|cU$(Y&Pr{ma)crI%|hRt}@A z5ea3C*#=L3ix=0CYiNE)*F-f^*#3hwBCkqidXy!dXWidc%yfv4Di6|S2NZy_I3kRgFOI|xPTS(xIopRL< z;`%HcL*W90a=QBxN)lO2q`}eG_uxZsXIC(g|L`r9#axcI;a|z_q4;WBC=76p7}L0l zuIO-wY}-R#rh05pIiv!vkY5KkJ-hCjc%0=Gkq|06{=8qBO2L7Cxy1(($&l4@>20806L0ATL*4=O5- zabvk2Rk#H(q4voMu-ov@BL&aXsyPNw5kNiM`rS2_*s5?yn83YvxZG6K*gt6Zq10c; z-;?pWmWJ9J2lJzDYNM1XW@m-J#KeO9v#xd<1HWmR=+kfM3%!QdOg$&3?&xLY6vQT- z)mV2U0Q~Z|%a69w*_SO|TM?VWqF2-NaQo*a^2Ap2b7#{2F{Z5VFmr1lxN4{qpbt~O zUWvP-aHCmCBL;jllUV%?>R^aiQe2e7TfAm18c6UNzH7gLn149@#Altf>tp5?|A7z; zbTXrRssu)JuLqr+GVscS4!GBe)ZqdClrr$*nfiqQv;bW1Aa@rps1G6#{>fj$X!8oi z`+0S_woECc8RV4$NL&HeAYU4k zVgul!y4fVv3DNnW(3%c$D#r8L@tLLrI+Cs~;b29^@_*+82;rsL0vyFC;cYQUqhhFC zDEiIIBfK~vvjl*UIB{}V2)9@OCnnKBbCw%?@bsP1nJMd#q>vpnkX=zdQS_Bu$<8|! zDR3tShsv35R``JX9AX{Tj6`%-I@>zqcl$coL-lO_&R9&8wPsBya4|>cR`PWlqTUGBDB&`{A;tp4RLC^vzlOY` zz-eq2brB5_nCSaS&`W#1yQ*u246G7K7<4_98*#kC5l z>f$)+cvtB6Cc!=@S=@+8f$M?El8yAGWxym}@k%$yAiHKUDI?AQTgaU?#yP*g`eK3Q zN?3dM16QEL{=GNk27M!ti&*d8_w8NY>Si{^w>8SKJ1BphbSj4(r#)Y4I``r|h#cwS zWq=0Z*(`N)0UzzfBSqcF`c>hlHBe}$`ihc=Q3&6)QaTKQgPpP4ZBW<`$Me<8ZIxuT z{QcbwgK;r#rpf0waesDD`2WNic=mjodl8WtzyQ2JRm*p?|ez40!>c}t{ounNvgx&FrWnDzI z`r?c{5gem`17h`O=dNVnC=*rR#wL@!qzd_)dF%MZ>P3QZUwT6!!f9NGU(MN<+e$^Cmez4gMc5ECcXruO|-xky^wS0<%= z!F=C^<6)tZ&9KHQWCU3$2O+ikHh%^#H_(uC{$>=4*upj`9WXW>J9exS;4DoLJ9r$v zltnicwNMyiE{KrDC^Elzh5CNC0@4;B&YE(?78E3@M1HoZ9?p;?rM#f?1`Zo^;HbvE zX=p|y#LT0E)m+%FDI#;$Imv~9VthhQP04V?1-bKtFi0PrY^OAB7<1X|NC2EoET$f4%22mRD4HG^X6whbLD_@=4kK*f7@MZG`MZ_s* zhCS7`NR>KSuJbx@OV?N&^RO>{hh`|z$}tIk3kz!>bRnVj`#*Og`AWm7$n;i#ey==c z9kl9o{JG=>B0rW_H537A9FHg4z^w7NeJ?h68qE~{Y&>E4em^lb!tK{Xw7NltX*y=Q zkqVYGTp*NGe`3Z;F+!;Vt43)a0sd(ybj8k9yYt8|S-Sayo-V4+V~XLjWy0-_*zP_e z9M`+Sl@Rjp|K*3)xc8G)5G~h|$Sh;?{F~xRb0HFPAnda!rlq$r{I#k1yt3P15n6c| zGMoDYUMw&($zHv-mDHWd+0yaQETlr4^KBVTru&K+w1_`;2Bzl=>(%Kl+K@Q1}UfyNWdu;c0M_I&0@eseFd|*~)ok~Ws%Ghsy zbdx0qdePkB4x;%=K;{h-if5H;&KdaMM7=T+w*HA^(uO|*5W}MH{{g7a&4$yjI}D`E z{d70WtEpX}fJ^5at(Hj$-K+S6J@&&(I>t9WheD!iH~)nk*l1{$EqU%%4zZsyWW9bS zuAe1OOQoCYROCm zQf@!hE#%k6W36AG^B0XluNh(|G_(6(m}yDoWws+vBslN4@CSfMq^=?V7YPH+ks5+# zxBZ)C;Dkpd%I8Fc+xa29jv6x8e+ zYMNAmQ=(=_bc3MOGfvFnb|hz{i9m6A7>=@|3x7#~7&lC&4tRNcG=F|HB`b?kXzcCg z1K~*GF~Q2u#Jbz)0aj4@z+@qtY{Ma*oC};%^d)gtDFJtu z@ShahcX%dMEXLwsVU5nyV@Mx>p%f2!@a*zYo{7;|SevUZGPGJkvs(asU}m%9$%Jar z2i;atm{GfV6C=wR&w1=d@!-}<>c#*0C{u9|t6gs_@knE9u>%Lw{~EsR^DPFavf2>j zlV}P=zrWf~IjlU;`5B!=G`i8{3IyahZK%Xu8(Zmp2wd237qc++&J!aQn>S;qwFi>O z0dYyZ1h&M~SeTX{g?-9*sl;=pY&>hWq)lQm1`9`;Ux4&Xs3=YzfA419mco^WGaNc1}WArqipu>tszlaHY zRd(a{G~9moOMSfL_O*0XZ&K$PmJqzmvhz~+$j?2Gc|iu}mdAI%prUbd6H2|w>3vO| zsd4S{S~XvExrpM1V<04FZeI*zCW!vjk{KSu7Ff`p@P`a*^kM24;0$(#4pQ3~vXrYh zj(QcNd_snjB#5nzer7>(`VNMH$W48PVFxE9`tazB*` zW>QbOghizIiyivZz;Plk#4ofjU<=lKwMy}(Jr`H0KUMEzA}sT^=ui%{UGQ#X$5H7e zYVz@$2wmC=+IpUV>mC8ST;<#DCwc}C8=JJZ?K6CTEbc8^F>{bbAb*=mDFe#~T*+>& zB?T6!tYF9fBa%Snr5YHNSM>^?%hY9e9{Ac4>t-02Tt1W8%Hha1-;ayjDwC1oQ;11Y zU*qy3mFgCeFvlF%f+8iL(6(NQBh?FNe2Nh!=~hp>`@p?Gc<2d z2n_6wCtW66x}E+9;7M1Z=jXr@%OyEUld)nFJ(2J@+H&X zr*#VBd-e_DInnx8-tY#6!RV#1rSvI01INY*BXBE^BnSBk4#}`GNnGhj43<$u3`y72 zhqkd(-X!(DPe8mVPHJ{X8lD`MW}nX47&=vhNi^!;fIIfe1jlK}8**287>D_@4zkLC zxoLc9sKE-G>0o~P9cHym0p( z`lReK#oPcK-eN5heowBBeuQGVl5C2=?HKXCG0LIFG=l= zzwr+qorun!*|`k_{jA}F$eu%Dl#9>Vm@a1*LRX|C*)3cRXQRKqR(Bg^ypY~p*YyQ4 zR6lun?*^>fBhHn}NSaC(UcMN{PwMRVbS=_XwB8*jneDZ6z_260x~3AAfXSn02FcnL z$w%azlhpm#k#|~)zm6)@H~-VS$QW{Fz$WaBJP4T1Di3uA=OHRZRJBzQt4g#+-LDy* zc@aR}UvBp@_?opDQaJ6PwI_BAn3h7^Rp?XBQAq6##+gTmYf2o#Vy68%tOd{fcSGYM zc-|}(H!aP1j6mju?RAYKL(vgwt?q6mYWZtAkh{n%(xy)0x&?Y!EC|3~Yx9_m(>$x- zID4(~78TsFG5LMocYzjw&o5h0Z7Pub8m;Ii(hAobu0dzWh$Gw4ANwwi!prg} z)5hJv%3_eZ!Z?d&3cDna_t|rM{W(QvRYZYP%^cU+ROdD@TQfUHDay?X1KjZ+@QC6O zQ_53xQ4nHPXTE8A3Fh!S*ETImgOAFxhC^Ce*a6!}fl6te`t_K?#yaRk%`pS1=aKdg z#Lzd-9WFM_Ph17yHc>Wf$R)!v*|1Nx7E7GjkMd~f>#5XC?5#p4%1hZd5&Gponh=TT zKm?ACG!Q_8!A3K!JHM+d88zCO>i$65mgaZrGngY{R({tKrECg=iH2TmK$Ul`Wt8qK z!Iz~*4THH>e`HhFJu}>UU<=S+@dcj3L}LUT>|3JY5aJ3Y#;q5_ky@Q=$Q-$@|1H06 zrE;OO)x%0V`1-}45nX!TzyW0N`og3M`TsG!Z4Km_dENFXM~@8<;*=T*fUBc%>>^66 zjEY7%XYC55dDr>k(glwh6a>w;;F#Lr^?9PwZ;TwSA1dzCk zlCaD2G(P=>K0lP%xIe_s%q{oT`Hq4kq$my-m8X~abx}+m0N-$L&J}~s-0t!4<-Xsj z!e(lfrs6Q?OT&3t&3vss=GGT0NhvmhfuX7R%74yBW(>g~5K8QXFq9HT7o>r7=?dIio zVm@*sClPhskvA*n*rO<$f=u7kpRq8AtdSs`M<_a8s|hjvpsKtrbTAteW9>c8GK7+0 zbPTmtd|gtz+6Tq_diVV}P+r~amNHt(o~y+F#$Sd%OXb`vogfriyk)aOjwL6Mx_9BX zlxN$EB9a>80H=Y-8JH%g73k9E00S2P>vSY z(Or5|>X!}5AG(kBnaXDYXj@B%l6c9MWe!QCdAaL|@rLV(Sjb9;;g`4Tv(FfJB-$Mg z3ks=(#Top?n2&jWRCIteWhvfKO~v;ESpUw4zlY?ROYY#Tr}@nfE0w`jx#k3|I!-r% z33WKZ$Zi}J^^IFLH6gW!wvW`Iy*bVd;%gHFA7Pya;JuYGA}reJrynP4s=$Q%AeX|W z;V03=%49oMAlTw{HKB?+;eGY8oC-zWz@(&a7~;(xRsCP z7r6W72SVW~c8eXZHpU1rh!!-lmekfIG{br?LP0gwA zszT$04yTeTVD`8VRMxIg`>#^<_R{4~G73+~mzfVH|J#uJVr9Q)l4jOqyrpM|tSW)} zpgK-H6lg>u6|tR`0>tl?gBUlTSraViv$T5GpM6&3`c+ay4e;|;EG0={G0a;r{s)cM z=*iXN2Nh7eNddG~zPVealbI;Jpq+mBJYpkKRy$#={0Lb3@4YgPPW^AY(#)E$>`59jP+cDP#X>*;+)~(mX8G>8$(nf_;y|LKL%B6 zzxZj8+K3=Y#xZ`~qk@W6?f+nJ2bbwaVh2SwV%;ZHMKH1nSDhh8mL4vsL5(=cCyQ^M z5)7^qz>t=p&*eEK!x{qFtyjc%O5$0fv;^2OM>7%S05G}H+@vNR_Jhlm9o0t)RIYz1 zwm;?Y9zq6@_roZU9@DOIFdVN+(`uWlM@&?Mcizd-K0QRre%Q-cnN6z@+vl{H0IuYp z7rzOj_|KaOI`h zc{J}1$_SS`!d1LX)oMq68l0eCuGAQGjIwuRGC`zW(kYIy`iV%;mJI#$Gwe?>LSNGB zPr0{tsidYF)3~(R+)qFn9%z8>^TlsN+$VpN?8>1!!Yy#Wyoo0Mu8Nt#raz zz|Xcg#6cK+PFo(- zx3B0F5(>`~?zFs@S)x1c)Iz;?jt*5=0C?UI)Qw*w5@-5sixr+2y>Ux|Gc31LRYVF= zS&a{XHsR>F%?xh8M~mANBh1MJc_L}=YLEjz@PQ7 z#!a+S)OBzPSK*deer(CuhhZTyT6^x_>IU%G#9~E2;S>K#pz#V=0$O{NFZPB6d2$%3 zYDkn6%2vx7_xZY}IN;`X`tb1KO>168)c5LpDiNQ1#dc0h<`5YeSkwdTQ_ zzf;dEaCqz+$FxNpykzLzgre;bDFMeX8UJB-vJq}6#M(#M!AGmH%XPcpH+??*{o(gv zmT@nra1WS(`K_9$1Ssu~e=Q9mj=jK@VAyFmGu+(fAN3>>*2$THo5&tZS1_*HEh(KU zeePJHblfoTbG@6cgd@FNPjZRA4qU~N1$5Gxx3dW4%T2uq*m>7GfF{Y*G74-V~-amW^<0B{9B|(-vN42s!M|Jxf@`5M;WR>3yu6xdFG4f>}->zuA6ZD3q zrNY6AD^>AFO7zblNa%;GKG$-;&FCb%3vE9g8Wncr`rp+;w5>0a;%?X%Ms7c5 z_Phi1I=+5l0l-1oMV1|7kGnk|wZanS9h@T=@3#+KZK#si1% zO)|F@iZQQ1UQoYFgE@x*zmsjl0=i>HyL`VluM)Ts z?#_F83U+Q|(j@m~I&e?d|B`(LKu?lsSd>c;n5%6=cF)LcOI}><|tjzz-$MrN>*fR+8j7NVtk2nH3IA&a;%sM5G*W{1S2+@HsEj z$Vm)C+^|2jR!^~hW!jEkl~j>o`}DNynF=o(1$GmUr{ihg_#$r*pnE@SnbI&Lx3{mV zx6?LV01$(0bBG>DtEAb6?`xDy#E4f6%FgK7{W0Ff2>t%|%F!AVhFj}m8Q*Uil@Z>e z%T7U?H>M@0ULrXLmq+K7g-+>F=JctZCI;JpK;KZ6AM@roQwEeK8)mP|j^Fb0j!J43 z)qF?(Jg|;W6V!-6DMTK-s>dsH7})(X^Q$C~w!ekm9w6(VIatf?u);IFky@jzvFihyDv9?CB0edaV=Z-~d&JC$@}4 zsmFTkZRp1gSeT*1gZ?3pi1_<*>V&3#tK9hN2N`?JuXp&WZZR8L;pc(P&LnitP{i9J zln_C5E>dnltc9?o(`S3DoBRbn>4sC09zUC5t&g5#-??vP(pCWs&&$ z05PPQY)^5Svpfiatb}>k#mN>sCS=Q9e^hm^UwNm`Nb+>i>P?=iGoE2dEz(TMD6nj7 zjK)A1BNi0Oiv8s|@gF>lZwk?21)+*khBl1~c4GF3cs>DiW!i&qWgimw!OJBBm@srD z>A;&I)Q(H0RujH&-_6s^@(g_x>@}ev6TpJ*<|<+prv@K^3Kt#vsW4q<(jO2^B{v%C zs}yyy3Nmsmw8CMu`ca6A5y}IZJF#`F;%PmhKlezlxS@feAm65!vV@!=TB<_~I=yeE zpodtkGQ@H{Vtzl{k1)Ysl+LZ~9~#J+nqa7yY?$<^2BxeKWQjrZU!t zmMh=(?CEWz^qCoDV#vMCsb28VpW+W<4Yb~O6fPkfK+!XyPfSjDjJiOW;zmc%S;M_O zxH?+pS6@>EAQ(9JFhuU`nW(jln)QDH-lZ+MEXxA#vF#mmO^edQ?C>2d!K1_JDk!HC zg$cG`W(!4}DIaUH*mCYnydV7{0dnJzp_`md;X&jLKDKcJ6d{gK5FrC~#t^wR*U0^`3-yoP#1s6l7iTa;WJ2PEb1*J}AUzn_VQ z(%4btzCcP~uBy@U&!_-j66>9{(ql_PDrRi1)9OeITPD1#-wq>MqofX6n$mfwlZF}M< zsPu#}XQBaa&#tj7k#Bh{_c?#(bMFOb3_T`adN_yPvopo@HSTo*KT+AafC3Gu2DR5b zV>`-UV7*^V{6GyJCgeax6(@P4{Ja)5A^kS>uGE{M6r@Q2avWM~b5)2#I@0e~ zF)F=qT-G8b!=A5^-ZC0=2)j09Zf(k<8O+Hsn?bbDj)_ETSh!+@!v`QSCtOyfgdHkz z1ltrEq;n#3Ts$Z*LzEC*(AD}ujr_9R3LTu*`l375INI{pw#jOblF*ZwpmP==^v2Et z#V~$Pra?CL-@)DYmQS$q2dO}0vdc+5@ zm6;}`Pm?vJ^}L%N6dHq*q{pGZ6Fdxdo+nz>tzHgHl{(O4!N`F!57dzHeyZg2QPbF+ zDA%;MTpq_v?z43BX=G9F6^JlLW=O!BKj&z@z>JeD8G8g}yVyUc_?l<=;{SXX(j zN%HNsnKOhX2OV8O?zy_ ze7lK6N6RBC;BQL1T0Z!~TIhl>Rh+zelPV9Co&6zyEDj8Cgd(miokFK7gr~;KHOJ>s zkDa=AfFroH@PfBk>p}+(902)31M5p)q&_sY%j~Z~pFK6@oN1@2l*xycmzB!Lw3xJC zyl+#m$r@macONvQ@r>cKs-AT`6Nw=UV9O((c$e(CJSw;vb3LxXgWt+H4-f9S_VQ zzJ8>mWVAA3`V#wIdw+~b`|3BzU1JJ<;vwmcW2|E>f*#h+hMY)rHox3DPP64K9bQs( zN*yf?S*B6cxB%*}(*VNy6#BYV>H4!a=x~TaXdI$u4+!E+#H4*}Uj-kD9UJ3wk{inK zu9M&JJ`asC{Q_H7Ci>wiF0CtZLiLfre~CkjRC6ylWT9R#7s ztP4?N_EC>_0eYo-$dnzG<`axmZp0*{(!T;4I+uEC^v&T)t&&Ft z|M}UDc62?zJ5{7_GgT%rJ;a{p>5uKI_o%O?v<$2E?Gi6x;<{2hOAvPj+E>)Ua>@{ei_{zSKzwORKR?L` zL*9!dQpaJl`H=7Dyyt(4`bU41pokt5IW?PtOK(EfL55b^L?5qdFSb+)!PK`_duOP62xQ3mNZ%N&RDSfS=y zk#SoLA5rjj1bmg{de$v@OVk}p30N1D%R8)uTpUaq;bZjDO?N~(X`jWuxmn__e++2E#^P)9Qy( z+W6{>cQVF30g` z$y}Yvu&`TaS`*U*PW%ig?si%^IPJ`6@4R%&Ii_Zby!7>QzIZ+5tS`*=AmB8r3F?G2>)LSnl6nZVH~Q;4tTUlZOqJb^elDbPtCI1j@r5|9ZqNPbfO2m~sS0A-{p-lK0+`e1 zU=Rtk-d!Q{Rb8TXUP>9rDqL5-NB|-5*{*MzE;(LIocss1e%~QXjY`b9<9!B`Q*4>q zlT_Z44=xt8TR1yvVI>8mAkmI{7b4H@g4tj&a{xs^y1#fiMm8NG$Q3YyePT-gF&VF)+WD_go(&Z>J)z{ z?su0dn@qraX_f#H&FyR~L#S$Np_sA_PC;`0(#{(1iJ?t%9!}w>Zba4&4Xi?*?{FHy z1zKD5;FwDhmt0(E_$&O^63QRA_XQHV(BvamEtDm03qwN zFwm+ERh`tDq!hhbP@%IFQ-n7mmW5Y^>R^=cp}J5J1|efyb;bmmzs{panhK~u><;|S z#>?uJEApe$?K@o{o`%y}b)4~#B)xd?5QQdn!XI{~hd> z$>p&D4w0soQ{_1m(vQ|bK}-qGaA|7&7Dw!#8h%yylZ$NtBn;H`5jcmN(vjj_S({_` zl>T#rZ0oX)<7C9x0sCr&cdk3um}V5EQ*5#tYXIfxKy4c7741^rw^S11wlKvm7QxzI z3Jo?~a8V5y|8H>6nUDPy*}w5%>R)Ty*IAigDbcxzg!re6kx(-=KvQbSy)P~ay~=k3qktix#dCUqnIBL*ke9RyAIKKLvmY9^9>uL$jJw& za=%X87~SHGaEr;d{1c@T^Y(0!5_-NvF8Zt_+|ZdGm&IAj2npP&qtHxI?QDDH7FT{7 z&LonN+hJ8o&B0)4rTML;6Z_2?Ej)+DuY?(Mb|`&@8js{a8w&mu~=K?wH!+HBH&2{VP6l>cNrEOmA?6J#oj8TcTbey}<7uX*t8*T;jb zG6I1SU0o^!^~mI-dHvs)wIJP#T30`EvQkh43Id2DFKzrp=DZKV835x;y@)k~v^gc= zE%50M4o?UUB!|cVZay`@!e)3le0h&6??ZdT0JKW4Y*mQxRu6!5(8fvpLXE|LSd?$Z z%s|1j>f{Epx8U@V7ST0J5Z*4jSd@X|Y%AP4(<80u?1%~se2+kCTzp<;Q!i(J9FKCF zETKih^YzoAf53Lh?wu>q8ISe4p;o*sJ{iwZxpWr-ea!yu$vE6}q9zF|f)j%gMBc*S z8$ad`Q3&ujHWCHTpTyD>gLT8o`3kYTNW-{=4}0g*T&QTofJgovK;tjwd?k$q`Y81E zZUZ`M(x-1~5_J*#5THx0o6o!PV%x$9qgiKMeJMj^I%1c@n2?YGlSad{wZ3E)yWjlC zBprPu%C;&11HH?jiXFJ?eX>G%+4oKBPS>RG4jtEoi@W*9JIN z3L+HrCN=hGgZ_FA+pLb2>NOG4hL@WJe%bEwBlCnTo_yez9NI_eQZcA=)aG!epM8l$ z+z#cty}EMx38@+0IXw->;K|<4YXdfa#2^d75H35NxIbTQE_eR^_1_Oe+xFb-ATv>6w|FauQm^<*6C5eDiJ+~ z^1AtJ0f|m_K zacZm?_YBX`L8113S10v4%iH_XV2F6-5~7~HhQY-~t0Bm(WSo|ipmnsQ)#`b>eQy%j zUCMf|^&+>TFvHj?{=KE3tjGm--l5!oHzu%fb#t`?c z%lM=LtW1lGd)w|>tNP?UhP8h3Ix*Ei(Dde;Y znbc}u#=akN!brxbicd%LnX*Xgo05T4# zWXyz*C3%XfRL8#ld7)E}fw_cX;D!%2=iu>w&DfMnIax$Uu3)@x4!|RVN=MTGi zdC3yP2I|HFf*1$ji$jL@aba0QY*ed{J?hnX-<@-G+lXT}Hq9l7+_o|Px#eLosxWYv ztrypf;W&nyRFAxrq*rk3WfB9ZFHC7xc9Oi6AVPZ!7UF1d_^h;+k>G{$XQ2XuMfRuv zPPyV|wbsBw*d}xl!5+P?(#yA9?b>MQuor1*pm@6ML0o55y7jRBH$Lo_$BWvFz9_gH z@W@TOp$*b>$kNU%cx8OD19^Bm9eG5D5KXp*5HNVtEfXp?8G^f!K`cMqXUZ>$G)j9( z0(nw1NxU%Og1=Jk(HPR?jL8Q{$HN%1d0c-!JdeW(3G(Ab36GUrxw5$1`G~Efhp1Z?~Wm#LOn*+HgZ& zD%s8STl5n0WWCXxK{AMFX<7O?p$Ti{WWKu(1)jkhXQwZqVyG1f(G`?J3q9*WOBRqq z^6pLDFW;{>y>0V8BBT;cW2#?W=e z_hqn4d&_|3B*#cS^CA6^c-*$IrghFGkC}GsHIxZzZZnd{b}T(q(V)ny+Iy75-panvQ-O9?}yH{;LUyCU$)gg8R37gPb?8z4%T3RVcc zKWCWJU^jqZLXbcG$yqC}BTDg=A&qJi_!RC_+7V&@hFGfcUvi@WwGcYn^a1ZgnvAmr z{3teYi{F1LtWEqxIEaE(AEMD6eHKo&(Yg4nU~`;jN2fl37s~dN3QMq zNEC={x<5OF^w^{8`%(OVD#gpXNMfx&2Ur1SqXC;}3{rH*M<0 zfaGiamgmw_k4YY8+Pi82>%NuvdZL5B81>O9ZS4i{5QSbY+zQpyY^hmxs=I9sG3~OS z$*`{%<#SQ<(oA?`a$$~t6YI4#ZL@#~Jj5HGnAoBEopy9Pwf>UL!n8Y^nb>#V5j~bQ zI>pQk5nt;}Oc6K(!k7{6`@2w*kZ&D;-TYo{cR;;mAHRD_zHkBS3m-;?gcHn7|3sF> z{GBvX4{XlUCLoxpS2&t79g4YD6GgGW|0=Y6GcM6!TV2JQ>S`&(mX_spZ%vwSn86F# z0!$1V_XeNbNLxGa(!R`hv$n5(<{`I)zn2+Jb7ap~eZNtkcz4Pv=z%2X{_|7)S-o>M z+(>8{-eQ1Y$y923Ya_1-Y)>R~qumLo38h-Q)X;#W0_T@M(&B6$s*z zH&c2X9spxRpJxtO*8*^OoS5+KSE7v{Qtg~qGf1DyY-flCT_joC#XLq ztlf{tJsQ4`>qM0ZY=Y?C<85_w+X?_InBw2+Nahmn@;C|@I${Bk8~L=Qu1 zH$kLZ!7BUR9JfH=(JzH3h#K+YPLZ()x`nI-L;K8aK*veyjj-A2&wG^u*;YV%Y2|TXD{N4pw_35d zx;}hSJE&nj$K|cihNMGGZcoWu1$}W#UTTfgfv>g79y`o+v3FyV-XG!67uAQubGaN1 z=B$U~Yq7Z0*cFi|)O6Wtk>~T(DVG$q)37C)ildLQUd*ZJ_CQfmJug~CtF(HvuBYmD zZu(~6mE@E0iHeYr);tQtMA@r)q&B(#yA_>~cv{Tk2Xu8{y!g=W36KBvH=R>>MwuUp z$v?1SrVW49BF`QZH?#9e63L-=!K~)GYN{g>D7n;g;g;1A_Gl^8X(25;z*2!-N;f}o zX6K}NNsn9=WxEdFyfbF!C|8-tf)t1da@_88$>n0F(vt3qv~+ojSPY<$8TclS+Kb!@ zjGx7WXJi;8(`6%Z+lrn|6wQBD)XvlS+j@HXr?N!Ky5D1h8*N~S*SY!8AB29BtCxp0Ym-u&S1i*@!t~@THv}t>fb(Cy-jhMfh&K?C*E?S2SO1j zwz=^Z3F5L2x@4=@hXgoAOc)8?I>6)WglNpKUlv^9jgk{Iiz`iK|5IEXU3i?x z5=>oF1#SiM32KHdwq(rD(|Sv#0U0l$M+-UFLFkew-TAKd=?B9esg-lbBE5%8pW}MR zx28m#neDe?a)+4%bRa0rBJ84dJ(aew+~sr0A6G=ng{5i_oftC>C{yhQy?S~BSd$_Ldg)IWSnH^mZZjhm|-(kErFB zqUJ}e9t9Dh4X)%F^(6ztm7)+j1ns$G{vW%5^RC`acx$SCi}gZJ1Zb|rmb_*vpvO>| z;w3(EYOCPs7h`ksk!7rT@WtOU#Ay_mBw|I9JO+=O zGO8R$x^5VQhUkX|*58V%e92sIhe^O|MmGRa??^4J%}q%# z_d)f@`eeLthh-l%xS%`#Iv(ldv8HT6)`>qcXl0cJ2WT^v_}NQtH}Ml+=8ZR{cw6cE zN9x{}1Src#WVz^>ULB7lXXR}}y4N6|3qi+tWej1VyHm>-3rvG=$*w&aqM64+OBgy2 zC%on7S15C~Apo$W^r=*EI(|2E7SON{3cHKBnk%u+%$cRZ4qaMM58|zu`nS?mu+WyY zlZtxeDM(Wu8e|(MuG783e?+q1MIKneQ;LvBSe^QM_#>JsQu2YcIWJY|6pW1Wr?qLw zUZU1Nlsc(4+YUM9PS%PjsdS2c7yGQ9R(vmWUmM4{3`8jPMfIB6zc%sorixIfnJZ)` zkuogy99Xp#UxCke@Piz8nYlI^7Ij8%8<&eqU=r(Ra*B}sZv^}FL~hx4)P2k$3& zw?uF15-x*69PZUAoQhKpC?4T^GNWQ@c-lc8o_&!Qr(I7Qv!sKQi)eWtvUk5~UCflz zJT)YPU@*^^`w=NN%&1}_l>dI^W4;NnSvBecMX*vi^3D%)S_VyDoceTpPJr8OV{A#H=IclA z-sfUsk^3K`YKp9WiCOC}0>% za?!z2(s-`4e;Bn?^~;1s$OaAOU5sUxD~8Fn%BU~(ef7**BnQ-v8AQju!;B=TI~Vy? zkV0>;RN%`|a61z(#<)yfKve5pFsHkk8X#wMVEj`xQtiVly)l4}DYQJ6s1V;{gt&w0 zo8#DSR0Htn9F&tXtK?hSPZR@6;Riain(kWgmtm5G>szhlJA4{F9w6}{)60T4Qxyxx z#ETQze4oL?V>OEBnLyg~`$&uEYYw}=_YQQDo7-4}p14}prlzn!Aa)=Dv z+mCp0r2?5+Bn_`qz-StdTZ@rCSox_JJ=1@W+%f!VGiFovj0d*E-5P6fpCxL(Yeo#x z-I-e6!HJIde5yUPtXbhRc=603X7t>uyJ(o|v?+VvviHf~J8}Ww-_McX=n@Cb?!25h zF}x;hS>+C{aW8E=l1S-G18_r1L4xoHGKcN*UqC&enU=0WYC{slC#@*kZ)KjK+!){K z{ikt|6l{k`q!H1lxM3urW`};&D7~gaZNDh}m22$_WOXNhbS5a>+%#e$@J&^PHGJvY z0l0ebO|D_rA?z@gOYoz~F$Cf7aN+DZg$-fD(^>NQSz#&Ee}LlGCGj19c-$skZ2@3g z=s@OBO$^XC5cMn0xIt8D{k3ps>Lt5bTc_9v^xZ{3l#rQKZ~+RC=iir&5(@>vNLgj} zY{3_>`5p#ih@a$8)Cr1HQ!yLH9Go$3OQ7w1kA|k=-uGCRXbDPM-at$tvwX&bNE@oF zmfT`3p`9&8R9D%|SuX6)3pcJ&4Hf`DYMz1a4z)Ye57!Z3k#DVYcIY)^9)dYHL}8-W zR7d{BmGE)5L~f*|f{7jB@ID!IGE|IV!;^==4Kz-@a7+ zOIKL&m#v!F)E(ke%t+#k&&Y0mXkIb~Y$U)J`SnbAiQ#|%GpX8Cux8k2w;hXU zu!EZJ9a<{YP7Oi=2Bh*;$6Do_Top&~Q9f8Hz!Nv%A6L9@V9C$;!LprE=9XvvpC4

pTK$fR|4?(3;q-af}j*+_Stvw^f_lVL!)EUHmGI7 z{cz?%5HE%uR+zL*cZuQy>(z4XQAPc6v~Q@BazCJ)P1gFRr{YwyV~dQGQRlli2!Pn{ zYg2u`_037%q8T`Q+#=~rIuTJ6^d*Ou(Q0MQ-#4{gBW7uxm;m!Ky zx-$i%ZjfNsw3{?0CB;U{iC6X^|_u}1?e2?G48mTd)oG(*_z8O>YY4rKuQ?`qQNr&5qj8Bfiou8 zK&8fx8PdA14r=4*U>q5_?NQX@J(YZHhq!qnmtNvj-zU8V5FG(k&snHaeisb^1Z)h> za&-Uil`w4zl&pjO`{OV_x^37bpjgMTN&;yKXw`ds2kpmJ>Dt+<2XPn2MQeiQ3|UvI z1xi+$CEBT1dbgU<@TUA-8x}v^nX3QdkG*K5fm%CstJjPKWx(lH6hlSZt6|(}99oaer$Vp_=^|iyi_q4D{USfP|lLL`k zM_ohfQh|mVxpk^Kp<)0-vy1499u3JYa@8B%5j}5dVZfV{Ru_$R49AR*jn4>gv6m=J zvdgXYVK#NitI$PP=w~zsMZvu~-$@xy=x`&t_Vd>Cc7n|pAiN&L)3^8Bj7?tJ z3FhphJ9d>Gyfx1cVUZqdA4OT^i&7n{QUW`YN0q)FO=FPmNlz|>t2PfC{s0Y-_r@&9 z^jG}PXyVwhnuVn1Z?Y!sx&*0vHfu17!GWUv!$AkZs=rm4a-4k^j8i2K(@cjyG-bz~ zS7u5wHM3@g;O?1XB;i;OetbkBh?W5~&5e=;Y88-c2ta2xU3;$y2=J3~Sc4^HIYPC` zzHJL(c8N!$GN8^EBkuqh=R9)wu}ZEgc#FoBbh%mi zL8ie}zefeHTsoN_GWY1m3nXVO0cUWwk&pZ@A>ju5(JY4BDXEFp+HqaWG{ol}tI-0d z@>JNbHx|9eVku-4y&Az@9sAt0f4ow3%bKh($1EPX1wfMx&@@&HQyU)XOFdgt!stdE zAhw6vUq)-^6bMf(sdoa+1!bU1Z@%zQBfM?dIM~`$=fByXRzUj#Jdc`!O`!$yCVG*t zDn?hKghHWS-?|T|U?8Io`Ln|Ytg#H^c`wM-$aeA}HPvWgpGr0te{`wK(4MErT9uSV zfeH#Dt;wvR%1b(os+Jt2g9`GqNouu&d`K@o4dN8<5yGIjOzWk7vkAFQU>~2H&-mX* zqKh0o-IM=T-}&k!+TKC5>{|;acZiu}PWHKwE8R6~7+#Y7qDF(7x?4jJ-AIN0m0RH#d|Roup9>1WQ7WE!}PSkHxgAxQLtf4L~(X*>+QWh$11) zf?2-feZQj=L4~_(YhX%e8{KX?+5h+D`M*&-LNL;PM2xWgtmhh%PX>?`zMn{sVY&lf5{^Wx> z+4jK|&kVx3i73pwPE4K7igG z07fe$BAtI2>FUUZ3c-;~fBYlyOY{Sx!N2?fi^*HliOhwGN36Wx+L`8!3Mxe94k%;- z?2zVxK8oe(VNKoEIiY{+uo}FC=_7?Frz|1E9K7oR!m^@-jt9G}`%(`&OnyqJI)h+r z(O-R4P9>_l%yssCd6@|7_12wiED;7=tgJnwzjdMbJ-Y#>TLdV&Q-b#c5IT74(ud=SSU|O(j%1YD!%#3{Q+GYt0Jv8+Y_;~}`#-H?NZczV$-+5r{y zBzHspbrxcTdQ$~&p!jB;2u>uWBV_>*Dp^s2xS>;wlm9C$eR$A;xH^AxFqq^mu<2sT z;U%@xB;fphMW$V&H8`F8R+8I3q1no4J#d#?<7S|(w4CGI4qftkM zW?o}O#|LM6X`g9E1Ee{FaOe%EsI-kj3WevaR+_9l^mx}qGy+71=+}3+h4hppS{=4w zT^K>dqUTG7mudg#>xGAn_2y&yc<1PeKc^2VVMS3(z5#mN!3vFsO7|VrInY)^v z@dzJ`x+C7E3&ba(+{ljk;el@#YjFwhRx?!~5UKJ!?T%Xg1eIN`p1I+q<{tzFr@e=yoRGdf zdta711(GX<>gkW_CG`e=1AMv8AGUw>1J_{B{b*$`KR}tGL0~)aBkG$-UelkEgC`sl zUK#978WV?&aYkk_Nd0e0ZbvBw5ibC2te57ytIM4)v2qock^qCGnnX!({Z6kAq9lrq zfBzy;oy#W4vUpgqX{3dvXhWc^t~NFrS`|}~c#E9E_ru(T6w7M!O&!ERYTh9H)CukU zw@aS|sx(Db8T%K+KPK>sz;FH*{@2i%=bO@}BQZyO++dva$glR=>*a8jhze>Y5aUkq zUwd8V_q@`PnAp(IR%|Uel^TWF>OPVxkE}22RX7#@mYNY=g`(bKPY`IYHpse7qK0v+ zx1oU&dGsRG!BQ-t7I<{QBqJB7vno3d2J}m6)2XYvi?eK*M&4F)_Hy!Wdi9=2q52PC zVA@WkzO38)1>|SdPZd3jq#%iCgEO2=j~7>n+sb6sH%^D-bidsw!>0YIj#(&@XKx8OoUh<(Z>Qg%EI52b=SYNgQeYYNk=%O$=Q%EJn@k zwYtj3bbkRp5vX;|$DGGiRc!^o~ z4<`+S9n@d2xb?qvObkJ^F8lBs=No1_rwn^*rYA{_g57sbKW5)*;i3}ZM@RtQ(xI+* zRDNtD``MThHTeMk+<~m}XCVK0Sk#mdBvGyy=7cz0(WxVEi?5NKY!IC}7QVbfqi2d= zo@hpa!L3P!gcSVGB%EOThz$H+`?H!NxLbab29iOvJZRgS_SseaH5SZzEnzX{(PM`Dm_m zXL!n32iYb10GP=Kl}ewHg%v>{*b9`cV%yPPU6sYLYu6Oe)xoU_jbsmit~XG&?kD0) zFQxMbaipjGX-cQ|X<*J3s`4#+l0~lW7@a~+(I@j7y$Kx8zdkN8mvc$bo&U_F0L+Oq zn3$a(I}=Lf99ypK=u0RU0X?u1g2P3NV>uP(hIg;ygt*XzOqm(=i%IQIavqH2kxu0e zu%|>D)819)$F@VlK@?}3*w7pwWwe_AvEGJ_pf3#%gPdZ*4lKdj!qnIQg!4r z*+uNSi2T+^1dT#ZtMd zmKs&pv#t`Pdsl7Ta-4Y3dIBL~i6Mnn<1jitLRv;*?Iq%0uB@mm zjs?XQJN(Y;tD;0!ibnlv#nh(W(rt=TBZoMVLJ>$n-7t&S z_lqS>_XLsxQ}TbR{GIHK)V2=R1u`wM%M&6ql>Du29FizSpV@p z8VX05mbg6OTDELTdS0QS)Z@Edj@kNmbX2kUTE8W4eWS62%yM?`wiS#DJad6=Ho^MH zHZmB-&;in3QXIm*1D^63fxPg4t7YbK`YLAlJ%dBhAxd0KZB)cn0j?TBP`_r0H_-O) z?SdkNV}B&qkN&RC&4m$UFK3_WAa124bPQ$?5OdTxXAFP+$Z$7iTIwpo=VmP!?uLbt zQ!W)&7@dv9t1kr-a(Z&V%_NBn=b>aJejV&mFp{AD#}s6(JGzURXHU&qjq=x0%uNq; zr@KmkbQZVzpxI59_gO6Vi8RQ{G0XhB@gkvV)aD(*uENE==M46st7M;;YJ)Lm&D)*@ za*k!Owc;+<|L(>ovk9qyc;509^@@xfbgr_8q(ns`0ZH3$`!Q<^d; zaAt7-wCpbqcofzEX;UcXjW@+tZ=;R{&96p;n*G(N)-?g$)3PI_*c`N*VL5N%fgZE; zyJfu>Rk4{sFi3{M-RXSH!@!AgND7K6hmgAxjr8RW00I zNsA~?XDq#%Rsg{TKNqhsyR;Bn-Qf*bK_UBtS-TrKb!Uy0-uFt1wGGJe(KPiLvnr)E zAuj`F>$yr5$-1V;SF}x1K{nxuT7AC!GWV3)TOVosgj?aR&fD-`f!- z=}#i>Tw01{m4Q6DQ9Oa7W!0@u?^5`O5}ZF&LGhS;JB9aoa%%^zl;>mQ(4VTb$ z`ZJ3IxsHR++pr2pb6{rn*7MF;uhz&pj`SP6KhRz&X=yQxqLyL!r5CTbgRnGw*15e| z^2^}cHs)l;`vBSdsVF?gvfb-R&F%wn?ywSEZzBhix1|hGi6MkAXT)Qi2K-R)sGRc` zBznw}T#Ay8^G5S)(1pjh-}>#R^pzniqrRom%^PC+x7OX-(gdG^gG`1qA+CV4BIiCJ z12!B&taxs=3JM@C@ONax&^^xdd8jaH$pZ9izdW9| zHyv;G5Cg46ASv#!_p)0m!|=irl1%@QpbKNg&c{M=*)?G+RWmHouGo37`wk0MiN7vI zTfYU7KwYPfXV6Nf`;3zx4YI&v-#fl-eHo8pT-R!V8bsJ#sHivQZ8 z8Wf-R3^98Z01c&)Hj4iFLY@+8@lmB=RvfzKg*2nH|IodQ+S9#`D^n9oI^%eYG5Oaze1rxGiT&)Mpq9I-m_oc-=K1^!of`M#%EVe z-%riAo1@_Dm?(ZCt3F0gZ@Oy=YAKy(9>!LcgAbj8>*teJG-ZLX0EK4~ zpK%Qeo1i)a$hvJp$KyAzl=jX8Fy}+dhtZ5BM#N98RX5TaVARHfaKCO>bs?BGEH2nh zb|MG{U#CG~gfQfz%xdmi=ApOwMe~~wlnX&K^us5eQtyX2+dGT%=bu>3DoMlo34xEi zt+%fqtE}h;3k>Y7kOIf9UhzOA_3V06FQo%p+AhXF_h$i``r2vr0d-sbb&Yv)6f@{4 zE#@mNdFghE(E$J>T3_|z*#kCNz|UBGq58QOu^QdeQnvq*I2?V+ihMkjZ=?x!^w=#` z$H_$dcekhatDNkzquv?(Jip6X)fcn@TVa4wO=hj7B84*vQy(~y@NkUdY;*JgG1Fxq zq7^VySYqezY>pZ|tK9@;4s4}@bsjv+ulO1li^g_Zj-$k~SBJgrX9F=Aj$!<2ikXD# z`<)-JYse}N*(Fxf&FqE?NlN!nX2Pguls+V#}-*FP2Z-g|ZZb3E^@9lnv-lhi;-Tt!)2Ij5qgeI1t^Wfm!;OrPrg3)mpM zA=qS#R~JfcA7#8|LCkl6Tk5RcXw^4Q7faQq@57wdQ)f6hpzL| zMUvoeZQJET98>xo*7{KsJ&J+x zTe*`+-9~3Xs^-p#yHLRN@W=?sz&z?57}3+BxxJtj3;VW$8SiI4y=0s?d45qLb%$+Mv*SD6BL!5mpXW<2J4snZkGfR{l zWs&sg*q;P1LHKH*dTj?9(Kdyp0j&edG=RMo?0H&%GBVMIo7~w5If_4T1*)%9R%o) zc&s{>M@U|~dc=txSY=EOoQD*u;es|k$+IOmx?7|tHT9Z7LRF{YbPTaN|A9e4!+^$k z|6XC!BzB|3A8sWt-*m;uhV9$3ATBtvcJq)^@Y@Qv?#JD{hS{%HkOh6i)oZd0E1;%0 zSpUNWoN7JIIs@y;UIYIsb4h37nv0w|jI@%SICN63zy zGwFWZr%k2szUar>*c5)|eoNCWdAbIo>MrRXjm8I2Y2xL09U%?iRTmZv#4siAf1sRk zzFy{cRo6c24E-vVuT+27(~j_-Xrk|2MV)wdJt_e-VD)0qCL}a6(Kc9nP6?6DTB7>q z+uioj@WnvGnRi%k@2nmFUPvuq9&sWsNzuDO!}${=8jji?(MjYqO)$`dB{aoysB3+x&1#PXIR*)Q;oF~Rpn7f9B556B$;dU0H@ujRf zml@m^yi%h9Z07{b_!v6}Ol4$ZI|u`+U= zH;E=<9uvLb@xHAvvU4o8GnaeSNu-7U({RbV)W&5<)w_*)V3_Q7my``(ov6XD0P>*D z0`ja8eHE{Ntwqyd|5l*5RNXp>^t$f||4!J`Z3rQM`xl9GrnOX$BFG-4Sd+4)-Y$Zn zo-Nt+-YGGQ0PdNUM|v>8*9yX0oj3n0AkaFE6T|CDxeat|3*Ix|gk>&db27MYy790- zWM2nO4{Q^MKTg-k%>}WL`fa1TQ0korJSR+IQj!fAIz-~|@KWgMNxF{pbHgZWK2qz@ zqtT38S4pD=m$G~Z&iS29Jz<0#z>s?{{~_oSg7AegaQ{P&k6Y`CEbX;R(m4iHGmmbi z{Z{9rFWUv2)eRzH>>!KH`AJUuDz{bfB;^$y5FTV2OV@E99motc?l*5Ju7WcN@HiBK z^&S-Xh6Ia_N|vYZ@z-B9B|n2*k>UO-L}hQH3bkf~e+f`4FybR}yMHAMbb~!E-6d61 zEM@l`wi72OXGi&Se|b98k^)paFJ}2TPiVG9`A$*P98KA0`bDkjsw+={ZXKRWKzI42 zqJxl1&xoQ|i_c?s-{K5dv8*%vw488~8eAy_zn$)g)4g^gVT`o>F*d_}Phjrc?4Tym zkD*OoO^=)Tk7Ll*jFL+?5g78&)CERD=Fc*9VQhY@JIh*>Bvw5auz|Dj1>+i7L=EvE6Z0LYauLgo84~~g&|wFfK3{v% zc=mJ6Kme8vm#1S{`4PPYPLE4E?T|Qpmy6s(&GS3!*+ek1WBs!A=Rusd$>g~Z1xNtJ zm>9PmKZ<}Z#9V6`m~>94We7~Ad=P&E9I)}bDL5EtPgOw~I@s+2i{WSu`)x-W;X2>2{h@Wm7>N3Sm?VPQsA4`vy@ zQKz}&3SRD&mgI7_^ns#J+IT>{;$N%Nn(b~3Z(4qxs*5Bni}i2MObl)dq}}%IG2mpE z@?3;s1fqREa*YupbZubW_Z%BwHYopX)XoVsyPtT1y!kfu zJWb){j@LmvJVgQ!SSEmm2ty6^IEQheaMr;myw_rsE0$vOsYS#c5FVZI7;rfAL4H#b z;UH1T6=smM+3Z{+_d5D ziB1Y%QMr0f&va+fi%{j1(iuwG_$A$kfGl<^qyMZ)m&T!iSKx%+BWDp%l*v|@*aOn%;0wa;+7L+PHR^q4--Uf;GCnjd>F6@C z)|h&Zu6R^|`XQe+!wqxNFVDT7;~e0%LY)bQaOE=WY^Vl6>tUwb zjaYAa%hDXZ_LK;bG;{azhmJ@Y)M6oGLoLZfw(mY`_r$)rFW5#d&`0tFzxHw=e7w%F zGEHdh!CMk8FjV7oMgXfB4@@pRyXf>r*2ClFF{ediKACM?k^LTrg;TR4 zvF!H=mM5BznB7ooU6NI~?)llY>xr%6bjONUak%g^xh}6jPT>C(Dpe4Q@4m!+`w$a;3;FoGo3`a#w_AKWDVBUI~5?xZ6Y5VE75iO@BQ7ZlW0^9k6=!s(u?h@qGh3bn- zoq=Ihmx?8oiqklX=DTjTTXRW>YW-ra*)j-xKi7aFUjGP=IMkw7P$g|4990sZ1|73r z%_CvO-2`q+s+B|d?sg+B)?sTM3n)33S#5rKhe(_kb8NEMKx9MVG^C0NMO1bT$z>6$ zIp@t_Zm%t6v?ug#2Oc*xVMvbSR()LlX1XsL!A+BebQ}GTFQrHK4P2SKb+zk&WbVPf+;>K!n~sY0-Q>JuZh4n8l_|; zJ@8+ZJQ(cKH4+1xP|tEUH_|g}sS6__g)_j3)1XMAM@Sf<B)OzJpo&_`PUv~9*D0xB{1Vq8Vq@T zS4jsB*^`A4kNc$VB|d_;SB^e~5cV$VtU&@6%}$t=f>VR6z{uM;Ou>T;c$TbPEQ-Ui zXXj9)Irr6=XQm-jV_{U+J%F4pdp8v{u@bah`?Y8ccTS@VzW??7*!C;K)IIryL}ot~ zbW=0YW>Frep}BC{PAexwEVD&8;sQ3uv;UXKY-#t?pM=eVXv*iSJ2GlgYp(-Gq~>U; z1TEtT8bLv=uZ}8fnmJ1}a0!CkKaEPU;+x^ZB}(mkx4oF{M)yijH8kAM=Yrlz&hFtr zYj>B7+GSa=1Oz{FmJYsIh4wx(k<>l#TEH!&tKPOvx@wTnEt>>CEYToNg@{YyW9Sj$ z1;)K7Ud71F=#B8u?WXcB591D;go;Oc{3Ej9;QV09pEqC~Q5uaX(O#Nh26}|JCE+-2 zAi??oH9*S0uR1J)ILa9c-0MFZlrc~&GeTqZ177g?$vfOSyPjxCtJH=-C5BU+_` ziS&HP1CTQO8{BBtCUE3kO+|n=YL_R{Ob_zR1rlJJPe<~8Hni5z+g`l#7FuxUKkx^Q zupWX)s3?4)R`|nT%kBZA5AeNFB^IeY(s8jS1-dA9*XQZeXOQUC!I<2d#`G4Q)f4XG zgUnmrAUNEQTQXg1y+YOKFBDL*b=;v4gPc>u`5Ok&W*cDo*Ek^*omIIrB?EZ!b1Bk? zt(X$9mz=q_4{-ZmJ&!24v=Iuhn*p6B3g&7E*Z27*PbDE z`pps!-VDfDkc6+ezEIA`k^yVaRFq@f+b;F?HDAMYANHdKNnJ@IiX?+f{kz9%6S2d! ziJLz6>R}yvhBzd9*&GPL2e<$8rnOuL|J&1qQ-{)}(*lzq>M=e7DWaMB(bVZsD=8{U zM~c}^fbV5%9dgKB4bw&NwMEj8&lZW2!{xC-Q+-@0MR)A~6;Kn=sEi`J)kxA1ZGsbX zV}|PF%V+9Bz<*T|pg*%WsU|01_v0mtBBN|WEfyG##8_I&z3h%loAo8rxe!QJ)}NIj ztVX~nsK{T9cWbjr@EQm3h~1>|lzR?bd$+~RuKHK8Ow}5~_MI+Ww&Dra?It2uos8USCi>d7xVFje%_^PwwJA+r3{zp_8q zx|)UgUT|V?5m+VQxaiwT@ZksOyjd1B>$VzyM@~u57X{7tqSTCTu$|ddt0){)lyv4P zs&WYX%N_&+uup`2KEHNiWxfKI%cU7pJDFi%D^W~=q&~L0Uh(y-!q!28IwGX(v{VeF zR3a99K1nFn?mW7H?|q5vm+*Um&tD$$=z3XeytJJvI08x&RW%A# z+K$7rH~<0XSt%?_QYT!FpS1>T=#7bJxZ`dQjgK@hAxQ&qL0!}zzb0%cWb-@AduZ1F zK$*p>C!T@w-sj_!vUs&WA?TIV1rh=%j}Z&=d6CETe0int5lVwsjM|Z3!-?}9z@jLP zGq&LjdVCngU8}>fYY25YW^Y{M&uXi1^^S0?lh;)AmZ&if3ynflhk{yzU@89Vjh zQ%S}_RhL1v3H&+A&={BcC_H8dm_^ph&O%kyPjUfBe$yG(A3K7z38xf}Hd8QJX27zN0u(99@VuCuPxS!K<~& zKCkcx$wMiH3JbQ;7mtNFSo^tSBLt|g#JQRcRZCXkPf?B+)CL<-P2$zqr|h9R0bT9u zbsK9C)9Yfr(vpLABP52SygG9(fY#Lsxaw_!`L&@(NJMO-jgc7QQ;OUjzY5CkW?^n# zors>8II9yu;T7hG%-63sVs0uq(*ZXwG^AKH{DeRsxy zmWrd(ZC+&fA)Q)KlATY|;S}_it1Oi<>*?2%VE{e9BUdu=7fno+?=(=xh&fg7B(FY; zd*a2#2%4a7ju7jz6a2s7{fOe*BWzk^m=Q@$rDfaN**5pPM_f4-4nEC6jg{Gh6KPz%nmys_IF2++ zurDj~NQpLLZB+;+du}K<`WRf>t1E-_R{=t+2&=2+!H|wYm`sVCB24P*=<#6xIQiidyY3hRrA;Ad z?Y70@e*@P0D>o@_SD;453>p$57uTZ-qnN#;)rzfnh@ekN3mComR9H<^l@|z6N_-I1 z8?%C*QBc73wvWLvE8*}cIMcK02cZ8NlwM+q)oYg!CX_GB!Sn-tM6~xh+EtR)t25Ka zrny1!EgAt0A%nVy?X$Bo)=jDu3BG!Cel#2B3%O<Q!os<_IA~9{@ zj%G%GxHt}crHKg28*_MGxl7oPryfAU=3v5Ql*&fYJHU+DP(TESb2jkmaRmy1Tq=(V zBF8nqNAiFQb;I%cN|}c{O!sQx^XhTU69+eq-RDQp$V{*X=qgm{;hoo1CBcQq;1HmKp2w<6Q5jrf(4l^;Oc>PeK=*gF$ zeJ-yj%jqGf)}4T0^XEUE+*flU==5EePW*>g#!IoS5=Y4ib7XycgXU5k>80ACF%A#E zD4MnxxBR#JPUIawK0D>1q1V0^U(c6xNW@BmQb@7XX^IUB$guPbl9|a8ImUY+hfUS% zNtGf;rr%zWUevDvAUgYeSKdhhD#fE_BzVwN34xGEdB$j@T=xw|!u*Gk<{KrpA%-b< zf?T~{%D*u{w%$?SPf8P)SujCTEkxvF8vYAuVVU!rPALBB-u zHWK28=}nQh`ars&a{G$HKdgxnf?5WiYZr09#o%<8q}=S~>B?%Wj1np1NOJu8tQI?x zUHu}bd0@;-jM3|Q58p-1UcHi1KLY-KGZ5MF_QXY6%9-ABnZN_IW-GbeIe{!#x5^Kd zOZGl;7K=js{}|_ZK%G6bj2Hw|uOk|N4-`zXiZ%1X$oy@QR+V`ungBqep6oaJIG`}Q z8Tfv(f!8e1&uBEtMa0N{R%HeydG%;qSIa>B5aV8AzAB!$X5USC@t`(?!Qe)@=VtF6 zkY4T*qg!Q)GBK>A-gm!rwNj2eY$V^4R`JLzMjz|FK-t|zf*f5)hTY<9mI=lQ{4+>9 zbbhp`V~GihDY|t5X-sgU$yUO*Yt8SP0S7A3h2DD!Hk+Aqr`wm|X{&t3eQ&sD75EI& zejB^dv z3ugmr6zw>JQZ0K}6$)LFE)plFZvHDpYpo&`{1WFr0>oS*4dYH4x>`%)?<#~;YLh;d zgalL&O`coyqyRdj;fR7Bk34YMP!0)7X2(4R8;?cOB&Ado1WC z0@uZAA1NU_5dxw2*Vmx5p?|ZLLL!z|892FODeByPQN)fo z?M4b_BEod*V|CiF3An3UE81&^ESeF7E{^vY%v3 zu)Pxze2|jmjYPcad8o`G1U-N#S=11VuVXMNuqEnkzTRk1vugd%s@HbilVcb+DtwP= z+QA$O{NA8DssZPc>wk21?^<)u1%&bk#O7F1mB&AYhPp5B$%zq%N8{2yV?05?Iw{ECngu5z-?7U&G zxhiZ^b|3XikKBwS!Z!u(KV&jjF3yc@gd1UuROXBK74scqtJ9$P3rVrnY>?IecsE3wJ5EK46 z-CR$zai}QEhr^=R|MOkU=8fJGBV;@w$%e))exJYt;hh&``GiXJhJxlymi@GktFFgx z#-6Nnp6La7g{bwXc%Qhhyh(5Wp6z@8)lC_A-{O8#ucCMdpKf@;u?49iKPbewz5r2ahq!YV)XU<(9zex@`y z3h->STTpml%EmEZFUlUJ2(VeEkbN|gqY$daVK3QHJFxF*09$(64q9KRV^7b1f?~X^ z34At4VrhuRmRbR@VhQqAONAK2{Y62BUueZBk-|A8ecYTlxgQe8-7;ZhUj;wXT~iT(SZ=KFvjy{Mq1wG^bLOr95)a6?yGwzveewdSpc0G zItOG#G==4+sEixCVE^!Vp~Zta=m5xE_U&FRtBFKn$C5hIa1h(17y^UDH>UgRVV!w5gISAszV`h1ZPnn5_VM<0IpBB%b4?e6kpzsu#4k(O^+tn*U zW5RdUVC%c=WvX~^@|gEQnSokk<@GrLS_nEk7D0_)6WM&B0B~i|N5xtN;Sm1!w2Q1) zj+G6t4r8TH3Yj})$xGKG%Px`f{P+|kCF>Uw$7o~&YD9^mA4w(PUh*{woSs*EV?noZ zjmGRrFium?6*D^=knG$^cpUKTgxAgmLTmeEEoFILsoA z>0Oh7<7_p}1Tr|2$ryRR|d-J5Ld=@k7XbY49a0Xe z6$Ok6!J7st(*e&HUSUW%T-i77OWYhoq<$_+p5p~9MFDFGMX>WpRod`B!FatIQ0zCg zQ&51)_lg39el2Q)wc)sb*69XfLux|>qz&dZvd`o~z^Wx;=p}3;72?o0IbxzKdt+8~ z>*jgEd96bBFCb21ZsC&yze!!FF{GE~1J)wPnimZCWTNd;Hs9U0$rxB@ds1U4R{|v}F361Dra3-dXR^nUZ#VaUal$$2`9}n= za6P@jhs^-^hCB1y?%4e;aic*XixpK9>_UAaP5#5l?>c;snkyhVZ1VLOdh5%d<$kb|61|IqXMp$Tp<72j+@%SA{y%m=X`C00n^OIjS3!Ft$ki8?WJ@Z zT{AxMu%!FYPHr)|GzwDjH>^||oaveGq86~4%~@`anC%Hp9L8!ER*(=bq$4c4j)_^= z(vf+Zjp|9*CwSo{NjKpRjv$mXe2bIOLvXUbIsgr=Ausmpi!A^1UI##A4w1|Ya+Wue ztG32*_^?Y@AdbxKmXA%VNZra^Z;QEQNr-a|Y4%5Z+7Df9lFDn2i{W5(NgUGW@`idS~O zZrg2-`MfVBzJMc_U`VWSb&*j4JG<&>&nQ!pue=+G{j2mcsDHQ!qS=?4a5(08BgxISHcFX4;DTIO`Ba_^E`d?V@3ti)tjtrx-oBF{3@hVe?;%asLR{@5bM<_XtpT%lP_oUK?UfmqX~ z(0nPuFPDqtVcT=2%>|YFciK7piB(!i-3BOMn5wdMOCAmO<>3TM;t&vbCw$-n|Di3Z zr75#x5ighcu&bRM#9{0*7mj=x?F>txFKi(}!HA9cxlYfa6YK%ebb+Uu*N<4I_C~uK zc^XUE<;DP;V_IUS_v(Kxurb12cE)zt^KDP?0*AY7zWuB^SCXQmsf7vtD7TlA1J@CG(Y&Y{} z2}~}CdbrX>uF3;#_tpT?m3{}T!~7BSO++Ki7F4AQHDtUpZmg3GQtUm?-ttWv&8JG1 zJ!F_=RwExoOt&#T5P4hf+K1}=lhwP&5hYA6JXL&Lx5eF zaj>{f2K-RGQ`sH&G9{-pgs@#a9MD*T0Ms$r@L(6{z{We&;rr2hz9EAPriGUous@|dKD8iG% zP!IXkreaA-(adCRihNY&Ca8LD!b!TseEXFKoH3J+TZ?$({Cul3fBi1A@=hNfRT4NG zdsJbs5yWe@j8%xgdwH}fBKA(sN-1``&o3cuCh02pP(9b@zS8H#o{;Lj5P~*y|!`Y}5SeF+}cpz37XWo>z`qFEnNy^r68B zKSgEIYO0;YTVFrr?+b0DpTu2R-@#KaOX@*d-zoh4xmXQW3dC6$vB3_2!1NbO4B(x) zW0!UNfsFeyNYeulDyJCDOna3LjnOGh?89anL}GBxa@zqT`%G~WSRwMh7Ru*Kbt}CC zcBE3T_8NwSOGwB2GEFS!chp&9#|Xvca?e?33Myr2Y5t>mtf2Kz_%;+j*-W@+1R<-f zrxDKn2g;iiynKpkzM(`Pwb<%dzKGm^Xp+k7MooRj0H5^hyN(%qX`t3@&2ho|H*l{E z!IT?#+DAm`O*nTu7JSsBa&xyC0kIKYr$q19-Jh?{_N$Q6m1oTCV0oIQ#DS87aY6M? zySek?-|2eBAY%-(tz0@6ow!ao_;l+%W|a*dB2LZ2#up0l{AaRd_MReT!sxT^D#{<> zS_3o*&7UT^$G%1u*)Us{G1Bi)u=%a~X_`L5#@YX*5B81q|B>qRG2m4(Xy_ygXI{DN za=+LsWoAy9zA&kyWlKBz+)@E)`UR#iW^cCp!Xk4k7(WQ?L`Y-_EKJ=}@~sQ6DpNto z%5_+6zeU6Xg4{q5LfFE9cp&`@hQaXB7U@*n4+xVjRtmAFl6)5PPOjlivOd=t7%PGG z6ChdHKX%M;l6@>DkA7(X4efUDY6v4V@IDb`gb`l71yngTCwbqUbr>)UiCn_Xj)# zSQd~$rt^<=DRxlZMRH=U0#&b4_w*qJCBsnsrJdbYako=i0*4E3<i1@-p3awI#pgK{7Gq^j`6XOG9Ds>B5k84n3ppANySWicG6)})W@`?JIVGrI zeeNs5r6(|&9zy7FQ6b#<^84QPFDOg$LD z9Bb+Z%H(M;vOoL8GDSZCE6&M3e6xO)YoS@hIj{&qyUg^u3FcR?zi{kU{_Z;c+JH9f_|C9 zp11cHa{WI~rGg;L*$$vV2pT9V?LP&3&gQb+?__1`4TWU+0I~G8sr2mH=Ttq$$(PFB zgUqfylyHS-)Nqzfvk0wMsMUcwcT_5)t=Z^AzmLdNw7q)G9ywCiJ~)J%WXIr(jkHGZ zyx0(#vgv7S9VR?*Ot{|jjhd2YqSp(=u_mknx=Q7srN9-e^Zq) zu%(Cf(j9nW{g;*fO!_*4uE!m|jvHK1FbXkHqvHLj7`|!JF}-;A+nvd_Xhoh2rautT zx7kxnlqb`85HG&|A5R-zkb#aqcIVpD;88$l+BPcxqQCd^l_RBdrXA3Z5CXX%pU zSF6OJjS(=FybWlkg2aZu4)k=!FHrQBo+wwi!#Fh~Rls~!j(u@;vyP@N3}DxaTv!}f zgme@pi@H+fpG#^)#sEhA!*(D09nDI)5{>P^^qyyJF&ue}q2F&IAKh;m0JPJ_B-yCW z>ra5Hf}Q1(#wHojxsZ~Z-H7tD9Y> zjnT*{_67?x%Z;N~Xrwn!*S31e_x3<@i?yhMKQULE5*sa$BZC<&iaoW`rM~t__tStb zqct55kymlHuHBbs_>6dCu#`JW9Nl*ZBeUMVX$VZl*K@r7Dm{41c&q7KK4d*uXJ`W-ah11sauz{7TG7MI_W@uN;;uYv3e)b8QQ%Qq&91K*un67;{zPiTk*jPF?+)JXj4Tp zICMXq;M5%%HxT4wLBWDad}9!_?A~*wO{aHD##%==`}P=vHws*;x+UY%gZ;QFTH1#W zxpCvOn6bw9Q4&~IB~+jdQy{Eg|J+wwhuETX{u!Vg71*HnIa<>i{3wA&CZoCNy7Z)p0b!MDe{$i^i~kW(%`X(Fp+DObsfgZUHH#Kjody|Bq^) zJ1$@#@HN4JS(&I3hBH|%XHy(Xtc-98q#~44^GWCu_4|d??%^n!pC=Pkj%OilOhvV5 zooj+rHm)ZdOZsxu1xsaxe~`D1h}vmsp09o5>zG7PKep!6UJEDDjfMqX79)Ma!!nZW zx35UaeJ(74@Cb|yq91mEgDJM&gze8@3Mf}-(QN9UA}j`m_I*M&6M{{DCB=r!YQLeT z=;&i&P`)_36|Xk+*fDG0@f_Z?u6>d`sB_$k>w;>nw=b(e-{h+uq9&2J$>>euw1Nx6 z)(qs!ilDx|h;{B^7mlP=D*euox`pCp;yn3`C(7@MpDx=>zUjdBJ(DkLOp5n2VRzi__X>KrCf#%7Mz>SMIFrbGO!u$Wqid1 zHv*(`mH&t0LpNSZ#f(iN;!Cb}5Yu<^Jr4Q$$4A_k)8rxxz&)^!+hy721up}Q%iI_- zmA$>&P-jeO5Woy`j%d-&sLaY~98bNjq1aQDXLdF<$5T zBd09OJ)<#U6Ot>Tm2Yi}jna;URpPd{&p%|6ZPVm$5FWsqd^aRJ7#PicAeh(MR~M?) z_hQ*@BP`HX8ofpQ?{=r1W~tFI-tqg5hdPoeBXi{#6!T2DR<5`-a<5XAh#&Uvp%(92 z3uB5*<5fo4;M|0`D&~PPaJ?%mQDJa*#^{u#duT!UH%=@bNS<0E31Wg9ZO0C8%NTJk#9fa+!tnyEbi1g`U0 zkyT!Hd|3s=XMsnY^k8lMu?t~DBBNx8!NIhbQhA@)lA-vd^}@>kgEZv*LI zD3JbuG@$}@*(szI-6F0bKpSgI7g)>{TD3*j)m6VJMKTS)7QMJ`w@r^36(Pz(?WB{F z3_%8i)m{p!p9R;$A9EU*!h?2EqP+PmOu?JDao@4@Pe4gFPQI1I7HpPrd1h&4KDm6C z=5I1)^F4X6)`wP6O>5)yY3ZdAY+ZpIQI!f-B^nHNu`Lw?DqVjdthKeNLrhU}AX4fXmJ ztNGY^i>>`vr>4*95VLYDiE?RHxvjK==p#6H@(SMiH5eV_)8-YNH6id0S_EOPC$y_v zIo9vEya$*tnp+FE=D{}^T{AC@DFihq0nYHRRgJw z=Lowu%gbjduFm~Ey9(XW!qgUw7&ff zm&kPcm63_*Lvk*1vbG6{Wd z1s~-!W-t4EY#n?#AvLw+aGH%tjW@a)<-i1@(SyoF@NRG?jU?dWg?9#*{bdR?D>-1^ zwfp2wIzgAwJ&G?EuS3Hp+fj6;m1WV7u+eD7>pL`$iopgYHlQ2;1YR6iftIKdb0cPl z{f8zIy)Ou=#P%Qwi{2!>r{NauYZ?Htx+$CFsPD0mJvwDvrD3A(niM^UqR{=RJ3e(f zGu^`vnu;xyl^2`d9jgU?Gm3u)uC>I>N1>pSlK*C*BYJpSZ#$&N1%oT-;IJLlI}(-cQN?G^i0*#HSi-ZP3-G;s1iTg0y@XP4cqHQ;^f1l zy)$r#dsLAU&sxk8m^G582w9?Os09915_e#2yHZm&v>uYKeNo z@4e}OLmtdvD?3HQ&kVU54fzx{A;bhVRk)c6vmKrmpIwry*v`*`v%h*fWCOXD7DjTs zGccOf;0@N8S!vG1k?zy~>zaiM^vIwOFkg3EPiG~tO5wfLkn<-OMl)gP+p_mi%L z$job>SQ{d$YHT=l2dcX)jh|dW%7_<4xUP2kQ2T>K)*21D;Xngke5Z@UVNTclbU0|j zta2LvE_rR9a&GR&GSCn+f0B{Y7|C1v4S0Y&By?r@CvI{|;`~_4w&l>iq3!rcU^HxW z{a6@T>TQX|E)>Gz`!n#vK$1;KJRwvjtmO5hpd1#SXGlRB9X=i(4Wp?9@|@?Np|ayZ zcy?wfI_cxD3^4waZ&g^h=f*IKmT82gMyy#@lwMj0tm^GJG;~|+w#kRz4mye%F zSYr_HGttXv`MLtd^UJ=sY1_oBW-P9D`8`|E+LDve0is|E z%3<2#r%2pp2eIm%b&Xk1R8vRIX(;|Hq+7EP~2r)xqizYGwlU-X8p7qfM{MJMwFRVRB z8jI>bCR7c{?Ls`Vw0z3gOci4JB5S~kDdGvECmh3W)`_GsFSfo#I{f9 z0n$gpud7rkb>JgewW>H~1g=55Wl%11NA6c7S31?|)w_`TfbD`UYxfN)0r05i?$hfB zZOQYxAb!lk4baFkq4HcS!oD&FulKuO z{5K~LU>bjTCFs)+GAZ@bRgQp@OwEiE%2LGlH8I{S^l-y&XM>ZZ|2Mh6olOC&>$JCw zsg;0=ZiFCwK&ein500+6DI+C?X#kXbpX5QjihC!S{dd8tlK-{O{f|YTH={9gq(YOL z{n~Q_Be$vYyX$jOuUg%V4X+FynI{|2L8S@*Dc7-6wqN=JO)-}|7C1Z#!P7pclBNZ@ zXyj?W`OgV>Q<_Q11*%#>f@=Uhh7IV`TRvL#A_x7hAVKYa{Nm!|Trs9Qfop)&m@Li2 zFXNM%VtPNE<=MLw0#LmV)Y7P)Uz8CXvD;pn8BEzHymZq-0*iKh%}26 z97;?Pl;Jz6nCOaiL6lL%%7&|WF3b{-BI(n+z7y5Za1z5P-8>D0FC58ts}=;f1Mo4zHcsGLjz! zZ#|!nVVFr@V_9x&)(ePs>K}qG&OJqN+e=97lEQ6$wU@}A5i5sCZxS|lw-QG(75$s^ z3Qe5mfot$|3L)VyiyP=^hkra@`v%me8xf}6*{ON^v9&RMdB>fYy)tSaQhJ={X@>TvtzL(cK@ldav z5k@=eLI{(3GO-mB>skR7FuJrd`JRu@Vt2W2#q^OsAZqmN`L>1lotonEJ(_x%EZ8oZD#hr-XD0`OXy>FlwSe`Y<+i0j25R zHuo?niU52TD8@UYWm^q2RKq@{96A`46I~s4;70nEk>Mo0E%Xzp$B}hc**AX@WzJJ(2GF(}PJIN0$`^8pR zmf4iDfkVBM_yER5nQ{sL-tDta`bF-xo)|kUUXePp>`bw)qaKdEyV3u)5HsP{G&R=@ zaC7tcvoC1zNrN+1x7TqrBYn;hg1@JwB+!?bH)&c9^zY=Xo|XnQr{ zc(}_EfU#tyd~GkPP_e)IR#96heNr*BqibT1k7VbEAq$RzF4zdxQQi%~Z!MC#l2Jv{ zm-NQk63Biri?FM-rW^L?b9dNH=_~wGukRY}CV_wkV{^yo0u51!|KLAeZ9E>$IBsi_ zMXI|_@yUy-UgSrAmc0&DX;NE7rN|N9?Rz*^Jmz zcjJt+RI&@*-6WET&y39tq5|3M?*fCGN{5ZK26b)L zeM3V)jcJ8Vk)m##UQ}2QM9zCti{TP!;5pz@^9E<3w~g_>l}2rB@Bk93D8W+!$g7qx z=@tqO^6%-a@pwjiae5Gw`(Cy|9ZY$-tqfUD|8y~U)@Cxn?NZSK)WpHN_Bwo$Mvqm` z2g}pfgqHLREaN{Oc*X+aY2{x=C`0o@`W-rrDsPQN>Ew<470CyGC_V>)OO{AWcH<+k z{Y>-7)jDjOr&Fq7a$9tD4Q&rb8#TJ%6Z=c1;=Se*^}PRnVs*aGLY%D{$l)tIHGJ(XEtUTNu(L&Y0s3~52O2+0rkb5SVg z_>+FWuo>?o&4;YK@}if-ybjgJN=P0z?~q>VL>soQ!W5Os$XjtTKV?ycE1x!UvGe9| zl^rC}<9A>CxHe_~0XQaX@~!&K6+}Lz{7u-sAHP4In4CB&A&3mCn#a^_@z+AclPRp@ z{wRPuOO`tpRaYP8N~3EArFDJ92$SI0u$R(pgff7C;~5WER%Czv8ek9mxCrOTNa)}x z3nV-{@FsF>7S^F>{QwXzqkPTKKMSG8 zs6I0|>)o0(1uc!b_E4z-u4e*yZ&T$VK?7}F1n0UR7>c-x*yrR~b?GmBvtT6MrNY^9 zRpH;1X)@cW26J%@E@jAgDNlfDG|Tr?b=aDS13a>)7qE!hl zR?cO(8&Yf8)=M$%9B(pkKu0e4#qDLGu*Q4DsW&L z5L0Bmk$(lRmIWUU;B*(#;n+#HKjCx}c@Y)xsc&r*3bAJxG3!$*7p=&hLt%@A!wKFlB@vagB{8Cl)-BYkFN4e&e!bDRmfsvWE69cs?_+)SL^A05;icY zzzstDbLrFA9s6g%adx%|C0HID|uY(Dk z|G4d|`arPYDLwsa5w%cwx)w7#_-(xLZGT7(Bu%iDXOjOPABGP>tD^e$S6oz{>R}b_ zdD?*$2T44@s5oan2D$PnMSUN6;c~+lvfwJgp2jkE)4^WLpfJoaNG9whKGzrgMIrZ9 z-~6Pi3`EqNh#cQ9*CLd>Rqkd1RuP6V4ay8%6oDo=_gAi$i#i?X^>Hwf%Ju3|pBjZhwbAQR_TY{>ou;V94Jf z%Ofyp(e-G~ZW6)`&XV-VvTi`#S0!AQ;&b>*{P!}0QUPeOIpv|Et9TC#{>Qc+QMzwD zF>>poV%A~`7)BVW#a+>6o!cjJQK9l6n)tEs!-2I%`#gMwS0dSBC!Si|@L{9qZOQV@ zj)u5oI)k>FxhDwD|5iH_^?UwXR!_WR{YKc+VCT*P@e+A*+JspAB2;}YjHCDN;>tPGhV+bc0gied2fM!`cObbHd+TXJq8QW`UY}$iu(80pK8wBziz#CWxK@%gzROE zYwXxtTmO5mU4O&lYi)lloUG4mBsqYa6*Y~M(IiW+PJDk*5n#O2Z(JYD(@#+&vb~Fa z0LE;CJ`^v1#lK{psOq;#q2vy-T; zDwS#W0yuHavppEjD6&K2bByl%`TMx>MzzuY9r-l<1Ag5e#!jiJJFr$rn6dvHl&X)E zecQ&vp58zM`HJk~vb7198R1IRC->B{rt-jYpN2ME~u5)SBsxjMo zvxHA)JMj}K4(9lPMyZB$?R@pUXg>z_Nj^buXJi6C7fnshv0fUJ;+MTf`2k|;iM0b+ zQTC48%rA){gsF>=qlu)5IXOb);tpqH>0E1Ejz4szEGL)zPHW}{`ljS z2Bip_=l;$>bteh>YUz&`U-D}wg-Ya>xe1dS5MsQot61$6LRfY{F6LvsZ7(;&tp zHaQDk1{GZLtusC9o#_xgc@=(L{Oc6n_{9KlJ^oc|4-mq%>`qG8ESph|?A*}*Qlk_R zY;9+Pl6>Ob#8~%4yU~9y6xKF~PA$7}+gf}jRBDvamC@{`8b~L?32GRFUCJ%AcP82N z6yQCRbNn%ljfZ~)u7o%Yy7LNpbh&?okk}Nzza%c9UHZya8xTL`|L73*kNHxgF)0qx zG$QmR9O;I;O_m}`D~CbrJQVf3CVHot4%YTS7so5b9z^98?6E~e;~Ff~=?P_U&n!np zwXElw=^~J_X@%GV2{GKrs8_cit1uoG#<|Q2!ni-o=TPoyhGexZ>GYl8LIgoYB83l7 z1aYuM5LnrV{-zyMs8w$(z$ift-MVej0wrgRDZJ3w<+25=G7L3Cd?) zq%0U6E1@2jTZ#fyZyo0I3Vl$Zaz2tW`Fhf#r)z`FMw-L|3%7+d#E>?mU&(Qz!gmW_ z*iDz!5ghe9o{Wx{fgnxhIq{&UtzGzUt4NqlRmtT-HiY<6E^#kTCY}^>cI(0AvOap6 zx^$s2wQvL=@QC%3dQ%@34m4q#gFm}|C3yLv@09aeiE##B;s|Dv0NkLn*|3C$3(7s}`Doq+1w72rg(VOZ@X9%-v7#gS{bNpF@v4?UCu z&{{`hoSl#jQp^u~84TP?R^y_6J$>92JVHPBN09ilRJS8ZGy6|DsufVEuBwqcR5qDc zzPs_FXf4&RA6ouI|D8(-7?L>1NRAGGo41ojI|p0vGlT~V@+6|jJN~eH01klaAX7z9 z1Rl$PK{?>7CI3-=3sW9r1Np+{t_a|1kCPI#ovnD*+vZT_-zEvM5~V}rhkc=m({ds* z#c;uUV9cyX0?k(+1yQg4s$YA+-T@_}sh>*;HM`R|;m~K!aM;w^m?fzPB3i&JD>ygl zcYZQFL7$W zrdo@PoeM5TVCTkPEIZ0`z1kuG7BPqc7|cT%4^X~ z$a7Xe4l(G>JDmRup-5rc1cNl#yx{KUqU+?90*;JRpkZg zl7Oy-g)u6ZiXH36NAQ-Sni*okM(f9qez@WS?hN5nQCMc8)89sU%Cwex(PVixg7um5 zx0{Lxf0~EBc6q+=&CBOl{GmH4DQx;}Vf)rOUC{uk*DGMU1@~dlR|^=_oo9LcJMpq4^l!b*Rhmo`n^b^_{CShpgGc*lSL_Kz)R33X{M_Ue2)3NG8;|8A842Q^^f z6owo>bC8ycxN$Awj~uF2E<{);Sp=?f?-e_pdANlE$ID~%ZX+y2+-uoy*%Jx}Ss=(B zmK41-+JK^z8<76{CICA?#J}{|R<1^W9U}JVnk7HzLXf=vQZKD1U6KzfMvNdtN{dT@ z!cL^_OnYyBK7XG5_b&e=UJBpyr#I94Q$_st&gJ7^1dk(4^n@E_a|DY1wrA#FN1Ap&hSAUu zwx_zG{oSm?rdPks84`C>@v<^iiq zv4eC4?h$K40HYQ3JcUT*dF=uPs~-hATpJKF4CQK%W^;C5p)OhtD~t+En(bJgN7%?( zy5<6F&n?;zL`DonnMn(V!@I3v(+N^U>E7yF)k*G^2f=pcuoECYA97!4%<2~a^PU*aKDO2ypp@xW_`v@AcB`{XA@{pUpRo+- z7BS3o4ZzguO%W@PVAI#U=+Ztt)$d!qcbiie?+7VC-9W$qoF^5uHF!eT)8K5&J_WMQ zJrPCN0~AewCG1tMgkyR_+r2J1KCnTP+mgDXE5AXIqFH9`U&1a7_gFTVG?t}uNT1i_ ztx%}|mNkOX!si@ac$F6Pi;fDX#11B}OcC4-swo?x&X<^Z;+->cBRFQqHaJrWJ>$ne z_S{j_BK}0Pc|uIgcePWVT7a$(_&ZN|Z%N|%pPrI5)Jr|*#26QQWN|DJYDWJY$zJXA zwZ>1_zeM6~Bs=wO#W5p24M8ZQ^o zfQED7jQ`pEJkMR#Os&_Yr}IBNrJ8^vs^+^T%)O2pWaUM5hD@nt%k2AJ62rM6Bp^=XS|(GFSq{EB?OFLar_s*h+NPW4>H3H{`2c$8Kc zOEQM2=pae6RRI}3IfgITFk{e=Wi8kmUxbBv7);xYFN#dTg>g9TaYf+tZ^167p#eYS zmJMtOjCru8mRjZ3-4`)B0ne*&Z@al0TtV~f!ajCOp_%hWK(~^^Ez^+JYH{id?-iOe zp(a-q6<^TYFKYY#DCz3Fc1!_x#q5L$+ty$vM*a2<)NYNJr~S*FGluZldicE|I(tNp z0CLsvh^88|TphOBjo<*i+wj@mFXy`qp;>98GKx1oAea57+5zoYgS6=(0p1a-lq#9GR>ry+4 zlaR4%nWm3SYkrX_vZxJO;hDY#A;hCw~4=!X%NXVxiR?4OAr>}*hLwtIqq)nh8x2sKubBzZXs0`}L7!7(o2D&?d{Wc=i>AVdbv;2O^?oXqQ#y`)23)Stzx{ z0GEhj)a3Y7b;r6+ssV4VQQZlZ9(e|_cDuiE!U?LdZ?VCj1G_L&wkk87kdmVusTZdP zdfC-4N`Y~4Z!ZfKS<(d>{K|=Lw|XT+@#1gceCS}>0<2!)G*59=0G!fTNKOl@pd=a~ zPkcvx*+@#eVCrgBwZ$_K)hc?*9iYn3T~E*pH-*yFxsyf$(nM@Q8<@tjh7-m`QE=?| zt)dgqh3GQ3C$!YS7xGPN_9l>YN&VqwP&55$qN^7T$(k z1<3gMrjaLiIYB72$1^O@f61nNUj2sd!HUdGF)+6zY2r6NMT99PasyKqda)sDa5el3 zmC+=u82QPm9-K?q-dBs@xm&Pxnyy)Bd?dS&8lwhXq#{kJ6?RTGD_B`XeYOfgQ&8B# zZv*Piik}p#u_t2luxiY>9Cm}FfOZhq_n=g-7|FUJZ~7py2FPbv5(@;(ldbvB7*hfp z_mA-292A=k@*rcKxiI(7Yk|tPly37>sU+SrnTgv$N|0ySl!K&R!*zr&)~`f0(t^23 zO2Qi1u{1u%{vTRW@;~?(w)#lhLxNwu&r^9Up@R*ns{l#E1gm!dFRZ-&K8LQoG71A4 zha4j@+o*M~WnxMHcg;H|tYu;eg69@dt%S}VbgLcijsH=ifR)jOm^N#`ma5RV0c@Xt7SCH_hY4t_p$N)yF58<0oR=;gC&BttU zdz1=fXokAs=Z59P0HTkgIJuU*o_^Ify|&S;YAOb!mWA@_7TzU?-x9QZi%eS(kt1mD z(x95@SgH>xXi%RK27;>`%zWZH*M+KV<``B@!A<+vsAF`Wg4Afxs%ZtEI7|z~ka@0# z+c<=xMFy$_^;##gYW;!|^gGqh=f|MaC$D$5gtoD zJ1+fTfdT9!Xy5BAJDc-!0Isgw3{Z2K@$-ZOUftQmFik<)jrzAs2@M!dFuLf%^YZ#w zzzbBrum^_~xd8DXoV5F0!e^H0UfUSglm)6Ky~a>85PAD`5w>tGgvwLaqB>!@2y7e9 zefA8o7&R7R zFGom;Jt!)#F-r+xc?UB~jr9iS5fq?F)hs~*qkY3F`5`*tZybOo9j&+kkc7&;f(okI z(E^9`LdF({@(8LNir}TkZ*nEiM++8)TnqsIk1k{>1cuo^f}1-d@jrw`9x8gx~b zqs5@v8Y)QuPW)O@mSc!I-GR32uqPDg&QQDN`0A7aZZ(CcAV1^|`c!w1Vr0M6)#Z$# zK5~}boAiODW-xJzj*PNf8})4MibO3@?{4T2zq`4+pU_%JH)f***7zwC50Ph*D1xh4 zTwMi5(+N7ww$FYMQe@ZnK!w6FfV=KS+9kpen=HT2sj4f!oro+5-Vf3Q!F;RcrLE8g ziONkweyp@*V1|rD$xE%T2iYJtu?l|NBWoXgBtCXl!j3rtW{>1R6a-eWo~m6yAPKG7 zImT;UvNw!HnMHL_4cMEVAN`6FTDxl3jt;zJo=16Tp$4kE1ph`#%^UTko$rxk7uP{4 z(&^``VS41bI} zbGEtlGBJC1=R}eZ%or4TqAohVWbtcdY^gDbUs48+zk#_fKG7J*eIdRf*)_mJ zQGgXndRn%o-rnbl(KOGD)Fe&=9Q#tO);}7)@S(Hc+!h4G1j1kw(XH!Sqij413h75N z+cF`6cNeT#Gs(Nco{)C4KE{(SmO>)zqf zWxkw~1rVwv!CJ=(hO3Nc+TB_%)v;z!);V2~@PVmm&^~=Y0LEr}PBTwQ@zjV3QEmx5 zvY0KC0=9a~pRi0~@6?;1z@(ZQvt}k~*j!Ye=UJ!8U=j)f9q6ay`WYGmd6Tdzx5bGE z2d-%FO>ud9+;`Z&_nYErT=I%n)(0pW#vmj;fl?V~1=E=nLl2vF=VB%~@pcWC(dQm) zY533hZPDh%Qv653a4WVV@qslKxN8#{OTZqt$4m8!~lG>b|gq!(zdQZRcrDd&~_CNg%ypn`#3ILI|+RC1VHdN;$1MunA*)!B_~ zJ=451G9_6VOA&qZc$8O}>l3dg%nojZ{O_ECC0+Wc3T=fZM5aD80tQj+$MOD3O?(C$ z`uJQL${OHFY(>-D4qt;q1wo84H(Htd>9T zj1&zf17+n)>WQxH+qU)>**QP!jpF}`n7f_Ut|}%hTZ|InOFTIJvjR?FS2*QOM0mKf zQi_efSIh+uJ4i&$!^<61LmWuV4*D>Nnm5qrZStEV)Q$pf63!4?K)`#$3cVR}2v#jw z*toP{*dRq`jsfc8A|V+Fr}zttEXQ_oZGbO0%A{J_Y3J?$%qj(h#OQl`g7bU6?pdYi zL$YgfkUrlcii+12fUM|&zrjUqyK-bgZ=3>bEKZwcWL=j9XM=Vc$pOtLbY})oiGroWrAfO&^QDdYMa5V&a3kl6O(^8 zoBIxMn1xJ(-yQ<_CpuFaaz23p2Nb6fv$pa!AQR~gB(g5lMjmhpdy;t%l2|+KggrY2 zxzf1qM-PewVG}k$R>!2lh8U<5WqkXdgeVnrjNK1@(>+Sy9a{)LPU1XhK3ShBG}?DF zPCIlKGB0$t)?|V46rP0UeY*RBGUuv{7e9OKWA3$S0FXD@1WybFhK5PMtaA$cWMJfK z{!y8<*{m9WyWtGs(mdDb-BYry^tTk2pdv3$_~*(T|1)aMe~9%T=f+IrVyEV4`u3HV z)-vtrbHGP|BxAbq>$7*E81p}CBxCi{031Hkb_XpDFQ>Hj&OgEcF3uPoI1UKQt~L-U z!PSS)U@PA|1!&o9+%KacvMI*o!jSE>ZBmEk5YOdP7TS`Kf8ds8y~0h02eL{QHeN3N z7lj|1JFUN^4&t6`>Y}(i99-7B-r=vRcj4GnD26jqc6!okdEl}n!5mWp?y)971S4(J zyLs&iyn|W7($AonY(@C=FAZI}dzp&G1?gSfd?6sy1Ra7sGm^Te$@THlK#9yo%DK0AaX zgigSKDTATfjush{N>b!9HM6QP5-GJf+RZzex?kHqcQ8ivf|}Z?Suq%r_}nbHcXoAf zSfk)XASp7ER@o1Y&Z|P_nc{^qKM~35rjE#&T$L!^EgE<|AdCqD?SCuknKAR$3@!m- zU-9^jl7$+XLfdpX&Vp7&>FZG>p)>_4Tyik5rW5|7b{vAThB+IE)1e(txMph_EMh)p z8Q|Rz@VP-_22!DAFtFC4P0@zlvYCUzfD`>yP;MVSXywn%LV)x6riAFpTu*lF6qRSf z93U1~16@`@R3vRArp|lDTiBY%IX}4C?Niqn$&py8kg(V6~Rbmzy-sb=7!5oj@s)#G9 zKg@{IIi8mkF@5gr#8U%)6fM#Gqzx+YJmXrp2j(b_t8lH05kTn@POp$a?5CgJGubP4 z1L!#|NZ`we2{eft{U{dUYG4tFW>u())$a5}Jv-m{@CFvS{?}6a3$z#ww9crUmT}N< z;B@|E&v-)4@opv#DWL)Sz-w~~Pbdr2QdJAp7feH7CeY&I`j2UF$^YS)fncjY6uq$j z4AqM-!EZ@A<))s{oF2i<(g@wu*GG3f6w8B^RDM3hPzSegfzD8 zM;+P@b~rn|_hJxCBP%gr?%Hm;$u)YhrG!mFYQ26%g71b`I-ho+1ov)OE9q)sXH=wn zdWkaxC>{-!4WhOIesG2ti(|t(#ym>y19n0i?3&_ILbU4!M)0-aTfYw@aEw|2tr`^rW4b zIpX0Cas%AmhKw~Ypfkl6BHqjieE3m$TP zdfdnJxX1<5=LpU~lXT|{*&7tfL#jXJ*8GS~Fr9t9#>6W)A7E<*`$Tog1qqOT z@}?ztb36E7rRPDyloqMQ9y~FGV>}QyU{-=zE_Ec1h3x^wVnn=|Mr8Z?WkZ_(Q!$*q zBiX4#6|k7UMwh46OA8gC4~~|yj3zMqt`6&+2I?o7)96a0M~Xbucjg(% z=Tbvn4>b=s1rZ4=GwL|#yivlNQQY~;+*YFAga@j7C9lMZ!T_2r-Uk~%{BdtDu{qv5C^mTxNJ*-L(!CkZ==q)i_cvF| zyMN$f3OBB;%0fmdiYMX$-8V=(6mPS4Pu7FA$a@GK_JZxVaJ4n(Je2dzFA_sU#+LrX zO7H$3M`y`DpSTmCWy9CkwX_TMUd{bx+1ptJBJO(nSM{5NsGK>cnhi~TyK((vs`b}_jm^rc?r%~Zacl?oMoc>^TM>= zp40y>6@b*FN8?H(<puH&qNJIFFrW$WoDeX;XGiR zarfB73H>!*nox%PkZt)6tkb9@-pVpI>Wljd4Z&5fHp$@fIcX-EpQvoA#baAHv143w zI46hh%g<3nBtlInvRz+aFTwA}CP6HvDTx%7 zCD4CROfHjyr;EDz9`ibD^U8E7Rzuq;i z;?q?Jmqjmsqc*<5QJ^A3-q^}|G#v0|Ix)1Qjh>y9uHZ}>Ej9HfBqX=YCy->^v5 zl$C6dzAr|5b?f}d{}~yBW3y~zsus}a`bWqF)5o9xV3-X>I&M*(ywv1uXJZ+p+^?rN z-Kouop~gGmz!%*~Sc{lpSCh!Jz!yySrIJMREEY~pwtlGY`Q_k)OzF}gb9y1yUB0M&?^k2x(9WU$y)}&&f$R09;sXOQLIF*7eKAI6sNKevcm%NE2;x z!d6Id(AnlGZEy`le4QyW{{t=RUdRtXKuMeb(f4A^n%;JYNSn&wbOTNEbV?3=rsHz` zD|?^T5~a>9d|(SY>DGhmj4^J9$-xfUJ~N=6Q=t19S!fL&l(@D#KKL0>d;TGlbF(#_ zc2Qqt(|y|DQ9?lagj?s*piWi+&mkyZhL*a}lR#52qf#!S5=2@PLk^FP2h@BFaO+ej zt93RzDQ&O{ypV$qS8RUZh(~I*u(vYyJc2&leEz~6HG>Cbo1dnpPE!uX9TYoE>~h!N zz?x|0o08i7youW{+04lyIIG>AmymFNNH!1+K$E>TllX0CBTCR5GNJ6GFGbV`_&{#W z;j{lcOlil`f|r!sHq^SDMUA#F$$QBZEKZ+QJl4G1<#I!{BD%PL=EdjU=2xT^_B107 zM|WY!pqy#j>-ta&GPnyzNL7kac|jF?x`ns3M~&bLV@rAfe3PAaa9wNM<@pC0vZHC< zfJxgVrDJjF0cf~Sf3fa;smo)OD z)ns&L`z=^*J4!j>;ITjko&zwS)n_9!E`@dA6J6;R3l21qn>0vVn}DP*Pwip`RvX&0 z-v(l-1q>Ju)O@MWnjCqTBzX;|xqDdSWy^3V2{>u=bGF7L&Otizd_O7nwndZn|j-fg#Au& zEglTb%uedN@hpTayk;BfJ7GMDd1MilhRP+CFr{{lR2U=CbpL4? zB;K!e=SvOVTglv)b739*^{ulW%IXq$pSg}G=A-io@=C}WE>$eK0}ra0V5I+=Xn)?# z_^6+y)Aj*B-R56a``cho$J^Gd8cHV?%vSTS4p9}Um(fll(73Dt>FS>F^##RQF47^f zBhHM+E49-R`BR+!`e}6Abp*>Ik)B2p*jNz!;)Kh7W7`RUrPzQbEYhT3f~ECqy0SQ^ zhjjj{=3tRcJJtpq%)xLN=cRJw_%MrZf#0$tDYgc`K1v@ip2$sMYJ9gjZE%R*>%Ja+ zrkDcMi<5~Nt^#(I655y#Yq(Rrj`zZINBYn$A{RlR5cMXkCc@4P{}LSjmFn2ph+>R# z^!_DVe;uHkwN&v*!jjIj>x;OP^5)&1?^_kd$|n*}y_Xj!C4byqZ?h`^Qv`?4vJ@h5 zfU}p!qu3fufmcXhz@yI`YSjc?j5%2CQO|Ezi9r>ABULx5cM51`eflIA!`?qCsVc*= zKvgw}4-210CX@|s($NJ3aq9ob>NF(61YOJ2PNpocXCDaE?E+V~jqF5hpp7l!M564g z*jc&AN_N3N57||^>8sOq_SVnHL7`Nbi2V1XTg6J!E57(U$-5QKdDt7YAxLpc5Q`BM zEhYVX`!(^AD|?*8igCM8uP6RCRZ_~SVQ{qV0T48I*RQ4hk9o)nXo8kJf@Hv01wyQ#^W-CO#zc#*T-w zq`yCPGch)J1a?KmE3pstu2V@|z9y*`{(Jp*Fd3GCrc9#Cz*@Vt;o4^y0fIjV>cC(b z_-`>sB&o2W{@O}^bg36$bujcaN{W%JS(iPkiUC%dRmyM7zP@*+7o*C2NtUYJ)p528 zGiq(m+u01x06zYLTt$QlDdbq+Z%3cq$D3y4o3uY1Qk-eCs^IFLB^OWO`gfPz3*!+U z@5f@J2G4${cJhPWkgI;e&zImV zXs)cL(#|rG-*J4#I!#TlMRV8QBu!Gn^|$(Tp!c!?J9~%#3IQ$ueEyJJ^|mowe3HiZ zT+if`Pp(vGQcSYMA-rFtEoUgS7ly*%&Brwiwo?1mF06exKzZj6?s%o1u!7RI5zO|& zW+c6$#IVObY7_NO?)5AR41-^IAX9%ODI zU!t}%>|=;QCA1DJvD_D-_Yc~GrLsj^Wsr1tl7cTBSW+JI7-pUH`JyvuYQ3QY>XJV9 z^LMi!`6lnjgn@0&S;RU5+5yp zJR)A!t(-Rj^0!_mT{3F4W+FDc9cBJ2L4G0jv-S&%bh?-C8k-8QzVT`e+4}44J?_qZ z9t8VUq)Ne52^OK9<=MVkP7-(gzoCm6q6~)5q?$nLd7w%)VHi9uARtR~h+7Y-=vB44 z0tQh<>jQTL*%2>~gT90Xi$jCE@)Y-FytvE=Wx0n7J6WM0R>X63-b%#?l z{GlBX4lBTBiZK`P(+gKD|Ym(?2&7RJJt?7ZVc zvpFXcC?b9eu}?q>)U&){JtP0bOH#mNpidmui_~I0$EZ3}15LlOket&i3v<1mo*3pRxKO()FENF|HhCt+vcW^Ai*TUoAR0GK=|xy1Lz*>W zYQ}vm9WDV?ftzg1h-s1WMURzzt*q!gc@x4|s41~jm$wQ1KjQ))*9qa~LK^T*3zpX) zx!&6u9vs*QhY@3wVOBE=b7kD&(8FOX9fVq{8Lx~Hri;HoGOXH(H;Qg^RQn3%&6H2SDwrm0gUUX%l#^$!$o0|U6l{oE>E9!-RvClm7kneMl#x*I(9n&$t84ZA(IM!AOiv2+iZwRG)bdYKu(IlO!` z@#LW!>KMzW;?UEBcR)mrEp_kaQt`gJ*>Sr6$S7++Led~6XO;FwONh($9Ow*;B&l8m zR0}O8$&e`jcafK>8ce_>`I|IMWFUca*{^lkE*Ie~>1@1@D>@TH9eI04ebq;v%Z8sV zO-4FFZV*AnL1*`&Z|u@^vw3qWC8x&4b!BQZ~ z@uR$JZ>+~2R7T|z3WH9d^1X_45@%7(KbI-O65R+xINwn$ zzdPp@&*l6P)lfnwAL5%kE>-b$SE5Tk|LDan;kk=a5e?9&5$};NmLt51me91`#2F0r z{3IMOH#{eLD}ss-y|%2Um(`j%(U$@~KYwX4;AZbWOljnicOu&Hjs>tPS|GmgvIWR^ zsVjX%w%+9>fc}r>zQEWNIC%w1t6P7iA|D4 z)a@NWrM$MDRYqG+Wmogw7`Y_4VLOqG;p8Rj=Ghj&=_8<&h^AF?OhnJT&m-k zxcdGtPa05%mUN+88$6+c3Brxc&=uuiTOAJ_*`RpO*)HS=N10T&ns4q0KemqKsdE9s z*k3tpcKuafLN~kpld1dHLIT4}{|WnAMZ{shplesE0C}5Cw47G4P{Ryz0yNXmW+e{j z9TUMl+I_4>_IMuD;~M|cxZdCEQ5d>>cr4O(2hDvE+AW+5g^zuBdX!POmr(kydlX(^S&q;3v-2*Wa0?5u%ph`>KU z0wtJ&R;aNDxmFgYHB=pqh`QAA zU}0dzsK5BP25yNH#|4eqwun2n4JX_0q5bN)H`wRl8qX3BoXI(9%8VY_bx=rc*1^QH z*w5*EJ@N@llN%TlX4c>z?7)rFIsbg zX0d!u*-R5QGDQhHjJW#16g}tXk9;qgqY3}dQ7Y&~{Z{G4bEZP>i8)%e_1RV|j;7og z9h*Y#T*#pxmqLt&$9#K?)!fwpfgmAHVix1Yb-VBi-M&S~i!*vD1={T7${X)6LCWBc zj13OZ$!hjts5lk9XEi=M^O3gAq+gJWkVL~YWgV6AMsV#0^L5qvd3~CZ_NA5fRZ=vN zsexuFd4%gCS@Z7v(9OZmWj3=X-fot<@Cs>G5mK9+OxSi!miHw~q}$GZp2vrpw;@c~ z_o$I1aef%K7BfkFGKE?>PDYG4M@u?$(2xPH(NkbFX86Z}Dh51X{ z)vpIS9!e*u-CLCy!@4Na&4oL%&eCtH+}}vfhXU%N|5Xif(J>UY^kA=4l|s&M=TuR; zXJLshVn!-9@}U;<&-%OWJUXL!6fA&(Qvw%9Yxm28_!`&%2|_^k(P>wY=NlL|}$O+$%DE^Ad}16|nx&^;&jkqF zc5>aLdQg*F-Cx(E-SYd-K5QpE7( z*{G3D4E3xM`;2w#fW)w^-p33Ixwq0C(l*NsC<5h4^8V8uK>E=gpwsDthr}+=VkN!Ca z+rB4QqRe@IMy#Cb95~ac6&WnDkm&$;%SaY51XH&Q6fTryEZU~$z$o(FU3_ndIA{c z<@m?ek`EL<7Ym4_zd{l(zngckTlo)tz>ieM9C1Ir$cE-nj&mcFqi>`~x8$$6xS_UN z2llGVu=1)IQoS3CiQl_!GOJVS5wtEAy@ehe$`Nhs3foK%tXDyWbxdxU5|ZlGL@R`< z2-npZN*9i8b?Mj_NFHe-!oZ+*K>yLg2=yu7sJTmXDEV>~>(GGLdipyHx~`sTnMCJ* z2%a6-Kd&6KzkSDytvy&wog9=%O0Pw`{pQ2+W`khKD`XCHib=I}l!gm=>BJiSd*J@K zDXV23jhV_Ha6k#O0PKv0(=!A3tv-^L$;IajWAY)-C0(T;W4-O3h~!N}LZSEL!?N~J zJw0AZ`6&J?(TvFC_0F&7l2O(+)0OHpOv~5Wg-xC9gqE@rbi+eQ(l4yI;0maN?ODl- z7AvRWqFIYyelG!z_2o^$a9IME4vVc)^3099+QEP~lI=c&-{W)=qh#9c##=1|?a+_FXqHq24}AXjId9g^Du<&t{>94c!uJ)-VaAhcta{3=|U z?fcV4em)n#(wH6ines!gRyK?{boinCN^jMthqk4i&S-)*uK& zguD=4N+M_<2?Efg_CR%mrGJm^L(s!H7@EzBi(f4Zf33)izplrT@nw#~-d7Q|)Ep{G z{-+qv2Nf-vTfXjqwHPp81t3V<5U9Q&t*4?uIL{vUXXhFw=m5 z=t;vQbrd@68Z*B#?MUmq|DU1{D?e_>$QAl4`FQE|E5^+7^0kO}XfY@|hb_z8B=Wkg zzf6AXa=Fkuj;r?#LQd&czaWG$3t@G7cs}w>%loQQSZZLQJYDYxEeabe1jtsal)}4F z=#$g7GJ&}oc}Qe=L{?aXOtkoXqHyT`?cuo44!hL>48AQ+c8>gF6NTx%Kp+IaLW07# zW>(sRe9MY9Z5jm`B$Qn=68#d~3PCyEs&a1uiOc7g7P8hg95j_cwPul<1PG^y3td60!(J()A2U4(rPi zOfb0BCYfnIFfgcSAb|m~v}yE8IPK^AN;?Vl2!v%9gI;(YV?Q7CF)B;593xX@0d(u67gHa8vIYkp)vYqge<#qbI#wmy{hcO)n%!M93|c4{mwvlgRyD(OCw@pqGC1)8!jBIs~p6inY4ME z?@-liqpZwv_CODu<_8Z#Af|}X=u|%xv||@hxfB-Z>$J9rbD$*dW)7Dw#MuTed=e}v zX59~+oaL%I*&<*g;A@32uC4TsY@)CFt;^cDK6j)7c)>~)Wo>`6toe)!%ip(t3*(6wIVkH#gOM$G07-s9>=c*jti zmi*_ZhSM}?bRpAk@WNQ#Ljxj1XNh-dll>u0N(EQ=A$ek1XOPXPlAdCH%?oka+z3RT z)lfqxSf4aGaT45vJQEp@Xh(7P@NZ+APcs9w+!Putq<+txZJycPQR(<83Pxs$rqK$f zN?wUZD4Y}B`D+${EWo)RsdJ{KUxA%4Hg$i59D6}-`N=aItEjErs~@X5G3>ORMuUg?NeG{I*DelgI-)hXpbd4rfM`g9leTUn6>diF;!i{$= z#0SnlsT(7AfkvmJrRam#5-D?{fZunHjQ0ks+tdEj^<)-BsmCdN{g37&jS?G(gGC!*wkJuq(}Wgf7(OiMGKKqb4^PLzY5={b@u^d4fC3TJOPDoo3ZP5qgEF3Iy!?@@3YR<+riB-q4F*F=o=#c}TH1>_sZYH+LkDKo8z{rZ8jU*o7i4k?-$6r9DGrtCn_)$+NZLlsUWf1XavXoND`bko+vvH% z(#}zb$p(XN>(JJ=1x&95;<ZFvMtjx9tquBZTD&2CZZ`(~4dDU}tlJg90gfq_?PG(wyacjUBFS;|6 z1OjY6E}uXwOPrNQt(q)oFZ4y(l{p%pkr~t7zQqlg(>%AIVgYnqv&t9yb&+hFnn$T= zP5Y9(Bz*R_`u%4-wNn`rQyG-j4NpL`hfVUm7kLzL)$fLRK7D>SutFV$U=^#=NDB1l zb$o?&An0r(Nqm52wQvFN?6fU6L4~kdP2W>m4?80f1q43R^9^7pIAFN~4tX2k2-+Va zJ9SpSUZZzII7HoXax?jEe%CDW%|zhSdxVrLX~^sZti4C)lX)LL+}{vWs4kS{RiU0s zVlLoO&L~v+nm+R#8^lSA89tiBddkcq5{f+_mQw_I4u=mDF}LI94Am#n>nm0n6k5Kl$6b#Ki5eUOsT$)B}8 zrv`^fI^0`rC<$@S!89J-;$=eUhiWTYKq&Rrcpq<8UmJ_c))EJuQbpzpBO*FNRz7(I zt>OlWl1gv;OWRFuCFzsu+^=r!s8*NOT&Ivn@^sjnnB(wb>OeN^-?Q1;HmQma_M|4*VDVAY{kIW^0h^8$yjNv$ngXXGa(rgJC$0^C3mHbCvb=&USGaKKe! z2L$H0Xs@-PP-#z83~^ca6g%`}!=i>PGrnFKCze#CFQiSG82n#|yUD`U8Z!hx_NkjM ztwKf3Q?Q*uVGbgyUx9h3!0IBpQ5@92VESopE9T~$V@xv8TDzjS8{)*7r!pA33BGZ1 zq}^1FBmd-97GA;Jhy|5NvQD*U2gE3kTbgmjeuP}Nce~}3 zXuM!_YCKiIA!m^9#c!`FF*oe+!Tf{+)##3C8U?)a8<0b;u)sN0aj>yEw4ZY*ers%F z=aZr5Sqn_K){y^AtL7auzDg}7B8WT$HzL6ucNS*Ux|zakEYqoF38B?r66qrNBDAO4 z^^8!RWJDouryS5J(yVkEy4~5z>fLthd9bPr?z+fUJu@$EAKV;KQVNgz}qZ4(2?pax+X^`y!)aG-66 zQ8;vM?xW-7v}*Cqt%)KTV@fL)JZAzlPJMTWQdQZmTk$AA`Px5*zfiKl(z7|iTCFJf z*7`Z`1|Hh^)j(@MRMUqjJv83F1zag?d_G9_Mo({Pe&`ek@O}cZnZa^eln|deM_8`B z3#5|?iiN7YjQ)vpVfG5(;)w7|h9+60iSqSymVhb1aP5K2cnS8v!1(WwpQ=yYeg7HY zC74dLc7CySosdo&cILSkp;~*8kSBHYYq%C`gk)HD)6v;+Ww(Ej?(ulxsl3`6m&xb`nEA`ySv*jFS^Xx7FRq zIc>u3%gEggC`L<$-|@$U?PVe=V}mx!3W2I%gLt?$7mqR*srqc!flDj&SdhuXw#9Xw zagPecwf(PT1P`bis#;3%kf=%T38Qd-d-2|%0H0LXC#cSy`Cfs1b?Or7)YK;50Z4i` z8f%wA_gWw)0FXSuoMZ^Gc*TQE80Qa0Bzgd{+BpM!`iCRlr|dWL&nOQ6*$^|Uu7^5* zsg63mH@`W8Nn-Z6VyyTbqfx2MC;RtaVJnvW6i=(_gx+gS3#eC87id=`Y)EG zX+>4Ih$89Nj%m4(%!5Lm!P=~Dw%5iWr332zntl1EK^;Z9LKo-1#xV6kg*;M+ZBzQd z#$QI3rQ)Nz3bn5Ar@MvArzkyq5Q|i~%a-<|Ye})K7-Psi?{bBD#a#cpKzB$dcz~{s zkNn_nN_ukDZ2Na6k+9h`K!r`oez2{0_{qZNDACq2tIQ9|>6l=(ec3;FMJpon0R$|f z6n+9red8qeMzT03QN#~)Ep)gr+vJjO!PAHE+c1s14OY7;rd*ahITo%D6j%I_FZoaz@66K!HDD#z46p8UkW0 zll!2sZ(iwX%NG>u2Jx94P^S0)C76CQ)r8SQ*o5Tef5M^WCaDGy0O#R2uz#M6?@@j_ z21Bg(aa>CM6uW2$;_y#~))D=G*d|q&#BXR@j#xw)3HBmHVm(`5+&4k~BM&ZX-IlzC zuanm@^(Y-Zxc0ximfw>g`wLb8Hpt{;_;9m@I!}?x3q{OU-=)t>U^k6BU$A&TAWkOm zR?lGu7x+lWmK__(|F^nEn)}X9Kt6HgiIB7CgDRG4U^j`rd`?sC9%T2Emb*VpYa5w9 zjX%EbV7n7>e1z3`tBnbYE4lQdpt#eBW>vmxy8b`cz{nGlyOC(ki<4I4#8oL1#U}C; z`k`1H60o_`#RSpmrpmBZ(2zZ98Ihm>+Z_owcgKYx>MR5Od`*FxImigk-&NyF8I!HN zF-yny23kSuB$RPLnw)eeJA(n>N#H}8bcUPqBPdr`GwJYiBa$?Mk=P`f;b zk`pl{2M6UE`&od<)~A8F`Nt5llMuz_9b3Tk!3hPZ1Tz;tH61jGAL9Ad6O1{F+zfzv zDU!zNvOQFkgW$-Ry}v_B5ZVhB<$7zx)D#P-%B-H1{6?N?TYnG~RgBW%SD>uuY`^9+ zq{~eL*Y+dL<^ao#E4QTSTL~EdcD-;H7k}ZZ+jcaaNa(i&>*iozl(L1xeF~6;a|*+; zj|t#VB_R7K51Q{~_2fmC$;00wsol=cbM$wN$veG`#&SO(gs&Q`=NjR>dH4t%P%J{2 zq8hK`iD-RM_p*p)Z-R_f!x~H0n9Td&|ocODmatIfAB}ua&RLdA=Vs)Nc z^qcmg)U^VQ-Cf|tDG{KB(x!h0%vEGEMcV|)#ISh+>G&7}BE?JhEFc z1Kjk{xC!dA0Nst3t&|W34*P$0$~4GgGu#w}{(J2&0e%sf#o}!W^3TM!U@9|X8^#d; zPeWc-F+B^a_vqym#%4_miL9;xq2`XxLh_1#Kkfs+@;$Wtp&N%<&@4=!ASsf*Kv}$l z&l)uR^?m)&BThKntD^Xihj>ErQXfL=N2b1A%BPQf&eOrWi=^-s@Pl*X_C6rD%mhk; zw&1{1`HW#rq0?`Jk&aprUY*4gmy>|L`6-uE8p=kJjai#&6xSE6imju-)$dMwzx^P) z>u5bgrMtJbglmx3g3Q3%5pvBfc6R)vH*PS6;zI6qB`8#`9WO_D= zJT(w&2WDTp?nw}n%D_ZUQa5$D$&VxWv6EZ@*t*hgw^#vy{Bbo6!%L)sbi5`_U-4^F z`R1u`N%UHg`f>=JsxW3g=*cY>o1IvQx3CE5ChGc#+A;OHPgwI^<(MmESjW50l*m!2 zBD8h0<5&_E;o$nU`SBVatuy30m^j~Y@4@=5TrF^PEdf~C&K4k-9+U6^`SF@9h3K-) z2#S~Bs{bwl^g}MGXtpoVl{=8T#uL0FduUu!mLMf4(R*F94i{imouKvDyY|oXwSNE! zOu~cGDd8!*+U#IQ##rV;$Z121ME=TkIowqXv3Ha_^%bJ~qNN_&igVOatN$tp1cR`HAS~~)GGolwS>{+=@W&o=IF^gTFb#c?Rx9M{0eK^zO ztyl+?`(kJGX;D-){NnkHx9qo_Q0f~>fhRv#{hFKj@X=`mzf}krG$Bha_zqDg;fMRI zG+YIc>x#zS46>oH)1T>ERde7U228bv=m7p8I&HB{%E(f59jsY9?!u<@2g1pjTtFdt zdnbs~sP#X0jxVM7zBP1>ghF#ZuUz*4I*u`iy#~myTgDvqG3G_jMpyJ6Rm4o;Z#X0_ zH~f=A@2H`jHGU_z!@r*9m@JPk2JC2=K&{L|HZ1D?$fi(%=&DL!2IRvdpsU=(>?2+H zfA)7`={=}nz(Lw%cve?*5;^f5Y8Ys^Qb6M>vZ`hyB zC8qym+X=sYngTQ49+9KXC+f*5mH8Jh`8kQum077=rt|yNz<=~5-txe;Y?r!cyxMWdeFLp=>ja=uP z1q!2@yq%)ZaWxjXS#@HcCMtA`Ou(0G2B{n2PiAtsaT00OCiB7vPhlH9hS{HiueBVRavJId&|#R%Jlsd=wNM#_^^4%fdSPSED2=-a6MC z%`k%jJY)-9Un&``MICb0uGfzmRjqn(y%}=W?6QabY)@(u2J`7+K4NOC8no;}`<%>U zSpmkKtDymz7n3vakIg(|Fjpq-!BAQ2=M=PT-=p{c^4EL;lx230+UR$LWtrcYK z;iRG{gN)TT0Or`?@#2tJMT8zP3sF0Nt>mVpqp(XFplb zce{h0$Ly$Qvxx3*i>Z}$4gxY&v*ZVwcf<8oh+S5mg|rWA*1v>7g;ic**@Iwe~h z{FDpXWy0ybT@^pT3^h5UTlJ#^UdVj{GyUp0OuL*J0x!%j0RWWMrFY+9VUYycq9#UY zU%+jRAV6mG^+0YdKVYzPKbzhFeT&E^D2(x4tSiJ@DPaQd)NSJp#|G?fkgwKV9ZPM9 znc?{1s71=W9HIm`xb@<#%4!DhCcIHM?p|?4_U5UWGGxPU0e)m=2Ka`{vNyC7J_hA?5wYvn-_qURUbT3^FWjYt=YjA=V2 zS*C0r>JJ-{wRm@I#yN1G2;D6ejEIF2(!$KRQbU$g^dJy2Zk8bGjKNQzCZFP2IgR1n zY)AEG!6`Iky~(|5QXa_7k@Z5!^(%g0^i7|i2giVpijWK9|wQW3tau9WudK< zGvVl2z&-@w#>|NEqq90P4a30nrvNuZVwtA5NDP+q&;jq9sfh$R^N=sxeh;8RK5M8+A57{+k6` z%Z%nh%#T99Pe0>uk%8l<7H(kxigX6`hg*{$HRSmbd#yf^>dNA{XQxfA+5Z9 z5-7M}0er(!bZ1{D5N1}~5b`t70yK9Y5}2cQYKdWIn=CMAE_h()>jyTX@r{HL<%}$j zOc;@XpOZiv&jHRo(q4>WlNrj zF%s4g`XIjzGLw9}8U6MA4TF2kY?%c65#zj=qsrKzq{Xmjib_ko@thw}cyp;ex+^X^ z7iTZQs7IQ2pD{3_Q#e>|GtqnrLA7i&9smcH}HtFIbg+V_xzO+;ie({!$d_zVOrPFr>w0Li;t3{U~-mf*N z@bT5XYjgPo}t~#%HBc zQ;(jUqW2bDNL_<{=_lUTRw)^{*7rr-iYXMMzcD5=AWpg+2cjg6>BY2}@$fJ;y+;y* zCpA=v5=0t_YzW-}kyV+eB+c{kJi#G(16!s=m6oOB?7ckpP4`$hm zyF**He&_@y6x)b_UQ}yAzAf)Oj9PM%pSA3pu!=1A#gw(!qca;J&wSO2y1TVxbf?M8PpX#8g znUa#ULH;FnzTBhEH(~u#=N3c>wFTs4*t++iA3`SkF|l)QG#uw$U<9&7=+@LpKhUo# z+_0u=Ov{F~M2D1EtI0|$Z4tYeX|!i&hWlzzBjz2WvZHRo=M&b>-fp^(=3Oc(i%Nbs zR4N%x#R1l+zdhl|f;xaTaA7}v70bph)%0l@50H-MOZe({y}ZDHcVx8>!V~mj4uOsn zCAof&!hToSL7V!3-7@;gfvW^l6KDSCWB5w^z7(V9AM5jg^h6p7`v?fd&XnvE!EmX4 z(6*WS&r0C%0EU;%ccsSDV*&~6F+xS2t-xQp$lve~=-3?ME|5W=1%wkAMXwjGYi|SDM`FD2oHdtx~z13x^CK|2qQ9jtD_f zKyDvV-k{#dh_B&hIShY~^4oMMK3fn51$9+(G{;rIXCxqPn3y4)N|DfwE&It1RfN=1 z&Gp^y4_;O_MnT>A693(fY)LnUIAKeByQACB8W>0-|gm z-ER@{Kt=$}0*}GZeczB`gw|1Hm=n<1q&AYk<;w{7BPqI<<I%0?fVjzuLj!n}wx7QjWOKH&l}J3*|}rQE{?^ZQt779+v|gID$j z_@YXE8EUlf9+bKQsJgsNJ(jFQm7i@B{QlTI-V%%(6VPkYnL3TOC9Dw3QwDgZeOd$! zDoLwMa!6@wTzR%Jqn`L?x&6^sp3<2e%JoOo)B{>ZYxed2?O-_;^5|#V3^&uc&1x*KZO;-cl`%f=bUOX?46g}pWIzeWAJTf-GgsS zOhOiB4>;O=1I`MzK*d93N|t}HHm(904nL9lx)2(VUsB~=RfU;`ZZe?NVx;2~9rHlv z)M`N_!*{_&MAj$}QG4QvNI=K*)~1g~_@Y#it(l~)XmXXOHlq0ydD@Syu7VCSzT|Xa zG&lw(@N_$HGs(jR{O@h|#-@EAtJ0yI=lf^2vXX^9afqxr$@e5635T=#~b zdn2FV9W^zUy(+CS>Juv|J=ooEj4b7gQ*3=gqj`vL|OXRZ3 zLofdsXrNg@)ef=+t-mPVZctmr2bR>%nn@Z^ny^vxF>3`^JcUM`SZ27nHlJ^?YjsPt zUNzDyT2*bF$+-X&sCS^>D#K~zHbnB4AGrxv-w{GRJDH}SXA$&b76>Ve9u(QX=ElAc zrPzp785`5HYeW&DspooV9GpIvE;p`H%N#X=4gTwKYvt_N%+H4(v<+FLA%|nRE#%PV z4YY#!B%Fz1+ht$=;PN-Q2)8*AFu)Ck6dokLB}Rfkz5f(Fx8I?NVaFesa%gtb?}C_l zq7x#GYw?^-N8o-(`eX{RFo~qP&0ax*ZscF7(Lbx_dzefOaKgK&m%-pv-zxRS9f4Lj z*{|hykGkF}lacSaOQfF(94Jtbv~xJMZ@?sVs=-9bJ__caRgcjI*c~ljz`=P;ii13Q zwtU3BWReJw-URN_Is2gQWN_Y*%L^3Bw&XCxELfdtCNc}xMmUxjVg}mpk#N7k>&Ekz zWLh&P<2`s13C}l$eS16n+Vq*b8+kEMyE4`K%V(m)c~a~r zvOWsLg#Uh#D+y#^?zl-MztdHDg(=p{5~^Lw5tw@3Swg7xo}RdO@})|AOAA7M z!pG+`eQys?1xYPvRey*4o@sGNaKTVQTdbIDBov*Ua%kMRytjm zW&*g#sKdji{(V5=eqq2C5;yqo#12r*Y@xlwkrT_f4`q@CJUKQ6psVP`(?X|f8}8K$ z>;B%Dq!+! z3Qi9BY+D0KgZOCirIAVsmUV-FFdzudS4fY*sbzBis+hRq_%E**9ql&$sP4Z7Nl1wL zM)w9^d@J= zc)+%}@dsxd0|Gdd^Qpt!4<59VO;Ab!xP(54l1a4EuKQz?ikYa@`{`in+Ozo!OT8+l zuf-rQf6Yd1e6F~Q1<2iR18V`6cG2@ozPUKesNWEo=a&N2I2jBfV*3XQy$!PjG|B{s z4SUm9=k3ZQk*plCP}^neF&2mOU&V-bV|jCYst6%QJlafw}KmP0e;o>_q_Q7971-6BK+k22QuaMeE^M}C0JJH@gx1mbVQ}{P$ z{uh6Rw3B3~0Z<%$X8GKqRaF|V*2IWg`Ksfxu+dkh-hVk<3jYeYj&V z5u15}Ee4C(b?`c(ZEQbI1%IVjGN|G$jrv@D9Zwm_qfKRrOS=*fpPC}2S{b`>WwCKN z4TrxQW9+@Jmf|OmQzSfhYB5wF6j%O(XQHsX(MpH;B_&C@NvF%tYmu$2h}HoPO+QO4 z#u3b?$DW>EU}3ymM^ie=%c~N1`+`eqqVQ-8t^WQW{kwd%GSfSZuR|-XRVA?wyvdP! z;fMA}Z^xRl9o)>GQYKib>0FIdI441k28@L9Jjw>K;7Am zrw|atga4vJ+G4ROjo?Eu2l#OEJfhSBD@~wox=!F5z`?h%u`|;N?+UFUA%_( zkGu(`riNtzC%W`(et@3n%%cACNttb}dJ&nx!TBg6DF6ga{QP;7-bhJ&dCT6acZIOr z54oY-+dprHa~}zWG>jop8F>?AkiRXyv++GPu8V|q58pd}1*QpOWLxU_AaCdQlN4e} zY~wUmPSEcPZlR9Hi#$rrzQfftI^&PZyF|=|A`=owPJ+^dI2MguZ$-cwuInm?g{Co& z-$zq5T2l8(kp)nRz-G?J*^zJdCgIEKhh7K>^xt*9Slxj^+EkM5o_IId?SnN4c4n*) zEz%dezJB!q8tN4opxfYbuO({?%UVVUyXW&G-l{%rNH7(QdTF|i+V^3b4@^v#KI#Y} zmUmV}KvlMT>Y;fa#D943rSeWW-BqA7zBPT|>j;2K26UKch)AO#c|AV1TblY)3C-(! zYDd-)7?EiaKJgE*tMZLdKccXga~uuZ=-&WIDC4=%$;~NdLH&gwc$pL3QkGp9rG;w*BF&$$L zM}CtFa?16T|XoQ;>&0bjVo#%qj+|%WL!Z0#P5f~_g-`wVQEMbG3%su2=nnk~ z8MeeI^^l{01kn8bB3vE<^KC+1s+MEoWjU~5p*n7<`qcUGs)&tuwZy_7A<^)B3$Dr_EY zg=2D_-2~%cK~tXwmKe!HK)izrE2_s0j-)8I_&8f0^^GHpV?uVuyJf?rid_C zI~VB{qxyChzx{Ju{O@yO-HgQG6p&ENFE1g}g5NSogg~~Pz^^}r>b6<`Oq0e*$QULz zAN6wv@j0(KQUE1{AX?R2j&1i=rsWzf~P8;_jcQFwZDeGbPC6r2L! zV<;@Iu{ca5JDWwz(EC>zPfDj#>X0mH6}^b4Itz&&L1JVt$aVufU9o3-P6ZiG`k`{_ zmt~~UWA%yCmO(>*yCLxy#o)aT$6PIIyPhue3l%+UInQyzxQx$V z@>Z`~ToLxg>$a23x>6%xic@nlf{n**7K+xZVqi}8*;?v|cgDbtH0jvG zM=Qd(QFs#N#svf?hx14IvqW&XO?@6)`hQae+_$ulx1KZre)mUM>4I~uxkpx&LAxLY zm^OM62L6C^%jXj}p{Tf~UG&HEhkQQvy1rd@~(~{oR z_e>}&T>z{Na-`;Q1aAzbjXfc-uJM-%a~_x~L1lRo}V!w1jre2v6gAP1hMgDlL*yC@*zda+A=;b2~E% zqL>P1;&B)Iv@15b1n1n)M}Fg$6**eo{}{!jR6k7;?!ufU8j17q4bDe-a62sdq#$b{ zzZse&mO9txSpp~2Q_NKcSGejphFPlRIO3Dr#mBt+wSHZJOvx|Cm3Xl_SN3kw4ED58 zwvG;Gi`*HFhV;W|@6?65H5l=`{A_GZDPeiARDR$o_`c5Af5V5vsqNhnj^|IAmxv{{ z4X)$J=YK8n*Y}`o0JDCs*?=X5GQtLSoODC^l8~(<-6A_pwzMl5TN}VPQRPkWG>x_E z7Ov6V{D_prE0LT~EaxiOo4i_(f<7JF)cKj51)Y~0YmVcVLe3>6*f{e0iWd_v6Riw$ zu@G2xo1*=!X3UXz@v3|_WzYI@xvc=(=k_0>!>;THt%oT_Y>XHnDK{A+fzT9K;|;}f z^bw=L0Lab?jQx{0rFbPQjUK$@LM5=kaf5%g!Ha1VbJqXsgs8E0myy76wQH^cz!zB$ zaokG+-O?t+wKjV2vedIq^b7#P1Evn-quDR<2SsqWbk!B=PLwc;QCgyGOH!IxY{AXN zlsJB?Sg#LGpQDUTPiiH_n0AM7PSZ)ECRdHP_i9?h--pw8hf0g^ zq}lwFNpb<+24#^&9V_}2HNw-ocyh*T3M8e^0;7BmhH$QZQfKUfy<6*qHKzJpuIUFT> zi3Ul9cO+1h+h#<3qJ*MwQ$}Ep$TC(cH?lIOs>$1XdC-R_A|ZS@5J4m9#3N;I`wR={ zI`%;KQ6`#$*^c>U{yO_l8&ac8jIfw1<(r~|t)03u6Q}r;95g6&WLL6#S{jLS?|5me zrvol93lb1lgD;Ay?t(yM+c1O7c@ zdW;Y29#^2;Fb_aPi4$;BzI>_bPp7eQ8EtCu+u{g0%Y>oiPWK zfl0&^>UHui^@^=udOgIi9gvsC62;xEnacQI#1$5y$)ma^F$kw*)hYg}a6TnNEOd`3 zO8$-%XnCs%&lS&t5*0?- z0lM88F$eh{xXg#Lkl=Lt3Ecav(VGLntG>}T(r&h0W287s?hBfFIaBd(7J&x+*IX@@ zJnX#zSA;)1`!X<#h#_D4q%=~tNO}YqOIIWYTH!Pwdl4EC2|^QqfmZ5lL{w}rGKd)% zX?9{06!|p*sORSluBy~q>Hl8TBys$Ua0 z19hiu*(50%8GLo$&nY$SC7jeTc;wi%>rufMh zVy$BBYYvzvKpUVagX>D!!erQmq0_YZSfe;Xn)L!vMHKIalOR%& z&X(zk!~MSty~;t&1_skiKRmXr`NR~S>x=Lor@HcO!i-A2uYUEX@M2+u$5Vp`JU~GG zY#X8s`4WF0SU#@i{=Xy?f`qo#58EDf@ABC{TcztqMm&lT*>%@3isqDjX$QotEM&ue z$vqAr$cr}UoY6r4vqa6=0SRA7>y=yx%k!&S8%lirujHKv0dddN0rx&=Z2PvhU<08Q zMBn=a;bF`_2&D~C1WCPdCPY@dh-k~pvQ!hAI+ag{f{PAuo15K%^CwBXH$dW(sG_4y zv`Bn#ky2kjdEXDMovTp2K`CiC#bEp(zWuPy3+sKZ#DN+o4_@WPV>-zFZ+8&Ot^kT~ zeV*-wI_WCLd_JWI0h6@qH4lmt8Tnw4?MeWe#?qMua_VP%V)n&s+~klVJ-udsWG}p4 zoMlu9)|Tm39*+#MVCcaXF%j_WGBK}SOcVTd>EkN$%iN?YOY zz=iBr?m3{J$w#vgntBX{2|f|d(I5`>zIEyP!@s#rsY=x+cx2?xAb&t%Us)J}qCww~ zF~YY^@AdDiqd_REcAg~ET$J8|yJYwM3KS9(bOvc1b%ZUSZtZ})zq>Ro^?Q;)FTEz1~^G&64VWsdQ%?W@s*dxkn$&Ciqd{2uu55W8Q8(lMvbhOo_8XC z+_O!4`Wzy7RBFV_kUrHqW{Wj03})c0QdX-jSfPVRVvLUc?bY0kc+qZ{`qr`nmj9BE z;>-q+EO-!Louf_dG~^ycIZ&9Jq|e3@oL~Nhy94lZ;o4A&!ibYC(r3STD|=IW$c4}0 zAm4ru1oG*M^TZt~u;(XidUdwhc%9o<-bkKGvHzl)KoEU5_P6+75z2BW)z^TJEtQgm z?`8o0l=t9x<9i%;AAXa@iJCPY0_=coQR1DH3@Va9%MisEW3-@VgOCN$4r9prMHR%E ztboU^FK=EB+TcYDTosq76h!LDB{~I!X3)j?@h^Hl!lw(z*^0#)e;=pTO5@g)5#`q-_;aYHQHpxm5R{vQzY59AsDg40*guAt7Eb56M+QkIwD$HJnua`k| z_A)<}oz@o++mkemIPET+5MU3cd{jLhvO)YosQbV>x zRXEQj)zS6VqN4n@ovqH{C(t7yW7hd|`ZXh#3g+ka(EKzb)^dI|7a>aaY)qb!(07hC z2)s9Vwr*RC%bnz4Mr2Fv))#Ktomg! zAbu4&M)8534St_cscze#(zunNknq35UltPmJFW4PUu3A}#I_DJ8jciI3GJlPYJQxp zxgdZ;y_H;{9P&n!#4w&7CJtX1Tr!R|xWpJOU$*&|J)3wmy%DNZg<(BAkoGQtvK4p9 zbin)tO#GtV<7?9hCJl*45W^JX0-ji+PJZ(@Ew2E)EpZ$k+*JliY9ISs6ih7yb$(8l zi?cAT^^AEozH1ZXnvaPD9nJqES9^KA7`b6{AQ$6gkd+F^O?f;2uz5eKnr~62)b&(4 z00UL+o6pR^y@34ID{FK=s8qMy~_*3Kx}xo)KU`>Z&#brz+P)Igwqias3_=_WYVNPpwrdD4Junb zV_>T1OJ%I2aq*+{Z7>bzC^9KIEB+GY?)Y1L*}Cb!jRRMuTF3QNf+=f z;Uw0J-vS@4SAd)T&_o3nqN4VTuQWn*bR2WGVTn`pF6xJ7sYu=hUD9|hq&-*FGaQ{z zWo(4c%oNlMkdmJ&$Lb~Rs-D;YwH`W;xu|m=(5VH7z1J*gJXq1T1N{&u?Wu27zXH4n z=ehI^U;rrI!K{xCF#A=~Miu!JAqGGY~@Z->i5Mz+gp z4^G^L2)f6Z)8*-%=c0$6ikE`P?6brV+Y0b5s->eepU=n=b zc$FnHUP?^?*$`g!3FdSW+T@1Lt5r8i3B=-(_0(v=0D^bN;h8@rdt_NNWBzP#j$;N3 z)w@K?gQJK(o%ZL4d(&;NyDj;|mLo!NLp(&ew%YqHR=; z^Hi56K>OZe!LgV@tjx_{q4H?>O^_D$vsHq7I%8sgNjvd9qe!Z>0nD0Qzux3=?mZja!uA zNol4B1#!Qpl$UK7gjeu7KayI1V15Io_L$bJFp`qP+zWJ(eP|;z!>{qxi6ssEWWYEK zuv5fxgz*gS$c_J>WP-DoDVP5bKD2AnuGDP2Yaqe*Tv zId^`^4-V__27jGZY;7{JK#*#;*8sxYjeoOGd4a!G{F~;lqA=+)W(b}1r1n!V?E}~M z=B)zh!CV!20M9eZuqoat_SUyaBgWt_0l6~}L)o^gUm4_Jg&GqRRmJJOZ8vWp}2%J-M9cvxZkqd98&xhPzha8kd9K90Dz;=}{3MAm${XF@b8C8ha92QIBZ;NgIq@FuRbH7T>Ngn+);$EzfH9d`8JX&+1I2|^Oi4su%HYH1 z&&NtsS6cbdSM)Q%2iQhR$=?u-dIY87h_?wKx2DA_OX7aLP1YPN6i)n2J;t4NqR1U?NktA_{z zHl~GGZKjPtzSi;&70kC7>o;;*StD_|IyQ2?vxs+rtA?c_HI({pXOIulIYB^=d*`Y@Z%9REZ}J+- zbx|?uY(PYE_yZtCdOSL;Eg$s$Q%fmM^)BuM;Ir6)lHqdD3oT1T4WE1!qi!uSvod|{7muf?7{~kdsS7!G9ncdx$R>NuW%ndz2R=aWR|2o zEpd8L*F2fyak@XD-5561wW^YJ5TxoBhSPa{MH_mTt|F3pvWoi5@vgvHO(=A)cj!)4 z>);6zS(+VZ1NBp2N>^flfEGC$F|9F%AGbc?iz%J$%fp48xS>nsZ|eZn{GLa9eb_(` zqsj-GZHTzqz^kd3tzR|zLP?IF%b&ylqG_&pn?{W=^V%rA!wZn5HunC_*R~B(Mh^IS zQ7w-*#mDyass|QXB^+v`PVc}}%#SnpN!v+zYA&UWgmqYIJ(R%P+x6Kd#E*K)YQ3Wj zBF{MXl~QLx3La_mGWXG+CV4t#K~Y(q1CX?kx9SOl-Djd!9K95ev7(1#9xjx;Iu>Sn zvmiMZt8B*u^+O(;^8P?Wpb#R1E4*T@ww}9-6)*o;-KqDs@CeDqQ`3oPEqGcjkqNk| z@ggX{FdFT~mNKXsY=Y~)AHdQK6WikjfQGMlB{z&D_8QblDrz8x-Hb)-HTaZkTiJjn zkc@@=RAj^SeDG)|JD` zPTK`*^?LyQXvs0$SBLjA-?fao>J++D2Pm!(`IyMH z8sI>o*H_8y3eY`%$WKLhcHLC`LfxgaT*^5Si&k5KG(Y44$V@YS_axVaEHFdR`g)X( z+$-EP-0DVC| z$`v)Kuum%ATs+!n@mU5VqTLDL+!}mElsgA~lqh`0MN5h*mh4Rt;UQ0hoXD*u`^Sp+ zZpt8I+d3vW!)Hp+C(C*-prEzwwqg3|$I!d3Yw#d#@S!L*Dz+y8`EQJ3o*wiDw-oA4n6_y(~k!e7+1| zZu;Q)X5X<#ce%Wn2A&}yRX~++k{JE2Hn&SMzHn(SW-?uiXxW#jbQqS%(}+WQ)UU3a zFS2K7Vs)Z|NoACKd6@L%+q<-g_RPPNA5KyFbQ}4keI<`a3Ug}0R$(tJ2@aEtQF{oU zN-I}V6@t{v`yWMlETFGU`rj`<_0$9+EsVXHN;*@(@R=}V@%sw4ODQ2si|=lTLqG36 z2H+vn>88DQ(mPAdCYb^nkdN&T&35gl=uk+<@6EDPW(1aeW%j+OuaEr1sAgy8f+aE5T|a&TqE%8T-N3G^|sUV zza=ZHk!I}}f}&QwrkQQ|iUj&Bu!;CqyyPDwd!T+Bl8p@NDa?+$q5Q~=B=~gpuW}L4pM2rBiugZVx4tsoUlg7s)C9n%%NpLW%od{R zt6wJm2ED>YA{?ia9Pu&NR-$VvUWsT4lct3EI@}U{+pPNjSo%G{*eMs>!F}w7d~`~h zMGH$A8-yCV^10-R-7&hawR4R5%d47>uQ)JLLE+*-uUtCftJEed4k#ny_KVv>{$79W z!H!a3m5G%1nE%Frd&_U#{L;-9Rvw2~o^6fVpMHaem>=zy;*@ot5Kl$(;G7v^H^C_4 zI@N22zLOg8?&x+sC5Rxj({GJfbM-2;ODd9WEbR@gfeSJQGJYH5ttmgciy%QhQ-Xru2oMklVl(HSLdv|t;PJQ@Rr^w~Ijo@z>z`fs_p7~ay+?zzECNA+Q%Ftg! zI;l4_Ab4-2IqjX}0Tr%KK z{Y9xX7j}V4jSW$od z`zqw5FdohTV0ok-FFxwK9914vtk)I!cVUgS0x^~Y8;+k2+u8%z%Ke_uPW_p2sryw& zqz`qs&*=$kLN5YBMA&{`t^al_-5b8l-P-({!`V{k9B&E9{F0TNu#Rfb?Oh!SW{s1= z4j7Jx@i_Vl`S;wB6}@LaBKk86;bibKLr1JXT)wK}VcL^#AX%oK4=2CwyD%5A3eko$ znKvM7XHIlQsd{?*-%I9@vBnr`4-T=^gy-0o-xEzP6w+Am|AV<-Z@t=$rtx4j=vZxv zfe~2jbUkyab3eBZ%|OMC0Y*79iugg_=Jnu1;Na649+YmJWHtz^!R{5?qB*G#!!@r9 z0g{gP(g;BzX4(E!MHJ+nX|TBCKiun1yrDnk(>z#00*0D^1xj!XnxEUO*~Df-U_JYz zgJIb5@P8hqS|4PW-4~UuhcXRYo1>jY{b{ipkEhQ8$uHR0zP+ESGWt&wE-5D`Rck!r zUTTLL%Ilx?H(cOL`>5Jl-1ge69&w|Vl0(|1Kg}+xvQlla#mB#5URxKqM zX}ULQcpTz(=EyTe{Z9I$cdBuXC{1I^>7Ou34IQ@QVSTin{)Ttn50GcF1qi3=HcFQK zWAmK}Mr!@7!>4jl00uU2U@i1F}D2u-@&MzL5-9AA}ln6lf`{ncTd+EINu1 z!rj8jxFnIa_O(B+Nr;ZRsBOP!XO5{4PQ%fS!Fhwl#c$)KZ(y!j2KYk1ueeop_-MW+ zkLk`K(V%q7#OS&vc$M@rI&cL#CsP9Qvl7fJ8Q7I^!}gBm&?9nY!99qNJ`*9ilKhfXJnz%L zZ!HQM8_$G;PQMO491cm(g?1VDxdJc9)e$2f%Q0ij zKz{taJ-b&?{lsHkSnP=qfPQcC>1MZ;%( z)bmP}OUL@>A&>S8c4Ra$nJuL@5Pk0DjA7ASnaBj;i+@ApfyG%{T_P~xf9E$;CVOEP7bVEY(BH-dG1IjkzhoNX>gssd3ZK20{1P~Dw1udo8s2Gw@eU)*`J@kLux9LaCEEcdyl zJhz_qeStF;zU+itB$A@C|D<4SED9pjph`3faO_M z4-x|6HleK#Ue!qmL=^~ptd9<-^15HZP0KgglKE=31&fkNYk7JMGlm&2Su|UW&G4I= z%M=Dh@MwOp;0aVNi5;m|{O6d2pB`MjYth)n26w+5k`YT1!xE;tsE+|z&Rmd3+UTdH zWIGkz;f_LQjYhzc-rZ$_#phWK!eyj83dEA&o74YWac{EzLa~Pv{A2dWdU%snuYC1`tqs4=m>DvJmO0O(cb74u4 zZuoh6e7kArCXRpM6;w4TEP)AUqRf`Hz>3bumN7YqZEo z)zN6TQG^p%Q*t8<4GRDUF(gnt?6~4{j%^8S4hBdAk4?{o`{PZdj{jrDN^=$YIQdZy z@OyGBqH$+gJa7y+Asq-*SPG8VZxd>((~+b(I_>{^d)UO!Hzyteo-jK;PSJVMi>SQR zq!H+=lTe2*^m0_;b1{-z_z4DG3pCoiglmF4#i_Ian`}Y`5oi}OSg!OgIg)@@sbKZ` zr!#}E?MNe?(&YG^M{d|r$Yccbuc>E7?F_p~J?6))J>-IzXWCDnZQytH54D<_MlIBm zXmxltcP8E)RPqj6uXIfVc`R=RQ4jvxWTHmH+`Sxu5UUpK)_zjZN}hg&^j>irN*=Id zN56>+Y%{l!nj*f(daE2Cm_J!et5ZwLjpj%nz49)0KNq*Tn$KliZJ1$K+wQC#xe~1!32uHrB=HZ@mtHTA=2!}t+#`bhqgS?QmMDG}o#5$!r z{0e<0TIcyN1@YsBPQyDZZqulUOK|$>zSQ1-kGg+t&&%oML>@>CWB3KB>YUZ28@!@P zJRnV+@7mHOfU~4GXImD~f&H|pW{h4^PR+5mA@NmtCCY2a5>YT+85}X!ec9?wYEHy( zC%%cIBQ+rzU{AT-mY8_EIVIk7bUD`;n`C>W+BCEDT_Zxdo%d0Y;SwYWNsctnQF z7=Lf4Yi_412ZKGjO9+;--*>vKB-hV&HHr=z-+oxXkF|&o7f2))uW-JBJk%5JD)e8y zCjf`u;QGm(?Yij#aZpkVdVus<+K%KFtDWQ4;C4^4FC}%wg^+GyIjF5#5{)eA>@z78 zrOj<(tM=WQb%dCTC`J+y^?Bo)aaxO=04;yR3 zBcF>DHbMw3btVa9;joJv2U(3%JR6TW_n89IZ`zq>y1NA~H#0qdC-A-yc=eyi#Z8

s}Nu8j?MYkHoSk@d)czm$c4Oxbb)_4$eq*wT$ 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

`4&*v?a2bOIOA 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ɗ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

Q>hc0eI6SYosm9NoWYc;(`(%}7ndpJxq zS9C1=gC4D|DDn;jVl=?9U&tr3XN)y>yHs|z8apO^tDqv7(GBS{NMk;Ec$8g$Ol!3& zNA%7Ry?}|IL@jyWQyF%G_uw14fL^Ef-gEkT-#*SD4Ey9I$Cb?)Wr-ogAcVN-nc*$DI=D>O}fV;VrZnj$LhSiq~!GT-Vj zeX;mb^iXcvbDlmY&1Ig;lypq;UgfZ1(@o>BF=>HXFt@8;b4@+58|5;Fri{(WdL$^~ z^5f*XxB`HChYUtFCuB-l|u8UA-rclxhe@>qe z-3W;srUFbmH^E62@!-{g3c(vuBj-|_LP*`|-W!CL@Y^gltSH%5eh<8~Opw=XjB9lC zWR&8sLc=3^3B*CYA0$16(vuUTOD?1YjSaBDC3iv#D51sRUF=Vkc1g~6Ki=z+GJ zPas@Vc;|};7}plp=!Kv3VNo7n1?P`y(4XdPmWqC4bQwL8usyre#%T9>EN}pX8oTWa z#f{>>l()Tyovjo&knU$+4 zD;kyjA;})Dx1Z%4)!ExlMSo!jq8)G5gCw6~NVI#7Jn;$JbDzRpcyqat^=FBm6O*aF zHLaBud0_G5%vL$z?{!g59vI69k6*H3)@7mt%;o~~F_OVs+mZfLnXk4WuOF`U6yl3I z0i*NJ7d(fGAhS)66K-`>0|~R;m+#eT@71x8x9oYtoVg;@Jto`)w`RU*2xu;`@67@b zI^P^q(voTHl;eNjioEDSegR=Y(0(`VXE`RM;@x$TO(z1L&Uxg-(kEqsgtREa1lH}O z7b4!^OdmLzuCIB5GItKv$lqQ&_Zc*?-03oW=XG>iW^$Z=+E9IOcyV4;Xao{Y^u~*I zhI6$T;S3!PxZ%n*!*-5bIJ5#eh7VT)#^)HNML8L@l%h@*Kf$Z(T@-T1|E*x_*z{IdwO$bmZd|M`a4^p1s7Q=FGK5zE0nVV|Vo1^m99YqbPFIB*-CIB1e%X3oc zo8IY<)kpZ@u=^NQq`(}0m7x_|U5MFznV8NmPHn0WLacn{2xrOb>{~WbuP>5NAduXi zl>w}!=qF;?oq;4%u3n^JZWd!#@?=n#=_t|+{S|%L{l=InEE!PwU};M_;hrQ-Fisrd z{`@8;QF1-@U{&bpT=KmG*nO$WJG zE05h2xy`sex$rg8+PJjw7S15F7M4z*vFo?7=`TTx{Mf?6A8HXBfSs!Q6&z3_K|tm= z;Wm9494Bq5)?4WfCEV?8iY@ToQ#olsuLZU=-M>6MyS5`tddoM|$oe2q$3dz?!QjoqcF14dO=xsH&`o4w&G_(`51sj@gXaf4#`^x2ntq+^^f zsJr1Npdc-i&(>@|dhFu$#ES3C89KRW3w`syzrct z>HG~ek%qLIZz|HSg^{;XSU;_=bacOUkGfq4(G^6^B#q!ce%(?_mA70|&*<`fCAXF( z_^PsxKHNPAl*AO_^eUfYD1!PyTMj(h)OH>%_l8I@r6K=86{LKwFrlC_yq(rQaa6q( zs1HMmRGzA2JQB$cZe59P2+7M6bCt|m-#^R{u~$s^+Y93+bP;(s2|Q8&xg=3L;TRofiu+m$2uf= z1@I=+!h#35nqzMxooU}_HznowwV`5i7GuLDZvtrDm`Jf(@2_VWwd^?m zhq-)r1M8|nHxw#8Ke_`ULe8V0H_$R}E>?7$_ z2}Op!-wg=Yi#hqBbI-+zEQU$bg?ao-N zrO$1R5!sf9yJZ)So2>+(j>JUb{LOM;d>s9{gaB+~D^QQN?-}Fy7IbpG6fIg6@IO3C zU?IsSe6fwIhF7)#&Y~s=C>Gi1Nt=o1t%$@@2)(m z!%nOiNEwkC8gWe_WErq+C<2ohp1XICB&=MV|4rHM!cYIKX6KzWeMn>vY;9hsU3qS1 z0R3oj-hNMveT{n`;r(OXWAKLfZ*JFe+cY!|`10`o35;mbuvr~XE!pM9znpMk z6uf(g$~)}k?b61shv`a+?&X1iXsCYvDht`Ic-Y+oDulyT9wLb#S?=6M>wQZZR>J>Q zCG(vzTx_pK!&0JZs3c~&RYbo#LH(G@;4HZ9;tcMBP0j=$#>r%bC8P19*31G^Oyi%# z%JD;9YWEl-yfK6Kh_+9TwjRwFD~cnxk^P;KsyR_n3{* z)!NgXA{6)Dkg^aDs;c93Jn>a5t&lmNU-+;3ZP}^A3JC}1<=0^^6F63Ynp=)AHNnB( zS{({~(y68=wL%cNRf&Gs?*$~JOs!>zVh`||b1KLn*%}qCVrhRk4g%}+%KLHwe;o96 zHkW`5&mJ>so@x!C`Bz*DYiea9x*G)4d(7yK@)&DhJgiD#x55#qmDF~P0qKnp8jr?` zw5W>F+XfTHjBOy^Ns+sIpMa!eEVHBDV9_5I`o>P#3QlTfO+JgLWZ@lzKPg5 z`rmfaC)g5x$i=OCKsrt^=ya+SDOTI%xX4C3njHQ4%q2qc5Qg#G)FZQd6wuksyT4D+zi>M=G(0Xdhm(ij#?ZmM^6k4 zZmm?6wCfP!`<6;Oet@Ftmk=20QTC1>92FkOvP_P@RYsqwPaj3V<;pZfZ2i%2+~h7-b+MAF%SpV7=9AS!#Me(#zB~32`=0y%TZzA!$- z0KGkw2q9dzGnRzxx~hO~OQKfzV#jHoK;5egn2#S*cgyeB6HK`-xPBW3$eNsJ>mBzv8Pq495m@5D9zgY)?R2u`?WbDD52lI``50P`uws)aKRLn#9ZEc~!O{HVT@=5S^o$|`VV8V)rd ztsjsl<$@&vpZh&-+P1a#VDKQv(=qhOq;8tWR#0BYvR9N|!LA4Tq5u=H3k_gvK)V*( zSAqqRV^yR&mFYA{N7i90d$36wYV<+7o%%0sV8Ft?|6CNS>!dIG-6kWv%LV1EW`8@m z)X2#%M-UBGLm5x0#az}99wuz(m3QS5OAVKWr8ov1n7b3e=F0c)(zcDpEUg&)`joHD zbr0>pA28qoJ!ZYS`At@CM4uA;r4%_@7)X-k3)*R z1ORx3QC7)}&6+#IagrbDX*SWY*d`g?x&lR5O@V4!C}bDn_GU{8Z?%Hu-E${^?iX@^$$4hSdP4x@ zvk|68OO}m#Mg0^%)|%yAl_M*N>yGH<(R^NkhmzFbtw{|~V|Mr&LJVf+Z^;AA6}!4h zF`oY}jy*Jj%36huFs1*uzaMSoCPn22LEyMi-$@)<)EZWnVM|KGKu>-UjQWM*@>g%#XQ7i-L)7L~dtQv-y8K zI2v<&8$AUuMat;v^RhtfOuUvwAO-U1TrzcPeaN3#SsiHbh>19}?h&AtvzJx{gclyS zyQE2(h+&zSUFDIDdY14l<5luYK1P!n?_geoTFIh{iC*k4#`~H)+Qd$SN^{R3Yfn=3 zw_~bE1<9^*X2zv{VfN2z9A24QlnX!7N!elAFdN(jOK%fZTWJMK^qK z@<+5nA<#i?C09aK+J5D*h%-TUaE#C1snw?y1|ILf9;fg~nwJ-sC%rELJ+}JM^&N}) zV>N*2^2K5o;&xvtL!$vPDaK-T?BF(amIZ zMa}5nzqMJJWU8&53exn=Cz;JYB0zg){GGgyD~FH~YY4O#icT)FQ|Y?{M5%+0%C0Ck z8n?j4h&V*~{nx0*=Re}cx!-^5ho?2}@B^tdygu_gNEiFYs$Tmo=6VR5^T%Yu)3&bQ zeMblfZ<05cY zWZLl%rjE_gJwNRr@AJ?fB1;1UbbNHvRf3vx8=B>i$QwGy>7n$jpo)D*!&BM~%R$Wu zq4R`HWDuIJ+yGc!T1Q6bPOz$bJf;63tGnI|5gAdbT7W3<%tvGFHA?eGCz|2EIt9-m z+yb!zI@JoLsyUN}`tVT^Im?0>y}HH)*>O-hEUwNn1%#oB?jAyF$?=Q^Sloux0yV9I ziVykblvFIQo`O&lzS7xO0nYLYT>hGscLaQ(E{<_iSREzAcEEbg@mg2c{@+X^YcVL? z=%%FUg;dh?1QknUrzQ~9yDLBh(RCBn)AJNOA~xt2c5PvLG)0baZpgz5LY{3&bw=2A zs8axIGbuk4GA z7wwK(6gKIbskbMFcq4=!dDnT2Yp7#5E{nZ)Paw5`bY|zP#I#ZRW^C`)qS$-(A|%fK zC=S}BLRF;cFV=29NgaxYhw}9zEA0u4aH$~D?lzGc(n~qD3Gdjv+Fj(0_r5sak&aV} z?DqAydIBtZ%vo8n?`qEB%v%UPw}=L_%NuG2-aiB=^83DSr^m>@rGB$e`4*Oh7NlY; z?iN7A$WWZz`~r=uQ*?OFDAX02V9ja8Yd*cXh?idf;i3q>d-F(jm&jwF`|LP_HYr~U zQg$k*b$Iz^GJA6;J5rq~miQs*+5}yw(gY}l?e2YHT6=d_hhh^16M&et*E9B6nM;#8D#p~q~cux z1~-o|BxARM1vPc*=Gy=_K*+ymim>nsG%ty3!O+r`Q&r0!^}n)3v^VLz0Uxm|teU6o z%r68Ud?j4VRyklgPzYUQHV$}MBU;kBK~W+84yy4ZzjfImI|opux8RyGBuEAbGPz3R z+|9WGQmeM@tkDoAO=c}cL&B>8uw*yfxfmgiK;FMd^GJ~nyM;mqaL=3sBwq%@hIzc5tmZ_vn3r3_6k7w3~NG{&!!4LYnwF}en z(@4Ok-Q_2OY?fhqT0kZ3J_9 ztl}uBYn=~9{y4Q@(+!W-d~_*;;I~tT#K~H_&w{;HV{>>Wg4iy#pXV7_ebldI+--?S?GfpTqg$+q5X&JfTlk$Mm1N{e$)p; zcM5+=c!XiumR7fgj?4C}xJ()HPJk2=4&sox_bp1hI$rCKf&@Q4&u#(>BAl=aIRAJi z#P@j;^FLjyaq|^RW@~C=(%33T{P;QX8a{>P+poRro$j6GAtMkbN|3R&yJUpDjr&4J zgkl&lhDYc%O*|n{9yzq_w1qa&foz0wrjfvi;8dT?UMF0h!mf(ytCPlNl`bp|HsCEL z+g@UiH_wm!Q3&JNsW7Myl$&ijB884QaN7T^XQ8(^I|x;Ah3O?=z72eL#zsp)wE&b? zT{51tJK$>jc8mbP0nme;2P4D>T}^mK(HM-?Sd=DQbcY^E@gbLCjT=GvP=xUQfLn0s z!O;ygHC_2gdGmC7B04n9mV}@BoDGXkrM8K*a?HuqWP$gaBF=}hz~H7G=<3r;DJ!E* zTXjh3^&rV;jGlHEwU7W_6b6yOla^7;N8rZwegE!(a)5{&f~o+d_n*5hq!}0xnnM9$ z9pIQAIk477BF)32O{dcIIJ>AdJdl=^o;C@8dwycqY!h5|MR>r;zYFIMx;L(@$aYe@ zx2dq+nR35LYtG5`+)tq~p=OtD#p{vMuGp@e{S1&W4)7Ko3W{vceo*=ZsOC@xH3Sek zc8BTKmlbqp?4uZWE)l=2#}Z^3JMZWhRbjqkG8^)@>h6v!f^A3EhF|h?FuZ^5?6daF zu%vmv?NVxf+>pNVy4A=f5!*BigtTgGufe)%*RntNz*r8-%Icw}E-@4hA%Ga0f8y`; zB0q)*9%P4$lagu>QcIap9SoW^u4E;(;8<%}Rtoc9RKF&}QG!yci-CcbrusuJ@xb$o zi3KOl&}0hp<(i(G=inx5wWm`@i=TixX0a=|>P45iV8p?%<>)@$-D0ha656`9$swwM zfZ)t6I4mUpFU6WuD782WQ_-!#yUn2qHj9#&p_TiNhb!pwkOY_)vzc~Nk5D0|7#n1H zxc5gAGBUACcO9gLgnFQs?iB-Md93RXdc(*hxZJ2pl!=VCkZ-}IKU{?{jPB|jx8j{E zi1wBA0wb<%3T0lnJmqsEmG$$%XKwLyPWRR;9W6x#VnTI0L;)~f2bbgrw%VM<^$hOP zW`#Tu6&nPgi;g7(bVw~6dEtUxN)aXzmfY|dhhLLt{ml#&v^s4>yv9tTjGcOj6l(8| zq%c?bdRGS-bY%0mOdhHfMC3-&BfGp&Ow?kTY&p69~-+KyJfV=I${_iVT zd=eHHyGVk5_iZItu90$C3oSF+&O+dp$yeEX!pGrRpk=|<3p5ob^QZ*)@cZ!M)K$=a}$KXoE8F;Bt{A?o1a1;={4J zWV^XrRa_W`(nA2*zf1=C2LPJFCnFo=xf2X={(I{cVG)gQ+(9WpxYGC1<2l=vkgUBC z7u%6}L<^T%mv+$)(OfcN49$$aLw8+#srZC^_hcvZ@)Aa}f`ax447-e>kts9-BD`lT zT!n^74m+65-pXJ`K5+;tDYN8L{9oGrP6x>5WO8^cYo>1Ao4Fhmmb7f^)6K~oFQ4|e zM}hlf;jX3-^nkz}qfMW4g|n11)_mD;5)D~Fx8au1@RK{@{7Dpksxf}cK-z5ADbD8> z^B?j}tpcS%)~7Aa5p#++)v&b*UWcvi3`)`2O~%%k3>K<)ESIP=Oi{fNA&y^H7~^{q z5-(^22(+)caQO!L$kt))@C{k=!~%Khp{mH-nV2DmAaIbV!d1aenK)70*<+6j}<<)CB3<x`FOf-j-ag;hYXEIp&e6Rdzv~*7<|BxtZo5H|}fcAYom2FDUS$-wa zT*(W`YMvAV7-nou44ZP$gWA&nd}VUZF+frM(}MlS$MuIK3p*?|&tu!zdAg3{5+|#XH23k?x4K{C|oH6x3J4p(^>8n?CgpG}#7B6T^d=3> z4*eQ11d`T~E;8zL#nxln4(+YPc~Xkq96S(N^MhjGHEte1X?=(oVZ{m7G7TZz*xfSA z&sWvPMljGXJS91gWb}pgl@%iAlOHeDcspy{D9RHT#wBsY!##naW(qsZywK2BqljZ2OQ3>cJE=my9iQCl5MM$5~pZ-G}Go zmNzcsRtu2nR|Xa#1O6w-aR)+5PN|khWLE&9UhZAS@mL4t9ii%!1>SrlHxP<^Q$3^b zNS_oJ8BgOPia1?z5`UrXsPwQJeKg3#Z0LpsGky#6k?#%>l;yRXR$umI;XJ*Enf46= zh#!4fQpgxx44RfdF%SSO*>W{wHwPyJNRSkx8A6ZisfQit*UN);bPQDkn95C_H-HGR z78?7sI}==@i)7L#gO83gfay_&XR#)^e?%VB<_#B%fA#8Y=P(Lq_o6dv8|<~$E(1SQ z&Ll)QJY|oAb;e;t`AjvtCd)2QJa)rpn;C)AxFvD-FKsVR=*eVKcKqsrH-C)2`PLer zW7G(`TOBLVe|A>=2y5j#-3DH`IR~tG%UD27lzqTIeB;z^GUkK4EFb9&l0}J$rvCso z?XAnJx3DtJ-8$I%u-S`^`E{Xy@m5E=AgRWKKza zX9LOU0ofG=8!zRf*&e@jq}_ z;OXqZ!ab)AV~~Zv*jPR}vty9vmZI(V*b!!rkL&>_{PHo2CoFay*Q~+XA?L7qzvgD^ zvS8g;JH^Hmp^+C0B9;?!*QtbRM${Hu9}{X~m;GDpm`{kI+b^2Ow!THJDV>kv&E^!{_9h4%jO|fD|3AHat=dv@)z-FeSg~-w&Ah@p_3)(@V{3FWcqOF zuP|S3;o!b)QQda2EV87TDQ+y89|7flD*dWz6!35rgOuNe_p0OsEJ~5d`V^B4?~8kB zXH#LTx-|y-rzB9Bj&dBUkQe%2FVr zBYqFRjucLxX!BavI50i!W9UL~|A~935INk(IL_)n-MvWSZ?V;0w!FoHa?6%Kls}*%9vi2%ZCB|Zv+E@NVD^c60OFzf)Mi2? z1`-{3?Sh4G@YnV^_=o_y`Z7=l+UnFanV;DI3y%Yd8d7`X`j&oJYB!1<&M6j}%9+Fo z;}%t@=wuXwfU%jQ`NMVZ8e|DOvyD2rED_AScAcuXq(j%HsXCvXF8*`=U8n8Pn-MHr zCGyOnv1Zq2wSz3`cAce4&2Z}RK`--;hStcYnq!qdv{SXeeL(G3d%a|wgqLqBGO-^w z`_UX}k%*<Cm_8m!x>!{b>!Prn2T$U7k&9%?`1nc6nb$NtM_z!T)X7LHp5P`xeAP z=@2Tj_^zXW@l`9=PPn;;ppS{FS(U^}kd+XqIX%HK%Wp})>%h?Bhio_fab95PrYdj~ zzUHPZ5Nz-Q1LUK1Ex6x2ln9$JQuZ1U>MNhyRv|c5l9bJW9so`$Ez_Ml8-H)3r;<|E z7S{k1)0`$lDv8GhL-zoS-|E2qERWHm(YLnbQ?=0Xt-ip=c3r7Rauhg~(K2DtkAo)X z&<4wNcHq39c&?qa;CqP`I*hzJKU|>Ng+r6~oEq^qrpLa|KtSk$-)n+@3)_hpiE4JN zx`aB5OO=dcEaeVgaZez~J%gdsP688-b)tvJ+XF5xSHbXMQVbJI)@dML(o_tQ2gF_`uav>g{fOx!5Gb)ur#bMOkEvH3OP1c6 z|9f_S4hm&VH3}@Z{WX2LopQv#auj#t=MQz@S?{5hZP**W@MAm_0B!+`hq`NytdW|6D~e=L_l77d88DW)cSGmv?n&kr#-jpRT1g_zs(f|RAH7}!XcuUoCb)Fq zKEJC)ANu3lTC;Wg@-=k4GSq3=%dOW3LLHe8*Ats6aVppl(~*#VHZaGAAyzdAijs)< z&#aLF*b%lFJ$woF?^ov1FjGb^!O!T~a22vivI>0tRW5YDg7;532nl!C?pXyi8xWmi zmYsl^L=wM#(1hu%U^vf8uyuHCFPDYU3`*W}5o9fzPc|76_iS6UjE-I{`mf2eU#YX) zNifyvO;B5TWQ`Vfo&%V8!tQKC$3)m5^t$@!+DE)(_vJfDm;lE~Ko2wdGl+SDh7+d8 zw-V$V=2%*>Rjz|ihb%cL`x+?_4;x2bVZWxds|GEFW10r?i0ng8WtU+eK)J2MoCMtY zHApE@`qUwnwH;Aq^KdKkucEpRQ$%XzB#9+y)_{K0{+{_YMe>PTanR831}G0G;g-Wk zMZMR2#E4klxmbgk_n8xh>rlS2uLh?~#_kKYG7r+VPD{(#gg8RVEBn3YO4Q1ZaeH!vwQ4>JhhQXZ(X(? zJdCt6;eN!dgXR6Cf(2u}7b-+3xxo_p>TEh9gKwWZ@|bB6;$T`704zO1{|@J5zV3R< zTtY(*nZilV>3h6z(p?;gTE@@EcI`==!i9Q9v$TP)M6OVn>%E`XTOBVUZwc(K_jx!> zEwu47_(9&q<5igj?_-M<7}wy5Qr)`wsGdPiupYL&+j}T+`)(oS%S6mp;x;_%fSyYF zxirtY>4j+h8H~;vgQZ%PWyfhaDX%BKI#^7Pcf%O9id%N%-tx+!4?c;+4dEASJrnj9&3 z!MZM1V1Q7dV|uuK*M$Y@V6NssMYY(b&gue((Y_6J|J&Pye;@)r886sZh*sfNOZWUj z=oUB`sk^vV&MB3cG#|O!n3lfQ7PdV73noE#J*!exBKmMoS6wWK$5(wn$5$`pb_mlh z+cI}vB!Qm%W%wZNymjmOkDYqV_V>E&Gxo)Nn*Y1Pq6cSjSC7DzVSO*x@4fPFdI-i@w`Y}-5*i>BezKxgj$8S{I( zKKPY@D`=KIU(Y@px>uB3;Y!nRr0e#&E5Wbr*(<7TyC8XMK|pCuhc<8U(#sk&7v zOQc7;?aaHTV;0ph+Q84t)>K(B(pf#uXErSf@hI3qY0xwM6jx0t%=Y$cD6qI(QyA$+ zcaiN)2@G&m?vJ4EFjit~SI+7Tqu3DM1OkUmi?be+p9%j0Dhrz3S2Sb`_K^Tf8>HZW z1{1>=T;PdaT&yPiAch)r49zkm5z{*ti_9hod@ov2S%`k(Gn#aHQBwFM^jL>5+%ybO z%C!E>+>AqcfJ57@;j5dDAps|bofL-}Te4eO z;ZcZ(kDEBHZ-T`+?2P`rvJ{)ZDbL-VM1Ex0tWA2bc+z#t!pyJmSG5+VEy_j_L1JIw zaZDk-|N3aZ#ZDeffQNy_aVN*40AB|T|7Sh6fzVRzP%BPMQxqKw7KHBP^Ekp>Prj`P z-ezF+3Z-(UQdwcAjd^RY*(gc`)AJ?xk_RjiPeqeXG@u0_Vd>-I*Y}bn7T>zF))M3R z9Iw}Lr@TJehsp0PbOXL<4??xoj}n9N(+ToT%2(4-$)Re$pTIan@ve;BfK|E3!GOf= z<*$vu)L@Sm^$Zvngg7zZ-fD4{NhF6dC~o9&%@c}e6=OTCl9Wf%B-dsjk|f>{tr3ALAjHINxs`+R8fsBtWH7lc@UHx5i*uH%7vG z-HiCi>QUKp=tybNwYL?_^3Ui06x4AnXT&gAik;9>(UQr(wT$R)5Us)?N}W7>=~u+R^b*!> zol{sRDfN>|_X?q9=h4M|pNOFp5(s{lt_1+L4!y(Aq6GHm?!8;nX;M71Vr|0Y1xQz3 z0%M{gYMz%TQ!chX;=B2x!>&o#9XEfimR#_&Y@l(;pl5)M(T=ugu(wbHpjjXu?Xt)9 zb=}8d`lEUXMnYXQmzf2&=F@f^hlxlZIo0 z#og^>Efu%lY~z)wUYV0*rab!kNW8F`yJxj=8z|{c?xlPZ3W6#2J2!YS=O{zbHZzaghz|ArB7O^-*(`eI*5C=f2KZ<-{}V9PRSH8`9+q;e&ufN<-sI z+!Q?|L*aFaN@H`yPfh&7IVyv)>Be;7^+ClI*7%R+oqA)<$mDiA+1*XAJoKFslJ_9a zag|6}qAOu;f2ih#rfI_rHwuGMxb7>D)wd-BMlaM9sL`6FX_Ra8C@0@@FAsgElmD;- z47XeC-aX1dsCPj1X|@OztUpz0`_(aWiy&HdzoTY=aIb6GZw)_u(xychvd-1Xy5H^~ zGz$v43wm(P;w*d|94;KdpH#@WR}J~ld7A>r_YkTU*~MoB-KUGIsq!?(o-b6b z7cINQlu-rDkI+FfeBUSr;z9+@=-~q{OR#sOF!dgjACg`1y2&$?uNJItwZ%^M&;oN= z8EMQlQWiTx{a)Zx-J!KKuB<9PhGje*Jp=;em^Z0`PKDE=tywXV0Jv)}j`BPXr|q8e zD%emQ+|e*b%_*{cH=^pR$V)vhoRYb<0k~LcN#|bBT_HtyWZH=CrLquZ%vQ~>kd6PqHy8n{@p&=pl z8)yQE07w>5dfs9e=2JM`8Dy~cCwp{~oBpW<=Doty#ez+}G16!*=eRIoLP%T2M;dZS z(zzz=EA#cmidfiU9{NH#$+%C7D~GQMrd%lG4VOR(*yUU8B93Qq*)Av`q|af&h}PO= znz=CSH%Npcr>~O_OSfVfMryK;QE`O^_wSWdBD0=NZ^!9Ho0w_@@M3E4+`sIwJG}~m zmcn}JpHd*@k`J|Rp5f(fD&6sAcycw4?LMCZl2ug{{h{ksI+KFNFAJGj?D3>@l5~dt zqTA)RDFM8-7_d?2S<1PleolT)+DlFC)$kX>cx-S-{;*Nz+$3_{{^6ybvo{A>2b5GW zGLT5MY6-ij&t*?EAn(ZV+-N0Ogiaitw?Mvx@B*4}X$x^cZ5mgnEA?SS*SbZJaR zy%m$*$R_AW0j$dg9+7`2Z8_=5rKz0+_I5a5+}MsJ>^Q>fGXzRg*uj}ID#8vO^|7ID z__!hSL90Uw9dH!Hkrp?y+Y_vhB> zPjdWH6;37}-b!!}#(SI>Jr0C6pRF3j6TZ0kJL*fGC7Hc6-p%osS{JXd;6j1pjxGy0_WhG4$qs1R2PG z-yv2KRzk*2%C*mIo5XqLQ09T<&lVzG0riTJ)Z*%88&W3?=yEFWsz)Vgz(6dAR#TI- zyZ)=0utg^L6En*T1(@oBmkGZ_LTQ6KmA@~kHnHg4pz~K73*XfwAps&tC`py`IDgya z2x;oAa{@6Ric=MCU%w`Ud~Xej(o<#L2Hx1I3OdYtiBX<^;*X_(QEuH!z?Q2_qNOEO zA@NT#G3$BRmr7zIwBSrS&V4z*Ul345w5D46ZBIdd+w9Yugh2P-_Hj4Ttk_Mu4#=d6 zR!hzuEkb!NoP?g|zix_=B7pG@kotU+*flH=`F^qd#N2uotD~HfWu%~)v~Y1O@gGWE z7_?ot2^+Uk9A~bO&D{>p_}E>Isi|CCD7`4*@2~e|$>Yg{alo*PQps3%>}v7Xssk=k z>!hz&PAm!npzf?_jJzO!J%L?(rPjh$;9=?e!5(gSV2vPG<&Z>|!(g#O*NFgyA3U~K zwUI?%Y5d1V!))=eIXcmgAzZ~c8nd8R9Jvg*%O&jtBN+_1<&7e0D{SXh$aG~tv9cNgJl+=Ncy~$&9vUY)?Q)oR{{Kl9jRbt5n4sn@a6=gcnkqq zfj|&77~*r;){n`DR;Obcj?uaVJKN`l%Nw;^oIy=RSOc|tRcxFnYtoE9>9uK$W=L=T%Q#1Lj`3ID|JTEBDzb&$ z`;8Tb4c&ysZ_gf(bh3~}D!tb8kzL^wpYfe#k5=csuk6AxI^+WExZjb*YhcHB2?Ngi z`%iI%wjI3q>L`Y5UZx!Fh|Z`ZseeF`#y4iuEf2Qi<@Dd)PgcCF9c6i{87__cPcxRt z;)~}9R?W68?TI6#o4Fo(5pRy$--r#(*Nkn>KC{LND2E)Ceci+`8+H%%-(#w-oi1OHQ6x&U4ptXf%^{Ty^Y~kpX|pmMM>R#P+b>^b z8aG_+O>FP#*)>|%P*^_>pNWj;l+ygZB}5E5sJv(L@Ah_Tzz#;mLkYP^mqMH0~ zo8TQW<2oW-$A|ggxVC*nTY&Rteq_Gc+@j;@1sQ0%5 zLgQV%ttS^0v)gI{vIRZUE+OKiD(2uXd6dO9Fcny;Fb# zM3IdoqFZSAlP3288MVJ?h^hZ7@g7SLs=5b)J!#&+gDR_gBfXZd+VpTtO)sY`p390a z=~_uJ);03GX%M5GBi<@eATp8)KVFfmB#$D08>;ta;#90zmh>g@=efsbNgp;HLLlcn zSFZLNLSwU}#m2idfddw*#7Z^3f@k!`J4^*XPI`|qhWa6sIdVvt_|}YPLS0uXiFSjk zGLb8plXy>>f$MH>WLz!48WFSu)<2;KxbjOa?D=>+igQRuZ$t+FxXjRTQM`qHl{^5z z6{Df<8*d4WUV5y??7BMdvCduIiX^)6!*jh=>!I4F2(!xtzTO4@38X34U*^(2x455x{V&yh1T^R`lV8v6D4ASdy=Tmh7F z9531`%5D!45|q4Iy(HH8!o%?NWTXIs;}3HcJHBa0nDyHa^1VeMior zez02Q_j|yS*Kk|hAFRG<^OVtFr3+ltF%f}~VU$y0Q41`73-fvLmlgYBvxMB#?v(w) zSdx^w)^44D(&j&0D-t{I!gx|qmPGmwsM0Odg)1DB4m%wBl8YIA!uJ6s5$TcJs;W$u;k_b!TopZ#G|{pn`yYp{?ce3?p>rDBTOOKJ|Np>9(q?T`#Wv zKn}JP5*g#c^nI#aIMR&ng+XG*jzaNZ5~k&lX5PYI^M$5)7OupQ^HRNCe=F^t7ifOZN04>SC51UxoPU|B$ow9JmzMsQtn$iN_Ed&ULm#11R zYACJ-$UErX;OYEDp5A2nPBWX7;8wgf?2xQcywy1Jvo>y+eE@rZAm?V3+Pu6XsG-kP z1TjZ25XXkn;_smri*KcPh9~+=|6!%W%avwxi=3U!GxON{U+ZgHGLt2yU)}3~o3CFx z(paVaAcryrYH3wI5BKc7(Y`v&T;#C}w` zR;WVrM~W@Ozuh8+0(1qj=A*y;8R&J*$npZ#BWpLihB`+Q;s{Q#D`6#%_g8EV1I!oPVi922Nejl=;SKehr^# zkN;L|j*N%8odl8=p{Q^PNs&NE(m`+udwqujR*OU?+NzxD#+TpBbc-&Uji;tT=DxpSau>9vw8)%{k~QO%dRf)hLdt;{XptC?$odNv?8ZxLLnK z^08GoBglR$sl5Ox`GH#iB){grQN=_NIVTK5ORnxXN1*~zQEzRJUS7>p%VZF*SCN(V zBT0FiDrZ%e+Kp+&Zk_B+qHVhTb4<@j!l*_EvCsZ?_zd_{=D|i<2Q1Jz4U2YuQCaYg zRaC4m`i|ByVlQtqHVegP|5vRD?}QAVw+hN##n5x5nh7#1;rHk%8nM9;02jpolQu(` zq(A74T)Z~w;e{YIJ82#z!A02!@D?aIMb{=%-)!3mKO~zpnSrSri-5PuK|~#NmAuDz zh;bupUqGun6o=P*4_R4i!8a#Am2hQD>0Xp~T+aUUc=|W*|>C%o(=JTm!3uH7fZda+BlHrlVJ5NAI|~9 zZV*|f6J_J|1`7Jm5jY=%otzRcL`x1|vl?^*HJ;9kz0zd~V-YtNivc+4u+x4CP`1l)M2?k&Fw)(U4)0+BcPLSC*ue)S z?`}i_1$#BWXh6GHRQembVHT8_WhA3+5$T&!q(+t= z6f;n>Z;F*zysq0!Lt`RDB$SBbDf}aI4dXZLrc69%)>*g-Aexigj!W|sZOZA8z1b1g8R>0m47MAon+LcnRvKo)e? zI_0B@B0tjNpx&==LE`X#x9(30@g?{CPhAc^Z1^j0vra}J9Wjf>0k+^nZQ{DA=+Gjj zZ5TI=B=sv;L z4V-0gK9pDp62-5s`!hPMNIo*3&#YHjAAvV{*3lTmc^~v!v;U$Ry<@LgO_a6Y+v5So zip*kl=k0g$-Cy}|D=<;2d}hW(&#y@X>ZVBn+YU-XRUOSrLU%uGwPKuq=b5V8Gnl8`dF_Ljb#gy#(;~O6_JjT{loHJO}+b;pzK9 zwdA!idftZ*E^>%HNFmg|8Ns=jT-1({1qfC84kmehPE>6|zDy7hZCl>Jaj6~cIBT=H z5DPkiH0C=orKy*@d+DqtVv!$_mQk6Y=77uM_Hqe7fEP~`l_~==d+*zsp!kdP;P>?> zQFiCP>$+g^}DgQ+SO?$Qv?0Extr=(k5BYnb@Iox)m2<#%7D`*i< zGq_(I!wl>`{iF>-qv>kP>!QlYG`nmGEQJ^$McUHzjmh`BT?>FFO90x-a&saxW^$Yr zG)AF-@9j3C&O{i-`ShrXav8Vs{t}b-jJOBbt%h`QGS-qBJ}9!U&v!Xt5@yiR0bXC9 zS;)*<-EfcrohIO}U+u$4vMmPr%5e6FLr|1nJ=dG27UBmGLFn>k4y(;&Cm3!%2rt^y z8Ys_;`VI=>WB}BDbeKj6*i*K4tLWzMdV}_q2hGM|aOu~t;RfgSqG`VsSyv{(nMQhB z_#iwqfE#+wXutwrIBtIW`P4(<9fe#H@GdvUpFa`K-ZY0n+2A~j0>Nfdr9tDK!>O|{u3kBt?)iLZ$(@Rm<9b&7TX9(sWM!V|ILuid*ldn#|d(I z&JKdq+TjuoFOtx+0Gzxs|g^2rjq4(pm;COtJv^RUa1vv4Z>B#5fn_ zmQds7=Ex%#ceyWO80=x)#_C>?$q$;}nQz6Ar*_Ywg0qZ^C~U3WImm|U16ZP6-nI`z zhQy$pov*wu1{iUnP;2sEkiEYr=3rr>I>nF|R_e`_0a`37)|Lx#gVFEDg)6R@&~ z7x-FY&gOhv5C9Hp-`UYVS`*(|ex( z22_u#0wG){VM7-~4i}2iU-I%uXGLePyk75ls7aV<1dIU(aNV!)mb*V%ZtTCGm$HGu zAKzm=lOPq~3JCt6FuSLpIjQwcSkHZv0hG$K+s|fbd@@qbniu-R#s5kYxdMZR#w-qT zT%xKb@{~&X2n6_fqhfdPNbJM;q6(fanX|WT@g9|J#iYYxC%G-D8K&%8tQPqLYx;{d zWC^St!%sgLg#1dqMqT}ACXJO}5Pr_$^ z)Xr4ReV#P{P01XoHJ}Mvn`Pq|H4J*9HFlsx;9f}P>1&me? z+ru+CGh{s%lWyHo_Xtsyv2MLF%uJ`O4|!);tZycS*hT-%))|Ens&1Q)XFS$y(z64s z&mv-$j0Js)?huikw+-AYdME1w`>!`~(2WXy_1#mRV&%DVVdc(+$@)UIva0vlL>bTm zc+nH!jSExfVM#5%tCt4!&(Oz=`?K-{-kO{}(KM{*T1W&~e_%jJdO%HAD|i^s@No(h zikMFj$d>pa!DoWagraGa0(y>feyO0H1o?P6+#?ey&5|p^(J}nOI>Qo4g*9L#1o*Xk_M# zp%SurD>kbvw#qg(B9a}|(djiWPIJ-Ejov!EKAy4CfWVvhuLFlk4Y78>aS;|`QCsN$ zxG@B1<{`@0dDEcQgSL?U8#n?qjHl>amL&Z^ELW74YA+YI-h?DIf>tY~DJEPB2q8$f zqOk?h&OJ-J0~R+truDQ?_(Oj6iiihzk5@x?!F8&*)mo)rro%B!3W`fb??KQdN++vhr+HT5p zq61f*B2=>o-dx6eWZIvzKU-KAR8{?xKofea)=#$*VUfU{bEf~eYX)gg_f_1Z>2xMU zoY>Bfy4(7I{1xh8L=xOQ9~7*2wAX_Kc~Rk8UUS+-mN6@yyU9;cXcuO>#M;!?$nawm z{T2`wEAXrXCd|RC2#sNTgELLXkxbCAtnWitdFgy@=DS+}x-#(^{52z7#;Vo>R~rg( zAAw;pUvsvK9G{m5hAeMAAwEIvV88JzAo#Of+sUc+&(vK<$;J-E=;h1ap$^=ZN;T^( zO@{AO=dtt_cN(Dit+983DoAz?SE=cGFBZ0%ZMA%<&I^J`B-M_hQ@$tg0>DMlm7p#* zl2SKLlYvlzWYfL68)V%{82%1I6Q2ziRYhbr<_KX5@aH0EB&}isvWni#w?1SGYYCV`Kccyh@JMel-N|I?Xo`xw(|&0#F(>b;X+2W!B%Q1yzgq;1^8P0oRjf6^ z%BPlQjw8rIbbh6yV*q(309U$sm$friw9|+Fq+gqQ;i<1GaF(PLKnM`T;){5QvH4Z0 zq}f80CZ0bDnA_A;?Q`s{-cx4k{U7Rz5EM>%rB%$1p-u~ap0FUQW3bz>sX_#tKE2&n zT7nfG@$wOMpU)mw%)$#x@g6jv)ZaJyjQzDkUJEk_j1V;{isVM3LUr*J#ckm`YUjEX zULke9dhp(DT-n`^F3pN$Zpy1ugU)Mp)^=BSb}@-_`b2(jueuv-o#cxCh1Kdpgnfh} zT#CMAgtvN-$r8;JR4;oXhI$5cZwP3PN;m|&wIAXjF~mKZL+Rov9ogfjRwzI-y*{}; z$5YDYUcBt_he`dG9bV=zaGoLFZxVNF>rGBHQMxrP*}c2Y5xz<(ZKC$`i#px~qLdw2 zZ)`ebov*c?^0eF)nWSE}aQq39@1|Y#ZZ0t5D;4B1igGfQ@pJ%#s65?YOWnU#2!=U= z)gg*51E2!<#Y#8o27c8n0Rq^_#5{_Z(*EtPD(C~>37#bmyX$a;nQ$ZfXB-Vq$rQCr zruZMHvHCRt#lbX}R7PEcdmxmY8nU`3S^uO{R95P2x1A9QhSU6h6a%fN5s5N zV|WfDHuuww9xOVCchm z?DslCLJKmOcG)kpU_To^SQe!`v2{cH1W*~TEKtbKTpOUQ!Wqq*hQeCk2k34C{95qx z_v;s$0XD;}3Jk0v(8QzUjp2gc=wrO?+MO;+vM&MBgc^(U=L3ykV1m^~ZvZ(41xF4T+UB9KdDB?t7gM36Mz}3c8hO9Cc z$YBA*x;irdWu9=3jlH1t*Q97-Xc!2^Js)fWBKJ05rl- zjOs13fP_#&6@_sPS7@1Usa<*r19mYsHijsHmbf4~4nK)Jt}jBXQb_-1CIbt$v(ePIZb&~xA6 z_B_bxrfpD$z8cf;678hq5I$O!aLggp{5-%9K-6Q)F>9rtx*`AryRDIlKhcyL1k$zi z?bg7v@YV>3wuq}mo%gjFI@y7t1|`&u#B(N2>97%xPF@MBqJ=;x4{WlpC_zKohDr6y z7;wAEOpLWd4Pe2TM%J3`BJd+@@EiUrgM5ZfSH}~mKMjWzg7=@$* z$u2XbBTe?>h=c2}JQM2zx{#9|M(Ms_nq+AEej+VT@tJjsxZML%gf_{4D`UeK9YyGHsU*IAroK)d1|PYJRyP}Rfrcblwu{G^&@y|ai14%;Csaa>*+!{mugkBi zHj0q-&V;JPQ@r$NF3F_y$L^{ABHYMR1U=>27R)HwLRa|-QKjP5MRCS*Jo4HqM=B~U zV%|_vAJy0$OS-A$N)4B#1YD)!>l9{#tX&{^l3Aml_M(EGGsJ4h_DPIoq* zQ{1f>WfgDOVsiSW54*I9V5rB!kN$Y#zX|&;OkPTA{ZMA=ccM^$1?BJCe{SE*i_)k0 zOvI*roPi&DIRN)eidtKH8)g@1cuXcZLale!S4;WBm{T^WvIA1nKrAaB+qoe9tRke){TKK1 zBhz=M{iGC(5FHat`sdBFVXpY(3?p0#N;cF{8qN}0Evm_1$mDQ8q)lb=(y#D14H9^V69{v_g*7O#oKpHsM8vx*a_hueQ_|N@ z;(Nh{3`}K_b;!yz;61Jg1q8rRW)EnRTNSu0Em$YApfxS~6zh$7YD6h5>$PFU&&16e zK^m#J5MTaNffx8j`my}*@F6(qWvp9o06q5_xgiz7l6L_}_2%Me$rC`p~sloK(vh?wm^O6}lfO=Od;&j! zUG9E{7_EXm5s4*BuWW;=(HACl zD1xkW;4((C?^f|2y=&DEl{~!KtXvA%z9gy^t;P;3<(34#rMV6hQKAJ%I>!%T0rcu9yIjkXqQ1IRF+q_PZF@;wh}{^-LUL?x||-V6rjg z=grs!`tvkYZ4t3e?=}{8GmdJnN8Gpogz+}aHWtWS&n6{GM6JCc9%}cmp|4BtwP8^c zfMgNuYdGYZ1hyhv_{S?>aRtSwY&fC6+!A9ltcFL2_HAtrDWU{BJAaODAvbByQ|gby z60?6;%(lNd4ajGf^=rnjC>g`7j}=+TRCmX%zxIkgaYhChY#{CkEq%CK=Em->OsBWT z8BlO(aNZSAmaP|jCqR3_|N6R*$q->qeTJaYSHZ!P7#$frSEziP60^}?R&67mLWs}{ zF`w#0u?0Njz=Cwle8%tA-N~3OpO7cp4aWUwJc+?MUCCj)PO~XEtNB?ZF`d+oBLq~m zLOEacH)>r`UAUdQV)&~$H-_7WQ{E8X=K{ik8NM}To@b**iu@lRd=&yFJkc|gi3w9pSrOnY_RX+Ga|dv<`%`*?~{mh1V6Rr<s^4sa9T z^!K2R=9|ZTtbO@P$nE*nTdpuGP!n09qH6g7fJm1XiY)Yqk=fOInx4B14(c!QTaeH@ z$+yKG<{z1wr}O51#KF{sL4^{z2lM&uK%M}wAF;VC>Hvh z8cMs2;oT-{lSsaM0$XwayhH|)XngFw7z;{HIwYMsM@I6PXUYCu9W%w=tQ6;`VaukM-*6VwVKngFwTil>SZ)*5GPh zjVt?dejdkSrI^}$^Ayy=U0`+=d}v%ql#5(*-T9aIYl*+i_6sgF=&g-Mc-J1u!>kLJrU_+Y55wo ziL_6B2#81<^;kzLWl!eivFPtC2W2Y0XBL<9xv{8Xw!p^6)Y_1$Jx=CnHuN3Xfo_Z+ ziY40IABMs{nr&5#s81{&ZuCn0V>SHpCo&65+k;fDAz5WhQ-R&ziAWIPJ~Bs;g+KrT zDt`Uuvi@^Jmx>{!swcQMub0lCgbAnDQiv+=?14C#NfNOMztXVgK}(8X7M^}}MZ8as z#REnR&8-6=o>tbDF+LH3%yw4C3TiGoq;f0MzEFG(ndLW*bU+dh3GCi)8I|~)5!av9 zYIq@d^#`9BWKDN<+Z|n<%?lP@rzMs!i-VOJrgMVfe{ZDd~H?(*jPcKMRCd;CB)VSr-q5)D{IP zHb8*rhfqMSm!4Mg;PpPU&_;OX7uAbT;7)CE_kbr_a{>zj*8@Y7WDt@rEQ2JzH5;)@WwqYDb5TE&wU@-9D{2;-S~# z_I_yxh9rCCYhlFZD9cp^;RzyKlY33;xiaA!-Je_}`LDnqnA@@jwDFPYk!9J>pt45{ zfSwt+EC9`F6f1*_p@B*&!`F+wrEdrfFdO2G9#wWGuwb3eRFb*gGDh|S0`+XoUdR}J zV+rE&D1zM+9m1Z8?tepnNQD=!mtSM~QOJN@fsRs z>_4^Mn5FdO>n2jmTK;^RsxqPl$`!&LlZ(~M9f_HP`GWXjMa!2OnF%#QiY7eH@ct2C z#n&z1rXo~mW}^zt69YYzH5f==7pLL`xJ%I0d=OCrF%BiAnSiNqhKoOr-WFTSA6Dl< z^kn)NF`gTc+menILfBR;-- zm#4>G2!6EXIrY<9-isey)!baKHFJV%g?mc`R#Ewyhh+7`9BC{%$D{uvg(5?OLd%l1sQJtSoLXcF;oQUtfWI5G^GayePR*yzzQ&A`#aE0 zIa)EN@*GY*&b#XcjhF0-f)6vIat+0~U}bjf7NfESQZ!{uvtZm|9UrByUl&A1hycIX z8=;DKz{Jd_geOy_HecJY|;bWh;S zYYc6;y%s0t$&1kzkfo}TPj~_#_RetKU8~YeBGc)5r+g07^ zsh1i*C;3Ep5u!)~C@s02=v>lu_tTP3(?4L=X=;Ny2@rl=bPqW%b_@CPz^c-@@pVVlKA2rf6S>Zbu%~=#RWH*lx&wq$8iyE+jR`wKwP}}x5QSikg!U34hy98yO6CKo zl>Nr-%bJ}@9LEKKd~Q>}LsJgK9mTQzSHZUH18Gdc6)r5@S-LrH&T%(19SA1-UeB*N z>kaOr;me$C_;8g+m51c&TiQ$|NYFWT*7kzlD|5a_B-uql3t$*wu6p8Yp z9`aeH1CIkh*yzhq7%-m7pV|F^2?$)=E^l+e!yf(cJHO9)h-FWYhzHj(^JX<6>sSKKE47eG57Ze)hSv`Y@9<3G29TcV|X8r_Lkuz$o+cMTW2Ys6Vhr2d5NgXd@#ALh-zdz`e5k$KQ;iZ6FoPMd|8f{m_! zv)nQ0%2aShoYq9zqVsc-Jl`6n`rl1zO1{C`FnJp4exdz8VI~!?mX~{CSDTN)#kYav z8dML7tgr>oy9T*HO>CJ=(8I|&RJ@dncBt`W(BsrWZoax;7b)Is!OZ3arDCcvwYrablJ#He_vb*MvyX(p0 z7(QpRamaJv=UC43;T-EZJe>a>?aj>+_0+6<`EcKj295q$fE5$;LAr&MW!{uaBQ4mu z9JS@aDIaqA(Nz5AUa2M3(gGAI>%&J5I0Hpo`N2o_=&^wcBKQ>Wit7lV>=RAV;Da+T z+O@u|H@geldR*_y@=FQxGXbql7cT|+c=ZZ?=^V$BfL@QK|MrP-$zwp`Ao9M^V*lK- z5PK1D;A=cxN^z`!6QmrZ)#nH0Wdc7=hRZa~PsT-jDPOQyRUt79>4R7X*6-~o*7J<6 z5w1g8fZhl69j)@au<`8&u2d@WjSd~N0!5M@6@ItN2v8nM>h#w_ZXICn9*O3}9%*iK zG-DVkZ!CIhJ>uH=Pvj;7O1styssnrAHWo2-s!5oa}m_h$AMnlJ9q!k==1I0M_h` zJE^5H@B0AKucn29-$r5?!l|m9X_D*4P9c~Ptak}amiwy;Lvah0{6$Z-cw1_j`uQXw zjxhFgoZ{Ap7vLu*nl(I`5TH`Uc9vwFJ*|zSd_q!LpF#z0$?NDNb$Ug8~@p ziuxNdy1K&il9Oq8H13OzNF)aha4;tWBqI@Gh&4Tb3A&y2<-Ghq%PJ%!O=py z4ilh!;XN!O>*x3?a6Dra?CxRn1U(su;6te@h*@Mc0G#TzqATrWf)Ag7r~QjFCFXfD zinciyNO@@hpYI18uWq~wW=?9NaRDlJ`1!hUj(6?hheKA+Lhm#;hExCWPkn!a{qP(= zs2n{x5Xj>e2aOW>Q}uk$l)}T4(u8nPKe4*U#c4$4K_?lG?+Vf%7lN`cq3iGt`C+fm z^ECYg3w3zrdK#oOEt&R{x;Rotk|G%W5dynE!3!Y7S)b)K{io9)%ju|ZLp&%=HOus? zDV?yrkxQl0EbKex)%x`O{f1nLJp;g${WZ;8)E2x_s97{Zui?5!UH3+SY=NTB%UJCb zfdF`~P%}VNH5nL}*~zkqM=7a~?OP(Pw@dVSR6=c{$ijJBa+WANCZI%w98AJlfa(p= zW$qi+)s*ZLQzzbo=GGs7=sb~1M`${PU}tK1ca z#k=L7_7jLFO6zBT&Cso6ocRk&)%Y4?iFckV{J5z)#IW7oz8)m~^T7XLq8;L)i~?Z< zHV&@Xbv`eU&&K5}08BysKpryeIzAw>YLkkX$GdM`fF?lNL3`8VZf}djPH_+XypY2n zV))qiD}jx%SGjJXXI(F*EB!2nP}UDQB`d;jcdIdD*b01z%cDi63`Qhgr$XJjkRh9X zZVNz1G%Q4G6q*5nQz;Rv!P=7H!{H;DV2wE`&8vI7{#8817BqR7DrR*71(ih9l8y5% zRHj3);3F6Xj4`9Bzzx$SC0PxRN^B!}H_z9sBFzoP6{9(PCZZ~*9xNs$j4&8wQYaeF zJ(@!DZH6DPNpuq>rAhyfuqNaP7zWBr;*U+vh5RK1bcvve54+Mc|Cej2s^@)Wx!fRm z!KfF5qf9KCmJm%YAio0oOHBO2tDQvruGB|(Za+0WMbs*0asyAG*+W~D6uHl!l`Vtt zBrzq~Beu4A-eG|%Fh4~AxW8jZSM`q@n8O3Ts=#hs@@F|PC`)Dsgq8}31BF$ooYKiE zs?#$a#DfomNg_IVA7y=rYJw+5IVO71AD#wvta&`_0ydS3`^1((7{h#fkrz21qCE}? zw_)*2iW@!3z77nNhp{g#Gg1_XeHnrIzP-3D*nSWz3PJpK>ZOp=s^lEw4VFB2AMF7R zn4ng+w4(X|QdEHw^4xDgT|ThzBg;zsNDq0>y?)0MKp?oYk#XF|hZ2ZF7@XXWuubm7 zwqJ^2RY(>BTI~|x7>5f`cSDWDZGkUCghW!&kM$q`6y{iJSs>6D!~(YSf^BxxL0H~? zs}$>Q$D=-ZEsGTRR{ahpwNyBoryj?nX?f8jfW*9>Z{ZZSd`Q1_BSF5|=-Wp0L- zoE}jhlZ8~055=BK(|CP+P^oBAQ)X8&+a+liaHc}s>927(_ z2W1JGYMIqoy@z9^=dW~UB}LxP?RQ>G!Z|Qtxf5Y;;=zhWHPI3oXjZhs5p%vx@X+kR z$;>IKsq7Gd^MBBSM{>LE;=0d{UtI!`QB+&|Ei#hWFHoPGX5M3QR09vA=r>IV*FX>? z7|)=GZxSKd=sxGe)u`%c6R#PQX4q14m9*-*(L||&UQ!xR`-W2NpxRN=|N5!Rn?MPq zLP_~#<$+t?f!Z(&fb(cW?5px=Fq!f^i2ag(_dd@pW$M0t?WK?-@Zn21BoGXS>j8Ti z_#U1_gK2Ki-At&L|fDcS3D4Y#x4>-f&+ zn}fyYXaOUTgND#v5AfOhBGER4Bhc0RIv8?tc4*@x3(zWGX!j$~OP)Bs)q@~@lO(hi znsT9czc|zl!mLZD=n_uQ1XGh2Mpegb7q$^bZUFOE-tPF3-Li#&La|C-aj)u6ySyc! z3;&bTAe4&8^sy>?(^QJ%Jp*NTJvYiPdYtS%_FXG6F!|pQ-H!CdkysS?7>Gx~`xNQi zLpyaCEIXdnkKD4f;4QSj=%Qqpz$yU+iLeKxpaejQ1ouagAeEoXZc^1R#_K>}HdumB zKp+X(_vfOu{O6Fj=fcIO6_~laXeB=iPQ)maak&l!^SlJ41T4plkk@!s`ToY3*^a8j z{TUK-m~iG6Y|_sIoV=R8HtlT8*LnIs3-iJDzNT}Njjj1JBs$=nA*0TJPE5>+G*6>rb-gL0kKLfwj_MP1M@+o391u3`$|S%!HG>*Ha?9|0Sg?sh2nz7D zbrvqib1|)DxeqFB|2`{*60iA`>osD@v#(uZrcx);b{*_EBw!E`?6!YC*S2~|Jic_R z=r z>XspuCZn+0c^@2A2;4lp1$;#c-vR3*=9j>YzEt<8s$9?tzfb&HuK)i+1aSF zT_8i_3=GY)2ni6TnhqMjB?Feon#{c2%<6#Omc|R0$}U=T?7oRH975GXj{wUk-L+WhuWI8vTPR@~K+OU_VR%pUVNmlYmk(&t`WeT$x4|%t&u|Mt{;4``)ks5er zjb|9Ce>w@T%@1PU^KgR5l+eVh^h7aSl{x>|cy+X-Kn58O# z*|>6^Y$fp-nB*kBw^XH&a+~s@kUvob(|?9t z2|c3P_uOodEQ=}pcumA$zv{HTCbj1qH7LQ@kA3h2A@k;2WUENEL&)UV)(|bB2HAq8 z&kIe*i!fxjPZh9(>Zn;?hFKx!vY@+mFczigP?NC-ncD2qTX7FPLU~Tre&y4$5B;P! zE1@C7X+l+c%H%1AxIZ2c9aY2TrrCt9Bd(CY%4`S zTms5|o!>*^+R^U{*5z6>v1BI6Ht;ZG#pK6$Lj2q^rw=?N{|jgNQZQHwU)78ec&a0D&(!=K@9 zrcM0M7tX*uRa;l!YD}-?`9E8R0qiD1esPgc!8O!XNp>1pv=WvM`ua5o%41*pPMoZI zch_@1K&mM*2Vn(>ff*t`p1gTT9iQNEMh2R{K22Q+yf4*ZI{CnIDwXYgeVUyUsuZ*x z)3Kh*z6~}Xm0v40-90P3%m^XueMjC#ei#vNGUVzNM^MY;gNVzy@kWjMeD)@uImDP8 zgmMMeB8{i1c!IqMAY7wLl5mzkS)(Oo+3aSKQrJutS-+^px8$bAw~MbGR*0|h0MrNz zs|P#EJ{dMr-<}S%YXLx!A}i9_A;3yZm&@5*CSJ2qz5_q`GD*W=CLcl7(bJ!@M;*); zFeT$YtnA0X<*?*k@O`0O(v=B^g=wQU#{!lt@}&Bal8Z8R7T7Z&$w_lcS+ihq z06y>$M5$oUH-+CjBI8&~KEj2cw&Y3oL5CUZF>C8_^vS+p=(jaQG&*;D;sJ%&e5GfN zBAk|%m{+>UMrT)xnqIw2!uBeRGTUsT7NbD8ZBX4yJy^C`9vMNifK52Hp(8ZkEsFk{Z^cI0Gs&&igv=0 zl{~H_+wVq7g3?a#N{90|_cVSD`orN%b%d=7`@)by44b;0o4)hN)c!-(*Y!%U1q^^O;NG#k3+PnfIkX(9(Bd)g!!uFNMvU=Oh*ld5$68t|o(Oh3W1 z>8CfBU6zanu}Ox|;p_05_V_-d-48v%<@YU=J!#Ml;aMZX09+|XtSBr%3yr2^h(~?H zQ%Ew#_1o>ZM(GZ%&X3>~@~v5Q8}2ub$UpNLVauhaO(*^ny&7lyiH3?Na-oaDyHpdm z%<5_VDZG)!hgYcdVu3q9&DTku(=Jmk)b5}sH^q|8wT$~f*;i}uS*vdt6f5Vxy`Q!M zqb_GX5fB1W;BLqX#=w*mr*zjIV;0CC(gfksi1cw3ht1a#8*8SO^ra}#c-cpG;xl5K zLZze*#r!2|j$0k3csT(2#9m}z|32(NMd<724r9wZ+UPCABfZkA?SvXkbyRFgE4EDAKFFYw87U7t z__;!}jKlJ=x>?NNA%0NId+>5%*18-Bv%o!O4WmYG8QKnXN9S!;k0o&w_wryOYmOTeaZ3iu&@2?QOis1{+oAY2_3o5U{<12-?mDD%n3A0~u z=WKfxQW81({F^#P9-ux_0wu*PY)pG(-B+9-gpt)aClI0vWzx7aCfaodYIQ42EN7GG zR;x+(Lo+4Xj|K&np~C2Ova%%HTO`GmGiaddF_d?4lD_P?#Ga4KRY+?`!chLJ-(8nS zRnn5mrzL-0`>V2HCgGcw<9^Q?0?aS%uH8D$0x5k|wlf}RJ}J2ST53W5HQeD;BAz_` z79YSHI@TqP9!rAykPQ8{=0ka*x~lL??gtTm3&T9eLY}dWWXDNbUGgo@2^hNQA}2vP z`azCPm16QyTL3+klGwzMXeDz&V1=YBpytwCZz7PH!wrW9w0#XgR* za}XdfHe_OLvj;i_@4yO~-x&Z5Tam-R;~i9aZH74Z?02*+c+FeG9S^azbT6es|Fk?d z@ga{{OOIrm(L{mt*HmaK)m=4jF*8--?=U_`CDGl}KQ}6)U=kt?K2|*N!htTc+3BGXFj9#dcqYWq7W=+hL?knFZgj0LuPu&}q6#3T^pZZ#KCthskFa+K8siC$MNMl#* zs&SSp%d!iEk?v>1v()M z*~`fo+#q$jRjRiHP>Rus%+>y}==UH_#SZ+a8}dh+5f1y1d3?dtd(=x%gQQ}wBezNR zZV@((O*a=+m$Uahs>;Y?fhk=6z!HT&okOjY#p4Fo<;R~*k^_SGL=!Goez^jLcOkMf zj`}P7+M(PUhwLq^f{GUYWBo; z$K&X^URHEWG(9v9Jz%Umocr}6HG2JCk#ElTj=U2`%P?D({VpNq=hM@GXB>UEL!MQb z8DB$aeckV&@IgbNkgiB1Bsk1ReI%Oe)qJrQ=ToAab-%)JIcXYDq<0t8DSXL*9k>Ha zuvOvas|TiuH-(Op4*&Qej61DRid}|svU1$XMjE5;2ra0InSF!gC(yDlEW`aCY8J$U zYfviUGRT8G18>(-x&c2jg?T$TJFrka35hYEw@|G5T-n%Egc`u3p?8LTMjl!?TXWuQ5-9V@0w8sdn90kSmugZ`UwrVO6`)O z?)j;7QJir}%KB|IXlaJ&y|FidRzzo)8udlf(bLvYu6kol1S^4Oa?NpbfSa9iYgJiZ zinPhemY3m)jUk^?W&t+2YdtS8d0{dgvo41ieq*&7qXgN&tcDx7uSl@iY3~nwA#2ugR3nn=%9lic?|{z*PAMUv*n!AwDC%-t!3Bm zU!HE_5d_uMDyu0!9Txk>KR>LRm-#h$-t~z(uL|Z53yVJ}FLz_1sDB@d5`$ZeiAaO&&ohj5I&xi2L911pgWw zLJ`A35VSE!!{OtyB$af1cp$Ck()Kdc{Eal^&az}EFph&=2Cle6Qw`|7C)mAcu(k)t2L*MUu%Zt zn^e=r7Cr=vrA3`@0misiH#uRfW*lD<^fI1r`z){VaXPyl1(>383x4$VWsHjvP{NuDhTnX4_%Cm4x{EPSMZG+w@l&M2S}B(wdJ3(IoUO=A94@KZn8-V#5pLb$t-4Pg$dnvGC zCyvDwlt4CAKFP^e*7||x7rMrhOxL-z&d;y2aM}cBY3RhAK?FgBvyp~w30hH{I#`k< zYjCL44dw}B7ErGiZEo|GE`b%@A=KTPwHBtu0?%hD8_8<5X08Xs%WojTvAuhRk4AOV z!%M#y4PT0KtyXwpOU{oF-?gU>68fjhkaY98h;)RR?Y4UkX^g6%WV>>^flZ;h{RmMI zRK@Mye1hDU9z;{{fs{KaWRDqs!&hL-bpv57oH$z zAQKyVfz7abz_oe5c!U8{B^Sun4QOcV6V}g9uHChiDoAIbwcGheG;jcDGar3oYjFd> zQ7Q8dGc)#n{b)-j@%5G&4pU7^{TYTd@sIn*_Dv=E7h)5XzeoYh7-wARJs2 zYfxW$2JTlQKStnI324V9C%1Ne&Ve#o2RG-C!X**1hsJh6eadn~uU4(YyM)ZHjAd;O z?=K`kn1C7mWkWI>4{IcLW6+i72Ho!2aO_q&#$&UkFl~uXFfwZ{Hl6qMF5H3DQv zSGkhFLjpIVJ2-@qy52B5(KSAW5!DDy@Q)ljzn?Tk@&IN8|LD60{~6uONJP$ARkA0t z?SjY}Jn=1&gbG|>%zGm2gwZ*D_++V#XbH?WS*6Zs+ zXrV822Lm!7w`P$Oc%#C3vbzP;*}Z01e80@`sw9?tlPB=SizdaJg?bU0>)`tbae`(3 z+@^NVV;KE7jPcm!Ci@1M{ zrWj#Vwl5ZKI(|Ke2as4}6UpL9n(}7ZRgSED2*5^Pp7(JfCi@r#dU%7&D2vd~4;9PV zmke8M)33~Kkp8Xibq`9?Ey&8#aJE+h$yjE>UW4C~K-CZSOooY=LgZdco&a43tiZV2 z3*Vqld_V+&M))MH-lu$0zHBQ^^WhZ1jPh?wZM-eKG9o|aYC51e(%_4ucVq8*NpV+_EPT`%yzgTL z%p<6YlFSf4Wx0aYo$xK0WT8Hq5^L0&2)Q{?3ObH=Q z|4MU$gl#XbIkp~G33q5AZ=PJv7f-`^+#0BKim5+9OW_BzJrs*m@yhwqR}}3vt0UD< z#a;#h6&?PVe$_J=xucat)ecbX;Nr?jHRhPzJ;?Q!cDRcFu- zSDk*#`YJLnP;Z#~r9t+A> z{lrtGm8-))QI3UDtmGKDBEfVr1-&(MeIlbUWRa>9Hrulw5|FMrTxPKTQk0zBF@rL3 zuQM!FW0DOKl*kUkulV3j>nZZ+IkD_>E(n1CNOB_V1-2xNFR5 z6S@~m?1%+^8jtS*AHmEWrOBwZrGjhj{679(;ojetY#h>43Z|Wjnh#|uyt>^7f7O`E zV1`XDY9Hc&UN5Za0j$)5a_ z%4r-11ObaJY^WLQmp$>!h&Bg=$e*bz)^wR{S>W{eQpGq4%-bRt!3*N}9#C@6u9Yo_ z-uIX3+bsIYyf)J!%Ub3DMB19e|0x&_}(Ejg`N?JP-lq*9KmL9s!$lE!h#3pQ_7lI~YLp z7bx>_WeyA^bza9M_qs$kgnejA!fh%}pk$ zY>J69lVsqop`!ZcHQqScp!i;ejimIfiPl(hf}6cAT`8y?uTaokGZkFjG}+E;%Sk%i z7+2urHkUBmwrCxnj3wm&!N+NP{^uSyk_^0qyN#gm(b1B_X@H2+D<-w0MaP_&oc>3l zr!G+D|K(*kum4f#GCBLEkfUikDZaR?EEB(P{xR4qf*aa$}wwjh1D1N zy3pY@E=&E|?K`H2?_ZYFP7*LkaZ-yd|9quq7*x+I@Vg>b&Y8uf2$41emhlB%5~MWo ztS-Xb^k{70h>;)(;muLW^MB9gV4P8osVpA55rpr}i9-7TI(I>N=QaI3%@Eq6kkzb_slD71AnW-nYG$>z@{QruwP3ex{<$ht0^`saCpo#-gA^#!C* zHHID0Xm6m{)g@BT){}S#Q6hu~^<@TFp4zbEq<+H9WJPZ_@ME_OiUZbF`D&ieKqKAH zKc5zk7H4yJJiNRuP922g?=FfdTvTEopI)oI}n^yhFOf{UhR=sEL_7 zxl5Gim_aXU@A73a=`#MA({_S;i7hJk11wmBLfuY#QbqNnMT`i(W;9}y0;0_FmpcaH z-CZ__&3az&Rb1f7Q6pp=?ajNb+{Q3?Xq(GgWP+KZIT$+rNFIaS87V7 zPsA_;F#ss5{PP`GtB}1>+E*Obi#tDdTH?1I6j%bN2S&skbm=3bfFG7Z4wQq86M)>e zKfJnhs&T||Em)vb*yerJsc3kOP0Ei?qoa=hhsf#hHyPmb35%7oHEerYN!eV*% zs0c$kqTy&@mE2X9h}Qz|&*=U;c_g%K&|?w00$hhLv&3FZmxnk*NtR&dq@a!2eXNrD zGlvq~vMR4XFmADuWG9%*M-Mx51c@q+bLCGHg{*0C~P!POyT<_z(Z zb^xH4DB@Fh#6atlmSGE;s>se_>wB%+n7!f=$cOlLuyZ(ga)Zn`O5-MzDnLS)0yYYE zf%!>=@oqR)@`+KmJpCM!tf2ByE*vUeHHUra@?i{zUo)zpsL9Dm)*|})GJrTItKJje z?r0j0`ddS4jTQW|L6@^_HBhAzPv$n+i_Tz!cw&d0jIBgTdwZL-FZv`2^-hILQ*Rw$ zp%5^ST&Y7hHJ*KIGPpi|UpNXZ!hPY+@6_*i7XE`Udk1xp5j%e(QjUeFDr+bekbqgWC{VIXnD9?r zsu+#vc(h_CFprlWK2y|{U*kU0I#A}F#>ZpJnH=1uPReOwRVw1fKh~^sK<-!S4US~r zboq%)7{JGOK^t1;Umm^G;Iee*ei=W`P^oN}Ro?TQ3M(ojy83ttFkF{mG81UqU=(!I z<+=p`^cwfi5MzH4N`|eK7-fxzlGz%FJf?iKygG*xd zo;T0gIz5Xe+sNK5TXKJz=zpMvPR6;SOs4p!phW;T9D%VnVO7*o-#w}VvIygWBKAw0 z)7FV=VvEJkEE(*}(l*MH!rW8J*pz*y&lXr@q^r{O)dMjcg6;!hWFatN9SY(Vxc+FB zP$+1Jit`t9;xGiP?G2CZop|A1v^`#v57}wuCBS=+Hz{$d*9+ajn;-=5Mc^lm>#_As z&1h&%3V2s>cx^;4dA%cM0{MM={`Y2doLGbC75OGu(GvsOzR(pSoUG~im- z(xuJp2O7eg1x0}Wq61e8exljDfRMuH3b@ReD6>%h6rSot+u{>ayN z_$i}8OsvmIkC~_OsbgsiNqB5=VA*&r&@#U8Rey`Cn#1)08O2HcH@PcPb-IF0%lvQhZLO zKP#4!+pvaSza~t!S90l9EY3YxJ}TC&u04$x?yJx2??Q251P-X(DhzAOsT|Am5mq+E zf)8*!Pi$5>*9d*ILDs>qzi7K8!LvGrkEu48{SvY?wH0AfOWzL?mD>dFnbkG*>Bxp^ z9hcOcDqH$a8Q!D<=7Y&8MIVuTGzm|A@V~z^{&lQ@JL#9KzzC`_Urvwi!-|lHsB2hB z_M(-hnYnqTrHL{RYh6)|UL$EgQ5?ro_uf{w5#77lH9KLVfX=$COOST>4jZfpma~^< z5{c^4)oyMr3rG%pnmEi8^8ng1Jrt&Ep#r5Po9s!^D|+rw6K1xt`7>q2!%X)ubY4Su zV*B)BRnEO_)WN&g~J2+f6yXe^&ov*4#j|xp2o3y8G*zBDw z)>1^LNyE9Lom|j4*iEa12ZE z3!4F)XzTc7p~+n<&Ve%%{!u#XGS+A`06-lCJqctA;tPLw+?#hs?)$GQV=M-@ZH31M zS!awb%ILT*W{`Mg&ti-Q`m@C4Y9gf+s=C*l@&rk?%5DJ11}|0V_}7d_axwyV=VTYe z_CXacUuJW={XqcwVbkd`5e$?Xi7Sk&oMmDKteoS^L4c>g+@J_lT(tjALG=A%FqlOt zj3inoFFnLTVrKf`M86X5``3#G01v8W&rmOUKOWgYKEnbh!%2}6R?N|=l;BR#;s2^Y zF%R*hYWO^3vqyz50}ck12v0It5Q$C!L)c7T9mC@3je3qtnLrvuP{Lz}YLuh!g))6x)ePdsV6 zvJ^v}hpbC3Jq6Hkya=`?_p!@1u(wchghO8fvA9lN$Pu0dty*kv5Vp}MFlzV*DG=*HYthA0zNLlTxiQrubZ{bgi?UEk zoXt=AR}i|ymH^h825lM4BrA~Y1O;Anh8j#Q4s4xYE_sY~XUixHgMv5|Rs@s1oQ1Zd zOJI86H+wwL%pshwC%90ycI^2x zK{8&rbYb|_9+pu1 zDiT8=0o;>y+rb0W;i3#J+~2Z-^k?XFRXht$%qRskp2xe@uc?$eko)76(mXoUta z4?`p0EsIj@6FeT|xLb0kVX^D!J67s>Pyl89uR+0Ap)k=yoH#7f@IZr@Ut=qZJ#=e_ zv`qqN{ImlfSU(~hGr=cL5wZkk06b!BL$-!GSJ*vD=h~5&8auty>Z+NY!Q{W{`9B2~ zPYY@}=HP$`ddJE|&k2!2Avi@{n#gsg_mB(Nc?#7n(X?Y5VHz@C8 z5f2C5O}xVzJdZ32#fbkRdujak-NE>SYcgM$`IfbpcMl>EuOLq_2xQ zmDkVD^DcCWHaOU?JK5Q3)Ts`oHDHW|KuAMC+U0Yy?4$Rq(TY~dfIAv zu9Iah7!25|Q2#HSPnOLTP*eks3k#c>^Y2tO%Zoc=DN`i=oa&lxyXvhO_)KLW*`q}& z%yV+#^IhR*jJn4n-x2wvPUU8`>`>wZlL9aZC6f)8rdI5!yz{l6bsh(sJufo zt_=`H@Tp>y7GTU)GvzUO*`myW;t-Yd?m7o@JZja1H7w_B?~N5vCJvz1qRCa!D0cYY z?pSmeITd!jv+sW-`I3YX@*hUym1+xUDwsb*5J=E0O@!M>$;(N}AbTC}$N3MOt|%y> zk`%)AVIvAVd!#)L(ixu&45us>4S{&zV^%_(wSY`5XL@m;*NPvQ#bClWxY3UYE+j(@z_-8MAOxo!sx zwI<%_saJ^fkg?nHUs_qMTwZRH5i*j!?M5iBy2lo%sf|F4YbBwl#7o=oPL@Nt(~E$a z>U}~D?#BxsZ29x)r#v@_8EWpWOFvqI85NE)UfXFgjq1#*oN0awysrz`m8{F0?uxD4 zuw^u=UUkiOE@5#^M9F|&TC>b*SDl5THffDo*W$d}F}nW$sJ|`_U>{M*D17R1u4grX z$&2W3?YGA?$O7JkzgRj5?)qM{=9gqb8fRRU7o>W}rvEI&y}zR|RblV#-ZRVpQUE4L z*uE-Dt~{rRYejih3xT}Df6734#Wf2~uRSJi-=8@Qs)aILIE#%)3~4RXXtRZqbI&7* z2s*4*N-Ye`O)lnf?Q@4-EL=iELKlw>*!NEmrwy?zAcaMkA6pbolsp50v=bbFRdocY z0rP))DE-}2Z?OzvQ~bfr4(k`n>{?9p>f8p-V#7bwoxKn_Jc;61UXIt!2bQpp9|SHE zwIHB{T?p{-$dxE0-{6YC%a>e(%TQp(BtMW*2N13~g^E}Bb&Vb~`^YEd^MRwMa>h)2 z_oRbf`?zQ+`Uo?gxbvpcJk9cn=!Q&!FTz8!%Adj|G1^>IpwI8;mBq?v@xh=HxCA|0 zq!Wz$l9UO{5qKdp_*f~%qN`!Q@e#N3;eQfC#o_Z}^d6_ylK9CbzVVV9n4T977Vz+* zpM^9hsVT}re@=D_r`h&hoBGFtD=1O%vH-e%%cpW3WmUo-FZ=~PDhzf@6j*}VjdF*M zJ`x$GzhW_-kj*fljkQF}3HkZvC68U8EPX0UL}b~RdsWVZ^ucJ408WNqn&@73KsdyJ z28Vr*FaeWr0qOdtaL(r!!d>w&TPr5SZxYVBs@#*$7~jN8Wq-O+l_7CYlEb^Ha$7w) zoNn!VrzGV*Mf$`TWyh}gy{aQM~&dAO6jLZG6} zA|1(A_WbZTw9d)5!n zoO1pVqI@})-myuJK7uWwnwWM*pHau})rq*{M}?^qlmd-+Q=$>=|2VD$d6~zz@y2bw zP);yEKNC5mZT47`_Ph9m;GHFT@29tf!YMW!7I2TMK5lY_f8>=VP;!AR>*qK(SR0p= zfS~Te~f?Lr~qhnv2dVEcTbG<^ZYX89y|Or8!qUim$H)JZUA~D_n@xB|&staMvhy zH7zg_hmMgqPh1sW3Z4;od&vfK_sy;)USCX7?)z7UpP8QDl8jkygDOBW3TB~rO|QAz z&C>U=ZK4kO!g3)bQ>5VqhU#Qh-8?ESBM47R#C0IYvi|>zdj(W&6XA%y@+jjE*ejW-z4Y9Vlxy}b(hVr$E{MB zp|HJy4ev&qlLP*)D%oNa%{M(t_hMB|Nd-MMMU)Sz@tPPf=)>g&9Iao4=9=))*{GN_ zQmW3C=0PzgMST(7aRFQD7L;h5n=0^j5(s(_r2ToprsLDPurT?YBuHxN2lVD%Kpt0YSaM*X8Y@lX2fF1BCkc{vUOAKH=I*EeX-(H}GRm`ak?-6AD|auP?{ zzSr?kMHSG=3-kWu`5WKKhMPZW>O&m&R-MBHVTuK8>^Y{*m{maFJMSRvPv$yciZ;Sr z4-HikZrUxWF>tnLy)L__VYT_4>BY4QZ3Dvc@b>qzB!DXl+?}O#*x$P?02XazXNKzf zsUQOD{$xcQAqM{b_0c>w(kmd|2P5Fo@rKh5e-;vf52z!ch4Wkxj{r1R_$yLnAO~r< zOh6FS9YU)ZkZT?Am7@0ZoSCF;(jD-BpUwQfDwrk3O_+h!jzGom&?&kOGj$1z6cF;> zKmjWzWC*UgN}BNZ{nYcxWki{qL$L-~3zz4g|EqUhT87J`bDRSWr0vfb*_di>|Bp7% zE4ddblFYVd*&YRZe5Q{uS&%5BGKWxI<62*mE+x8C&pSlc+~@EbQ7apN6YSyf0s;K= z_nfVy7c7mh94%@#pkEc>mO(}7^!4v}rOVTc1D9&K@Ns>$tpFnJ>!8oup>kTe4Xi(J zN*`d=gv%<-;*ah7iG)y{p*?gS%wt1)tJ^cVWwJ8RoxGZD7$E#K=;!1#s z10S^5w1=`#c5pf6J`nyNP6DG-4hOt=w7~UO1|ic6zz2g(`n$ttlT?1oI>`muWI{P_ znz-)1I=KF1HBcRNL|@t(lFFV@9;=^SJ51kWj;L!*fOV(s)Fh%m z)?ACcGO#$zKG$|IX?!QPpD6dY{o)SEEIif%`L#5Z>8_YLBHScxQOzuEb}~dMg9!ZA zC->(ax8?*)rn5lFBnLTyVZ0WqN&Ll%JB?3p4Ul_)jCC$ zv8V$$DIdg=BVQ?A2la~Ywa_QOp2BxBoG)CwyY&v8zzeE#vF15woM+G!Z|YRCz1@J_ z!8~(NsvdWe0TINminhE*PBSx7I${l+3LZ}FDi^7xLKki%nXO|Hk&SrN2cD?+Lg9e9 z!>GSrnF@O>A@+${EfP{fgyMfa?%)|@Rcj|M(2O>rJ*(*A9Ko6oy+NS;d$?n~^>|hb z{+Ae}x^M*0nap#MY!vVzBB{{2C7nMF5oE|~+Dsgh*9+{#wMwVVCRvOfYn1UC2t^IT zcj*;5b40liKi zN++tUZh`pRO5xq!)pLgp(J9inOctY_5BvUoQRY`_l$&ly_(kq?Q# z8WV{ji29Wf?9`sk)(?_+GbJqk!MqQx&h>ZXB6=;Y^QD`zg%{;4dxDLBt)^7({-uym za0$-T(t5n5*|je`J!Na@wct2kIdLXT^G7I0X~@d>NQU-t!8X{Wc-X=|19Rm6{aYvy z<7J_xll&g8=>re*o>jiReB`m)H`s!)UVJ?v-OKEO+>53|s7&qTe+oipHEKuJC=4TQvy1=LAnk_9u4 z`${~84ygfx$uaJ>?jeYn1BLvD32!FliIS6oss2np4_;wti&&H(9sL=WnGGBx5Db3yJ@NPR>25wCElje(j#d z&y&_W*8@d$Zfx+NE>t(q)2^V{spd0*UxA&HzeW7dj`V>A^z`9bdny+~j1As9=GaQQ z7`}viTg4iyK==_x)r-{D8%ozCIPGF#?s@d3z*~@?Q`+NFf>4Y7+TH4If!qdSU*ZQC zCfx=`@1#gVt-ZPhUAR~2dD>0xlJ+%cOsGW4#&Cwn1a_*zZ5A0t;f5U5@VM1cwhGE9 zQtZKs?B-DobNhbGsbI47#W0ZqQ)lk{0+D3AiF>mL>e1b6EGs~Uif^A6K{-}hSr6a; z-XA5-^~|}^5dvk*#b*Dz=n|B$0&d`4whm!=i7zXNd1|r+^AY6?+JOtd>x)Re$M&W~ zzMn;$wmFkqbG{!Cd#q?-|H-veqDn{YUnLh&XmD>s+meo06x&rVI+#%NG3B;pkrfRjjBjdo4%*^h)Fvo3roP0h`5zNH!iF-x2|Cb1!*ChZHI3(@ zMgwHrfY^-eXi}F~gu{i1#abssnZzUXmW|&_;6%9mZF1J*Ax4$!A{O$%<)!Q2{!tv# zG|qgSbEgARQu9d~6CwkzTc&Ppw`T)t2Qal29MUhp($7ncgOX}|Hr^NJGDy+lC=m1$ zw^vN3+?O07VNJ_r2GhjAwp481Y+U9GKfvaR-nvh;wFZ`$I;06q1bSDSisW>fKswG` zw_k_XIi{*m%jrFWM2fw1jYL_jZ`1@;<$7eLHSi!sYf-#P9N{?m555HMu&tuYwW(1M}=D7S3`paV@r zn4BT9n~f^0s}PfhhR=D;)5U)>bZ@xGdE|0l8Xa`d$W2Gd7=P@oh8tZL940N)l^9<^ zXO0U9RFL;8m)CNsHt%A;KSn^svrrEAv+E^q)p))(2408$(36$zJDoj3Z;;Fms`}zH=@G^8Vu63(ZrhXHc&f zFMqs7E^oTuKW~I%)R+m0A>F$bFvH7~!bVA1>U_p%b(a$J>>y>9rJnN)8RpTUZi>r@xjXpy-ITs!YI6Ek4mk%vS)@ zDSryh>FV{S`9ewK`BHd-(5J@N3w5=L9C}?f(Cw^OA~}WzJoKr)((1YKqks0Hpgd# z?6bld7YKm2FgTk~iSIbGCn~qHx;44_IuKgOoiTCinFjiXG=KPrZ4<>-*4!krOi}xH z1`J^;Qm%RVkohnpgG|}4YZQ)tGC3A(hYiZ%!nX!V#$;oB7gHS77jTZ{)v6W$oDW_~ zeS3e^Iex2%Y#+HMM0RO{pDNW3bo+jBDBB+y)sO$(KEVV({Eb zL>weBXQqSp96v>eY*+d~r8zdV%ftiTZ34<} z#w5^9LyyCa-Z&D|)a7LXr)BUsM9=}`X4ga>PE=QuoO^>PxO0#KINJ*oi)dQY^{fkd z@+H-w>4dJA#53vHK?3o7us{O?5k+x!{sb^97^3LTJ!@HdaXnXw;p#jZNH~=25xcu3 zJA&dqU9b*52{$+GN)m5lrr@K{c9pfaX5ti@g>5GYuntl+f<+Hvs2A6 zYuUoyv#2@<9%bs{O3w+HLER z1mrM$cWdyS)AJS!0s|A7)QVc8-f61SOtCsHz{1DisPYXF=a3J)zW>Li+uech^b5s^ zs22k2=QQQ5o0?&APW0x{rgq+xLHG33BwLIIrRZE=ZVL4yzbmP20@x`>2JC#vq z6OgvT4%E&0mWKYyW?nj@Jv@0jqGL#j54_m6 zED78d^lt9nKs2PIH+}8LVA18#;a|i@!n9R|Y$Th0!}idOXcIMI;gWzwY>N$l*j5^4 zc4B~kwDBZniE08D`3K)dog;-n_6BRnUh`^4da#H@1 zg~$Z2JeOO@lzpNLcM4&*PO2ICtQsYEofMAME3CeS5>xiQp=GG(qXY^~$XipBd&WFj zz^W(jA%SHR(3x^)J_|U;psL9(^9|Srg%xpRBiy^oYJ1B7qzt4MAc-jIL8!}PhOk*L z&gme>@#hStHC|V8tBZjj&~?NGXv+J?Q~}W;LIH9qoRvai{QX4jKTO-b9P1cL{SW7t z^1Lo>mIU#Qs)x>;byNmPy7(z%3f$c5NAo1RTw)#!$Gweeb_~Z|zT4yD`yAMpG7uGg zeaQn5%7#KXccKT6tJ);++%0Y3?py(*8}3!m48mRehS*+u}OlRhmN) z<0TgM)?Dy_IZeWIF%IC>uGY4Mv4i7H08O2#Y2ju9{22Q`Z7FbO!zR;2SUVX%`N5{RNWSK|5T z)%2ng&B$LJ#%a@5_+Z&+$C1<64^In(`5u;=~JFI010zf7*I(4c&fmma1$@v|$a&UA4+I3iK>8l|*6krowp<1ri^~L$ETqi@Lw)xJsAX*-J${YI%LL zueLlOA&))AAB+a1%9h(rHFby{%f7H39lMnc-kgok%lJ2_P(n57nTs*C)A~#k`|IrP z9JkW;CYpde&X1XNSBfLhm#|017c^Ex1W~C7YK;8}!wIc(d63l;DI|0f!);^lEEg3V zfObJYYRf8=t75>S2pGiusfJS=WDPG323L=ACo_jf-d}pv(e0}FV2=xoV11;z+N(C0 z4Hv%ifp}|5u3E^zD%SkZ{SmQ@_Y>)T&VGIYNty80zBtQQheJzmEBckx5Z%t5BVq+i z&21~$=`zeIVRwBNXB9Gc+$9H<=}MgiB5oOT!7@&=5NWw32u$Lk08{W_bk7lAiyR-- z1=Rnf^N^yhxsJ*g-b({z_*_QgHAXnxAq0e#ivCab_!!9prU1eAG$MgUfs->aKyayi zS#~af1snS{_LdeHZ-kLh7t{Q^6*{Vlcc}p|laq+u;@5UqyAJ?~ctooT9`2I@hGIN?C+_nMd8a8GJfRP5e1%r@jV$1 znEfkoLKDd6+rZ%>xNgUKeAwKoYfnvFPoo4LeaNQWR)`-Jm#g3^W$#vEOi{t}cz4$& z(NtMm9{3y0FOmW^#&5GGf^|ti!f|Pa?x$T9qKi^#(RqrN$Ywp?B-I=l1r{|IJ z7QM_d?4I(dH)t#Y8h#1rnoAdDL#Y*4T>5SczPZ{WimKs_n7{!2>!1?RK!7Bp9|#k^ig=UX^Ubf?Vc=|mVM>3m|0%EwBur`48r z43~pvC0E8fQLT9V7P?tpPneUb;8l1F2>}AC#_CJS|3J^VuW9^GpIm z8wcJluIbCogO^N6C^abK`O!mdb^L7>4P;i*K1j%fDd^?>lc3P44P38&Q6kB&(cnk0 z-*8G$Y&SM$WqKRzMS)w|uQB^{%V)pTaw#YZ0PmvQFx9a)XpdzAfM)xIZb^D4A+e-v z?EvTt;g)(KWxzLzJcZll4bil0>JIIKY zOVp9ciH^h$w`Ljkei|jj;`7Y>WO_Wv)2Y2n3}4O|{cb1H@{(O*xCd`A06zeHu4YS< zpf7N7pkFFV>Gtnmd@-7_?c;SMV7|C86x{dXt%k6NQ3~TEGr9kmP#XV09f^4n; zI+jzSu?>x4ygqM*RJs0K(C83_JCTaS^>k~G2W=he(#O~=wCP-jgg2=+!x%X6zGAbH zHGHPkPtg|Q05jL~cOtcfy=Zb@L`&DxKV3Q{-x|Sfmg_%2ajtnCacwN32Cp#)Jf#GQ zhasKT3tuTe6c->ib~J}hi`zH95>jml(9>RT3mkA8wM9Br{@%q-6abnGvt7v{YR7ze z0_*oe8I@PKZed8zzQe?P1cUV$jTFW&#v_=$&rQfPNHA7|Rbxr2Kdn|1Z?djsgebndGxa#sy1z|m)D$4yJ zFDCA4C3E-02|7@R8s%R!HV&Q+!q$q1WfLjE%T zJRDa(4e7V|If<%WhK?j9NCPm&l;HdR$+FWS9cLz9P*1jghUwJQZo5OPuFdWfHt2+6 zVg1ZoJFn|iimn6mGa{bZojbc!M62_$G#4-UTj`?IFE2K$q2V!|eOR6FFkN${JtDytu zZ9z1>`?NKr*Km}+`@u5ouc_$WuJea#6OZL)LEpNV=MS#rgY)X`YwGpCh1fnT6;NEq}>wIz1cUv{6#>k*n=7h1iK1 zI0W;CLv8cNv$(LceMYckZPlx-gZ$v{BGio~_)H-(ajs>`H)~*u9st_cU8*uF_y$r` z@%EtuJ2fQ`_fhbX-z!3Xa~ST9&I9$Advty|Grme!iCKiB*W%mt!3mwDsTM2@K&Ij2 zgLNZiqxUt`V4?~)T2YUmMe|>ztPkU_)BdIuj}0~Av7weCo#sCh>gRPJPXekN}8)(Kl)Mj8bnmEkupn_u9 zsG^lcW>7e;6wi2dDB|rnR*N(!TkyfAuR$1_M?Ou`OLXs<+p!$rw{rHWRo@4cEhM_s zqY-Z$Qy|sL7TbIKWv#>{#d8))hR|}IQ2wC`L{T}OgD$#1>U=s|Kki3u`}N?;LCKGP zwO1XG*_qQTcTiHs`VJ^ZDpMFMw`7iu>YKmg?;C!G@%fxr3~TJB+84MWt{g~-W% zc3`>2MAeiETq05|d0Ilk0Lzcl#;Psx5c24L(#j0a{o(>_iR^0nj|O^kuPVO^rhNhfM0(jlUd!L zkaUe(%|P=207*r5h+TfBmeywz$;3x?8`D^|AnQ}vqItG&xR%Q6#-Fcf(mCnYhzh?l zHqV!Q$LV6}iu8`37Xk}lAnU>jIae3MJS7ap6qBM_PlXDl|CJMyI*eKotfDRnNPHZ3 z`C2GFEEtV}X3fBbmUp!j(i8=W=&oT4EZ6LPHG*~2FyZI>hToaAJDFlC`)t>wT6_cm z75KNhd&Uj&D?p@Ph@WzeEpm9;bQjuXZZTRZc8LXxH8XIyp4xjiOS4xkIRH)L!0G!1 zJ4(4DfF#vde@X4GADQQVbXuDHzn_OXN#$R4BbEqj7Gzr0lc$z_;DttNtvUtlr2IDD|V1eIWF^~Ru;G9pQx&-#{+YUi*8g;3>|h^*3T%sGaVog%>B z45Yx1M=h{M14rNij3{iMjBF-Rm|P~#gI+Dcb|*#2Nta%QF)H1W7L7taw)YhuJD z6rwta6as2(J&wXBG1b0=#udkwDr@w_%=HUVGc&^XEGOwV#=dq__ni}g;wS@-sVCb| zk}WX7++n~f^;5yWg1$Au6L_Al{zH)-g6y6ELJ}gi)hgl|#&I4bz_-pT5OY<8riO00 zHs%B*RQMy0quaU%-&*Wg2rm6OuEpul>-314!yjAJ*&Nw zeJ@L$N7~M%=lEa@e@Xf#gQ}5Ly=Qh5NeG8N?t1e7n7c-kC z#Jk(P*zZ2g5d2|!qZZvs-U^G)H6x{N*tOvi9!@~$Gi+DxD*h(QJ-oMl#*P?7UmL)Q z*%JV#=}y73XgCON7p*IDfb7jG(*he3b~_yek1;*dZnt^0;MiII%hR{>ar!)t{KQ@D zovs(y8U*$;etZDXeOmzx;AbrV%PC~HZ56(TXouKPtU5>z_`*Ef{82%1vr9~4t+(4z zg{1f`FE$|J0MbuyM~y*^iqc&~p7H%utd2?txK z&b!0vp6Vc#OJ`HViX|hz8w#?*6YCJ%gnS}Drx7Hy*b&Plv`cW*5$XX8`O2JMa7AQ` zD=%ZvSMgWvx{Om%^ev5){q3WkPJ}=LzRC$j6GtRuoGOf!+rS_q^}W7E(JAQr7PR|D z3gR>gcHOWg6OhuwIdpylzQB;bKGT&$WPbNp`nBtM&!M+=XK5qqSwF%kVMg7RQ~woa zfK#j!-GLc-?2F}IS?RwO0PaJ*e>YDA?!DalL89CJ!scIer#pS?+-uX*3r5}6B+X7D zwvYr_UY4=n70-Nb_K|^aet8*yZ}mJtKXMvgz5Sr3XDM&odJ%JN4Vk)3&FU^yV18O; zmWISOG9@&ZjCYKNbnYR2v)eE@F9j-g?k?zyv%!>z+8M}&-2H_VT|G3DfW?Ladt)4u zd8HP)z=&CZiRSrI8*>BIJvVvR+vn^a>6SvQJWnS!mJ*6)CMGb*?6xW(?a6`og>y@9 zq$X?6nCUCRMPI97FE_`Tu|ZNUwWDK^XXYl5;+(V*$yDbC^`u1fMAukny$9h=m! z?ctijv+cW5BQrlHjFJ|K8!q@35DgMfm@7Wdc$0p$IFTdy5Qv1&9+ZNFK3t8gc{Qba zKe)V4YxG^bCnk3HSr4`knrbCNLhaluj0A{gy!sF>_k_w1zMI7TeL0 z5D5C-O3pe$L|9l~=$FayyMd(f*Dqvk3so5rvK>e1BBr|Dngckfjy?6m_D_2mD};qczO(pg@6F8m+vtasc0Kh z1&h-D$d!Rr5Yy-pd9*Ne_$@YiY<{Cd8dLL&o96Z#bK~%b`Mpb>YEBonjD?Q)lJ*oy z^_&*AW|*|Q3CQ{uoKZ53`3u@&9TMqe)neH?x!m>YprKQVk?a)Jviiyy7(ZSwnn_(%_hs?2}defBwfXVxyn62Og1pZ$gh35FUU zc~Z;JZSMC>=X~}7UWA^wFknyC3wsa^uJVU1eK4aax3ByWAZIrv=DG`A%xmLD0%&}y zKky!PwtoH9lNFm`W0}a1aZ2`c#eNxLwlj+>bC9`Vyo@oJnt#Z{@&mYahANM4zKI%a zF!H}C!cC+m6l%*YP7P}j*#}VM2s)gYo6|bI8nMB#-QvS2fFRrkmr0S!3l=!@GpMAe z*5(7=*E8k^KM9nqTTZ+eO(Ndbw`XDU7SiaESyi1$8gk^OEeNF@cRcnf!AXFKcyJ4v zpVBMWf1SZ)aS%q_7=u+ysn{$>^}kxcU}n)+^+gZA+MhZ~Yk=xV*Q9Yby| zPglQ%&?6;C;I*fDRacYm`ny}mg%=msJpRY;g3m{>DdNkh=ndX*5#ST|YeQrT>JDCs zV(ua>#LfIwZ2{z)3T@$^V4+!s#%$rj7@@ZP>Fv^ihYBCN=|dk*k!s&xHt@N5yAcf3 zMUy!q*HtYJ)H4ajsbQatcw=SlKdCfaB>^%FjbuE%XAf-m681IC)zaGm%Cny<=unVC z>ksee9T}O9BKf<6Tbx`VTGxBt1QTwtG}*%(k=2)%@|JJy4I?lt<2pI+kFTR7xmiM_ zpmz*FCLuSw0ZwG7}a=|Lbce6NeK-A0c*vsLlNBk^++YRxSk+-+`S zx~3^#m-ve=u4l*|_;>>g1%?2*6PKUJ;_xhoVTa+?OU8~RkqkenXwQwfikR|JZ9bZZ z9JDxmHu|WumzaW$9M_P4gH+R{`YSkM!M8dB)GOo1#08XdbhrT(YOc`|P|abMZCE;m z$5|$sKGPQ7zN1XL#_O89;X5=cajJks*>!KadB~}D%8e$lMF^wM${zeTzVJWkW0d}ps3$rPQI zE}#qnyN&=wvj`*C@8TgZT{ah&jypPRt-`HX!bZhiXkI|>^2I?!4NEq%ZGPS}a69{o*?h1$ zd0}~*!^of;#SweNujYW`%=UmLH=I+T8b8^3cs>+ zPQM|RfkBOK?Fva{*_e-gpYv_4_oJ#DaR*(W3(I|y`zdDD4`qnNEKxoHAJiH7U2VL3 ziWBC8*U!n29?qYD$- zucY(y8Y{Y;<*Y=Oc^eBbzoO$HEhijL_+=zZ08}Y*m>*D#3;a0aO5KBAfk%_a2g z;d*qRmxyV)airtbYO817d?8$n!b1~Li)q}KYC1RPjPzD} z-CnEqiQ=g+PCuPa+Mn;fWw}p^(gfp7J*Wf3zbA2$QeF4N7;FLbX^tqsr<&j`#p0uQ zsKve>JEWe~&z?!iDY_jjS4C=yTOjN+H*!j{fHNXvt?L&I9io5$85JkFFI+L`>#XEf z(Hm?sZpc}PW??T#zlvX$F!4u#*0ANyP)|;uLo|J4h#$Qn zlWg4%b+H(6F~!UrC|gC~l-ggPHoW08T)$zYE6QgtYOalJyc9Cg&?D`)$b@cMzJI zrmhSXa?8nw9{N+&$wbp1RFbpF_OXXiHXrl$cLxrJsaen;U}?=>mkzAuYyf)ifLsFu z6x~>VwbeF%Dr(F8y=vnDK`yr-T%dihP$@YpE1&{EJ8|pOp0LOH(tTP64Q~l=MTS5@ z6r70e%Ay-={|u&jNr?Wct>-G?gzF8uOx86N4R05-jQZbHN29!~Bhoe7U#k-+n)Wjk zr-zoLRv|ej%dhY052OS4Cf>7^T{Qk<&9)o$UIz%{I&KSOmDN;W^D25lB$>wfYm=kj zUj&_5O=bkUU)%me68yz^ib3kS@%}YbDp|>Nzm(bim;GVHah&%vE5*zrfwOP5#wBok zK~pV*0`2dvSnv3J7x=8xnA^|1_L7YA_?^K3xnO#=RSUr^gE5=hX^btQ*wc%*O7A`a zy}Je2z+KN#lA%V?{F;%Tr5zHZ<$?nF6huP%YQDNorc7(ns`wp>p|jk>1ug?A4?NM1 zlD-6`bhBp|`Ds5h73hfVEBBQu9Pi_f-7_n)ffldM<{^>^F=`ipkI()*kbE?~_A5uV zilAo%WT1Roe=EHXlki0@ciy$p#jTm)aA`7uILl|zY;K&#-%D=;NxmZM*cPOqrVy_+ zGg7OAqCmT2cWxTi{&ho?Pwwmbgb4G5Yu+}{RLghXJ=os`JW44<*nnDbPlANIRh!!9 zf_Fqn&K=9e$KS)-a%y}^6NY~ex+Lx}HZ7!y(pTb>0L3yU&v2i~~R*L5L` z`Tpc5aCywHQG1&l{z!QyLrKfM@hIo$Z57djK*g*~v_Z3%>c(gxT5|zW+}E5Wsk>Jn zClc9Ixq<}+h9;7!s@PPmI-T~oV8l=#()uk9kDBlmC^f%4%V46tDW)+gI?bD9YQW(v zNGsp}GAo8Hb#aKs-onraN$gc|HV9|CNj%i%$#T-&s+p*dU(ld*i@F&mVpJJ$e62NQ z$iUs>>rEAOWIIJ5Te}77dr%!95UsJfs+YNwz(jXJbzD*48kOc^(RDt|FdfJ?Zp;w| zqyz>zph1?opEq!b_gJoM27?M22qHBAvDvm4bScs@jVO#lU=H8DBi!Nffb-w*5r^>> zR1V0it2F_-+r*4XupWIZLh;#Gx=S^Bgc^pxq*5d}1I97gV2bRy%iR-K>$lTKoLxTz zZ-pK@ZCPL!OHoK3*l9xsm`!umub3iNf7C=Mm@n%^XQ)s;25^O0`I_LsI$fyfxe-JzLUWUAr(Zae31EbqPU4JeH>%i? ziNeq5yu1HClQL;MnBebugFU?k1|#6(YUJ7PsK-v8I7Bjwz2hZzo9n%W2J#+5{>mg8il8;Z$M zgYw5!`_mFryFSa2lqQ7nT?(ud5^UW??`RHGMLPCwdL)=aj_RH|aPl~^$^|wLMfoz| zLoyvyk(#FTl&P}sYlmsXZVD2IG#ms8esjBS7DhUu!^q3z{{G3E&PZ}48wTK|wjIp*V;`Buenqj7D2rKHCWbN*x&wAZG^akfjZNlak2=;sA zC4$HT3u~}5PeOz=*(sL1Q(3tqN#mu?yg2Qy2#xsbuHm(bpO$551AEqVbrks}(0>!j zD*hB;bEow*=aevaGZU^s97*8=wK?l>ahe2q?@n|$5WU|RCjM_6_1UJ8pxHgb-hqhGR^=ZTP zH*&XzdAC-aCTT+%lbHG&n17}SpKgvTU`}9BY}q=Z-J*1WBEY*OSBxmdBND!ksvzgh zyLwmR6WVk6ULz*pZMlyGC-rhc@l;7xCozfVu15G@+A$;;Mxo~4Y9pssjTp4>>J;V0 zeb0CnQVBTvXV;9EEJ{u-C4(Bp{rhXp$M20{>y_xf>X`0oP>&+-qRUS@h7^rb-VxqM z@y`sSo#(sMe_`pgs2QGI!IG0o-a|aSw)7aNG&4tQq3c1bq%PmD^cnI6Dm}?QR-VA- zd&DuO>O_UWK;=b2u{xYH=k3EGU^rWpQG0=`ZW`dn6M;#|^0Nz;qv9^Dq={%@2 z?-*}m_Bxhg@nSpE2wrccA?pzq^Yi4GMtu=mVp~;{824|5;3gL_VCIql&p#c;9ndJc z5waWtpvRoDooWA57?jSS-yNe$Tg+L%I~apaV&h73~8~0_sYw(-*b>`pRZ%WOn5;pADP=e2wsa~Cu zlAqLN&4*$&w)_-dLHHTuv=|k|vV%FalUvzy$|4usrlXVwO_|#2nt_J+reee@u8>c= zv|y}5e5#VJUx2bvF0Kq7^AQ!vYct8!bitSM$A?88oX}n2+r+(oYY1b5s?^6sQ97CN zjD7$5|22CUD{vH66OolVG8Ph4&wyW8f9cL57~J^lwtO{pP@*>eB~AVVOB}eW{xesV zoj!M&M)dacD85u4_(hw`!J0KHM02{d?_dYmx(9|VoEMmyh6DnIrN(EML|4IaokBWL zPti?#6YU-l^Dlu&cz*Ym$blp^hOBlFREakWCC%DpE_MO;lYUE3{x-@xFFH~F4L`=` zr_znsttcHwGid7P{p--ZIQmWKvRz;GS`Q{b_U_VXl-403WpA(nbOHEC7}zFXINIgp z5Bxg%@}g-Ey&y(>CTqx}!+;IS(`xAuL*G%OEbi0Jv?`&_R8aalnEicQLV__-*!6EK zn(a_3%YnBLsb5CX>dBl{f}JBx{4Da>TtLL6AH3o+a&Z4jZb{Kh$-9RlB%aw_+w}oS z1K1{B<)&ERPEHvfbt?Sv>3n{0`y}I(6t8(em6@KQPjJpZ&!4TAJN4_G6fBB*K=Dw}_MI&WoaMn${wJ<>KM*AsPH$25K1V%3!Y3Ie+3nZI# z=8hS5S}M=zJK{o{3%%7w$xRmfd=XmeQnu;kac zudrgtN~93L{6Bl%n^^CB`-)R3Ai6*fT6t)+_+M7Wt$8MeRR=fyuXvHG(|uVv&59cql${!3A4K!iiXF4G?des@O4kRFPi|O1>fn1#)1(28on`?#IZmA_&YX39s8b1+3%})~JV?{t#ODuo#ArmfoZ-Q@i*^v$J4c zf|`2LDfLK(-)tGL6qpv3U{rvC(PI~-(2H6ZB0aV}!4TNTv71cDebL=sWY8}Lp^yPQ z;&INkffHA4b$^Frzu}9~Rl<*@mwgk(7n{``N(Vxoq2R`$H-Y0<^??KNnyH?1u(=cb z)?UsWJYuLb+to#xe7mE5S3$e*Y|R1Hb^kpG2XN$zqeWlyUeG?;n&HzxC3uOa#<{KA zjYLL;^}nzx|Lf%*JPB9)+p(Z7)y4ja3b+sVQTfHRb?z!!mQ>W@l6b;;m(#qQjnA{VKUk2ejUW1SpTL`& z9z<2oGx}&~F>_AaMIMY6Zs4~0r|m6=ZQu8(WW_lHKGoq}BYiA3G%yn0*&8aqv9 za<~;Q&VPf>f$^1wY`JrGd-H=z(}93#sIw7^fIl)~NYg}GNedFW8Bi%{6$pqKS^duP ztw4Zfsf7|#Qh!`7YYVKLCr{dXm4^g=H~>>Yq7uB&%(&3^gzSR z9eK^taHo*r$#BF% z5SB;J^>u_*Dw+ia@wlC?iEtX)?JL2wbHUOL7tC=;1onm^z^%B~!(k7*@qaL(+YS?v zp@t`KDk@9XS~5`v_ab5{pml^q-6hdyQ{G+t^OE0w z?6*xMw9Q%b(oXzajS?vwKkbQT?NVFm)70ghuukpz%@;yT%s}BA)YqjH zW@A%SHJQr$T9a*fcST@_65dnHk4B0Q`zJnUmQRQ%+MvKH|BQP6&Z)SqL~1X=S&#sQ z@5V_&9Ov$&_E?-+;%c*wK$lon1XwP2CQrM(cVu5)z$=`ZNp6UGzCb!QMZ2?9bwjen4!jJIHalfA(kMO3KRmH?>V}l;}~Fe7U!Nme$zAW!z)|NU`jQa zE)VxFPdjBa2Y3@od;{JHOEuibn`XO*UBud-Oy`;$RsGZ#fe>6gX_vVEg!(74@2B># zb?G^tIyx>$2-lD9(L*<56DxS-t<25~qUqxrr=hwUSI*rQ5bF&**CUtItognAiXO*+ zC71vio;P`WBuWxO-O`Tg5VptMBjVkL?)u|qD_oYzDA}g`tG`dG+B6hO-qCB^G0A~j ziK2S1wY8jq#4W;gRsJb*0bH62L6-k{p9ike`=5;8X9Jp`;nlTGuJ=iOb1-g%KH}Vl zAA{Nw)9%`4L-paI$ailLU5_r{+PG^V5e<5pf9kbK$ze9%S7<0&POLtBs=sN{bM$Ox zZSZ;5`7Vt{rDfZyT;%s#4pm*^XiUbX%YQNW#xyNYMDJ11f@+4n|eNQAGzcy4H(k0mYx*!{Z$N#{53pKzegB-%cG9w zlvW_5R7JM-#FkNd6p|5)yJWNtVuLFtJMn3 zNN0eF2O`-@>A;SgT=rEJx<9Vc|DQw!DcYcVxM@o3mNb^NW*M4H|G<0+jg=S;!Qu-l zbAp6P&(|ZP!g7J#ttdT%C8m9QOq$9_-O!RBO7Yf3@)r@#SZSKcy4hF~&<2BWbmJS& zhjhk%aW2gXY-P*Bh+$*~eO<}woN(d)or=2vXw+j)+$!eLEFz}?Y-#MV|BmNy=0scA z!XnNK9y*R9)q4;PLX(FY#zIqCMA~!4_Ude~+m{G0uWfi!|N+oEgVZ8%K+lMN18h<-UHW`in_YDPg%c4C8Qh^Gzpc=Vg z1TFg;r6Koh(q8-j&Q3qm_Ppd9hIxGYY3bI^&sV}VW?{aml9^pVv3pjb{-J%U! z=Va7N6jO)QzZJp^csNWaFQb`IU)#{FV@PNW5K!#tsRmbBI8 z4>3~hyC4~Pe7ye7(La75%T4ckO(}!m-`mDqLi`L9V>BOKx`v1G@{dIp?dl_Y-?O3m z>o2|Rw)9O=R=TJ#fY&MCaN*W8THM^YY%S1G{$l4eP^tpHrL7ClD`;c_MsPqF1XGRL{qBaLJc>n7EzT18H~$7g zkVXau$z%cC;w@T#-yVBz6mB5;UMhc-W%<56L@-&Jjja+*HPL5M-sN6_MMc@Ln(Gfd zebC!3mzuLF9`3@#dmOFsHKxi_E+accKZX)K-oEa9w420ngGp{S{?d~U6LPhMts_0N z8=>n~3;sVL6T1gyS{_w4%Rrgc6J!*;=1||OpTzyXU33FY1luyz;R_(56Vpy)?W92U z#8g1*{Nk&Z7pBlZi7QGsW7+5-id~jS(JbX^G4&?B2Hw87Y6P%SE93|AU$h$-xgyMq zQ(Blgr+YlKz;4y1BInR*qqk0}+60Gp8$A1U=j=DK$=ozQ|I?FX$?ai6rHuPa z{|hGC0NiK5h5;l8t3FKTo(&Xu6ESu_!Qn-<<`16@+S6v zw!55K^z{P%^q`Lb{{zsYaRnIJaaT$6u*7@1hCURqNbGB7 zpzW?o&k2DS>uo>uqk0A$JzHx?lT?oP)pVq3IzTc9g&|gAHMd>DeRCc&(Ce{rEY0Vq zSBI*;k{`{K$uzSE&v%TBn=gpr8<_ ze>WH{BgyONOkMs#bo?D; zB`<-!y1tGsd+Md;6G+kL<`UfE1?O6dn}H{r$m%_}cupT2ci$lGdTDhPktiC&$zdg)4G`{dX|Hw!C^~Kk?!( zy+h|WI;~xAWQGAgjZ7P1&A1`sAt;%RYqAdnWHb=_Bwp`kc z{GouEht-w|t*tUgo`+Xk)Jj#L>n+G_xGgy1(w8tK+%@mwVAn$tbDjfB9<24$ZBwyM()rQzDr>#wx$vQrUhWrBmW>WhfCdi>xLmK40A7|0jfi^q1yHq8LM0Bm9t z4Mp7>B)xnWk26`IY7TrB+@T2${)4L{5cfDD{>eW~>Rv-MBpx(c=BxZW^c%n#mJk7X ztlf}LLEQhT4?_JgmzK1!i=fEpFiv-;ZnNIHMEMC4mSX*v$prgSVI&ad4Ha!+pCiVq zuN|2BnLe{%DhrGos=oA+YE0wQo$d*Kq7;90q6PHSj0ZU9Uxet0Uy?|BH$;vAwj`>` z3-{ROGdy;1S?h&H^>T>TbI{2~g2(D?y={jDIhUm6F@$*B(#T)Wp84ciNjmFVbD62q z6^#Z~NTmJ;+(*nF<3Mfsh4%tVW@_1^M?D>Cf!Hz5FevrH@St@Vn7Y~l#B6&0ICPA% zJOTkZer#{kfibC;SY?|%F+}E-ot8xdhZ;JG>3AI}GGI<7+;_^K?zawEIvmC#753j3 z(Q*M06#qCa534P(1d{U(@2T%wW%KwwF7Dqic?IW_b))Sut42WUlp!G0c!a%(Dfo07 z6b=n(OLfP^X%QMuP z;)RhMPQ}vM;ku8=!KvtL*Y}|5m*7@GP+Gw=0DKWtFfOjl)OcZpwttVq^Yv|<^1_Xz zOxFnu8)%e1x8g*InF@ghqWw(ixprtwP>5Rb7A)ayEC7aIeM>|kG%)DVW!rcd8$Z>) zq7@!99zpCgh4jd}?I|oCu|;JDZlTP{aoxZk6M!*tKy!6NR($^X>s7GJP~I|Id~`#M zl(=|H64u=qzMsLlu?C;i;kbW1I&M*@WU~|#OxY<2mvs96z-NWQHvGL>VJNB_L9sVc zrS`_{g!l2~D44cdIb0gp_RVDVk-WS4!%t>a_GlLpK!{6sCQC2kdA^NxOU;^fI*RJM zdMd+vo*MVgY7~`$^2riw+8IXC-51;w{+rQj=f`VB<^sV#;@0nv#44Z*vdaNDkVk#` z3gdSn6@TK+XfUWzWWGhm)qjuW%dOXcBThV$&&3t;ed{KV{|#(42j=b`4xD-0r{qa} zQoP>R9n&~CfEt>f=+Z*Z>u=bg7Rju?$oD?FWa1M#i%nb4jt%o&43m+R-FwCTLskmV zxQfr%)dSuSN2)2nlu0~Jnv1aMC^p0DKOAI3lT*)H@PLS6iEPR?8K|S70mK@8XFTL< zS!Ost(CgsSO`YOZ^;-GtGX6MFB~tUkmntrL5mOEWkLukXn5G54n$d_I7r_pteAD#kM;nO1X zIN(?we8sCj^EzJnVa-p+`Fl%pMEh*wp3{2El2PmE)aU;7_`hquF5z*y>ey_t5nSjD zi?1RL&=FpnQD*%cHeS$wV3B0j(iv*?z~xEq40G>DLot8|7JVd(yHJxB_VaMZZ{Aar z?Z&-LL8$$d{)K&@+$%9TG@A_@EAdt5fDn&xN8|Um4hG12@WgyVf)(FDc*uY$y^n2o zd3Zlf2}ui#E11{hl9KQ*+icEux1Euv8RV3CoOTnZk`jZn%u-b|I$#>Ba@W@x-9lYU z-k^%Nubvk{*RcGyax2pM-^Q*7(^}yZ-Nzoj_beG*%T6t}T zC3IvOkzap5wg4equ^ev8R{Ah=OXO)~=*0=VpS1WEB>x%u-!cB)k0my4-+TNm_W5)6 zWoE==r@=#13PDfj$S3w7u8#{}gTC!wOAe>-=EUHzKOcC*7xpZd+E?eSq%&?<&b-Rk zrJ)VvCryx5zS!u!xV2wma+2Js538obr|NOoHUYQ5oH?_^{}@)eHm-i14FM3{cW}%p zu2~9@Q?6o@f)cD)!l?Q#gvrVb}@PwZ#lXWmS&JCRZnQq$xw4 zfqU=KO2R!w_`PV}mm9*Wac3Dkol&Nr&IZmmbo=r*rPF+YCMqK0(Mc#pE6r>&+D_?0 zYz*{{r(Xl}r%0=1%VK`g%W2Cop$B_e!j>K4u$WGob*atj=eQDy@SbD2S;1mZE0C4C zS~Rm*Y#VU=yQ9QQbP)o4Cn0SDa{x&ck0ZxvONv=iV9 zFRf&WU#08jAmEmt7`Koh%sDi26bq7}fFPikdE%POEOdssP$Od#LsS?4@`L#@j&?%_ zZIL&&{lc`uu7fL@eI@JXpWsamr-=uX=prdkk)Hi6AQpVH+cJ53p#yjpp7^#;o+xq} z2`%V0z5hQQNg(=rEQ-r(4@?_XmxBPa3=PX%-se6fqT-%z^lVDzS*$Uw@bWb<@FItF zU@>C?crDbq*G@-cLRsQQLFa7TE5T8QdAY0_8r3wiPeL3X1VO&~Q(l$@PWq?l;`laq`>#_U3dYbAX88s1n@QW|ZWP zz&A}mtK^AJNf1=mI5}Cw;Z-MT4*NQpv1-@)%r{Mbw7IoswUSVxrqTt7cK5S z{?za0C7#PDYUecbK_8VnzP{Z=FvvjO{W;H%fo`arZd6VMVo!06!Q-SvkFP4S)jC(% zG;slazm=CHXh@pG#re^OgnJFi_)@_RA=e$FHb};PLEBPgM)5NTL$C-w295hzF{N)qZ4$Gb#ZFo%kQaA>8ne9ArfT>set*m|Dp3m&)qxeh9k}QO?n;Ow!XdDl$`0 zl)S?@H=Wa_qF0`))|on{(jyaWoQ)Y5bdxR*h==?l2ede6tI7Iy;xNc+c|L3p<(jR6 zyj(`W+$RS9)3!|h-%Sw^bvn5s#yGxuAMz%+p=Xw=R?BS4**4ZNXY0i>DA09$L4iKd%zK+wDc#-xr!8S>ac z;KG3wLYEmaYBib2>HKo_7g49u~^@5jb&=yM#_}Ave<73D|rdauDqg2-=PA zz~|xnxVlWQO3J0yHpz1t8dlz99XJEO>d#3JDpPKFY6%!89bAil4efLI}- zNHC?C#T&2Q>|j{O2^%s4l5&>f!#mmav&>y{xG11?Caoi^ep?=75O?u0l<_jaM;(b0Y zI?gYvGb$+f9|QuW9E&FL+2tH_#DGr+c#1)K(a^1YN)AXO003e!g{~r6xZMWOiFa!0 zX|7+@EWG&42t`Ed5!#V8naZK2NEu8+SRS;9JP5|9;x{8I6O=ogHM2M!BWC&&#zU*! z(|D_k!nU}m0l*>7KMzBK|Hdtoj4;a9!+SS}faPPx0Q#lhl=n|O;(^JqJHa>zyZe!+ z46TOy!Z%2%z@DG>;kCa+Mnl1fn&I)0qtE>2tNvFOM_SDv(hdcIAJ2?H9tMhq7_0gT zt_UB($+7xUj=a7h*{_x&%z7oOhkOEp)&-J=JWYmH3U!p$JrM+$%1?!JH`MadiRXyj z)wV_7E){iYvp&9|?r1q6?r(oE3--$O``E=q&nQgM5c)N?b4=~?K5ZeL;QDs#BXu)G z1a46Mbgg+$-5zR^MrJYM_fp~_*Xd`RQ-FA@$*?jgVVe|W+dWzXW9pB$F7qnqARE*V zBpYXa4+qkO{m!GMY(~D}q`+C-({}H2Pi^(KAh1caF$o)X<`K`{6j-mQ(4H9HOtnOAmk%uS5Hky2G{|HHh9Iz~QTU4K(^ zo{HSk4d$gylVQ_)E-wVU&c%q?+_C!dMKUavL@eo-Fd{$jj)`pXv4?UBUdTbHx_bhv z(D!oosE%9qc^#lgk418Oi5nR+kA9p}??&Y)Pt_xFK=Mi2EC0=m&G}+oX_&9)!yTslqd4iQ`&tJLSPmj`7uQV4dDQ*3yWb)QEh0xnqqL z5EB(CHs>P0x%GGQCUwtcF;OkYxGw%>(_7;}EA%tg(ysMBYeV5G@Lo@o!h7H|3K3;( z-|lljgbqJB*yY$(Mql zQy5BGb9d0;Uhnua=6!(@HOGfi@;%~m0KUabO%x@DiXFP9Ml%vleG6N5RaV@p)-(Cu zieV-omZdAXGobdC)Q^g?D>t}>bnS%x(EHd0F_hYs%*cjm;P%1j#2BC!!*UC!9W%1l^jB9tF8I>0PWeK+_P86|wX`57Wf0cmn7 zg!`mN6GX+f?7$QInS~`0Kf@46b-|1Zt6M#Zcj3M;?g(+e5CvddCg`FS!PB$w>U~45 z(S&?+H~osZ;EgT zXFk5fQ31eH*&+Bo<0@|oy_0BmcFV=)d`r*&V)%v0#P@)6n?lgdM^!%%7Tbv`-MgWV zmQ=Yd6(!KI)(XVR0KTC`U_G;%Z-$;px=m^&ZE&gnV4vj0&cj0!=O(n0IvEiOCeg~$ z^$WposV32{k-Cc_cqd>Y-{0dO?pp(rCt)xd4POR$tAYUp3*dpCC!@N1EUg|>^YU(X zG1vCijN7CuHH7u6?^2C&pZ8lX-@R#8cj+D#k*GYmho93@49Kzvurl@34IU!#IbHjr zQ(y{Ow%C^{nDJzX9vC_wwR)H%%u}QzJxS~OQzi?#fCr4vUWvD8-U?3Gjzj)AnV7aa z%S8Rn4CU|k*SukwZ%u!ol6?6!PLa(?;{7i+%xqTWspJK#zYVE@WA8iv*pC;mTV|}i zN=N(Rp1Beb>i+s)UE~5e_i?!$(qxCCxq|2=_JW3oRLm2puA>j` zv022`5}|6_CHwS01c|9t8w3Bgz}gFfF#(xrzTb!xmlJZoL%OMw+_X20p93faT^+2r z%14ouIDGQW3lv#x>YDg-N1?+prfh6^h)7fYA0{KR$R5V4pC={Pdpg57g zaQ09DM#-BASG`L+C-@F<`3qm*zPn4#U7!##*dFBd+XQ4l$VQL=!%{+fGH)Kw21>KT zD2Xd$Be4a0Y2o$g<1_Dcf$kmuqh{VbW{K3r*F@Kky1yi#oWAd>BJL9J$mQsgM~|tU z8!b1;9`Ldq6YT--`)Dau{1p_k4J=Hy4bIot{<;_4o3BMb0+VPxd9hElR)i%Qa_Ox_ilB+xY{2 zR13cGjJP`g&%C%zaacVU4*aq)4sAcog|?4%aAF4Oe+1(*kXCE6Xp{3~XOa21M0xY1 zN=yMQ_l}o>xF=wY1}N#BDbG3QW+h>QkgAXGG3BCD(X*K}is%ok>NA6zy?-qx@vj`x z2sgs|`XS)CpF4{P`f~`&>^+9XvV7DkekjEoc#WBB6n?gsDN-&GUP08;SkBd_P;^q- zEj2;0z@-E~|pSb%+SZn{>k{XdGm77K~@D%8I0qf^m*WLp%a=yA(1;!HL z#Y{hh)tYWBPHN=$pZ}4*Y4DB0Hp4T!zJ|z1(x*g89{ErDH zzJnk?jWDr<`wOc?wjH8g(jji@8Y*=YDi4v)*!&bFWtM+}?E(EDNEFexe&tiY5!+^~ zWp0!77}r*_SEjxB${rKU8%&lh_kX;By~F$SmvQp60#AHoplqdcV{N}b9m4x9)DJmO z=#~LQfEpNPl<2RHngTHbUfv#Lj90ylcC@ZQt!*ew$WmXN;Qf@Z= zN1_`RR2aJ|M3`7AG*w2DnNn7JXs`x|qF_xE#fVYS&nh>=i)z&Nm_mrL04qPypp|PvB0V^ws;+fFGIse@~@J{I_ z<_wg&?GINL6Aag+u9Ay#C&#DZKj!uTiS*FP5lGwyv=4R*CKiQc;G?ak*SY~hW<-7l z7YpNoHMNwd*FJP%Xv3_b{hyE4H(&<*{N;{Eyik(lgDJtf$am!286V_n5fCOR2dsW5 zIMHH*3s;b!pG$&4)Bb(7awLTVf4;i=MX3q{h%ChBnWhKMQVx4kzQkvS zO6*z}7l#v>oaHwXJ*cD|O4KZILpDB_N|CPx2o;L$k_8)!mcRnv9eNCNyGn%^SdR`L zUH=eRAnLxS_BM6qh^%xNGl_u%xYh37pF-TST&?cS4U~ImcR<4>9_YAwjlTVU*7R-DNXwHJbM9-ha+AnhC(p+76vK*KUZ-cNy2(c~ zw?Y*^b#+F@Q-%fXYZE{0+1|Kpfz>dhdsn*gn4yn z%N1e1wZTv>s)!W|#6>02XPP$Hi~qL=cBNj@p|%jVzwB}cZ2AT}tOHnxBLYuseNU~@ z9io~_Y&kf!k8ros6I3Td$a#Zaww(hFxCsEu9_ky37L>CS<8nT zbd*`;DIkkE%lzW6n#C_od;XU9@QV7#R^N{@(`YqvP>Nbdg|&%3CM<#1W#A$@hT=V(d(e0R)4Vma7V0b z#V9&}si;vk(QpGOh!FA(9I|)Y2Cmy{<09t`Cj29lIHOzr!^OlCzf;*Nu4Hrkj-6hk zkCLuCoOAB8CE;sefN{YG-&hG)2eE60rJZcXWERk^8ep4B-xQcFoYaio8JufU+#oA= zKbnBEh1g6NjJCetbS1YaFdgXKs>Q03eTT(+%Olh4 z@MMMpXp*4oBqJ{{JvLNBr==+D5e;q$w}6rV%JM;`Y2+o?_JVZJj>&xmpIk7bwba1X z+3ZKv2J=v%Cxm+4`exfh)^|QY^wMf6y-{}c&FSi}(sw7~jeq=ZQ@nl~?Imos4SG8M z=ufKciyHPD9_r_^D&@d{0IjwK>Ib}R=N^n-V2A~dkaxk&pc~44{LyQGC}hyTU7#$ug#?$mQH>)a4nBPF^|#@M~eq0T7GMlY|OE1+W9SF z<3J`P%{qjyKV$+WDnyi|S@nJj7HETBaS~1#+>ZE!=*RnHmNP8o4%hm4Yt+3PH;` zBFJl#EKvX=xyvHV4KK{iU*O`O)h>HWJ$J0ri8NL@O}h!vS9DnD^#z|P*!%OHly6n9 zXhQM5#->$tf?`XelW|{BKlwXh@2hBaj>Pi=ii;M%_z^juU#)7{+=O#f>qK{uh`5lNMwII2TKg$!sg2{?-EB zB@PX&(b^q-B^3Xp2>FMa@Eu7bD!Lv=)6{(#R?hD;7zZCoz8bEal!K&^F}vHt-wPR0 zjiZ+|<-{Wi>gfd*{5NffzH&Nit8*5)uVch;&GzxpUm>HBDyhntN}0`C$}z2(ggED2 z7ZZb9BZ`#=KugyTj2k%e(k0t(wH8S80H(~8 zl#V(9%W==vefxB9O`tbfBin8O`PLwi#BVj@;HtZd*>($T|DYVJvND;^XRW|0W?P6{{Hj|}8Z%bIG zu^4An8=f;83jce1bA>al+vL&)>X=}GSqO;UojURu^sajQLy>DK1d!K_z@I=c+i?Pp zx}Aa;5$RdZuExOOhf?uQ7&B)z)3v(AC_J{|=ddr1xHU<=ar*BI`$=6{+*vLcfeaDMmpL2QPkhA!VUGy*?%VE(ccc=%2}#yA?H9*!OCQpY1Zwe z=c&lwW-6xu%#?k?MF3C9k0TR-Xza7Vy*jH@?Byf=KhjrI2eC5s0y$%$lQZtFM%!#TiJ9`M!) zLD@Yi&0KGHPS&IT_JR|D0d>+3sIlYfY~Ew}ywVP0-g$JEQ<5Nm4MUyNa5HhLsPFXr z1kp)HRx@h~zu1w}1meTR;oy6KMW(*^{=#WY18L{}uvI!mdEtq8+C=nkQZM;2yaYg# zn*L&$ptXng?`O#=`SsdQX>KJ5_fV2=qIjjS{E=sv49g{hk_=S;HZN10ePQ4-=VT ztrF>-3iEIVW(L!QkcL=-wU)HNMVF;!zp{!;o-?4e*O2Poq0+`Cr+wqT^0L91oB#{R z^uBsG=+0So4c|;L__yjZqcuIrZ~3{*+25WWDjet@6NIOu+sh*Ar^!WH+fYXM!V-Nk zuRaVOs(Y0cdE+?ZiD8E5XoAG~UCO`V9~5+5cA6PNi8$L$qKnWzJ1KLrrq9+Q`?i)- zbYL*x+i;N6o+U>?e~C(A6I@R)o)nA<99W$uF+1a0?|MYNSALQB(M6womkb*KDZ(FX(#mS(ZiUafxOrX zYrD?T*AcLIdGsfPj~p90=8A8!u$Y!|I~vLQ|2gz5zTeCYq&s#1@Y5k77nNndv||)P zwgVtD#yU|HG#rBVf$EdLdD6K7$az zdFWr@nZFtyAzW52d1z-?<82O;FXtp=r8ZB70wD(bV%mb|)~ehOzggojOC>FUkPiXi>AMI0nbnq#p8`&{)-nc(L0wo@{W~E)o3!qx zt9U}w*sjL}-ca%Cx)6VIWQKzi%O}XVO5Fa}W*abd*GjbL&|mQeRjh^Cr6h$*sJr|c+)p$afF87Mep9ZJC9YKd zB$cl0h@}0<u3b!HGz2G9h!Lr<)=8;R~x+3Dl z;Ahk_59QK8Q`MgWNER&mHxy(U{fj!dR$&(io3G7E9n%=ZSc`@3gnFPQg|H@aiw0mPUaPDmX9*R1 zFWBxh7sCAEv>LF$i7mRKH{9lg2BTC3O^N|&9^x+1unVfJ2oneJ@}oVDtb}6(HU{IR zYAJwtDz%ZxsJ92p_S5B)^OUyn&XD2!c2W>=UtutoSNVIPFO12Up< zIPT0A+HHeb-3ysFh5IwN2m86tH^A|;uk5W%K;j@4?h$$zN|l#XI=tTHNoUTt#0)P}mwWyOm=62;Py z=_qW+?SrdJg3Yl$j1*ejJ&(1Ibl`MXmoh_3<=YHB>3ItJfyJYPY_Znej^@243Px9# zn&XvP3m=C@T zqbE_9T4I)~IWiC4KV0HvTl`#ov8yk;Fz9ZEJfScy92fFDhyMChYWdxgU$4FxLcKqD zP8X|=SE8TBKc6;EXX4(zebGCG0Etge0+DZg35J)nRTqr&QE7IR^|uLiEgxD=M5ogA z;`~?VV;eAL0Hg@s?V_wP;)LArdFE{1 z#>dm^@PJvScCPH{ta-O(2e&!3<!dc(0X{l z2tV)}2zr3;PY4EzY6#rEpdhn86r$w6H$oA|^;ERY8IlP6(Q;<`CCzH!gco@8I$g7J zVU>|f&pM_Z34dOy{2~42{ad|0)Yzx6{t=O)b@BA0OuG9*SAMPiJDjFF%VAH>SnZcs|$LVq?|19tH&A;Uq?hmLh9-VTyHT|ov*@XVVZVB$rS6FSfw*^ zlqOG`N!7`2EYk8#Yb8IbM0#EAuZ{@ec+w?fH=}kkR(u^L`bjtd=CUc!+ zJM5x*+@cl{ionMQs8ZYEYM7~M{;NCMlw3NMpQ*nA#d71Tl^QtO9z>~77tm14Ee45D z!xXNgG$1}6u{{t(2FvMt%@5j7rIrukJM#mTr@QvsSG?xl?z6orqK)P;UPk%MJ^DHNR-1vYF0G6@3FU(fJHV-xFIa2o)z z5Rb)_g)swB1)Kpl44`@O!%!nFaJA!ZfDN*_L^rsJ49t93WyZveufqhI<3a*it)Q%& z<{?QJAbBwC_LwfwF#~`-ygYUB;%}dW7p6~Y_w|pPUU4K(Qve(eq-E^v?31-}n#Hj{ zN-pm+970viq8r!g|4R0{ZsPU0knDbE=1RyyG6ITxQf`{P=px1CJ%6sqBTnz|I`jUn zRbWaJi2fxFCApjzJxLGUg^hK9^F=dO%ev;i5QSl?sr4X*EhlR@1b}!#DX!KgDH@Xd zHh%U+rxGPctvpJTxK|%OcjFqLEK7KTYbp$~r#08!Ps+^IT1oP+vLBe@p+C+Q-J#>fCeXl9_G-Q*3-0Xzwb>J_p66VDd+vA#Ihrb- zz*ZQ;dTVTbzRCcKL?GggUS8mUW50OKeCHiHTir8AxUk3tMJi=8^iB8cYjrcBIS%ky zYSTADceKl_^P4{`#C^)L@H})#KXxUY-ml5Oi~8a`M&qdiT3Q|_Qd&n)rCNfzHHm`X z;e!I)ta*j0W}wSNnZ`nKf(566{P+6dPsswb^?ri1!)dvAtiFnjUhU3o%WDN#T)^$H z$q5+D1s5Gni9>(Ar>*6C$N0eM>6@44Po-?@2D;VbWC*`;a=+Y!w^fb*^<}yrQ>iar zBY!B{)3xAh7XVvggOd%rEMGeAottbKpu@@C(xW$>1uu^v!4bB?gzal@9Iq_hBqes< zX*j7~8e+7&CEsqX)=kB&pRyM)GQ-(Dx8Dz(i!143O@QzIqalMH zBNf&CvYg*k@c&K=)fVI;GD=!!rf>2G>(m4az7f zA(EU{BHv_>FLVLIv+P1gbC%^lnWO#0$$xR3$}JgJzq}I%7ZwMV$}+K{vAK{*o{9~^ z`T~6nVt_0nW1Mg3w+p*g>O_eTyTII-VD^FDLY34pwA^)Jmo**RQ~8#c!sPf6KYI$= zn+pb6Ecvj-W?41SVypt9C8&e~CkM|cl6&2htVi=Wc}oyDypXwNmQzo|IgtR)g7A`Q zfTC<~Ez=$Smj<2{T`+}S$^^&Ra3N%D2RY}7hf(yJAMcIr4@&!$E9wi$6@XP9_hu>e z%e8jjZ=0f6drcXh1yIa&8xWhn`Ox`;Utyh5mn1x}>4xoAi`x-VgqcOVZU7BFeR<3dZW4e)j%mT%=Do6Qu zC!UWjbm?uXRajwG2panM^WTtCI5KJY1e9~k(-0AdI~{4CBqh9_)e%Z|WmNDLmZ#B1^ ztwK8qql*=;OQY)P3(=0q=>(g-eTNF)IB3;^<6qt_EHuHBmB8vEl68zaLY3T5Ai0@( z$;NinWeSCMoY0f=j)wB{^p@dL+uDGJ}@5X?> z#0;Up#~T%Z!WxhE^ME7?02Vco^gNgL^z<0((PG6VpX3F?X1W6TO~={np&w%`e+}EX zcIF?AJV1L1zy~<3Ly&EL-C4=I_ZJo{r)gjg!&MVgeZrmvX8^w>+IAc*q%Kig`9UhD z=jV*u{%-50eP!*`LcG5QVA|)b34?QlI{mS!n{H7r45H49;ns_En4rVPnuVy=0|tu# z@f&VaHk~r&PTZb_lUg8R5aKu?iN1|&PMOlz5@*Di@Mz1nec3U?1sOWKS0fZKOjpHF1-&VPS={5_a9fuRpR%8Dy?RHAjeE=5AnuJaX*Ou6>&aY`6~$4RcpNXqDM4M0S8JXP6^fTOh*Tf;x$k8S4jR+)}TgIFJn zG{a`e!Pe$kd^&G-B}v|{J8U%3EWOTmw}xqId4>x1Do)OQA}x4RDIEm)x-v+%=ifW^8vTxyu@M&8b!ALf`wf*`5n>8?fXGVIu<8i#<`dXU=Mbim#8s zp`!;N&KKU^TWp)t_!8Jv$Po0BHFb)&2r4hTEFel@)H%j0q9#0tl4P;o-67Oqn86c zCV~73iBvJ7vquw$V4sDP4dnwJ!*lRZm*cWV)@txuona^3G3ymHDPmzL6xt9G~l$YyPN0d9?wC_Q;lIDn71x8F`-ek-~11 zBpl>|PD!F&zhxC<+Pd>?? zD5ySyszd@79+;XjC}ff}Wh&v#j~sY@T**7>P0yRUSqg%5Yt%tHn%tJ7`vck}PR4DvC9NwX=z%j zP3}AC*U@-C?8cW49Qnq7aEaW-CTt(I*>xr2$nWkE%n*Uh~ zS0>INIW82xCDWD$_WM6I&3)P1$I2jfFfsE;S^{;`?vm(myHHut;%)tq_>gR(V9ib% z=my>wqe-quvX=L14Q?KaGRq_d&L+#mj;=Cv`A&l5) zdWqNsPmk|7sn$^Xtpx!2=t4Y%NhZ~D^kaG*U#xy?I`AG)R#)_P^HlvEP`mBTd5g!c zYbpSTpWoHQwz<9l0A0YoU{wV#>L&=Huyjmc5QO5UpLmj794ffmH1UHyWjR`0Fgs2n z(-j<1Q&q>|dpxW_d@#w}5n{3HKhT@3S!G&JXRHM+@b{VC%ZM6<TvT|I zEO&Sx^tJqy3AdYUUsO0R`9JMmb4C0jkc}{^IoGV_;T0PWhZ3E079YTnO0OulHC&2= zBhXXbcaXb3JPo$aiw`BAtf#?I4o7lJG5TA>XfkLlg0^u)*p6Q1g`J435fwEMp9zqU z=d!aFL0oy#CU7#E6|U|!MCe5H0gDgE#Rok`J{FO%etG0Lb`&KI+$`Wa{gCdsM%rmn-VSxZmKs!HUpGdp8*g zGqqjy*j#`I_V%|St-^US>+N%R9 zme0ep|5M;R?`x%ZiaL;*omUrLum6sv&C|}y;GlfHNh5`l!a}FYk`Qfwi9)D)H|-bs z#qjXqA#np z4Q>^5$lrp^ulzvZ=jjK-*`h_-COyvA@V?^AarceFKgxa@h0kh^_(GgB6;=4&P~KQr zkix8_9GnwJvnCQjbZFs2-hX8%H%&R;A#|h#mdb6Eie8PKse5rdlcz|GhNR8zk#Orc z#9eUYId)wG%8MzMf$Df)VxX)^GWHtsn5Yn{`bSm#rmjMbR;6TwfbWx;`Za^%f*8ZB z9lbO3YmU-@ITsJeAWhECaSylf2Re4Hr@9VDGjgw6X%U*FSK(M1sK31g&hYm6?zABJ zQSow%qycP+A7M__>d$? zho0A8GcFbTgx@J}Q~&k@(XKUf*PWMj@1SiWyFNc5J2Yr7QOd@s0I2 z7=raH0QV*)zgFcnFfYtJ=rTu*&ZPtlCXqu0EL}_GPXxV!Uei-)ALSfT3lKRQKLZ|J ze;PraYZ;ecq~LQ=aG8}P01Lb$lQiU=hV4OHGAfvkOohKSu`PP9f}?Pd6Cc%9-3MM@ zGN}4%4!jq<9kKmZl8z4If-StYN|f|FCVx6dI->H!^(R~nllQPOgrpPC6L7?ob+tX` zj_68Tsl~G{?XSIEb5z}xJS*47I=pY}$arP2Dm1?812mUlX4;mJv?j$g#m>uR+)QsI zuK?5f=~1=9WvuEPs0`_E^K^D+f)nwUv=~QuE#H}gi&Rq7}2=xnio z>yeK&Kj$_@s5lcBe|pO)aNp!|tAki~$wG>CxU$7{s9b7UNxQ3JP*+hOEq6)~wSC!`JB>+hf4 ztfS$Z-6|znYqS5+9`avVUc!7+b0c_Ncd)OYRny>AjHp27dNpLWD8!upHjTl?0c5(? z%w0a`hy>C6cd&bdLKkI1Esp2qq1nhC>%*ZG^Z#G-+@UY_R(Cn?Fl5=dN}wKFn(oOu zigXof?P`qOoXhwTdXD1|Lb=&#dQ-4{OD2zR!!lPpp_ZvDELC|gmG&17u}K`I z;NC?6*gDa{lf0ZaG-x#gYGmjUjuC<7m)V7ppnSk`J|yhut}mIk(0TW}Go5H!JEa)j z&kuk-&q=M}cz)}cD_)hI4ga~Y0q$v8@gqk)0Yh)K31=+W*p`DBuCGV!FJl0_Z7LrR$R2|Moh{rfvxQFZF)NMX^4)<(dL56D=CHYSV~7# zv2;j0t884Qc34|$C6?*j89M3id_Lh+KvC!Q_x%If^fx<>!^DiaI7_Ojuna)lW+*g2 zK!DzW>iLlJ#cWVVO7L<5f{cDLdqm0RU1L#@Sh>09x$a~GtN?x+@=EKHZaOu03VUI8 zAxjjLrU{D-JExJNwG+QS-psmK5P^67C!lJAcCI~`wEvms&0xt5Q12R{b4rwjRnM=# zm+^^>GT#JJ4pIvGX9zQz1VF}gh)z6c!Rm+Eo;HzU#bbDQ=ca?;eIwxGr7Or)%ragD ziIFVv>SBd!A?`?G-_r0r9RLamn?l1w<#$+6%;DQ=Z-p#_m!=)9iz<>BtCAmpQa^|- zb*tPW{>fq(7WXL4S{Gf*-&JrrkcmGO47v8yH;s$fRg;q@8iz3x7p`bXJI%PlRC$|E zoalsja;IG9(NR4j^%KNS$(n?sk`aL#BZ*41v1U*YgZWJ4Dt^t6Ja!?s1{JyEKmYr@ zNy02#n#)mLd023PtQg>^uQ60-T_>N8!aD>mEU-wN*Y~cDA{j#W$yLbcYcd915PZkZ zS{TP<`R=_U1DVD8u3r`BBeGBguy*)IHYv#+L=6CIA)5pa_{3klNj2Vmt%ygUZIB?b z*1LYT7hyoYV7v}`pl=v6$dWiLljP<8uZz`+81_JzJAWHZ6PJhj(!B>;FR4b zY4U(f4yr)1Es(%L*skbUs2}`NIzdSr0oMiR^H^J2@a#Z|v*Z#E|H^9!5g`<2Rwjl> ztnZ+hGP>_cnQk_@gA{z{S)1*g_wL$Wp_T&DcikoNYu{QzTld9K%nF;V@^G-5$Ots4 zk@rd!%YYF|k+C;31sJWo7#&?-`Cj9yNiC_lhg-nt9fa>tz{|a&!ljy28@q7fNgA7d=Dt`ms8)bOw{O&k z&E8tPuB2j>(FeTkDK3g`;Gt>mWa-vQ8eng&Phry>&0LO4Zf}HyIvM}`%)lZ7QUGMI zq*_}>j7FLEo0A)vlp4{wi3ry2i9SJuCE?-x^t^1NFc_|x0qh-q6fpJXu`y~zyOCLJ zA-MzSl-BU1eEt@Xy4~{S3V#EQ@z76)G7nZjN(i?#1Zgm=6Xrv{7hrkB zA`k8L*d1x58~I>az8!Dw5|cVs=X|i&e?R-`EZ^LDOBL^tSsZ&RB}!z_kTCg7#OtL( z@VgN8GBkAn8zLCnjRKP@eMy?$0bhh!&2I4uB-Y97)K32t{7n+$_B)nI<=kEgh&&wN zTc#kzRFeB5jWm>y9V4O9eqNWdw+p#}JmKyann_4^>-J8|cjEW0FaZMI(OJ`rx4=Lc zmsM!nPaIjpNys313Uvbby*n=447E8L0rVKd3|cgv_ob>AF!dix#Kb;GHRdJ`z$;&x691@u4Eu7tcWoOsiLE4z zi!HFk*M|(jpR3uF^hmxP~wWwR9eVcRk0gzr6iE}1fa?dZ`nT*pyLS`dG^o!llzGH@bt=`= z#2A7lm0I4V~qb;9e)wS8$H6MU69W@ zo?&!E@#TyH1AJ$lcW}U2wO?)u*^a-jEsmx+8ABPfwuQAN($vyan~d$Q3S_&v0^^n` z5XslYMhQS-JYS7Dq&x$qT)ZbHu5Zmg?P!J`zihiA2_Ph&(^YSkvin1rR$phNTp#+mYz>t<2C&%I@VUcIxkyoNhhdDWHrHtNW9suW-uf>kavu( z&W&@vPT`ER-gMlsa)2cHRlqO zKdaaQLbs40iBsYKp$<-HR16o5VMN_Y*MoHvsfIWFB=u@cH=oRl$FJUAkSbQ0wbXOu zn5bJhX*aJ8TAV9})%ng3YRT!fXc2O&h2XW?a(!0iQdD!*+2|=ucVv&Oh$$r^aoY*= z(Az)0p{Pg}dx6@6Py7qe?HM)g&3r`3j3s*klo7FY->^*cG(K~r4r(!OhgUX&T0{3-Y($awX^U+x2{Uf@8Q08CF)s8fB#6G{ zMc``iXs;tH*qw-_gMj>8>Ss zf&S+jSn?97SRkyPZn)G4g^WYw*vNsB;i4_E2*uN(0qTWc7lR;$_0J!#wg(CJX9j#= zF|TtFUG0=VuMBxc!y{j&3`*C~pa0hnfX;=Vj_;M*7=0%$?BcE7_z2E@ z;8d)RerC(Ls}Rj1<*Z%V?|@0W*p#aSBxy&jP~Roj2s`p|ETd1s$*lS--tZGcH&m z+G&UqF&F7*nG38q+T^3b;Q7<_Sw%LmY5diH!p~&SPIdbDj_(-CrXB{#c?0s)RaN}p z9ME%Z5Wa4eX9CKk;#B_bjE`xTp4uCsiT}Dm*7tsBM+pQ^$O&KZm@MLin1vV#?pgZj zBu8?XP~_yJ_Gmt=lrE(0yahCg1bt6vYs>M9`0@ zwq-xfAXOEobhLlzAG=RA+==ysqB_wUj7DaW3@>6i%R%_603(Qtf!~!l``q~V9GN`1 z|JTM5&&BWumpe-!93xn>Klb@?^+3yepn~Q7DanPKlZELFUdvjmYvmql#Y;Dm$iHdT z{n^e|TdEM^PSX}bHo?TsoJ@6lM*09tF5-T6^Gr~&R$RI^NB}NM&|cU4dt@i)tjk4t zGONjSUe!LlG0>PfsS#C1$pH&teXyB+KBFt5pBR_fbsn;gezu1E$ZxO_qe=}}t*YMD zQkIB?j}0IMyRL<^u7HR4aV<_p8FNR+PkgR!upwKu=?*Yk1JP{I`R(D?74}Ym*Q}V|vnyk<)uW!u_)cF+aDy1@>)}KeJ{}0p3=fcR zJGFD%Hxwhm-v>xmr_h}eaZnGRG!61@!LH-Uj2^KdlU^MFY#Q9B_SDK;avdx z^z}O)pX692$E_+V`~?;cRYmW;`{VEc6#!y|;lMbV1%G?eF^8^#|ChDb@mr@Gs4M8m zEFT$!DC0)^(e(Z|K#7iWLBWCZ22un6kCE`ik}8pz9L51gl!2=hc3_6 z-t5W3;IVeID$RuLq#3xVxxODiCK_szOb;bvW6S2?#oc~~K+(|Jlz&nUfv%5bX9zXH z@WDGUo&!yE6ZlD{ugK=xDe8~P&h?56Psw|3z~__RpSe@mF}H)ST7~v<;!3@izb`gW7C-N86bldV`D~tckNM_hg2;cNuZ1N5xR0)6d!hRtC>Do9$vJh0Z@0 z2;UANER$%5Z*_tCwoZtf2BIrPesPTrMxoWLHZd^6p9yS%vL+ro<8$vc5rf;RuCKP& zp7m3E`R)5*twI4ZeYXoEk!C~Ayb#}%oe?}pg5;FrLn;Y>@55=5V5uLzB=g9I`q}Z; z19%U7oU3b#;&Z!7$OW1PN0IjpSd0jsX};Po!ftdaf|A4m7F!7{7|YrYsi>r$;T+); zwmb!kQ&E^jDNuOzgaTz(mrQ8be<+`t=7;9r`L6XCTJTxJt>@EQQY;~V90FnWVa{i& zju(D}cXv=JBS)uJ9JKq1#l=)-e^Oor;O2O9v1RF_6xo2?{(e-+oo`EP07Lp_ zI)I~&>xWIjSw(i>)9^ZvN?ZQ<+&rNqNAxE~*2Cp7(yTcHbGqU>SoQKiGnGs+s-Abm z=X$VITQwT4Hp}Bf^JmltB3zf?!iMMf51Oi++qLQ*h1Hg;&TmI7zeDFJT~;C7%7Gg+ zF}0SjxM`|Ggv-`S2_OZv@`JU?gYWQqkrOrvCV=Y#|;q@7<5-W@D zYF<}v5-2J#tOAKeVwrTQ5UatXq9!D@^qW#H52q>BEuHo#cpkJ&Np$0#T~SOE<@N=H z&N3ykR6rBetH(vAmjtVg&rMzk-om1i(#hdb$`QC2nq_>SvYBiqusgAPW{*pi|nxly@XwB{KkSc#cW07819EM|;v>IxQ5R9%rulB?)^~1~ zO7FoX;{kCLOup`h0a;iQS)swW8N)Zher{#rR^d{u3Q-YN^I)9V!D=`Sg_RHmG?@W@ zlqlO)uZQ*{(R!0$jO{XF%DbT=!Z|p6N*ZP#RNh~RmF%}`5FzTJlP9k>m?kH4CDAK0 z!YJ%=B3GQ^ z4AEvQ&3>4?LFL~`9AAj`(pSPD1pJt4M@Zr8?c(C%MiQD8hA zaz6m!Ck|E>?~U_urp2olcg&-@=KAX&pPi}u)#}W#k(REoBDh2#mX)sbIG7Z0u$K!& z)dCXT#i5Lre!I@iyk*-z3+{pM|B=~)GaUycbF-e{0i2Qy33O9<^jszRQV zL0HR1;~r;2{0nPw2rAS)T8u(f1l*gyvJ*7wjkGVcb&o~&$vp6Xf|1kwXgbT|cf2LkNGbw5|uH{RJ<<5vqR1 z0xsfvx_TVXo%@;%wya{ipGZ-dNGz6(R-ioQ2IZNLbkz_aAX=Hi3y^w%uRlR0J%lg* zuOTvdlS6~!RikuVS`1v2R#uFZq-m#qXjS?#EAP`q0{@x;C&v7D&LaFgWFj)ZD2evd z)T-G2k8Ycu1A*GUaH!3?qJ8c~SN3$h$WPT8B@R&WCTYodu6?C1ov1GXd^7^o2 z$*cIm|M@*xnOCh*@W>bDs2#uH$O;rF>Jq8kAZuE}lV56n8W28VXhzeb!`%cz1W|G6 zJ(};Q#=6g!OJ#DoX}radQ@MxGM_}o%=!*T}9Wrrp+Wi^I+p)U)Eev<63wv!_ttQISl1L+%f_4?{UG(|kAubxA zsj!GsIvlc;4DSq5sIznMll17{w5k-sUgQSdPOd&vlB$l88lahXrvsg0h%T&coD*YxZse1lSBtwR1B)I*9eoH2~e+iX#!iAh*Z~m z(>L(@HZ-dt82FMys>BQW)gkBG+=IZFxpta#AGJ$lKe7YBhAf)cN4D228v~mg>;JuM z($Z$NaPqwLFMo&yj_!x#s@9*P?g;b?ST#Rmj{bo%B1f($?IE^FhxEMfIJin7{JnS4 z^`Al<->k_-P7A=j^%$tSV;yzG1v53IXznes9+5mYIa2)BD2|+Lj3r&@3Ndw-u7$ou z9Z7}@rcH=yO)w&&fem;lE=t{If3RfSc>!sqUak|}l|grw)a>LM7tmNYDN>%sG*Tz= z36btdJ5*5NOpX7U+q>X`B_7IfB-DO=#&C8-_+SqrCL7x&QkxmkBf5TO zNixh{juVnxPd-6Z8DGOhV6kDo=&l zXRQwS)FD+A?6SEf^A;T3u$jP#-_bXksnDE0Jq4SP;fIQ3A-DGfX@9CNbAx}#zy;&P z_v&qgb$YG;#4Ji&@fFQn{yRc?<}UN3g_m7L%bfG8*q}@g1y>u}RV?Qxp=MjBBzl@s+}B9R z=0{SA#?yn+Dx%Uu6>+K|hj>!D88p#BDNQSE*SlPD&c6z?(q8$6G?4Ny_W0j(U0bDL0|F0+^01fnQn$K^^ z$h$9E7-i|X+c|FP<#MEQ{y}3MwDdnTU$8un8q%PB;pF2hKcoBq&DCln;OPm?SOsG|cGf1`-{;M`{9^bxhClkz`%Cipc`DiO(rj6uDwA3KBLNjFgW z7U-*~)6Dx+=I_gQgz~p+x1$QCr=Tz5ChnKTn4CSAuQVga4Xl}f*=hy#@SS;{LRugh zr-!IOd?#8}r#ukl0-EsPZ>C02@V2O-2hh&A5VQaUh+m0R)Y9!__AK>~PH9F-p0OU) zfALX_rr9|2pj$6ns59VoP;!=nI!<~Y|B%`9%;xzYTYk!Pk2HGxN_>;rRdn^U`txcL z?y^gYrtt}L9^#}1qB4JsWC3t*U&z@+Vjr9mr4aR!ZbKiYpr~maU_oz_$Eo;s6*xu?PZzE z5}-c|HZ#8XgsBtq2A}sbs~q300YF>6Qquu<7f$ng8O%P+jdClr7SI=XRfrvSzM!M(|(bbVpCGZK=je6FOo1>O)dNnZ!uTmgi7yk)aJ-1VWnn##8`>)9D`V=N8V z8lSgVt=~_fIjSHA(h7F+GQ_AKB(fq16oW&}Ic`@cHWslB`WTm5;;ECewxAg+u1LIq zD3+1TQM99ZZHjmYS1Heky)2_J;VAODLGp$~_njnXsF8>l_+KU_Ku<4& z_jL6L)3o^+KvUaN6`BKM`@-!oe9R{@$#DKBX#}chS4`*Mg33M{iL5i@gB;|&Msc3$ z)!dd@|HQY@@Akn+oblR7n}Jybt4@dwiix8wxXBJ7Rjfvrapi@TNa6G_rpffY6%2(x zciS)R$vU{KUl;6Ybo$}lcL!`?ZBj?X_^lz1Qf406IT#S#^XT?_^0B1m~9xURCIlivY3J&lX>-4)5N!YC2OVQ&jMZlV>@$C=40Vc{~O zH)uieCIK{;L& zWxds?NMntze6yhDDQ=F`V7JfRzWZ~i0-iZMDH`$Ugy>q(S1Lf!)}K?T-c|rs0CDR^ zFUvJ&lAjkA_ZLuq%lfw59ny9?$B-rB!xO+DVVk>LUt%sz`=Z#qW~)8?N_NTv*jIn6CZ ztMtjVd1x*0Bqg-%V|FU@Eb@*iX_GS|E04lJLLZ1Uk_WEwKU zah}^V6Ji{2Fekwd^(8vB_bF?E*#q~XZ*eA(2Oj2yL* zMg#>pm5OjZh&?$HNOp_qS@EI($@$FJ~J;K^?g;-X! z7H0DWj5X2hjt&dhyZfIqv^GEQPZH+-4VA5tf)Vz{QzMXj%DJAt3<@Vmci2TC#0Ny- zVMt>Ju78wac0s|jrVM0o_bTJC09z>Uf}t(2(%SJVEbCz-OW305h8G%JwW5;oMXF|# z0`_4AO>o0a-%N(w9W#i8IBI<8 zx@`C^U2+xWp3gQo~$gRfS|wm-^xbr;#-K+lSl`sqHyhB zlv4npetl+NoY^qa9K=JfGz?Ww!mT75UcmcgoI(v#r`|2$AzwnPq&}khrvxN;Xm4WE zrVXeI-NmZ_aUz;wAi;@x6ztC)gqm5-XH2paOTVLTgc)3my{^&5^inrXQT_O&4HZvm zWeddYz^*q8(gEv9E5NPmZtZZiSx&vyj@$yjKnl;bXP^zRW#=98WhVW3$#z3*{Y~E2 zz%;ldus{U}9I10xshj}c;3JGFQtFcNsUcVp$_J$=Sy0&nlM1Vhl{?~JSl8sss2I#~ z4O5-%BQ~6=_0Ti|^0pm5zbBI?mamfWl_u%Q+1{+A+C;#4 z9@XskQ-BeHvI(rvOOf)S@8P|iX>kR7V`G_#nKZXPc_M*9&K#zfcS?>0g-BTuY!D^2k}5ogVt~gpVuC(B7n)gVHj>mMdx!j& z8KwigDY{uUenf$VQ zTBo}M-J)(1$5Ce>H)eRKaq%#iRjHJUZ@IleT(Spg#<^`Kq?^}TIdP8GE+~6XF_g$L zn%4h42PU^28PiHgc_The7kL$v1_Hq-NuPcVS2}T_0z^-+uOTqasqq^a?R`k0tsE?| z)BGV24Z7piglFLERrk2=_j=Q}t@I|5emE#&T*zdnA`FNaJn|lh7PnsRp1ziV z?(wV<0#^n5uxeZxl2KUl?9kw?ax7U;XQNaNw zh!q-=4i2#qANs6owME~(UV8_E7mBWPT@LYpb{8(-=c@UF+|f5;oqS50Y#5|{fX2tA zSI%FMfc;a87$po{c^qME=xqiFm<7J|+9oc!S5VHor%j+{4<5b?Di+P&psrh7&G8vax%-69dBD`7vdJko0{| zDiSSB?0!5!NbvMfUqNyeYFb<L9UsrI6o61Hvq@r10Z#98#VW>KwNRrzL}sCq8BytHcVPkt?R-c(io&4OB}e9cY7h z@-JZ1fCLM>G+xaYpT6gq1k4@c>CZ|$kev=u@?GafGcu9Gu z&dWu;+sW(q$=p-`qptihrj+h=Qq3t9qt?tyCI`SaeDhPIbh`i^XrI{PrF&V>BYp%kNE$t2>7k#C1e~t zp`c7rjcWyjOC+;(l3x$!MCX1T+tkY3U3&uqOUa_mNQ8sN1i>@0^pnj_hy#5xE~=3; zAu2U8e0HjreGSRtA~!{4o~*@(n3h;8hE$LY+ZUnv(0fe{G3mfoLtro(g+E6tu+;Ks zN+O5{)3`Ix^6?nY#Z`iUJe($70d`KuHerzq3p_RIt}*zykua*Vb2fa>qqnis3T6+ICl$vpFpFOPx? zBGKTIeqFM2AMhsT#_Xm_4y^V=)i5|PJSACngTsEY9K@^U6KSBIlqTn9L&wuX>j?|I za*maI`BC{Y!JpD3+8o%iwiGj~CMI&y9%sD~y-W{?@~S2KGW-{;mpH+n?)=8VMJpI0 z+`~=naA6@PhYSPw5f{^ZsrEjPlT3Of%ONy~GjWNkkA6<`K+C-@N_4vA)Qw%~Dv>Vo zPPrz9lwOnInGa(6byuzVtbKS_U2+!2&>b9dd!K13k<}rNI@37{Q`ki?#|DrVlW93d zDW80fZVS@c+Ci;7i)s_3`nI5FhmeP~*9!6z(XnAWmw!QfkbRm`rnRq`LSA6qUQktsq?N*C2&Jo8?uy<^j;NC!v#)j^UX`tF?mK)CmciZc znf`g->Q|}esEUt|OOSLwO<~i$LYWVYHGH5OfMK1bRJeOPt>bVpO_qIc2YFz-hVPPU zZ0wWG+O;o$S)F}dWH^xbSd6w@k-7Fn8YSuF2@hefn9AYWM!!8~%%<_~LT`SK=+0vbkV#1L8mQ@7z0C!NBo7Em@eeHXSECOd?Zv&Yn~dha|qZIE)f3r zmO0LMk~1H8yL7Q&3&Twh;)Q%S@HFq;VKCik+2K&8k&+#R(wtA3N;IcwP(HCr_7)FO zs=UQEv+DTVF`VB1tvVl@nb5fvcW;zFta|6Y5qenhP_8TR<#ZBYp^qy!T8;f9U4sCl zH_MPs!FZk5IPk;Ji%y0B-#f?h#?YpCt4D15(x(GtDCSYqoAM;{&(6@=HYVp1SAC zz?dkmJ`M$3LVWDHaC_jcCHo$CaU@gli22}da>%a<2{pg0U<`a5uOtMJoMzqrdJ4ehBaX<$&pHX zckB=J@Dy4jjaCQ!8pgwf&#il+w{gLK1@v4^UqQCdv+LFsc(xiZfJTLJb3N5e&C*Dq zWa70+b3gZG0G9x9EkAD$4Hb8hG^9AP?1g^9X+f?ciEujMalGnAm)j)tav2UJI7q3NK3cYo_DR=;ATo+}AbxF;a`oX#h|1}Ze5QJ)KQ5Sl-1}Gy!Hk`cD_J`$ z*Dx<0++6{<4=!G0DjF~gIY7ds!AJafrc}zuW2#YZBGz#B2Ksjdwl3NQ2$KkM51z9D@3xNrAg4j6- z&RYLCa1=<~ntLT9Y?omVIrZMD#Cp>mxFQWw_T%z%d_;sl+Oh`L?GmTLq%kWlwUS`t zCo=DC{ehwglwGMIGJM^TNFn4_5+oLY&r6MR91DK z%<7Ip9XBr^Ew-ZoeO`*)ReM|KzCa9{H%?1DQhSKHF2mmVsA$^!wF3QYV%MdKMn*Ca zXP?+%@GcX`Nor&{&D<;viKcs2vxBw37PmjexSVd=Z4KOn<60R}z#7J3MEiOE+3d@A z?7HuDrJ5|1h(lHdnzoe>NYi{n%5lL`#P*w3!mkIwv2#Qp@pu3Yd*~hon~CCP-%twR zhybR4I;}I{vo%vOtB07zp4d8#(Dq5*L(&C*{2tp0h`jzYoJePW#?N_z!GSD=8(8b?u7HmT4b zM9c)u%~}DG?uS-`b#^DBl$9ce8lO7s8Y$c;6{a16rN&pzUCl(^L|+51 zr&KNy8k$&Ul#sG|&S-ZfvVc_!b>yiKe0s#rE=qfMd^VcsnAn=LGBIOG*#qo)`+kJw zJ~hZyI(=`AdcY?To~r5AuX_oOc}!Aw(-L03U=RoY0?yyD4jkl|Hg0BZOju%$?LHtx zZy%q^2Y79n?zDJk@Aj|`M&;gPe)0HUbK%o&wq9TY+Y78A=~wrapq>n`V<)*0#P#e9 z7wiFLTL#+r<Gn^y(ZL6o zl|>nw&jpP6V07E#!Xp}-;iQ!vwAwK zT4S+J{?n2gvYkKe!dg-TDJb`Pvp0RIMRTI?>1WpQ2tSL>>a@?^y97xLA(}0<1>AvN zUl4~xw$Ydexa+v3B%N`03BV7WouAmI0|31pt$K7E?+zP{K1!Y-yx%Arax8tSifN69 zU}cmocW0uFF_K#b83dE3NOMCB)&8IS z%Dql0T~IP3ozh$(T}wh*`M|r)lBzo(I;(d8CruSJ9u?q zc;_3*GA}D%`KOWkHr=je<&l#$OpGCxvt!})wu+1+%> z7zMWZ+{>3dm#M*a<8Y9c&2zQw`3-u7wxT5gE%wdeLbzhuBROHYsg zO25`)Cb!2$)~K{z?2iez#Exp{-d1S-`@E#UIB5zV2q#y&Pws+|d=%NJTln3=-a5&# z-vQ#}D;nkG5v#6~Kp}C#IVZIpGjv4hQz9!}@9PPJTIPzsXWIU_{aRm7;#_4B5a4#% z;UTRX<)oDQW^vg_D#jZDH#ofb^KMl5gB+~V3PZ$eMhsGf15I;q7^`8>kY>jzqErTYP%gE0#8W;ebD^)UKWlg{s^?>3K# z-K1oil0YQKVP2U$DnTrqm)E#)O9;hD;E5)f9(9P{u{Lt1XFFado3*~e)3316_RjZ2 z{#LqfV>X@^8C}0sSruoELXZx_x1(15(i=R3hW*K0U%3U=`f~p>c~9Sk3W?Ev_|$dn z9B{J^&Jk3Mh-k_>RyeG>P6w~pX+%q{mPm^gPSth%6a0_v2D5z0net+GBh3TS0XYGt z^va*Hg|0#I0e$-J?&L}%C*S+ zEcge3Si8cZeCt(0{X_&ip%Icq2aVkH8Zk8sBe9z=P%l`wmFc3$qjx@?XSg567Zuj| z)!(k|a-G$MdBuGQB`0+l%4LJ~C&ZZvwpyV+#jGH+@DW#p?AI#SRhLqz<%(rUbX0(3 z-v4tLjm+}pJdjyY?L@d?c9gU%p9|52_47#X+Mvc5;ca*<7m8cHb;fn=u@MXW-N{cw zIxCP65$(b`8pcP9$1aaXbCX-35@>CLX&~mTa@w} zkA1W&sMTK>ajtdz@!ftAl?Et%_+Zm^18lts*hic&~>g3m!#TH>ZxuE4WEXtP4Y@)L@W-2MdJj(wsqRk0pSMwCs8r?A!)~I*oFt>2 z$e~|i(?v~=HI*fqIAARI!vd6e`X9SvFp-E_BS3^&>#iG61mNUH(YV=yP!o{upI}8* z>r~L2paxlPBK$x&^C+-fL0@_yCPP0k$PlIpsjUxS`Y{lt{=9cC?;thih&{&nupbjT zFmk0ue<|}s0i{O3*0p<6*log$d3}@@#UX1d5U@;}Ts@u+N62T&*}>9JZwLX5a2Yw!fL z1!Kq%G~1|3)C0Y-dPLQxS&`Tia0P|Mq|z<{R~;y#+l|?Gd3WIgN(_NT#@^>T?m5LE z*{uOw(Wvh6G(-5{Z8oJ#A)) z8VHneSgb^+9hTMoIUW`MDEc_s8-pUSMmX%fIE|{TH9c08HyA7{Ui@oq%4V?8Xz*`?oY4)Cz6BGDBqcSDy<%3InLS zQXbpecqujhh5c$jtUnXz*J7EqbE5ZN@Nt=ZOmJ;j0i|uE#4$uhdN; zQ%}cnIq@lUwQWzG#Qe|NvPG}Oh|o+yIJJnr@}_T0`ig*T|Min1M4{9EC+9y6cJ*G&gVi~4g(abZrZ;R;};VU%m5;(fZ3e0WC4eY(HF@>R`ow&m&` zN5a+_USAL?!0a?9qpW9_1Lh3Sy!7^Xct*m>Kz-~8x;;a(rkLBB&Epe8Jlyk}Oa_HE zJQXca_Pfc8iBS6Z)QJv0_=#wk0XwVJ3C%6yv zTc1_Bnp{uo#l80Q!aC8Ya8I$KZH2fqg(6ktGp>0Bb*BU`?IX6|UsJe* zB4tb}eD2m}8q`UZe@86)JTO;Exnm?^4HA3ln^T}A4_sW7dbWSHGNM~qG)xnNd2rvl zrBk~7T>9{B+b(p1aGY*2J)5QPDk=2c7TwB+?EgE`@1nq|k-W@%w|eDhM2P+tv!BWQ zTOFG@R6yHcoOuvNNE~%PfZwIm+&Doj{|PPCim-b6QvNZvSq-dWi=QO(kMN=f_xLBv zD2CY^6LZBqIxzhphb12g8!5>ak3Oj$B^=g%`eo5`nt`c|3mpiQ2kq^EbSfyt`A8mN zM5(LJ4Il97-oOm8?=elv^mkhJjBdV+oSZO}&Hr`~%e5;`X{bhVGjNCL+albC_n18f2?-3x zPJSHNlFdhVoHAdfNIxn`R156LYKlaS&nQhIEE_H(`FICM zj2F0(KgZDAUpu@ zZ1%u4u$$jGck@1FawVRvk~B{pc5o3D%>>yN=`>Ke5HZ!*HQlD!wp7w>E+-9>>s$^V z-_R-Rs|8%18Etue7m>g#QR@Rd*7GVQBEn=#q#i{J9p^ikB$QyPx$8YLCyR!kW$q(Q zr$5GMr~<1ebvm{;d9ZRa;0;Nk zfjscwrfbMA;%da%iGiY^A@6eQB?~?L?|~@h2)vaf_&Rf zhjYn@O`3}Np#$-GX5wkcxQR-z%wT&1qUUtF3qYNf3y5l4Me0_Z8nhFoDz?h2z18gY z#sRUW!0bd~3&z|9llWt$pXp>Xnd5YkwI^+Gu-A zLnuq{5acpsXI`{#u2hm2Iq5?9oy)z4>b0ZktA{4QHI$j6U4)G90ov3X2T%w=m> zq^k=G>H|E8D~WMJ?JCkh3MDYTp`!&G<5A^G4-e2@pU;V5_rKil`kTx0{=tCDHx}PQ zzw?_1H;)Q;3CXz-xTkL38toBt;S*_UY)1uW{BUcvlbxHGqJ66VO&_f%Pm;Q zMoHvfAn1(?qmgHVwF}N8u{;mk(;=^6^-kOFMIp@ak}BbNec2r!GWkIbfLbl9pe&}I zeZF@jr^b-oN}Km3u82K8acaZ%IHpC(2OMOJ^lIl~w2;qf2v_G`xa(tmfAMUnef2G< z2XYh*K{a0uym{%5hR?!M*{2hxxE+*%i(B%DdgC0D>FeM!{*7@8s~B8CkeLHBcv>;y z+(G3~7-9CcjH`cj)dck|NC+MeP9ETYQQ0_@?(s_pv~XK^UTtGD3VYn=M{hEMB1%6)j68&6+}5thGOc> zZ44E}eG))NIFf5N#Nn=HhA)+E#nZ!$Az=VB907{wl0La@Qn6oe4w;wQ(v~EVRCu~6 z1m856clOw;Ml44mK*xC+!mAk{`cTBBXi9g>9QbSq3`w{ z`~)~;Z6u~OrDAqnK|^%Xq@a~oSLaxk)wC-)q)6@fg%s1}25wiGN{1d|^O{ZOb@f7& z?ceF-3y=zSG??eUdH047MRH@7%EcMhxB zYk>y-!T#6?u?u`&Kmd0tx2?n;TpA|9qmw-YTgah2EdAv<{bgEI=COHbkuSjIG?3+B zNbCUAKW?eH8h}t2?!A}9v-QGqEInZ*F_gbLxQLa6qgt{z?hOO~He(bR4*~nT8)L^| zABo!R9O+xL_u0~0lgM)}>37q_6>oZe|F8rqJkx&p$eb6NNmr@OYih)WyW~TZeb%91 z6pO;Lbmf~6vzrifl@Q@TKz3@BM1}J~UH{+-MDx^c?|n8J+Nu`uOVldv{g6CsJ#%qR z{b4;YM&po|XA8Iqu9;`ImyR_=LI1$I!p2ZD>;kv}LU8G&)AwI#IBLPKcUBh(QtLih zn^;>t0k8T>h|{FkzBZn49+!hY&*!!YvO&qgFxf6HJyn>Xw!X16Xt9vY@&g1m9_LTI zblIJIHv#6QrS=boiPbCfXdx!|Rf6W@BEZ<7aN7GY8QSKeAd7Cm5MkIzz&#%ocr&+E z;;#fDD?%@oKMTd>Ma3@5S85IDB1PXfPvll)9^-OFr-%D0+GMejS&vTR4`!A<-9{R-b`_N<1Fprbo^0pJ7n zrW}4~y`O}i$;3zg1iA({F5_QBLU5pMs{8;S^Y6HlYe$g*C=oF@$26UKi`Uw^P=C#K z@!8egRFM~mY9};MQ6cH-@dUUHodSl$!lJ#y@yM@&l*f^$F0ja+EY?98raZN!n$7<4 zi@8VokpicsfQbQV0SOzAOu}9PuOYOIdBSO;$8O$hDydBt8i1KtgTXZh>-lzVfWlya zch6>MqXmfLLh@FFrYGLV3GzB00$<;~D?HZuteCp0R={MN(2`gA7lmVxL#W$T`TS=q zEs;-o)Wbd;ereaKQpdZl!~K86=oRiWf_1fkVELBDRJn=5BI?(pi8Yaa^6m)I=_*%*a_VQDJy=Mf1n92Ie!CgzoGAFX5 zx6xmuh}yuT?sVbxjWtLQ#id5inxt|k0Jj3yAL#1z!@jU*t5A!WyTjC(C;IZzrF2a> z^d-(Uj2q9^bEy1d&!iJpVjGFyKO6V6XhzsLacU0CJ>uUBcmu_XqZpE?FVo{&xO8^v ziz~xpLbCKwosen%p?aQ`mwb;l#kYDOzHTIA4X!GC{qJsnRfVy_q{cdp6C8YdMlwt# z_8=LYz4PnOywpOrTrTw@q(JuTUmdTKmH=~pIm9bLBKjrag6&v!ac}(d4fVG@h^#JQ z>JYaB%gd>4cqdo`ZO1(;=VH)mO5xhj#`3H3W5lRPn7T6~7o!1;g+%4K@jTpiuvW~8 z595lr>R5pswRCKL)9dv$piMV0Wm)_{lCUzePDGcH1J`2>!jlra)N#?CId-}kh_MZF zPZYVWD+kgK83y`7!gI0@N7xcyMBHyb*5uV-l+zvp^Atw_gZ353`X4?eOi8GSd2IWs zO68pC0JrZRL{Yg^UFd4e#1Mv`gYbrVCLL6|d7k6XaZWovu>vaP?1DG)tU_hznB)?C z9`D}E6o;66%sZdvBmmhqbrCD&LFM^^(LSO6X|eQ_ngb4Hf@}&$!r`^+0E(X{70Lus zZj#3*TX@A>-m?H=8trK|-cv`bg}BbK$o~;!#3Iasrg@>yFfgBInzw{{&R?7?_*1vW zhpC^5`EMyL|5)#)nWW{8^~nob<_48zhuLtrYE zY-@V^rlB-d#Uc7aNX^~Fm;~KksJ5)=U&9SQG41k+Hdyr8nsmkXocS3@ZM3KMghw+F z*AzWxA;`#nmhV(c1Yx>I>LL&O-w?Vw+yDbugo~J*i=@{So+`*85j5l`!TPc}vyL^|2VQrU)b<9s|2 z0hC<$Ca8M}HVI z7oJL92eF#=|u^OS=xKfA~qt(qRXtv<1gKA$fQxddrM4d6x9SL~muIEF1mB%;4PP zh8j}JUn-dw5;6%|Bp}$kpL}7*vP`xD1RZ1(Y{dk&b!L|Bx?;w`oiw{Sc7K;KOIpGF0B;9Av~2i zg5UMb>o(UWUn-^|Pw{VW0A0*E3LM0Gw`o}#qn?QL!_s)qtIr|jh{(g1?y8dXadi$W zM%LVKG4R6Kr7uiwdu=kX$nJtoVLe^#5Yh|i0Tc7xU*QO$)dy&yBo6nXG-}#DmK9g9 z@M)FkaqP@#&v3)G=i(LSTAH$VR{7lHH7-^|8~xLiPO$=Xr;4X`Xij44q_N?W(ifa1 zbnDi;c<{4(a4E@iIhU+tg=%+SOUJOJ{PE=v>Q+F}6Hvew8*o_(-f`%TWiU?H(KC!zhKu}-?^ZIG>#eCmKkuh0iUU3Mm@PYegfd}TvcVcSko%?)28-&fAoli0k)b1ZR)~tpedH4||D~q(%D8UX;8BJgTC@0!9>-ogU31L_3+li+i||xGT}nk_~=g2d9ce z7s;Q}N$gi&h`+JW%=%9Y@SD2SyG92Y5F23I;C|uyu@Qp8ve!cwc>2;HC@h{WYHQot z3{Fj<>d$2OX!VTH@MP-FuHb1S<_>xQX$7X5Q4cn=Ru~$lnX&MT$Pr&iuwnR~1`+6_ zc)Wn%vp`j}J_m+%8oHV0a1Y58PPl&7hO$HenNV;~sn!%sVVskNQneF`Q^(E9SAu#f z^ps|R7Av>Z_>eG&RBJ*L2sf?C{tEO!=H;{w&)YtLJak}PpcEnoa|p*$V8s5xu@}q9 z6kPB<`MSg`QRMB=WD6E~%t%=}M^sTjIMigF&sID{d_DH!nnbQ!@vV2z6OrHCFynVT z)UF|u(uQb|Ublvh`FF$O$^>|?n!llpIWV+kQMff&AIe+10?M*6Z;@KoQ>r~;nd2ks zG6pri7J0bhjvwU&4VU`jWdZJUh{BZl&Y{0hB`8Qa6O%yz;H{s~`#23T-ntXppDrc? zhm+QdcHTy9tK?pju4+9atLhWF~h&W*8JQj%ZqB>2bOD-mPxTPiJD2NoTJ$ zRC+W?k}C1P-lSgWyPq)TIk&-`qE(?}Cnj-!~>7YsSdn;E5o;Q=L~rxPWX2tu1qqExF_RiKTAs7^+kg;vKa} zx$&dK;(!NR>0jfd>=xMmg*wEveUBj9qO2P?mj;iBsp8e^w2nNb696iiUSL6=chIOl=P7R7O|6;A(K zOiIs4&i_ubyKJ|}9S3Ky66m9A+Ko>7ijI+JYZ_a07eX=B`xYsTS?R0yb>hrvpC)-7 zANlBE$^Gg%u?-v|_1Fq>|!AM`S5E2NW*q zVSTsApQ4XV;q~VaQA!;_Uz=fsL2kFD%n=I;e*B;JDLChW2enVbCf;U7&?0 zLy^xtv9Ok9UZoC(ZbgBYZXCu0XRx`^s;^VsnFxC$5={4$=sza$NbNXmr0gtJx_L9Y z@)NL3#PGAvZ#R`8jpc|Mr@GAcDtIcI#Xu2+tz%e_5YBEgG=*@zJZHRjf%EdkQ@UbX z*4kyWEa>!kmC#7Dx$4mrUZdaHVhrDlp{KJuvM_6b;vOcPwdHi6JCtsdZ4)=`1FHD<*WAJCN#@udOA)H$rcSepqVMv ztW5NpT8I-Nuv8~z^^SJW#3AS1vAZ>Bs=j6x0elvaFb&+|_*Lm1o0j-xk#*qiRIC#o z938)kU~a18&$DPiO3@w3fACCGfkUpD`(g&Y?$UBL)4DQaJ0xkKSZtNt*LQDn&|f*{ zdVuGlXTWX)2DZm0f$U%vWBp|&=3_z*0T}+>WpOpdD4om1^*A#_n%e}eW_F1sb{=o- z$(Taos2@=tO(yd>kcWnL(t`1&a?h#Z)OXu|V%kA@HRF7)Bo$S0cQI1+G&OeK*j(&X z?(bE0KNq!dc^8aEFCCj^02!^$Y;ds?uGpW|-WK{J6`%Bo%8Dm^FS7&P|6n{agwwLn zDb+cP`;a+<+ir+A?xKWNjXSp>F1WGyo!fWN?KrZvaCJg|mptV5%S0#qmewi;q(J7s z*V>c{@BeLGH@46*4k#ijP9PW+er9EP?m5@+Tr zzyfQ`X)5JP+MlFI^W}N>f9IGb6JHUFGbJv zVUx5i_YSXb>zY_&tA(+57n&5~rTdU(6O?87k+S3JNNKBzH3St11e@k1%_2QR7mJ?J;07ku9vDyS8=<5zJj7+c~mBZIP!pH_H&0 zsvmmBd?Ad%Ilt)j6$a|)LTHWEU|IaFR^t&}nn^Vgg2rqQz+)d+h?Ult$7|u*5aDWy zDJ{h-`9NTVtY+wtPb5w-b=9dZNU#i=WyWMvouo3IwZ>VjwR`Wm19&9_Qsi3yY1MmW8KOW|~rd zQ;nbm!Q#KEaS|K{$`*z#68#UgHTq!vNLzaJ?5`3k#en*Op4PME&zGDDV5&;f!@E68 zV$C-^WK`e|=HlDTdPsEKwuuedWTx+0&XflANwC)FL{LP_m+mgWKB3$o7wp|~ID{Kf z2&|1)czK$Gn5vD6e+uG$N-DQjPwoD%Xe$y~T8p4V@h?P)NlFk6(ELdyFkSi%+QpU{ z3b$8gWf6r@_4Encj@+Q_&uCE$u_1vPmKU6CfK;6*Yz#xpy_PIkKI`H4_SM*c^#$=l znA4iN?YvFXPcPo--?@o43+R0p#G|@~MTT;ZFraJ%=-m{}F(esbGW2GTr*Af$7iJDYL=@;PJ=JyY@+`_JGI^LHg7CSJ zGknkvvA-x**m0Bb5};lBni(P(vMptUfFmQXuqj z?>J?h7xOUfepX+tG-)ZxvNlg9pEypZ{LR4;Z1ahtKv64xY-uAk8W~nEcUCg)Q=efQ z$!1tL7u@2oK|GO|R|pV?P^bcg#Ser`I9)n!=&duE2?=KbdZ%UAq~VlS;m!mOO`Q9} z;dQ;n!e2lKS;-)1*9IPRmUTgV&VC5EUM>BQrS2zVLsSKIpB@{g*CxH6HR?*q)v@g82dTtV*OirBjCi>;J)xTL`bYQgSmb1}4^Vp__6 ziu>Zm>MHeZesTMwrhC&Kg|P%T?r2D6E~uJ3EcFS%g%7r9Q`$mh?I&Nn5CvGatuJzj z9Ldp`2UG0YHMIa109!5?Y!E?h$9mgl`Kf}n^BwChz7f|!PD8N;ceKPN>Goi7XK}L z-n|`47%W`AR%9PFKShaDE^aZS20ekB;U{luChYr40Bq)g>FON(p0-g%pA~=}O<*ZVTE) zPGS?Qlpd?R0W*Un1pBe6tF_=`_cZohf=0OjZFfrp}0@Q#>I>W-{L}8r!y2U6~@Lf$zAC;hAU9%J-m0Mem=6L;EQ}j1Q z9xS26pY84dv-{4S9F%_vq7%OK<&mnnVw?nRkFxSxQcUZ_|HC>lVOO%Sx=No0(_bKq zw%`#O_EG1h+nvB?h>C_hU~QF_E2{|Tw!`^nx`44F2jVaG*slsBNSeT&)oz{!qf#gV zAA#4C`b|~njgY7`XC5dnO}1@%$IjA=f2qxSfhJ%qVTsrS(EZt>gPkyBVdEXCb`l(Z zp$Oz?{aw)N0!p;8RGi1M;$Qhp6UgO+*coGy~O zj73PXR+QC+)DIIIpbK1uq(2;dL_fi>jIE2m-8V%AqcI7R+gFTX>ufcrx=RNN4uT$0 z7WhqSAc=^eMb^y_po|Sco*3*x(o%2Z%t_mI#a8V2GhhR?Q{{z|TFg^Cz-~pbVb2_B zja^wa&}yfEb(8zZn9lWZ=Nu3au%UKIsTbHRlK{{(gb3ay{$o=FC=MMs zMy?X+rfkAdsh31Y#cp(zl5>aA;Y>_$&j9VZ<`uV`O4Re^Y((+UXIFS~KfJELa5 zrX(l>4&2Kqd6~F9qVG^KSHZyxMET+IvJa%O_0T8q5rROgRF|wK-pdaab{d|CJD4CO zCu6CS`#{`mB4w;Ujn7x^!PSSbUTb0hyJV1(TzxwKS`ktL9Dit#H)F078K_d{K6(^1 zGxK(O;w3oRRI@`_6Km8X4$F8Gg1MyS#Qu_5FE|r0VM#(#d~MFMg0nj?aPZ3KrU5tn zsfH&{qje;-|1>0D=)y^gmhcQVXvm5+KRsj59k1lA=2&m;xotD(@nU4YPzU%ndMWjq z05LHQm#U_Xd{*7O4dZaxln$=IEeB-6vls7(G6fF;X$^gZ1bXIv&0p2$tjC-8^QZ`8 zS&eB7dLD5z7O(DRdU{a1fIyK^xh;`an9Z)UEG1%8rZw>qE~opb&z z)f%hbm4PIdTb2eH!vE4PCV<_0CzH2217FZaGptdB^~pU=k+A_SuBw~PVG*H;!)Pj1 zS`bFor*J^j5!l&A&BY<$jR5wMeb?^W!?$6m0{XZ*SoIbFD629Qao=4e*RbVO(kzxh zTh319LnRKUn{<=plNOmlOQ_NyV`{>qHNrh-7Xn`^Pl zo+y3f7S*#VkGR2cn$voxEEyHO8P*S z_(gi?y_>e-0{%Q)z1y-GkK+z-FTwhbs-Yzc3$o;u6Ila5y+G^j4ch!)2=X7=|K5Bp zTsqpm<3q_{sZNv~m&{zPs?&D}r5)9gD8CRmV9%yl4cXvSMX6Y$ig-RJ95#qz%$3Ab z!d=b6DF3_lvK4@9KM^8g=_=jsiKTsO9tD8AHZ_>gT(`QAZpt8-@w6?hdvAMkd_m(1 zh^^`ff#X5mGkQb-8qvEvWLa5?!c>ZwJ}JdM?dX_u^`&#gf<1V5JjaU0^(#=JSXaJZMN% zmQPt>Us6^M&`*d-v8xxGqZ`k14Y5N96t|3RHWLTa>bag!V+@KLbp!kI_Pdqu9rqi? zea_25mR3BE07jS16mu`@z}bNCsB_4DV4`bhh1Hrw1CTOc@3$KG>=;eUGlo^nEhSJ%T_b7i9?aOCD!=c3{*T};g(6T+F!pCP-5Qc@~ofZYF!YN5w z&w%lR_CQA1stpZKbr!cn8a4oU?y%*NIy{gOvVX|6Ds_G{?QDHIN0sPkQ5${RCFYeA zQg`@f|8w)~an;UZkeGhb`LmILJF>v@*mNry8r%+AanPAE=#nNL8SuOT(EnCn)9=@_ zor9xPJr)cR3YUC)&tq=}8yz}&88xO_w3y~0`pa`CP<=|riTKfiQ%E97Ud zT`Vv!FPSmUOJtn|H%f1YV@gNAbgl!fvFoJ~mU$+FTy$JU4lY+m(~Q2*JqpF5sJ)Uq zW5svzIlB;EBuc$Oy~gS{2m!%=MLBITgC#9B$^gtL-RHk`nmQGm5&BeHd0@q;F%1*) zb_(>B*8dH^SXkLV)ABJ$AiG2e-IRJ1h#Vze1@UR5SS9&(c!Pe?8Ed&>-vOd;*`8XJ zqL6QribKRtDNVTv7~mIjPG64b6dHuZ^M(Xm7ZuwjRt<ipjVAAb<}!&MZA69DeDxpDUGYTVT*pejT<7#i+&*5L>oNV zE``dAkg5JHkoO%C{e+auOL=i3KE{YUP?{ui-sBF8AmVSQ8UBfRXF5(3*UX4*5a9>p z?~S;Z?s4bqMm}*Gp3TGFQ%H)kJ`d*(R_dlu{be45R6DfKZMS_lx@lG8sU1^4p;I@= z)KQKp9x%}(k~XpE$^{@4(~8jGw3YDm5_5*buIQ{!6gtUngp`MbGihG1)fyZN{@nb$ zv{Xz*>q|IRVAn7|J&y%mtVJ%!-ps(wsa*h*@hd?|^O?AfXYP)coSXOlvL1vL#f~?A zwB?ohp;>^R6slP~C+t8ghje@ZM~2y5gi*>z^HOQ1oo{U1L!AT;%;Lp2qhXVl+DGc^ zIVyOvPg9MVkS=PGJKgCcA;nWGVCXPBum3`o4{}rNW!6A2?pSJ|M(&J;IA!iymTFRM z_9wh%q(Io){t8JF07A@sWV5 z(x8pTU{FXWhmVZxq%1)H&EKxFOo$JdIPBX4EK?#a?Iy}^x6&xqjz&QZ9bRjD6FGT4 zblY`bKUZQvzBAwOmnhU_kOTi;ArvjouqChGmxL3GZI;)-rcIg_M8!giHeY*68VU9e zq0s0Mr0sqI&UzhbP+ajOd5F-&ab*FK%?{c)IJSc3vD2-^-Jc(%!8D}zG<{Nq!~L?5 zJzkr>8v{*b<_j3>kxLER&PzT`^9Lic7&Bi>TUhrQ$jr0a16(;VGC7t0KaF`#ai^P$ zIR#DDJDEw{7X7wD+)QdOo$0ZD@Ww5&un!Q(z+66aRE|aDsEiq$$<4`t)?Jyb^`-=E zYoSNeip^)Y!KE|W??tFHhZ$!C62inutfR-lpPCn$90G&~>FM6u4kqDvtxh;a&re*@ zRGSl4FmCcLT@0R=OvipJPOxP@xNcu*ZR~{U93=5G>&@SW0BdgRh>Ix8`rKt zO@^6K&a+l#UL;ZlYI(4YcJjbhtmkXu+9qy49%1pztC^o|X72$NOQ>UI`eC3rH%x$b z?=qw%*Vbu${F8K4_`+Eoa^KA*m)_)$c7WVB@ z;lGLD1HMHy?4?sLj*Kj;7%z?!(bf|-Zxeo~OCdd-~`c|4P=2XY6VB?y_S zNd&X3@|u37<8Ba1q|jxj>{K$ObPhK+*1DH%lY{G}c$d=IgUsZr8UQ0e+`m~< z^t>&}hH}}GZ8e@MywvEzn{}pYTLJq!Fxc8M*H0F~WEGg;_qxiSd=#N*yZK=5@?uHw zP$X)z`sXL^f?6WUn$_%{S~^k9hB1_*drfH5Vcep@g4^+P^&kh*a7A$V=B7Z*_@V

uF&@s?nU=*JAnV+MNafL+HwJTnp4S>m7t@I}T8No(H zt7C?SGUM6+ETQ)df_)zqXgketXF?duKpI(e_y*#{4jO%@o64gn)b4VE?>(133cv~L zI8`}pS-RtTq&>ATRc00ClLWjhU?O5D?eHKewBy^I%F`1p6Nb^>2=u@2bVA|!+?j=C zH1L{jBj+gFvJi#E@c7yHK|RPmq!#CsLs0O91;qbP&ZqI^;h?jSL2RyuqqpZe*&A7L zw>@+L-uca)J#aLu=5w5xpgV5FWI13}s6#MhLBv}|!!-NwK(@e!z9tW#JtHM(*|C4) zoeE8?)S&LQ94>QI88B<{&PsJK4J5hy56-j|PaKjhFI&@AI=Qu+;{k;ZD4wnow1$c` z+eTsM-><^$?d}uR08)*cQ80c=?)$R zbHwQSIbB3DwdiJg$wI_GZok_`I26>sa&1c{whJsWWoDIZo1p_MkX6it*~U)@*FRG> zVlunqu8If2oZw**CBf=Z|9$Pr=gxzxbxhdUml5SFPK4yU((FCBO1>(~;!BKHY!diP zMG`Hvf2}>UnPHS)TQ%c0Gf0A~gq8ooPF8U6@!d%Xr5lfi$z&Ts)QmCzgu(Mt2em}f&Z$|H*G#Zg4Z zBof5f%6KJ%b}K!zA_ z$SP8>I6GgI#-*a+)rz6<4$Bv0f_5Ut%cA9-?2t@zHjEH53v47q5F88ohpm6(&tDw zYI2ao|3{`DH&q>XbY|0#yK_z|dkZze-@4&}#KoIjofa5&{=tB}r-vWBbOM!*r#nCZ z$@Fj|1wMJKgVh3*K%aDA>r0KR+q0w{e(J%1j97&D#uDY<3EvA^cm|V+9OePF`rC!+ zc?*dOH_eS_Pmnt^@TD!aPqSB-BO0u~nIc@+CYyhT`~%Z4(%$vv6wdkrk)e$U$h&k+ zipyf^tJP}nTwXBxw>+mp5?3`9qW8>^K&HAq9J8O;d&mhR6OiprGj(x`V7dTRCx& z7^XFUa8snXW6Albr8eenceNI(JlwK@JXhF@VXE+zFH`mH7+T3o$*ST`~ z83qydq)|3=nM8OnQDPZ6V94_3H%Z*Ors&0WN_3W`QZ)9@i!{>GVq5ZdW7X9dG_N>;h05(K<2iFv*u?MC&v{vN95!#i^0^~3UmDh z2Xq2Xn0f*2DxV^6%a++R--%|jXiAm?cuo9J#;2H;RL6D;RjG!BwSowG;=}LE8{08m zQme(rWNFQOROM`7zexxKUKyFB62 z3pxL@LQ=YJU+n`_q!IdVt%IBxMrA5|{Ew63N

a50dK!45IA`c6#zU)_xz%l*iF2%lObOJ1RF3opHDF>cB$;xb9J>b ziBRh#{}2cruPjySGN?-8ZMBi+t$uuiI~(gUK02&h+q_tOt51v&XcHJ{sV5P zOe6MNT}NDZvO!3C-}==}GIiBj+YXbAt~5+wOsNPxY7K3Xk<)|N6YDjkmWNGE5F)W; z=j|aW8Jw-50U%d-f1AzYBz1(NbqR56W>UYhHM>5<>`9cxsWmYm4Yh*VqbNauR~Pfv zyrB>AzNwre&ReaOi&@<8vXee`O28m2D>}-hZDw;1`YSsCtbBkTchNc_@=v z`*j1pw_vNJF{hdc3+WDwIhBX~o)ze;DPeI|=gZ7%uv{aLGrWtmi!<|!Zx7Kms4CV! zR|AB}vYpzFdFWT=k{5)JBof6YyzCge+r;M*Q)yFC%G$a_2yZ;CBf}phDl0Pl2`pc7 zCj6CEp3dEpe?DCo2q>zCcjWy7TQjdHALCdBokWpe!yc67b6+y|#qxuP3I}T8;fm zF{^RN{0BE$1m?;6@lA$cIEkS);k$LF-&6Mdsy0pZD}HOxBbyGh#MxP^Iw=OjkEFYz z8D<7?L`t&&ya$*X!qx9U(aPTQVUDBa4{u)~Oflh2h4rSm=dOA$txfYyNb_6>ZkRO$ zv2N<%?U?xzxDO>%ZytHg=gJc#pqNL5*|q)$jWykw1u9)eXdMxIJfJX;vw5SqC!h}f zZw`Qte#(#yEt{uykb(gcgrY%L0d=Pi>G3FY5;ceHEJ6DD=BF(i+$K*NKYF0=Lsok1 z+)4i9R_096GdZ`%;BG&1ODhoAr4SAq&3+$_NFIs<>-VO?aFIv9E9~ z9I4`SD)_y^O9~El_bS83#JlYcMm2MhJ{kvu>K5*-VQdx{^}6i0$hVV+L92W)DzT;V zrfdr4`=1I3U3w8W=0M`ywi(QceuD#M=LjMf)(F&lu8)!4ch>0O&yi51oW0pwP(1*q5y2Wlx9n7#%ie7}><4?QP4~rNl%@Kv(9|CsGk=lsM zH(au}k|bQ>){DrNk4d+jK3aB$~!>jrq|*NZoVFU!dWS#no{W?tp8BuoG~sWeJ5 z+Fy302WtJnOA3uY3|dEEBbD=oaL=1|9&b`Yx%4qjnW(Rs6ZC+U;#9)X?H_Ht(uP@* zK()({WjP2tZ(V^WQsKL`v*wYn*U22q`*NCv!=&%&043pme~XqQA;m;<_vGMqsQGK6 zA%I{4G~XH4m^0L-Gj&q8WvM|Gi-eR%=^XwK%xG_bSnjQXsq{3yBglH$#*g4Q+;pUk zfsqLvopPTMlfrec;^xkGJr9w`acAUdF0%x0yB3(n*GW_l!{?}7xQ~2;8d`-({Z*PQpXgUCYYgP$qxH((D&l#xz1e{y7{NA;VFK!yItt@hO_`7#Ix0!u&ULe52< zZ`|bV77YaB8JY9@sc$fju<#T1lP?e3jANWW8GXb2(S$JKFQk~N(cB@#@dKi}lh zXMAefVE#yE0|V;3C$OHD?5hH96kP4a&+u%DM>fY~SfbyjYFz8_hETs5E4;Fw&^su= zvl_4P)bV^~A$AEAhh`2Z1Fq={NtJD&ka=<*jrgp2gw$ z-(I3ls&OiwRrQ53-vNP(E%e>$!FhY1m9?#dsv58Ui1PS_cEdwi#UP9 zn06NU4iz;3kwY4Rs7hkNW0Ib;Xz5*F?M{h#sI@cGe$ba0FlUuCG}lhuU{J+qS`6KP zbW^6#U$_LZ*N@#z^vjaZ()aJoqw_-m`(!Vl$SxVXzTht>-o~Z8@4Vm7fxF@?xE@G1 z<VC6#{}L`x{=I93w-Rdvm~M9iG)=>6v?R{KI=a zbvb+@#ez;ejcF`W1lsRwkq9{*yLVk;OdOCSzyD6?x9w)H2|`6JSn?(ddrC}3D3e7( zy!q>xjk`1?t8m^_IQ;X#SaCyVXZ9J;Jl&hC-tyK8f!bPb9pvd9JJl=H zT*}VS{WQJ*%y6BS?D5Gc%$=YB)&AV$)396)4&Kz`J#Y7&Q{Ih} zKeHY9>gu06t20;xE+hn!I?M$GTWN|J?S6f-F3`eZ6~2^cU!qi;r~Ql1)6Udnkh3mt zM1St;;U+oDV3Ec~zN*^=ryQLV-XJ1dG%o^F^W4Jw#^DlXnBdtpxTvC<6W}i{ot=|t z(4e9tDLo^jx`1|(RsgPDAtLC4{=8`CX&AS!l{7wQObQKM`06w7E|;SA^HOuN$#seH zQhtN|ab*S5)PycI=io218RTNmGhKZL@yAxz((*`a6s=H$chCjO`wg2y=>b0jnMipdU&=Pb(^~&=Ig^jrMZUk~wpYPF zQRO}U+u%EZAsit%0mZtBL%%lLD%4F$;l(1vMiuUg{hSJ=-j%slRCFA$CM6Y6ar646 zrDL&d0m*QaY&}J(Mhz4t5zGe2w5H3xvpHIldY>^??tlG;D4<+DdKvD5-P{0f@>Dju z!r-_JeJ+3U0LP#R$jASpc;#u{r+L`BFHM|FjwFtRdu^swH}ERQgqV)UNYrOoP{abe zfz5b#ZEA;1_`;W0S?PmoByTcDq(pMLO=4mzycvUzowc++1=A5MKw~hR?ZIUd8J$Z8 zoWNZL>MWpiEO=7LD+tn|wwB;Q_oBK;ydWbSta-y@4uK+*-$fU?4!6R0xK>R$CR|aP z=9l0?jV_CDAN#A{kAJdWy9KMQ1;~0zhCSTT)%(g^%U^o$!liFtZ^F_v04AN=z#L&3 zn0EngqZ~4kylWbHq{FIH@&Paq zbvq6&Z~p&!|E~@ner+z|;BM>Fk+wjsu+0Zn6w;DU(yLJcE8I9Oe7-6x5DEE&p5Veq zHnjH-T}M8T`te;817Hs%VL3p2ZWUCxq(2@rp;lTzVYBX1!!}c0q*EX7$Ft?9!+z$l z3dOSgh2PU*V4esc`G}4Z7`;F2C7P}V!v`8`3X%a-X;B-kJwmhxxiKde^xqgOI%BwCQ&)MwPiPTDD13>s za*tyAjPzto(zFG`sl+@v{WOzE#Y7{d@ty*``$_+-!fKZr*T3p6^zO8G=p|yfhj}sC z{w|$UZFis@eZh$|UTeaBvAN4cb0)(l9YNS|yg=zU&{{v_T#tCpfX)BBF(vSBs90PN zgg%ekkmkJQEe^W0fyT{a5Tk~A0*D-TSnBSXYDHQq4tLSU!rV-YicSX_GseX#YQz;p zvzX~gFoRRh-bXro1i!XU?fLsFHn*tJ-wkY5fV`MBWfERK zKLY=2Tt7&PzA7hBaW0vq`{DoK(43fdpYLsZ6y36}x|N_hfKbG?Op>y(gpeXjGJ;)g zh$7@~IGTM8mPps?*%2GE=lQDJ`7nFX7^32bw}i#ci!8ln^939f>zyfOd(lo`6GU+AxWO z_fOV@fV^yY;IQ3TNqOYEi3@bSLskr2Re&fLEo#yH)LZU9HW>L+comw9JG81P@foK- zqFwk0h}sPHg~{7@A}sT&VhAJ!@Un_6n8&9}6z=-gMZ4F+rdR8B9x04mdJx9(1ql8a zXcvXNYOJFet;SJB&bbQF9N)SqQCxwK!WI z-YP6{;*AbKdk4Ca?u&qufree*Mg(cv3m~tFnSO!U30Lncpvr@n;oIjxlrjyk;xXD4 zc8C!m>YX2R9@~ zalBi1F3*jAMFoXtI6I4+JcFKCA%M%6YtYR9y;(JEZSn~QFhmSE;w7ae-T~o45F`t_9}x8d3x=}H)?VrPnh*H2ZiLC zlC&bwI%Fx=qj4)V(fmTeD_9oC5@TO&MNN0oUd=B;!E2ilW4g7hQ%h6}2t=(lWJfp` zu%P3c_-~!65>(f=%MHdU+PDyHvs>ir?ibSaEVKWGS6_S zRamdiUa^v$hlVYIBN=fy_M0nBcdQZr=`%DU7wQlcwrwPNvO}%U0Dszf1lRMVb|~2dX!G0 zEWyRC^Baman z;yrc|5u7`+H;>?tIwXt@6k`Ip;BHU*s7B6OlNye5lFkQMgPHHBagwi7=7H8;zJt&k z2J)2V?sDl z`up5<;>)9NH;SP9t+3~(>dCe$XdB>ni3AQbWm(K{FTVEsn>JPc{|O8>r%=6ra+`_? zhtsj8ZvRHl!ed`1OE2PyRIJJ-B~!^yzmxwLVURall#~N5V7at%CORL>GFmp3rTv=e zGo_wK8obEXUzaq}F^l;fnwWe;7x;RL&}#XJxZJYzj*NZwOdb`v(QDpDP}$-JoE9*eK$xdzre{L~%;w}2JOeqHYn zk7F7MW;I#q8OKOdl$fEl)e3*eiduDR58cnUWdaTSrWcUkb<8Nv7Hi|Uv${+EK~ zTtQ-t7;F|igB0_{qwWzV?bGtp0#g{}Q;59EIZ)EjGfDW~V+#XYat~Kw75ccO;N=B7 zmg~c{wj=kQW09?;D^j1HXaJlyg|_Xp;nuVJ5?y#^S&@JvW7@i`2)X$kEt zR4S)m=A3Q5knF(v(xVm%b>w3P7_5_e`c^$lEs0K}(|!URaU*^huV+HUwv}$a2&PRZ z`>BRoy@kuu7L^yDv$B>_yIsdIl=Fw*K8v$mhH2|_k_pf>SS2}}b(e|oTp26eOMJPd@R^8ZcRW8#w8%xVl_k1;m5?gFFFAgc;IRh`4&=X%CaP@X zWaq+1ww67|!H1m^y;Q%?XTYcDRsV1*{ghE|i*3n&k6+L{F;!T*2PT1JIQFtd$ceH? zj;2iIln~R9rwZs}zj-uUv8x)BQBB<9*U>s; z=Ey>ER!V11!{Oaw8Z!Ss>;X?g?|=d*#J`?AzOh=8qL4ezyj~Xk0VPr<28{=?KTwET zv<`8EN6-f3>Vjqz2%cOo;Y$*0tnvtB0K$?GL!SkNd1#TC(hv-tGJR z3c3aD+YAd3wGkdk1%+{k!o#T?$;3F%lmev=ZUbM={A6d1hj79gwB}v=_35^!8Xx9r zOA?9({HnQng_U9j_@NWyaaV?wK`XVeFup$v%l-&C|Dpzckzo4uT9Xi&<^GE^q?J(| zt`64GqJA(%A1(+uXN`iP1Q0l#73aA7Ud}a;Om|{wHo$`7WRS5DP97*aNuhOnjyYf96-#)mhEoG-2+eR&r-sO``=0S5dY9MIz_<^N*{NJ*Dqe95 z{Q9*=PnZDCjU)M+AidtRO3emi*P|E`!t;-VFVuiaohmwM#kr?1Q*~lAj?a~hnOjv6f&*929m@9ClCno*8%-bA==0O zs01C;p#j8(&f%DmRsCQ9RR@kpnqI-A#4zn}Cbk$iHFl0K9969rP+?Bbbwwjj2B==m znBfc_<>{cyGV5GBLsdyQap-g4{9o;gH z;ZF2^Hu#0Li}~!ocfcAJwrd4)^gJ}j1R&3=q{{-gR$GO@td(lwFN`l^A;KR&xNyVc z`uF7TMl4ssA*vkfF#0k@PJ^U2nmwLct{e*BS8=fpiUodXRazLVt15xw1~{J53K~@K zwzLG@34Dl;5XbMZZDC5vPDHZI9uL%5yZduQ7a8b4xjcO9+gl03TsDGinYDvUS^F#w zb@dgq8eUI1yAl!Gi1ztW>8+!$3_*O@69RPk+LN|TlDGYBZgT4|%1JWC-ve=G{ger- zrD7g?eTL=X2gT4?}gqTg2D*EeZ+%agQzNH z_J@_I@$rsb{RD|(Xfm8Al}E_E8>U%grKy0K+7(H3b`6}ds}SsOXCNbfBf&7^*+PRI zdBAxPVM~J{`FDqd|Jb&2wOH@}<&3?r99QPqd%4UlK%MHKkAo%4_`!z zS^BLp+n6Q((dJ0dDzq7|sfCDhai3oy+)kap{qg=}hTe;ds?Tgna;T)T4F>r&9C)%b z%VQ|1R`|Lj7Reqyp-$ZL1cAPGE-dVus=dPDdWFpSvwBz7>7Q~0X8wr>Og2uknooi? zcRK6Jh1g!Y%ZKiUIJRp245RQPUlD5%&42`tPV^ko`F|tIeeu9h$SI*K1K zT$u*DA*=F?4%-k`0v?d8s-|cm;}}tlA!0d;4;%14$3TlW7+kB!KaZSMV!=yMjW9LX zj|Z`2^6qXpL)cRJ-QLB^7Z}^P`f`euJkM_~Zi6tV<7t4lT3#XO0x0kE=j_ zoK@uy!HZVw!l*2sFZ%L83(%pZzKgYWA@HjHY-wW^cO+en1-=s~AxnR9H9m+YZF5<3 zf!o%9MxFHU1*;@$Nn#5gb-ido4Sbr@PWF}xk1C-wBqL5xr#_P$sl-QV3GMi`b?+@7 zPLJ8cz9A?sUg<79_>;Rk)fD{1wSX|gkjGPtk`gB&&@g%+>mBkqYl4ClmHuM|qq~sl zhqA;JLn3#`NxQYf_Q`=6C30<^tc&h&Tv~^lLlmIiKusUki52`-M6y;NO;@UWgPuv2 z?(rNJ5i;$O6g{^M-=y>goZC<#(&M~Vm48f8fx>}}^ZNlIQ&2QH>(E3+krCZ$p{+hCQ__EV?+q~v|ow3v&nhh-mupkwX_d%1Bdai zRHV*DL{}d={0!dg)P|MC|5Mm}n0!mRH zV0r5X?Utd>Y#v%pT|A*%6TGfkjHiQAhms{b!NIfZGfw|3Z3(q&H?xfO&5CUGYHZ~m zg5+0MIX6uwIpUBzN28SKLlpP!-G;`NY1innQtROU|b%)BM<}4A+O1=~r_7is(5%61^39HzUf#hrOZ_ zVP4jrnh|I@P4RFMc%Y#QhUjk)C*)brm^Fc{H!oI&s6!s28o#miO2yVwC^8DPgYRR* zV>4S=vE(-=nB5eTv5syzN5prVWnf5g&%2n5lu(kpwgOVwUzolMZJfm0P7=KPpBEY; zN9sB5d883DINl~MSIg*6Y+K#10FpyA96r=4LFZgCJ@5Iaak+497NgD-O?#)(oD`%U zmr=pE(sP65zqLGO|l<>*%w3R~5dKx69hDMqI;`Y09#whVSR{^Z=XZr}vaf}j9K*nhu zAuhBgQQGu)=2$5@dmbJZdl475;Ic+)1pYB+i6D*0{nwY{8gGNMxM>04Qb`JY#Kt#E zsAcP=<+(fJaP8h+;4`AgcoSUz>Y!wHHl05XQ#BFV+d7>Xk0#z|7=bb(6{{iOh4B%|gLDHmE4-xBy%ts`++UO2A-jGEbZ-9`-Ov!UxM_F;1@(Yg+C<*ER31t2 zB%m9D2e1$)@thzu3!7jDXE>!_WsZ(z2ADh)=UCBMXFLRuO^H$*&2G*499!&IWb&HP<~NV43|HO~ctT+AhpA-RP{kEg z+^X34xJ8ut*HaRfUHaeUh5>+Z=|I+ittUmsD-49B#|{q0=>`zgZtSeDw7wodK#>gn z)t5F|^gtQm->Ii#k&WiBpB`LBxGSSdGhxIMEDSDN{}=!;RD)P&$Za?k*rk@Bj9D^F zgP||Jfd2jD*vt?h%cxrJ1o>3%Oxt#^BFYTH>=_zquB!g)+?$QPO_^+b8GdQ<&D6ap z(qRsSqGo^@aQ#WTE3<@&0X7NGKZqp%pyB=LvC8DhVGAZ9)xj?{S(Em z>Sy;}T$}XR{Kysobs%UN3Wv~D%iT%@W82#tFLD6kJj~-j7*@<7p}RJ+V>4U@(7+Ro zw`>w#XN1^z^s?#mXmadSLTx?rsL`WsQM9*IKkG+Cmy*a^S(UGAyx1e4ok|*y>O$qU zU=>toPxU<|QX4!-O^%wIR}oVBCld2TDRM%ZwR1A@2NXgK=9;`UG^v- z)W@Q9@iEO0gs1r?tK5Oc+V{+7YP1i(9(XJ73ZPo-rBzJ|e^MT}L&)Q1xh!w5H>qd^Kr z=W$A1^ZG15=JLiOFP!VuWdU0RuFF#%iNKUT&v)OsbI(K@2uoZvs5=<&h@$HW&yCEF z1yXi>KS`c0<(cWX^Yj&)b#3hGq*2y~=wgjG=k@}vKc-nyW!MIOx3r|J~ z8xAKk%Kl^_Neu}l3d?UjC1DG3IvIdqmzy+SX}@bit&_Zvu0%NAWX6P6^2nNX9FMiL zaAUyBI+1FW39>10IN<-C5;(O_a)A@Y)}jbFdkSZ)%B%1SsJ^GJPjE;fgO@HSuD;Ut zpu{%IjpZHpe9;S9);K8+vk<-Q;R0)P%KVyG|9)H6boZ*z)8y`Ml_U-w+Fp|?SCSS0 zx*ol}%|n)z8pfzyK^Hz0vcAcOkC3LBW1#(1Iy$Hwo*6Y?;hWJ=LbjiJ_dqDY2^Bom z%CAaJg|7KM#2JNaZc@8s%Ld~9Qmb*)k|8O!R(yjy(bZN6$rsX3NAWuMGkydqcE`lx zN=dFo>a=e?6lzvH#ZDssqUziy4+?Sp7wZDcSD;aucpO!5EH#kSvp*TTvbQdyCoIPC znly!G4s1!C^+1U2h;8ndB{=UDNmSVLCZFqDKPn0lVMD?Fpu^gLqy3X1$s*x;AHJ7I zucKcsl^2kMMUK&V!l!QlJ(}-jH{JX%ccUCxT=I956qbX6+3F@;U}x zA>}Ku!|~6Ukhk^xMO@$=;jG8977fYL>hSvCdFJ~G+%os5MO_D5mi3g4_I6+SO~3y; zRKw+omlJauRL?C7Ddj$BM)Hgv12PrYyhX>vsKP;M^n}p{; zO0Pf%FhjI4i0QYF;SDKs`paW3pS@Nq6g_4m!d<7^%WRY<)k@%F?O-&VC1A9NP0dX< zG?ClfV}t#K;Aya{UhTkAVISmlbxs`=o@bC9JkJa&of#RhN{EH0JpUebBc(piuNUu# zlJcu#$wNrxASr5-2nda{ZxWhqWU}U(n|_B(C7%7|8w?G87R9C5 z#ei~==O<&(9(a8G2rlHBf2&PY0wUh(x)Xx5eGF@Ai+c^76FJPoaj4>6?a|5{nKXkq zNQ+xgVvk2*j_SoKh=%znKO_9CiZi?FbXKAP3uPeDU&ghFU$lXSKKk5-Z+)swR>wkZHn9zhk{j4ZVdk}qew5l(oy1y%UU9LjhZE3^}{F( zaX;2?k&eu;^_>1b+$dfs68@(u0fp<?})ElMf>ma z^K>wmvt3MV?+RqzdO!u?Wbcf17dv@M?yOHP@WTc6OwOG~sm;zmn|{VWUG_BvM; z)ele{oH(#M`lS(L5gR^^q=L;cJZ&pKEn z4;#eJmt#zTuC>En}U83pOnT_iYtQq z*2P0`J0G49{DwEC{r3oLUPz>;b?Q8?`}GK$yXvgvaYh4dlV_I<5N1HfzVx|mM)|9o z5!x#2yg9cf#x-Hez3aG(8mI2Rg7(oOwd@{)9r1=s4(tzgA{DU8VEBIh$Vvxx^mzY7 zWfryH(QJH*v0PDsaI*&Ei6mFhZiMGXLKv`Y)O;&Vm7M9sX4i`s9SF5eY-1EV~T0i0@rYw(J>Q2Xu%7be>PlY>s-_ zF+acj%M!NSHbM_NbpfgQ)+7#tzom5P=&aL!Di?ROh_~&!BFl0cdG3(hK=H*PG7ojazo#o=_i~p#h=cyxp&oqW_)gj6^pmGS07@OfRIqKMC^ZJ&3lJ{G!{ z#HfY=GSVMhfW*G?XRd0Jn`354D%`Q73kbjeClba8$Mjm^W19Xm$1>WnY8Wsl#Oh!p ztvC%B>N(q%z~|{te?k3r;5jDuvq9;iA{wG+|03Y`>k`MJT_z7?|Nlq(7+4rO@pcXp zK9gMhT1?YBSwAUr@E2EQ6-!ezLq8KAK?*mG2aX3{Fa5BsDDLVMft~L!{&Auho(6KY zWOX7h*#(XPW1{KTKqLsM_~PxyMCwJUZCTc^zh@BFN=A=v)R6Oa2cdvY)xsC8&(UmPu4usIh=^DI54*YVT{cI4@D?j z*tsu}F<=p)3ygGl-H&cw&Il4Ko#8Yyd0Rr{Kg(93Ax+_3&g@w&1RwhN@WP7CKbyKd z6%;_aS?NT^8538sB@5E$G0XDNH?Qhh(X17!2E+^YBB@apl!qeqNid@8+RC!Ef2&4S zOnQ>^2EP4@0vcGasWV&F11DP*-}uN1s8m_0?gBItzaf3E9i&q z<+xGow1)4OSMM3@;|XTeFbH$+1RadSsGBf~O_!F=)2qAe35=@|c?8-#{;0Fzn~}cy zUzmP3HiY)({G<-cTJ92_2$6(#f`;mjwVL`LHWDwjEF?-VSZ0S@Z=nb2S^w|(Hb$pz z>*-{Dz(64|#E1$4s9)Nywi0RBZ+E@9DM~cnZGhXRBDm811dz7-hA!j zm&W($NxBZRm11IFq;Q`P7gDYh%^*s->?WNcNJf&K(_5wUd*eu6B@_ngrC(PRT7)u< z{bpjflBa&HJ&;p)fvcq;umZK{3l`28CKeu#X<Ud9fwawT|IlZ%E1x}@F4udD3{h#?-7()s` zrPT(c$iuO@)WF+M%j$!$dcl|5!38C($;ZtnCy z`O_~O@Y|<GPH3TVeaxM)q<+{Kt?h)({!WMW8>so zmP2}M%CZr2g?(`2!RL7G42**WP*ID3p>b7;zA!{_@N~Fg-8-%YZHiEO*bpFsac#b&|^4;RQt5yNZpjUHkKay3S@`d zVnlmiDeNa%e0d)DnL?1m;`#Bg=LcuQNUcLkYV1r znTd`VW)`p@(JVXc3#xA73PXyNE&5;3e75?5+nB@NLdK)4>lc-tMJcLF7nrQLdN2cM z=a}=>1`Xqg-TD`~?{>;Bcu)|*g2hc`=M$W?2Y8}5=q1yFUBEeUKGqwC`k zfCoe+iJRrNCz42pX87tR|4Xcj5Krs1{gBo{V+-Z-#h|#b6v*H-w2cLA5H7w41(yCX zq!E_ZxilXo1s*$~Z)(tjWO(fv8he1I@$qa1EL6m+y<<)^4TUc#TpEhgc1DdPt{>=5 z*$yebyuoEsK~^ua4wn2#Gb88?FTECI{)CiD?t?s;AtF(zO{6HcpxXsM_|^yIteOM|pQlx^!d7%g5j{)LL4Oj#eBP>M zm_qF3_tQB>uQ=l8s=dak$p+Wi+yV-6-0)iq0jQ79jqOHN-VQt--=3lk_afF2;M&Y_Iohg@3r!hJ$ zhxu!+8(gf=g|yK0*+?fS{1e1bisV+{J=cqUd{1NFrw?@y1YTs^M^P_uvngy|SWjp_ zvNdUr`hVF{&<;O{0V>D+%|BeGX0JaK$C95YBQw$G_&bD7T;wBAoMVseS3Vwy+_ZHL z4Qhi&P&WrPU96E6=p#_H_o>$rR3`~>KqsA?w0*R+eeO6TOmjFmps zG`j6ZZmNg&hX?TY;^QRvX_^E1QzrOLt&$#2WY zJkhmB=|g`s^fY-HU)^X1w7(<*YCw!fD4P6vP1DVljJJ`_{mkO)$!=!!yALM4 z&(+Fev|PrZdV{TmFug|8@@4tUOvGV7+I5(@7jbA1w^GbVr~w07u~(3pA@!}ZhWig0(6iV%}) zu9>oNA)og~7zqI6G{jP2i*Xs>&XL3?la!e}x7jPXe+1eOj?LbW+r-$&W}C88tc;gB z2jqi>ZF^FeIGkFcf8||LTx;QwP?+6Hzg?&@S8;L;GVs=aMb@@LFJ3c>FGK!rAs}tj z0T%iVkEfta6n+iyIzJ@5DUeKq5UpTcBY38=$DN%2|29>MCdn(pDeP#|kIqoNaMk~C zO+FOC`^Oy_?ii-vtF>c?l>Y8{8p3*39{?_@&TvR7{_=wvUzY_5q!7%h ztv9&luMt8%Ro{^dhH~&nG+vepE86fC*-c)@o+n5ppbpW^0cCJna30>a?d|phT(mnm z!5Evy(>l3Ysu6InBV13!KOVZ<0fRMBS*GN{cZTET9fCBo0suuoy1z&%$d8@!F(Q&r z10$ebbX-rd!z2|q-ZGt&2R zGKsnm6LA^RQcWVCzIj+cBbk4Im{Xn5L8wFfm;?qFlM3c}3grcr@klfbZFrl2Uz4=j z4i^~P_fP$a%_`?l=qJ%V1~1Ldb&%FF&Nn7+;wUv#^alg^i~S8(&cjS&V>ub4;YW)Y z*=^7gSla0|ba-UjTZzLRW~L6let6vyy)i`Qp2&>|k(Q?MI$5Q+VKGitZ>i#;TA@c; zlBeRwFb37qYY*+NAD~k;2b8GnYH_^;8kTRzJwN5|&)M?yUgYNX`L2j;Uc2#p!>tg% z*d~F&m_-5hbgF!7)gFF(4+zEUSle$|+E8%uFXWNH+?5Y<(_Rv{2x1xuep=KSpgMin z)vXNgtpda?ANsPDfQ@<<(ZHY?F0t)>7vZq!#zQN?kvwS_GX+-hUf*^S$m1$=ZxXF# zMP%%=0;LT^WS;e)53DZ3Qh3;ec&YF9a!U%eV^lsj_OY6cnOqwIolMTM%{@ss?LYLc%>^iYS| zt!Jh<&D--U>w87nl*N}Met~^$m5x%u_MWq%EM_ArnWjA;8*O3$k4M%U|A1Rd9VcZ0 z^eP_;6nd|ON?x$JzXuo#Hq^{W7GEiEfkVMgs&@t*WKI%CyGmwD@+(7ad^FpK88~nM z2AF>#nAo!7k_l;C2Z2c_XOXNt&&SQ3ndqg#76wZt7dHljJI<_9(FI4+b~DOcsI0DD zkPL)3%lVZQVe9TAQyfPv+*^Dv&7bs3D$zbU+puGLhJ$Rh!?((_J)63V^sOr>GYKQa z@-;QQK!~q*+|R^ko$OP*fQCq#t3*M`u>>}Ac*<9@6yx>TjH0Yq;*8AQu|s)3Zj_Iv zF2$?Em6KlKSPutq;h~#{M5dKZG`KPi`8RH?yoasd_iNwYQ^;Gv*AI|ww(p?>7mHzR3|>}$+ex36!j2e+GxcB<5(k0D=(5J8xnTNQ2>PZ2gHWX zp%kUXqj*&NzAg>uDV_Z+wUp~83#_$JeVB-=+`l0vZlc{9O$)A8mD?rrS1wjfT?3yh5T-uiILFcBim#Iu9c4`N!_*UWyC2AptoXa&lZgk!A?jSiB z^5~0~_#p;rznuTvR+(ImCNPpnMuGre)Of;{c&iHRK>v8i=V05cH4vcipJ1 zJV1`geeL~=jLwGu5r89`xVVXfgp)=V&~kPg3Cz-HVpaJM>!GkUn3RONN~!>EVddLA z?#WYxt2W5$w-*}OK%KaF-4afPSYY9{9U!+^W{r@zu{1sf;_7yfp<3hjtvlJ1W((hg z833>)17_RFTIK^-!Nyaai(_9^+?43Yyd$r7dYwM!ug)|)zjtHrCT##g<4V36XPOzu6k>R8vnn<-Ei8? zO^jUR8B;fZ7w%+$yM2wh%%K7HKuc@1FFRv$1^HpB7JrXzPwA-5$%8u< zMJXvStKn^b3*QO6>(OMY*sZ(4Wil!FWoS2?d`tJ(-&oaA51RvwFzL_CbT0uzlS`>+ zdS|R!tC*}Ktn5_-7pRCF5J6Nr5>T}_Y(al$+=Qb&<1g)2$+jBJ>}{eu3T4**V7;}; zKf;V5`a}58i}qkLq{g+f?|do*tUAWmvbkZvOIAWw(ms0%QB6tdG8V?z%z?X4&S?2% z?Nx`B@~TR({R)|L5cVr^SIN!92d4TOgIYM0psy~7I0PSTRKeI+I&&@2paHQ&-~(mh zQNGENw2Ccca!_rVS4sEIxg#g=l?K2L14&|4Oc)Rev|U~k_8uEPUkMC*)L??4rj7jY z@KMygl^$|lBOD?;8xxltUTBYwzo36`G}KSoEZllp@T&`=s%P4Y@ZsU==Q z0xfEc(5zia9uGe_tI;$hY7Wp&0vMrE+N9h|9alBLoQh#_+J)S#Y4B+miZcapX%CTT z%j$spV?I|l8JM~gXWDCi;-vwOTe*CEB>TesoMUH11kh0~f3Ht482l7oy{;MqruD%V zZ<2m*CQ%r}u-!f}5?);c_5EQ#MH%#&2W-ED-Tux}ZyX4fz9OErdl)>k&rAG)b2aE7 z{}GWMZJ;DR^|o_b>#%cLH+W0cug3l?TKt+U_E3WvgN{qYD!4z@vU3N20v@@jb{Dz+ zpUy=XA#ONb3JWOaQ*EDlB8O=7!U=&t1olR@(fu2#!8E}nIG=QPbX6Qi*{ahPBkPM< z^1m|t5lYDe9(S+gnf1?EB3ZOD0?M|89!nXoWT)0Na4tUwG4#c1@1A1$a?elCUqfFk zE^6W~6m<^t%3yB~np7;Y8t=vpqPpm*_3!b+79a#8C{3BpK0fq8+~y zB1AWL>JEiwL6Oauq!VLz?D^unqT}Bpz>6UMV6t+{l$-rW`h~%;SL7?+$RFcvfsK+~ z>c=Nz0UP&rQIY@Prue%OnrCcM4eVrIK$%|6WB3VCf%==^WJ&r+=uz;>q;_u8n4Zyq zjjAvNS$D)l^kg{%9_NY?2)2Xmk5Y5y2C6n|aB>VC%vT@^^N0t5O``?;o@D8dsQDaq zM0HpUz)2`_=YC!x9Bb4cDxh2Z^?KRnS9q^6giacjQE3;BmrtQf)^7f$3goYaotz!r zy?WH-fZ`0;tX3`ZeuT%_IoK z=_n33i*`GwVz}PKjX6>UIyc0)Zk9on`aQaInFeTS` zm?OyhR2-fRHX`h-*#pcRI=d`B3TmO1Y~1(|otE5?jf-Yq+a96avc*ycst7MHD^;4k zLsX}Z0c!qREow2rPn8KKjKodU^m{-243kBGEpS?cT6R7^LdrFa90&A=Unaz@;xp8t zx|Zp1ZkZ|Z2ky03Y)yX)4wc*GQMnw@)F$ZLBvR&n(@p%#JippPCr&+ z>@C|r&!V8=^~RcZp(+qS#P)+C*5f@Q7*$1jkocgW<0a?+)+*;8mbXb$1ZYnBfEyL# z`1h6kS9Wrtl-WjyLf(uMKPCjr&+^>0U07MuXh~)3UD_v z9GRrz(7h$sb+21&j@j^acBbk9TCSmBZ(A^m=BX}Q3bvwB&!tdOQ5fa9&C#K!*{G*sjJiV1)17aM7%+ZALC$ccb6 z{1-{)Ism*1}TGcYi>X*YjUgnYWtT|J0)zWZ8%S%J1+9$c; zw_)sNX3QfKM#RTz{P7w=VkpgW= z#D7vsmC%mT{nG2o{>R7G zml%}jpEyZ3xXTfGY4wu6)4KrEqQfoB@yRiDQS~-cocqt3?O8FbuF|UsBZhVL zv>oD}T%GYtWrNA5BMMV5**>2F{*a=4T7BP;bX2{vdcNA?rr8@4wb?iixKx2)zWX)z z_32r%fygL-J#S{JAejADBS(q6w@~VqUze8CqpoKsx`d~85rRrAnNi45@K^AljH9yb z56`_$+MPuAZkvKoa5?>01d^AXQQ-jzw1gh}vYf9eC8oK@ZO@}~Gb5}mJ(skEvk~HO z@CMbYzEN-K0Z6J}ebk|%l7V;PpB=Q+CLxtG_|&mn7v7E;zLwuc;Sblz`A*ZDG`Rv0 zI`X+qByv=F!V_VS5HGqXAiB~j!N=IwMUve`7)le?y+!dlC0qfA(3R1-E1ooD(%G?) zmjofG9Wv884j8k0aQQ=U?N$(BoA(6j&dFZ73C|sc3THjCoshd&!@EhJDE*4zY`W!A z9G?z21=oy}d9Ys0#E~;-D#J%XK}p471@|FjD)IZI6niOj9I+~~QiSe6g&yK#%R^ng zH|QIn!Ru*My^$p&m_n8uSi-#np@QiKbk7PO4Q4sZWA*^*4@Ig6qw1S1aHV!k z(}Fad4m@6xho{C9F4qNE=qww9UK@7PT$T0*n>5 zK`T{MkMFDJ=FdduFDDiNM)?VgwVbpN^)Q^4C@<-Zkg0lm!y8}_i3gFS_Fi~%8OdURAe=(F+_p<={u5bjh=77UL%SC$Hf{&-*o zU0JUedvBz5tV}eGekQ8)KZ0#SO;nW|uWcW=M{@g;-mXz=BMqoHtVK$*^#0K@CLBDe z{e7u2U^I~6O2&>xAqlv`h{Z;@%kY)w>s*JQbC0>9k~{)YRN6KcAfIXUagJRz_={Y9 zrJjuD^RS|mgTKd!wiAF$b|D1>E}!+^j3J~3HJAiqt{6xx3!=Y!aXt3O+f*XKR|=jz z0it{u=Px~Sf{v4OKh?aP>HEqll6wzZ9IBVR6f0W7=s2(0YMOHrMBiocC-l)6CXav$ z%&m3e!LrnnFT;*O1EEF37cm!-UeLp7mxrp9J@VCqJIS&59!+y#vfF0#uRCGq*wP^D zZTkObXvM37kN7bQN-ih2Uu>X9Cz~C>m9@E)j;*eXkHx6JrM^vggK2zSH>d?&pBBah z&J<81woX7EveG<6Bha0m^OxGPQyiKUQYut`-{V8;110>Yi{*pcMZ|;kD3hwS#ws9f z>dU10sf#NnP;%|NSFF(){bM^?m9VEN5|h0}li%c@p8rZIZX-^60+#lmo!4*2Yi zHLJQu9s^O4NudS3mh*?XV`-Dj3{V#Zm6K8tjo(TwxT%8jwTz#HQjm3(uKZ$Namw35 zT_RNMS4xv?4o`iy*DY7x`7bUpAP0)uF?U+ZP{m3Nzi=@BK(aWeZK9w-6w>gzSNp%~ zyp}CyN$S2+?;_+uhi)6s%hzhOiRcqa2_k>WSNzlWA_SLBH-4mSn5YOBI!a=g7co>I zw}z(Y1mk+x%FQO(aJ-~>bAEGM-P+=x*47+cE)#9Jhqa zHZ%F&%`JzIbvyE8Ue|`MWLQ_9AdT$VPWI%a>6^eONu4f_`#XKKCRQ6NP8&2uReKKtNzW z*r%ux^ow;~^0!d*0~|RjQz?8L4K3c+&vOwTgI_36Z3}8pEfAvASM=%n$>$Ke6gJ5g zytH+3MinNIct`}+byQfKtt=;zdaR3UN!XCCKPper0Jns^Erie^HrKie#5O}da z@03?YpAW~YH##U;2D>KTcY5G}dHR5f$@g@p<&zw|eruMWpQMNKG_^V@B}xn>TN6fE zeqK<|snHQ500E<}ejN>TI{n2So`qHcTsE9+-TP5-m!7oF^IqhiauFeIogKtMGx@8h z!%%E#apT{nARyTD{^Qqf7vBe>k=atk-|}|0Dw4zj<4N89>TnXop`4 zH1JZ9JU~-bEz=uKxrx_6Sgq$@kyS#(3+Ll8BqwwF^$RJa^We}|$_Hu#0$O2NG`jH8 z2m~Y=197_ed~30m*A<$4!dq>2>wNL#G|(@OVPpHQ*30M@HYE%`-KK?F9KPhT-?_J& z4lM>7*X8zN=%%)-@GXdA#t`h%(&R}M%?!n{To#^G#49vf_I{~leK$yeOpM%id&ONu zK4*JvumG&)O@L7j5bx%MqeF7L(C%yO;q*tCVH}J+{VhTSN+gU4$e}FH ziqpm}rb32TQmUk%7VPalLQ-$c5Q0a{ZLl2M+6bS#9mD}_}-NbNpt{pSiex>{_N5u{k*xD*ym`Wp-%UX@NW>^#iNCHy! zr@BY*rHp*`F$=S3Sk7m&1->hCX+9FcW~T?=9OxS2@j}j_zL>>oC^_=*-2vyfnZiBk zI{+=Y%N`bz?mP#ePxmPGK*P>7cMM${*g#%KYNlzNikI}ah-+e_YME4un5G}5n)1_K z(j_g`{!%s1dOXA;kW&u2F3Pp!RsTqH5|18Vk=j4bfj`hM+@;AV^F~Th3_G1FiuaGz z+5^PeE)8wTg^Lp{_V*423cO09N9nChq6)m6lyMH?qDKV%vc-=tLHwsb2PA%JK~j5K zz&l|HqW6`QaX$Z~XPF)fiXZPhAga3WSjCYv?gx`4l+zF(%M5EG1`2kXG4!~Ee?X?A zr5j)y6d}T{3rEzfwWYSj8@=qo9e(?hqb^_2J8bFkN{-rDUI8x`b|)(^#@EKE{buGB z_QA;%#aM7(a1GRfcJ8cavVNh*87>ec@2VTlhxNT)$=#Q_7d(Q5<`}lC&I9^?vuh|| z2jK#lTNC?PwAUGWdEISOOMa`CR4pN#r^I|jm)r7StUp~BwXgd%ZZ=9g&=&G)y5FLq z2sQH|T@mm;SZuF`qU#y4BaeL(?D~6LjuBj7p#2xX-VBtoT?Chl)Jm73hoESkhUC#t zG*97ZuawznJ?Vp5`l{D|>&2Dg%1Cptnz%eIp8@0xj?{o`vS%38Exul4B5^6BG{py| z=m8{_Z?6kcQK-u=R0FFG9P7GrJJfL>d|@IPrh#dSX{C%x5}aM@GlYZvqI0Gk|evZY(z6 zS#{kPapo=4_9y>mtZOAgf4T1j`dKz9RR98=sjFkX2lp-JnNJ}Y1P{B|aMzL|i z0qKbe_oJfw6$^SYGZjm;I8oFZf8iJ06znj!@>XE|gKU$$+wQTTYMd1&{9L)Ph9%_M zN=lt?^t3UEj-yWiwu6=rnJdS0O*xw{KQ2Y=ztH*6=I}&VuM)0wAXIr%Vuxw7e#M!| z)!4Cc+f%D>5u0dZ!?JQj3slV+%}vh) zyt&KkYu-FIs9s0NQffht?r)+VU4LM|9n*pY;;tihhA?=U#oHP(5+5H8w|tf_8_z76M7a%; zKN2Sey7dB3y-bGkzHBkwlI}ugRAO(Zp6ts29msNn!j_Z;{vIAprne48c1r>*`j1_X zy;`|HjNc0L*4AIH&Ubcgb0+LQ+?z&JrUZ$ETEpj2KQ%91cZ7?`1gmsS`WdX~kufP3 z*34RqAuG&%r%W}kVt5>t-0mzupNig2mFa_VR#axxEN z9I44zhax<{%@v0*)SdWo5k^n_64!+ZG~s!6ykv4r{cso1_6JlVdDBPk6#A(+_*Bd9^X?lIO3<4(RW%K`e|h0QIUsdMf4!Hlw2@ z=Od^j>YF!?Q8JTr{75z|SEA9vva}NK8^+-%5LK%%47TxU&1q@irL~hEUH9o5LW`VGf5hlm$?M<`VP!m~>-Q_G@xmiW zU^7RAp(g~rqdvzb2_I_=5ca7LAuOP2A#&&kH>xuADUrwp)I~%rnO;kHEmkpwEQ)t#_AQqv@5af6CYCrQR0oL@(PD%(GR}!6f4KbI5AG^ZY zG8pmXesUn5*e^^u_kraBp`oNgHGSc1$!yRHT>U~lQ3rn>2jqbY+kp|}zL`1PkR{%i zI3sK(;&kO8J^>1yM5G*-R$fnB$|b^f-O0|{Lc$N zQ4A8mjBFBFvB)ZMq8!;@nVRsmM08!`YELr;n_}Wd&qcNtdV2Xcl)*u8kVj$fyR zPohQEUp*yy*kI?O^bY}~s*IB~=1$T_^ZRD@m($QZOR+8Gh8Rxl*~(YWhlt__{JwP3LUo|iu5lP+`yBa+KnBD(t*BKRM z&{<(Au}-9l2f<3k>({H);C%Z+YsFv`knZhqW6Gx`NPc*}EdTrnhX-V!L8?I6Q zIQU{2Fe&7wIK==<6JUN7>RvjzH4bkNTeQQm4;Z*#e;p7WyZ-Y+TDp5sujC4;NX^3G zNeKJH*ZR77&z~7L{whT8VWVYWc>RfF|H=AT$H3i}ok49()4|fjE9-36#*7w9Lar=*xW+xkt4PV1qG_S!# zCrX5}ZPks4s$N%nOjM(nGS7x0@~N>$#wpWVMg>|?{qm%_`lkz z)00C2h}2Vi)Bp1+WNHCup#YT;{&bZyB)I&lq0{J@IqV?t%J67c@gZbF=&uIQIL~Wa zOIv=~OSNu;TAm!$DvAP}?%17vL+>)dGi_|4Y#u7en(>tl$6Q2U$9ctxn#&bYT4zn? zv^krUT$kJ}wl;cUO_MhQXee+hxI?S(pl*fzDfzY?#f7S!i zk5l)PiB*u}nZKpiRif`e??*DQs#RITmDn^gQ z?M~5-aT#Pzh@8-DH}Q%PX~jTUNcw|cxu4Fg88tGry`|ZGv0LJCi^>C5q-IfvB zIp?Tv>(;DG2&~0vR_89bzQeS-aUVb>3C> z^P^PeGe|gc;pUq9&`=XKY=hrOOmhb=%DK9g0C3%4K$35-{$s{W4g`rddUT^+E-ww0 zH5S@7Q~Pds_Lsf9J!`H0L1?ia>{|ak*4jc##_!CO@PUi}_;9a(#Y|7aLX^!xlHp74 zKOO__&tqtCbJR%3nGqWv&g|zdV6{L3}dqJAH#6QFRo*@1TH7Sp@ zk>|sB%v_9s8iwpewKz-hABKF#bY{qvmT8m?#R1r>L-MBGrW@miJ7 z?!Lue1`M~oY?GunxStA48lo0Vj4hmB#+u3WqOT7kwo(cMwZHI?HSL?h1kf`dY}MM zgL(H_-B%E~f2|a!srbYl5WS&42R4K=KEffnoPcw|7}E^J9F!G=Hfg;%4O^V1x&_7) zE_(d?oYqD|hfnXBjgXvNq!Na~^4dz-w7T%}=vk#TO}d`K+(~6JHA86*{ah`-vCD^0 zKF&8+*x{PqzoL+nc#_?(BTDuG5ZpJ?UHwIK<>pj~933?7=2>7A0#w@sZtI57>n&CN!7wsrZrF(xq$N1BU-@4sI@rD>f7srAN7z&D)uXW2op>d8_1*t;Ik zY~7z7%T){8P7X>d(jh2)M+S`JV{ZP!qM6#Pt2_*2kt8pI1KGiA?FU3Q*V<8U=})sG)}9c7zy8M<;wTB~KP1r6rCIzJfM+XRyp=S(5p zupN{Ky7&1cK|{~9vE;eW8F6Ar)42$&QtR{td#+z7cDgnn8pEI z@ssR!b3aB`7#U?;Up83}FPQM&c-}_!`U7qY9WEdv%mp5s3TTkvX2$)~VF<)((w^_! zo-1!vd82R-R11sG&H#+bwqtG8(~wdtuu%y*aD6F zz%U%bdU6@bjV@wH{m(1ZKWAwLdUl%$GlIAqlG$geapnxli`EiJAQWZtOX%PV$_MiM zj7B=3h{?xK5K9m522rE1cxUg8!s^0p4q`VOp`?yb>Y(GrhZ*E;+u`=s!dXtJ*>G2V z=P4tJ(c1$ByRFLH5UIpJ?G6+z%@;QYx=<#?Kl><=Rb`L==pEuAy)7`1HTmUPcr_JK z1>YR=KWt|?0jRU7jv6*x^S#0%8KgZb_OHavCF9&l(c>OkA?dzU4acP9)R)B=E>u$- zaApP%N+ywR*Z)!*D5GKRhjm(Le|yzzORklLK4S7PZM17k=e&!QJPtzN!X)#PErFjX zvc+e}ETJTsSY`x;a&q5Y`4}$K({V&iSj#!D zNEh2Vjl-x1P-8Sd8lM>lO6KZS@3k3AUy&?DbwW@zUGqoNA#$eftSa!q1KRDsk>9H^ zozMlobR9alFLhX&p&6;-kOzBuO)T?H@M{lM-XyJc|4;fKlk z00ZcOneL?FDf6Dh{sY+c=aWmE1#1?jcZW_tXs<8*#*n0l9?Rkh_$<;i(d_sjL9Fca zh$HOAj}dEJn^K?df!H=h(ohRTw!%ND{VNXIK$AoP#ez!Tdq}7|ItHn`=&HoqnHT+= zQWE!FM}0yvnbFe?Lh2!d%`tRbR1KO#<~fZ_E0GH=)T#1`fI<8h<{zH@hQSM0(>(If zwmIj9Z2b#AS4-08M05(+dTz%#SWl!$zkeVN3J57S_uy%P;6Eq`_N2>#!)kS-sKY!; zDmX1b+eh2-BPwq16_4SJlqsi+dU{4iP5QJ-i07}za4s^ul(ks?>e{R;d-djrR)C$@ zwGsE{a`v<`04>A{K*bU1U#(xJ$7bHU++oOPPlz5a>B1q zYoFKLfabzNB^`rtNGT3|p*4XLC<0f5P|*S%2X@3Hr_S^92*eTpg93Y9L4NDUwO&zv zPt3}s%&^;xp<3HT6$Gpn3@4GA+xkLP-6L>eE%b3y^};?2lKa{l+$;fpk(2dfGJ$Bm ztf7F=TSt8bRLqsf&>MUU{Z!0l1uf}sne7v5?lC(~2Dwmsz)0vVrhWbY5F_pnkFUo! zW_)ot_?Q&N59{(IR}%8&VF%6`Qz(8Al5C_BZ^)t0YSd_YVVyaRTi35o@hFcxQosYT zyl6kCrg@?-vMz?)hf)IU{xG~hRHvu&B$LT!WuFT4H(>jY(SoJj$FW-r8!hW!mvutP zP^R49Y%|hSI0hU~Tn){HDX>kutdlgsuy|Y_d|h?xP<71TC$Li{T-M)YfQAYi1c_y_ z#n44C$0=-2f!Eddf}j7W-y(L#XNmvmdv(wOr(c7h0_&Uw1&WI|LZ8{7{H8mVa2XI# zW?&qJV)YuPt$W1u3zDEh62Zu>m3t=4Cxi0nqAH_V0_b^k!^vZG@HWA0-yBDh?o1G` z$5&o9%=tL+I!#( z3@j2YWzy6Wn$P(%zC)bP+dWUc@lsC+9AtW=esP@lAe$$Q4mpBfD<(Uqq&RQ3LoaIi z3k8+i#Byc3lf}HOqz~Y}o&oN4C2k*DbNHCy6&?hihsZN)lr3n>`8ju;KML@(Sk2GI znR*-x0(?aGaLxMI1Tu83PTPxv@$k7R5(JV0PnGMEZLmPNp!Xsi?Ntc#T;=?kd@r~n z8kstKqNoI${2PqeN7kZ0ID<@gZRuE*_!??(wM|ITXoF4sl;Y-6bP8`{eCp9Jt(yDl0Z32$i(WKb!s-w9jtD0pmj* zPC}CQXO~=OByGdo9?wnmNxjWgh#$`k$9@#ikHGZZshZtcLyF)yo)_aVBM>Lbca~Zu z`1CgTmYPA8{O5?<_6=NGpLPLm0d8bR_=^6_)~+2?8$Z96X;mWww~{8uB;KL-`wJap zFh}@Kj^?TY#wJ)1)VDIJyhN;RJp@->$=4}3r4<0=+E%%GsPlweOM}QRG#8Y{)3yKMfgN6F4B|ZKXr^Vx6jL)%}sf1VWg1) z`8xAEjh@o6;<=4`#pVK8;hNx(`RC<>c6Xxu&8{rj^^pMKuKo+u$6fj;I7})^ca4#| zYPk!bcLFXH5M5Wt{?<%>zH$MTgE}i$GvTGzUEQJ(Gqt+@^ZJgiy)egd#q0vk3dh# z>+CC_Gkv}_?%7_RolHNts%#+sCM($g{8$GVE*;Kw!#RBM+I%hpPoFElbAOE-cUJd_ zCa&pKQnG1hEsUkqV@Xeys^V$O4yeU0tSK+@3V^E;Jpopy3oaO{FgG(4R2DYPsSu+P z-sl>UN?Ym+qnZL>nfQ1ntwT{gJ>@1G7Q6Hj-5VP)ai!L%sr&KJswe#uTMaU_Fz$x|@NJ3v-Rd z@qsTB@-muA>Q+PS6GT{3BAhmK8WpeWvh{NVu3$2-_Nx6nmb1nzWQMBujWnbnr*0SL zZVOmqdzXJVf3r~6PsS4+(PqU_0DK^IQdWlxjHufVnU-S-QxKf~S^|ATuoO$3r$)%{c*Fufbg zitap8wFag3AIo{^8Va_^b{5nWtzbm74DfYKpX_kYUwO6jWnM9Yd~ICEd9EZks>e|6 z9J=0Lm=20PC5K8c73`l@x=7;!?9z?s%nfs|4;t;oKg+oj323x&_2Rk1Eug0c$0))QBOK3h z`eEw{s2eyA^N50qr;8b;MY%q9Fo7rTulF-0bshF?6-y~5a?v{cuY1`@S@A_``3zzX zFmVeFj$MU!ZMCh_^-Q0Cq=8u)5V2@`1z)G3f8^Y~PcmWS!$TSBJ(m0%P$5a0mH zs(j_E>-tl!+<;ks#5M$d>+n*!ZOQHj31}qwWu#`%OjJi9YTqX{;&n&u;23tCmhrdW z8HVET9L(sJEF{*oRK(v#CHbBhbJy9$ym{S{yT@zbHpI@m3VprbVp? z{-LiLb&$@gq*R@mQEjOc{p#Td23ie9XW(uN-si8J-!v@q+pmM{m&8cozgW%i^Rmz!3f(;t9R>|^ytntNJY4h00cAAsr=XhAA!7k3!(VI54dTaKs)hLx<;C07L9yN~eN7#ykztDu_8>06phE-oi!&N<=KwpN;R3jtws zi8tdWTb>o|_Nlg%KV|2yq+CKCSnXcycNo-_+^>D=I5h^`(E2C(~0 z4`%ng9-ut}jP^ZU%*=1p%4RPob<;L#_G^v<#To#(%wxdhvCiv-6v<)B+VpAt@GpQavM@j=e5uHHeiSVV z@wSsEapQ+tjCZ>5iV0hK;k>(7E2C#}*IXpIA4(?Gz;)! z2Xx+b;Ov95&$I;d*_g5M&^u}qa%ONnf7r&5vE{=Vftzvn+?f7#aAUI=CG&G9F+w#o z5NLAFj$rcrcjD>QPcIgTTCdNADApjYhHWIHnKkYgD+Z~WQwcNZ(;O5u!mw7^;cXj- z{vF0sRf7d>n$X!JiT_o~Fy@lvr|z$K#pN6bE-pyFz*(uF+?M@B=MEA~P0d&1P%4kq ztuJ0Jya$m(z)&V~KcxHM7%YZryFfeHTG*|$bAPyCdQQdy-zolP!cz@6KJOHMV6NSp zJ5W{>&4RMW3~BscQW(H(*iU+*GMow(IpK6d`IZ*W~4) zN%s}(hm%=J{@P5>KHYx_VV|M^bc&|Jl4lYvScm)uGO~`NG8`$Nhi|`8k|E!pQC0Iw z{J&G=5A+z{h%2wB$)O2z59c(^C*DF8!YmQ`vrT}pAJ-eGrD~)2MHSNg0MI%a2K&SL zD)nD95x=7(H0tZSiK+U}y4tO zjp?GiBZe$NC5>cY9Wt;K@eRxk5&`V}5x|81Hh9*1!XG0FnM5Y7Z%Y90OOJC~E{6(0`OkoYA$d&~6C7 zAIv&M^wZw!d7!Aw_zV4BXw6@djzugKsP~gaJrOl-2okgP_0C%%2D|EvPqEu!K;V|Ybh>hNcdm_qRG!im4+*O<>DzZ zcXu6sI`tJB=LjW(zT)Mj@6_Y`YYAjSYSp{%fgucLB}t%QZPS&20AwOv9_qG1|MC|ykfJ5ivBEU< zr6O6|f5Pg|*L6My-up@KxtHpyhFmq_Po|3dCWJf_Qj!h3hh~gn83JqxLtJx%OjGd3 z&@BR@n(wAu=o}N>l!pJXCsA2>-P|f}bC0^;UCxd=<6ZB}pp4!=5a#z$8y~PUCfrQx z$~ig4*#LRBhaNUveh4I31?kbMXi;cMQU{kYng{YLTg)(Sn@qsrLNjU z!z=#j{*tfFrAVcvv&zk_)S;2U)@_ZmCdni2S<3{{>7$81KManZpRnyzTd!y`ut%Na zX9w}*mKY;OXL^OY7}+3tR|3K2{IyF5?TtMVJ-6 zuZ77zlQKc|5-KK}!7#4|I)KT|0^0Y6sCbJykJvM06g}3MHGk<2Y-?o#Wh2&>&uH@y2HticKkn|r?6Ah%P<<}RnZ|9`Y$a9$Hau1js4>yaL zSk~?)|57Mb3yM$Tdq!bUdvQ1Y3Nd_Au&}q7YAD!cDYJvPslla`X0@d|EONR3JQhlp zn^6jYp7*|)2GQ2_NOT~$41F))gm8g-S4LB~6)l9|B!!`Cba}Hxg`18caE_}@BNkGd z{rdZ^=N;SD5IeV=ZzM?e6}s}kA%q%eP(^L;N%+9SarndvQS-X3(z}@wNCJ$Ep-_9T z?|~Q1`YH@u5~k-o(=VQ&}HW^W-*Nu zwfo?)c>M09B>s;0lxV|!--aOV+d3GYd-z}PwVef^;zXy_h6H6AbndJI3^rCs{l9_N zYWab8znLLSBiN7+AuPI{ZVgggL|OQig7?R&D#$GsCbe$@ z=g=fQs5i^|jmiNlBiP&al)HKMBw4xf!=@FrHw(93N)O8~FQhjuNJ6b+b?jhdQfg;q z?z+azQ@ei)>meqR!17HRU><-5PImRP(}|f=4aw?2;@)a88MvtYTk{um!DIuDWYFxj zB=1cBpI@I7%yNrn5&(g%4cysIJC4Xz#Ql5r2^uSx_{t8HWtWEui{T5Ph~nVnp%x^O zQW43C&-B^>eTYPT5Njn!#zK$Z@vWucf&JU+whIkvK7EwE|Bf9br>siAZOWhl6(sFu zQ$NSnN9R0uoR1i>nkG;0@eUZGwjPura+f{l$q7J6^c5?DRGIp&VJmk-(B74zshr-% z;!iuiSAZ@>M8cuDc&uB7xL3CZKQOJlqHK_i%u16D!>|^G>K%)K`tj57D2Q@lMX>$sDF{aMAK@}Ay(P)1%D|ol6gNv8H9@3 zXL;|rZ+o+1j@)==k&OnGT8(Y&m;zHIKE(T|wIQo*B}8yl@dLll_hWN~V-m7kgt%+) zvZj2Nc{Eel(BDz=PaDn5#-cXV~OjSnzuT zhOA7Hbf)+d#_{$7LF2!DuHvIOv*5z$#bcOh%DVna&E;B?&hB(g&ykC`#ft%&pu=eP zsUfrgmab)PRLExBCAkp7aK3gD9TG1541Z8kSCET)cyUS`JE*SzIe2_w&n{1``O=;pNJs>QFle$B8Bfd1|0htG~wXhjl zPoAgngs2v*VI%*yZ@?iLENdq4{KDJLY|w zgeI+;&zQDUY~oKHoKWjUGKCH5=&KqE70tVY$Hznz{jk;hZ}HEsF3mUARZV_7)&$+I zHQR|^F6i2fBe+J~85Zb4F8~?;^*p$vq~KRcgDP?&uFPGj0cQxV)K#(V-JoX@6v<>= zeRhIqcX_uJ6Y|$D0~WVvx1UN^5~D4-IZJn6L`pzRFWe`Cg$^U?<3ppS{g97JM-$hA zV7flipA|OcW*DeHuTqpJ1CY=0A~sOle9B`qdC&~K2%_Fj6alFfT>oW+?u}C_J?sle zmp*EZg=T9XFf|2UgiYEY{bypX=!^#wUCX9^BfIwl*YV$jGbfS3kI%vEX6%pyCzBty z{$LFbkRx%|npoFl3tZ)PwmU)Q{0{wOAVmQ0A=;Kbr~icP_U}F01~5tjkxq^ir&Y)9 zD)HH?DLt;(ZnzxuEJr!jKsp7WEa(t#ASK#-%_0hB@bG%YXTEUCdgo1BzxzUA`|EVD z70@1fHz&DI$1h8lXHKhDoq({PK2{V2gq?Hrb;AN*xiIVU>iOjPD9FY}2^K z#vDcR@Okx;`}7p#(#H3z?!}GE!FcJ+KA)H{VBlX(={0~-g2i8(G!|#Qa^a{ zJ>a8%D-}1=jv8BF9I%TSXTl8gZ^xDv*N(EX)hqC|21{ zS9?y76R0xsX1fz_ax<{F96*pUXXQY zeO$wgB7@&{*ToDElHbQsYuFVu{;4<8`uCm6Qa1mN6UCW(VLn(-Nh;Ef-) za{;dc!3lUTar1r6ng3pazzIS=f=2GjkYo=Ym4l}y`DE`K%l<0T5Q@=K^PkBcV{{oM(|Aj?dnQ4wX*t;&``9C^!Q}RlaAh9O1jH^EKlc$9UFg2 z`S8$&xH7zCe?@-B96oO{vu4kU(vz2HF%N>7Rh(9 zn7UED?@vp-C%Ha6%h`JeXCV^=|AiQ;H;XHS+Hp9D8*T?A$>(j4!b(cR%3qpYl zxeq{-Nv#3wD!AwMMsHCRP}0lVMiZ0#&8l2~69P7t^j*NA{hr&YGIHeo1N6VVbuMwj z^(-ldTS1CAwad)Ve%;uEj3x5ueHmPVFuE`-Q0^M9aq}pnNJ<=P1=`|;3u`k0-9EwY z3j(5X&4tF)()P1dX|ho*rifn%NG3qXBfpYMM~GgL97(#%tky!B4S%0ANp+iqGvgyG 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 =e-~Qprxy!q5cRzHy`sgk$(M$=?&a z1wPYs04?KC!x|X-=~K--GReZ-+Nmyx}^`0?NQ* zxS~Cqq`4xNC^Bjp47Hs@uN;b)VOWgx*xHTx1lP|4I@=e?ghzy|{r==tB8jap%&DYw zdi>EBF_qn3!dQ}%B^kPos6+4C+i?2&gLz`C=qA6KK)0nNhjv^o{voY7VSZ`+FK5jprn-C+h^FwIno zMThggSWj160$#m@ComKlLVluwX}Rj<|Qdd_Z7bNaZ6FxqPZ%MyJj3 z4`JF)3zD)7h}>l&68+GjbL)PAjMXHv>_dE?GSe}m%wj~(iFle{+iaqFZjRCiQ}qb}z0A#cfm^{tS*1RxrZ5d~{QBE8G{U7|q8AuAy*Z@=!72cls<$`0o? zl_;L+;KBeAJ8Dj<_-Z?UXOt93yYga}glCFK%&M+KKqH)@qme)-nriZxJ(_0%fhxO* zr=zc(iJ5q+M@4TQWq&=&mLuyN+*s`8)pLqVHH4zXSK-48nr3Z*7?wZw1qKGF(!sYHl#JuA8Vo?1pOaivd1jQ}=JbS6qJ;Ew$ zxr_)Rx^txr?8-AzP1YI*$6;s1nE2tqs|TxQ*qkeNy#^dQovZRUSWMpt4(qZFvQ<4z zjoqFn$3z+ga%yiRb3QwXl-dSBXi?7xrlH3`oVC{pEo(3}{D}jsa^?Q80fticNolpW zxT^*2h!%io1Op&Qy?hgnI$H!~y%G_d#5J;jgphmee>meQrIX7s?bSTc(iouUiuEQ7 z)IWlBDq>fEh>FozeI?MlARC)R3^w8XQbhIX`X^A)iz?%0$uR+REohy=B}KMF-d9@(88=$ChKvZK6#LfaW1v88&`mNPh(W(-s$+DKNBha}8)O=JwY(`w3=Y@5p&=pkxMCBe$?199c9kRlvIMdH|~mG`x}|-P$9oQ z?_rx>Bfch4q>pW%SndR854o&r;Yl=2A-TILbtdJS?lc!ofoYY8J_RMa5#E0nU6y+g zyDdReM#-{=paWcucyno$KU0H+=C>~d<$@W>nHiaxl@9?{7?hZ7qi;Er{OUrf(A>yS z7hpP#CZst4Wb4wldEQmWQC<=CbD;HaN`!~KOp2PC#^^N3@2x08{*c)RrvkFm+C205 zk5v#U{pcFAErVf&%lORNBzP|3iB&~#;U-@~-uBM5r1j)irL=oB7t76|Dt!P=Ibe3- z5f)yP(Vzrpn9A_A3$b1q30k+6scY1ktP$R`Q>+?S&$A6HKc_T#QjOq1Y4<}6=%G>O zH_cklT`jDbEdY>U{es1o!#-94lJz51%>(T7f^^1gN=ts1JzM{6;t3rOBOoXFCw>_p zf-c-Vhzu12%d$CQH0fP14Tnv_sEUdEma`Mm;JY4-?VK#$cMtdLnP~yFqD@UxceCA~ z*8bTfn;!ciE=nPLHhIO`6PFlYmEKR`$~faqKZrzt{JnmG5K2)eCdz}d2U}iym8CGg z6gtRM!Z*f)|8@`uW=F^>0;_%Qi-Q|_=% zO`@o@Z@!=J?d;v@YZbHd>ji`Km2ljL z?|M)sv59yg-MhcI>I#MWl5BiTI4AZxQWyQEpYcDv$o>@Mm=I?Z)zDxh=_94UF}C&{ z`=hbWu{hiL=x%tT0S)U^Pq{ij_TLb7$ZJAVIOZnk-7SE>8t&IEGKM@8lps*(LD?^v z+vm55(i@*us~0EsPr@E~dm=j8zZ25zvhTd}HqU6gt8BWW7RD#vhWoN5LiX_cOSDEN zi0*|mOrs(c=_53ccAA)cBKftB?77p{D{qHpOvdl^$ycnpo9XP!5NK$9(yg2wDGP6O zQ^N|HrQ8K>*rxLpMOORU3ExM20Z9SLnHpE)vZqBUbzUij`^_y%%)qMC>T6JrbC8LN z2XyVZm}vRcH%X=wF9>ykWQiikCz?-}1{U@zS?$T{PT! zA|sJNq{fDB+r--HMt6HdBLYyGky){yu6)o>vH)~=_j|J$1bT-vaV`b;c45jv!Q;%x z_~-XOq>Ir;`W6=mQm}I+P!b+Y%w3|Vz5|hM`0{GdLY3x@6_|cv6A{m=hQ0E&P-JSAMoDVC)UBTAx4-_o5yfDR|R9H zaM(r&?bOEhtibK%8jFAuQLWP@d29Gt>fln|wS(J%?>M!lwPi9Yt5Qa6a#AuI zQ}4cM`n%BmF*YCswq(Se>;B8@qkSGdx>!lr_k*hjoWi$>@qJdFwgjXoCwEH)g3Fkf z9q34zhiWsc6kO{2hk`{7;D}htyO(yd?H0V+u4k}p@V5kY-{kXiOAGQo-h6(Bxk8Xb z6k}LPA0BeZM9EffL;c3we!9}e(LnX^n%|*%wCYQxJvtI`if}r;S(L%$r?LJI{pKF_ zm!>eiHC3AZp8yd+WGT!l={JJ)LHfZ#C$At0VPL2D{$x1*G=q8y`+1Y&fqOKuEa`Y? zj#V8|C2ZbM$9Z2mB8z{e77<;J>Jx*~q~`BVj}F=GN1_h2CF9UZl*>hM?gVY0X6k%i=;kIs&`}*gL{8Y zx&E3>j14M0+V01+Ur$A^6L$zj#%#*h8NHKtcnG+{2HME^iu*YTAH4b=Nh~DvmC}^n z@0=$?nbk}Nsc@q7UoRI#=rsEIZ#J~v0=5**7ERiFP;A#eT8UpngpTLrAW^^!q%Fv% zw-^{LoU%cLu5=ZR+r|c+W10AU8+k}Wdhntwfa+DDIAca3SE)(*zv4-p!8}fi!`(}y z{LKF5bYBlzN9sT1Uh;Ivr3QhWDH)WG%&}VbR6%FhMq{RpzNg1R1=uBx*m$nb@8j(B zP(dE1jo&a0eg@>Rl)bKUTnnGpg+gt$Q0K{Ar57mxb-$rmpU!btb1GUV(rxn$yDy%4-qYunjyS zC$_Ki5oG@A9-4aMbWyw2quNyvI+WdpjSYJjkBC#=NAFCkm z5YFp?aB2y|yhKTZSYiXMAb0M7C>xt8vB*F)PoRzX@^+vyN@*9e{&F7!hu7m6tTatd zScT|o*y=G2G4VWlD98!#?@9_p}61MAV^}BeuUf?SoRjlKNe!6kZ2xNo6tJQuy-G2Ig<327V2z&`J33XWttBau3qi%AtK@rl?wR zs?tptKot-RFWuZkTvu?<Dwj$c^%9pvB1g^#k~(M122EWtOYPy9G*D*{FB7FUt>cfLuUpLSUH;x9 z1W66PJ>+VBq!vGxTg|cY%{R9hr%#<4a*M=_OgV)S$Pfd}_uDuCs$p-Pt{Np3BTo6y zKS6GT-qu?3FZWQnL9U#b#*7$ofs)loao8#y#=t>xU>-EQD!dY{ zcP>w>;9R9f1YmQdL6}T$cpYgO7CjJzmET`AyZL|E1s*gQBbAv^OYRe~8+|P&c+Uvt zf+LKn9=@ATSvIqT1n|0!m1$DI20kv_OdYgqtQG?q4I^1j>&W!K)MiK<*}{GAzjgQJ zZ+0fp^=v98@kI5r*}VE(jnB^%lsnE5fpu7NA~tTE-iC$2p% zvYnb~*(N?ow)afS{6>zd^oB}mfEo1gW)?CiWx>x!rwxw7uU1Yi(h%rZS8E})`1?!i z{q3xTZ|mBb*q>yt*Mr&;3ogv)?n?`oR+d|dW+YaE71n}l^L||Ot}Pd`7rMsnr@V3} z$+|4xMm!|lt^{v?&>4h&@SIj&rtN`Jn5lvpJvFAJqQ0ua>OpHTO?3kukR+t_rD{V zJw6+u9TS-IrrptXNZAyuloMyAT|!RXH?osciEIQGuNS(z&aFvw~0HpqI#5= z!~j)h?{lx0QflhI?$x9$E_nDOyUY{yz;13s76^~}H6gYMMZiJx4Ds|8P~QX97-*on zuLJi>IN*o@`=~n#r`&8%q`#qSR(;{6%{S3y>O<7{LWb*A5^h^7m z%Nho`Wz}~Tn)>GR)wU+^WItE1^6=@O9?xq}1ZEF8S4~iu1Efsk8bEJi!UVmNrFb<8 zq!!Su&d46q?VW*pln?A>&NgUwl;JInzrou{oLLm#1xTR*g!d&Z5ssd1Wrix!It}=`agbVlRTBOI{;(QjbkZgY##2-$@YQ-U#|-w?ilmFKf;>LASx56Sy~JdFjl!=;O33pA(;g?Y%l zT}OIaD$wZ?D&|#x(J_FQ$*f-yj4^?D_|@^p?z}0LgnoR92lpu$M5LJ-u&-&c=w75SB?JYHX@- zpt!Xh!D4uCZL{A-svGJ;09xo91`>BbdGft9J%d64Z9Rb2bG(9dWNQ=G{XnG1q&6!{ zC~@DF;Se>vNZ%|;k+X4;zC;IPT~2(o(Yn4)|BU|iRBqMjV{Yj0+NkRaFf2BYp?>R( z7nw12H#7vgx1mj-Bn6^~HjIOYi32WWR80rP-LjHiB3IV@r$HV&9EOwaaU3E7+)H%| z3nnf}!;_+|oJYwVxekE)Ma4VZS0Mdx`{8&Zt$Ur<$d>Vl;?x2r{D@v2fFGiZ6V+sF zcqN>gd8#QbS*Sli%sr{u&0{aWkvs+x{=@iibwJDL0)y!$@hkF?h11h+&JY@;L+HG9 zNo&$@-Obis);@;2?I5D2Qe@W*rvl&S7jG&J2{v|s$g;?CDd1h*P+1oRpB>N_qWUwy z&88g6eXbo~dAtXEx@KTkV;NS^>G@i;9NZ#s2Xk(N#BEBhC}eyKM!1IvC#Ojyu}8CG za%u>#MeX2D7(FJ44tAP+D+P|wCJb#iwM;9C=$8hzTdR)USrXsx0?@8*(hSoR9`n$) z-NunhAwy1l^CxrL+`n}Oi79qkf;_BGM5Wpft=vOkExWODqK7b%=#mEjFF?@0UEi6y zaGhl2db~w$l0NMlm}P(nZ}IOf@?t1sEuk^(SN3A>FtXLCB8WN!N_YvM3fNY~q$Pp6 z_vouFv1lj*jb5_NF6vj@W6IslhOJX9|AKTrGT0I%i4VwUkRq6tGd@P5U^}X&Ed@?zB;=29r9HC2WT}%LcerZ78I5=-dP02@I1APHte~NwN3m7Vn zrbP;04A+zHGH#&V8-d@NY2aU&r2AW1{lH96TX5Ki?ubq_4fV(Fn7s6*MVsSWbK{vp zIQWxUvtKtNFU;Fcr_U{w+CiUlU_v2D64sp2Moa2td0U-W1H|=K3DOp-$%M;EBF%J& zEq`f#+ML{EaS0%*uV4J@Ww&-6c_1z9;o}q5Ms_l3C)I@b3?-sEWo$b8_V0$4ahw7ONn6TWpTE7+ALtsnFfww9E(|238#+lef?MncIJ_5 zAZ&pjb!v)p(2mT561&IDWmjkAR;3cp$n*hX81O;1jQPj$rhZ|%L?hTIRmKxYGY>cl zJpC2f$LpJtW|Ikn#K--CUjrQyM@F;iYBh{i4j%)#uqIfb^Dtm$ZI7>wDTnrOFd*cd z=RAtuDSqxe1#>MtqeugVX=XU8$x=BhV+574q8plDbr5*|4SW$-Q zcDEsCik`C_))BQ9JRm{%S49run6bj{!`p1ns^o9tXeHHdSqtrUTn_rJ_&(u->z8;kFP)2O9ldhmX+^K0_E={^sYgTYCLQ31>$i!3- zPc!KRi*nYUL;)}M;#mvR0G}z_#V((&Z>=8wg{S7La4vGX@;5<0-b8ezb88z%6U&d- z|HfRVMriC_QCHIn8u82jAUyi2`7P(#Ulc;NLSFz2-k_OMSd~a`EM)@f!0cjWt%y7} zm($4@lr%9jLuORoAKsg^IcP6M&7^g`gK|_YKiimN#m3HhGA} zQ__6D-rS3(oM9;&sO;~6n=L`$ngr)0mO!vS5sjcZ|Gg-10x`e7S`~Zz3Jop`ckJ~g zir58#9(dANYn*TBoYJby?WL!Bqnn^r(#0)CUC!wkdC@PNgH*R-U)R?WbB-1_8#hs>|OH^1?%+<=T zomc=&NpYiwgZ_=A>BgSC1NG(PG!&5&w&Qg<>U>nBjCsZO6Ev|KPYsS*DPJ;{Ke6M@ z(V@}K@{mRf|10}VGh`?g$z_)uWnz+1XCmDg(BFe!(WozORbY^#45;DapgVV9+{b+q zC5W!M2FW0F6PYOJ=|K930XPnXGSNS3Xqx3fr{~rrVD5w2cR_{YLiLdAyj|N-BEc5y zUTERM%G7R{i!i0YKG14VF=}9WQ^HBEGVSJsDu4kPfmy3F+gK&<54OKP1U6;Sa6ZaU z4VPq^t~%(bEwvlW6^YsI#?K)(ydN)0CceTX?%>&F7Du03Z79J<(L4w0xC|+W^i+Wn z+*~7}sn3gK%*cBpN*{eAQ}>c{8j^?{1CP5-cH8(*C+5U(6r9J~5s9?0lNKoAesi|r z#BJd>9tth$U&4a=J!`F2E{K2(#!O%Xy7E)`-U5!Sus)bzsHGI|PA}E%x7PCQj=0s2 zfz2Oo@LOF-x;}A^$(o3RzUEjZeqf0t5N`vGFNygaVI7?=k(lwF>E$Xj@x?(|rY70@xev0?l2$ zT9|eD-WCsu^uTrm``WPsF4=6X;HUtJfcSB#XXk4xwSOi&b5=Qs#We^Cs>x?l8_K`_FP;&t;e zQv4=7JY~;%i52wcS$|6W5@YUi?2q8{rytlc6_m@|VFr3@_HKY_R-HPrUI>m^wkf2( zFP4>;A^}PafTq=!I!`1Cy{rt$WcynL2FwhL?JxnNDn@^wcTTyOl8ASJ-1?-2#>AYo z?8N1LSP78$`j7shoc4L*BDl0YhJqN%*9%r;XW$JB6^(&1E zOw96Fs@V;I^~Zf;++SOTn-b8Jq=l_E{*jN6+9AY5i5CV%~5ET;5?{ikcLsm{o%?Sy{5n+clO#lx=%~Z$qCT(sE)+PCpi`x>xI? zJ|w+8^4SX}vMd`E_^aWydOC=cIiSO9M|XFpgHTbinAdm2wN1httuAE$ZscA1ur4SZ zFFt)%_Yy$-op0HZ$e$p5&24V!lTsKQlj5Wp2vmccw|Y`J+bx1(X?8llE|@J!v+6qQ z=UY6fRpo-iq~ZWkYLj2gEXn5J?n%Mk(bh(QVvsBS>|vqly(46VKAs<8r?=7hu#jy! zb75@#5eBy8s19sK38}&K+)(xp<|9^?bG?2bay=ICciK=g)F=mUw&rjcDim8L9dq_1SOrBpXY{%W?5Tw`Z%fPF}a z#zkzSRS$M>hQk;jJu6`RV*70ta=S)V9+f5()DX5fel=HHFQjLn*=c-&7f^Af-{8ysEocDx=8SH@5n5kDOAcxM9{prmOoRI+vI+0oG1MgKt zxP;6UZ9m9wthjPo)l}`&r5BJ3jkL0Fi%9GI%sM?(ehXDWQ7&JJB~grPD;6%{^O1P5 zTDl8zQ9bk@?1Spu81s=bYO081CPWXq`kFXc%_kN#3*M4HSymrEIL_`{h>`X<7DSpN z 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 OCxZ-wyoe=7F;M=^ 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%0A5_F7F-z&+JK{i< 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

wD4Ek4s%TN8(S&2EzU|fU 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 z zs31X5Y?O~CT}5V^J9~WoEZx1~;uis1WJpN*Jq7_81_=T7l?ZI#t`$01?Ku#7bPBD5 z*5bP8f8$80SIt}#s_55B z?XAm{WWzX9@kCq1sP``dL9todO@afS2=5j%t_v8O{u#et;_`e<7h{7s_U5}!pAnBN ze3a%=7+4Y{G*aE8SoTNkMYzfT>|`znd~EJeKUBgc_C=+fqbk49Jf&^1d?0GOF}j(u zaN$?jdouf!M-<>g`|qD`>KxVr=gE0L8nX`U5+Sc+%C9J1?v!`nEpdt>e?IOc$$^-6 z#HdopW?$qg%-CjH1Ej@b!|g{Fd=XsdzO}*L>O=r|@faMQGIDiin)vX^g#@Fw=nXM| z6Rcy8@OL>I^YH17U!L6(A0Kc4ji0t)7PriT6{TfnGE*#-)EHarB7d_%dPBs2U{MKm z+quFiBwmI{GyxtjDoxi62%IHXEEB#!gwwVyC=1O@%6X?C)fQvUr5aVkR~Al>8J^Y= zfqnl^3BYe$P`pVpoRB+{IxrnnLf4KRi_>+AR|O1g0&tQnNYUx^7eJIurC{Z7FNs-q z)2XBd8*9hPR;l_wicZv~)*3#BkXO1_+-!?D-iJQ9$5)`JgXg> zLp#rKakDJNASc-PVmnuI+vA%DL8P|b@3lO*&+5=6p|8=mOlUuq&kUT9Fx%~k3#^I! z8c_NIv!hTxj(d893b7Ggq-NvKaNN}uXltGMzn`%>6m@CN_#Xb%FA=vE{|2ixE0iX} z8vHqBtEE4lO%-NGB+?_;8-Zrw+1-DePIU>r0)9n3q{3xQdNOjKyXol?r2R=_No+t_ z`Md!5@JfJF5&yd@(1fD`xWWH#hw}0u9D?RS4OWZro|{i}9rrSLJl=rb1*b6>Pg_!` zB|xAzNG1cO*q$j%EGx|6LgP+GjYreUJiw7A&?ajG^I8M7Nj@)0M*%eJY~7#73bs|7 zrA#X7HHbC?Hbc7ifNRhh1hZJDvpq}r|Bxb|Vr(J!I)7r$LY$!+@p z?nW4@-Kt51{=0NT#oGF0s#B-@W6aGR*kDzKb`U+v!?}gL=|IR0Se;0_N@&_8(;J=AE>CJ0nt;CJl7Ka6S3VzF_&9} zSQFV!DnhQVs1M(%K^e`Bw22a5Pbd`J;8ucv2Zla8T51ifLf<_j3hjpC19xQ%#4O{( zwRUPZliZR6t;M^b`QO~B_sn0js%hasd%Qk6w)rj%H`E=heh>Vphcl~DTfRy4>w&7~8 z$epQohAtzQ|ADVQcW<(!`pz|bpOO6DLG{|ViG46kv_Q7~z?SS3Rn8EEz z^mf+Po5!0XE6k^J%Q}4#QPvC*IgD0L7fl)*GH?g-cs?|i0Mk(h7r});5(JE6ToM}; zpM#@3oM_}DH2BGb3PKXLKZVe z2sGcU1!&-+%xnXk)8KN#&9N|{6_Ok_B5E#Mc2%yPHFy!hCmQX2t@L13PSpWHzM$8!d_ z+lx}SQ~7s}gp_#k=PU~<+6pD2mIXLpLKtb%kepJ*482NP-B6#=)dYB&*a5G*|Kfm{ zn%RECI7Okc_7Fr-Eg}>C!lp;61-)XX>$mr{h%S_j|KM3#{`pa0|H%7uL?u`F)b2pI zueTbtsyL+o26fj0=6+0wW{%&-Dq88FP|G`EX~qqPGeDq-JKZJ%TY3DV2t&zUq_vE^ z$a=TI!VqfGk>y^GF@D4<`B+woocTo%z^Tt_QI7L;{}lmC@9bFOZ75!4@mRfHX5w*x zaH$)H!SMDS-?h6>1u2e@G_W!2~r4LK+Hj_n5 zM$#^G>%+Sy)7oY98YT4qbb9=IybDHa;t{JPaF3( z9~O51o`IQd&k+7!kyp|6bhVzc86nh3ESf+Xl%(WLPDjMZ+*~5A5_G&GNge^9R8@GA z!Kl`JJ|1JBD%bPnc2TF-=w@x!@&$*EVoxPQT^}lKD7`X9{N

+V9UJ&g2rATdwcIYsGrIw9 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 z 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 z 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

i;12Cnv-l!=_@J@E}kzGB#fUVM9DK8u~I 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

6_kPlj=(Qu4>H}z} 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

0-1QATO80A|w#k-M-U& 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�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 z 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Ç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 N&WB5}x|9^}{{ZHrpOF9n literal 0 HcmV?d00001 diff --git a/mintlayer/wasm/wasm_wrappers_bg.wasm.sha256 b/mintlayer/wasm/wasm_wrappers_bg.wasm.sha256 new file mode 100644 index 0000000..a2954a6 --- /dev/null +++ b/mintlayer/wasm/wasm_wrappers_bg.wasm.sha256 @@ -0,0 +1 @@ +0c5411e345b7969cf867da54cd20374b65bb249b9253fc5c028123ec207bdcd8 wasm_wrappers_bg.wasm diff --git a/pyproject.toml b/pyproject.toml index e697f57..741dc6d 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -8,18 +8,22 @@ version = "0.1.0" description = "Python SDK for the Mintlayer blockchain: node, indexer, and wallet RPC clients plus WASM cryptography and transaction building" readme = "README.md" requires-python = ">=3.10" -license = { file = "LICENSE" } +license = "MIT" +license-files = ["LICENSE"] authors = [{ name = "Mintlayer Institutional FZCO", email = "hello@mintlayer.org" }] keywords = ["mintlayer", "blockchain", "sdk", "wallet", "crypto"] classifiers = [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", - "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", "Topic :: Software Development :: Libraries", ] dependencies = [ - "requests>=2.31", + "requests>=2.32.4", "wasmtime>=25.0", ] @@ -45,3 +49,12 @@ select = ["E", "F", "W", "I", "UP", "B", "SIM"] [tool.pytest.ini_options] testpaths = ["tests"] + +[tool.mypy] +python_version = "3.10" +warn_unused_ignores = false +check_untyped_defs = true + +[[tool.mypy.overrides]] +module = "wasmtime.*" +ignore_missing_imports = true From aff0e053693ae227a1790ddfeb94cee75fff770b Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 02:08:28 +0400 Subject: [PATCH 02/31] Add node JSON-RPC client (port of go-sdk/node) Shared JSON-RPC 2.0 transport (mintlayer/_jsonrpc.py) mirroring the Go semantics: params always objects, ids from 1, HTTP status never inspected, null result = not-found, basic auth gated on username (netrc fallback suppressed for owned sessions). Node client with all 38 methods across node/chainstate/mempool/p2p mixins: full wire parity with Go (durations as [secs, nanos], FeeRatePoint and BannedPeer tuple wire shapes, Currency omitempty vs OutpointSourceID null content, orders filters always sent). Deliberate fix over Go: OrderInfo.nonce is Optional (daemon sends null for active orders). 57 pytest tests mirroring and extending Go's client_test.go matrix, including wire-shape pinning and concurrency. ruff + mypy clean. --- mintlayer/_jsonrpc.py | 108 +++++++++++++++ mintlayer/node/__init__.py | 56 ++++++++ mintlayer/node/_core.py | 61 ++++++++ mintlayer/node/chainstate.py | 113 +++++++++++++++ mintlayer/node/client.py | 58 ++++++++ mintlayer/node/mempool.py | 52 +++++++ mintlayer/node/node.py | 15 ++ mintlayer/node/p2p.py | 72 ++++++++++ mintlayer/node/types.py | 260 +++++++++++++++++++++++++++++++++++ tests/conftest.py | 235 +++++++++++++++++++++++++++++++ tests/test_chainstate.py | 192 ++++++++++++++++++++++++++ tests/test_concurrency.py | 40 ++++++ tests/test_mempool.py | 140 +++++++++++++++++++ tests/test_node_module.py | 27 ++++ tests/test_p2p.py | 101 ++++++++++++++ tests/test_transport.py | 88 ++++++++++++ tests/test_wire_shapes.py | 128 +++++++++++++++++ 17 files changed, 1746 insertions(+) create mode 100644 mintlayer/_jsonrpc.py create mode 100644 mintlayer/node/__init__.py create mode 100644 mintlayer/node/_core.py create mode 100644 mintlayer/node/chainstate.py create mode 100644 mintlayer/node/client.py create mode 100644 mintlayer/node/mempool.py create mode 100644 mintlayer/node/node.py create mode 100644 mintlayer/node/p2p.py create mode 100644 mintlayer/node/types.py create mode 100644 tests/conftest.py create mode 100644 tests/test_chainstate.py create mode 100644 tests/test_concurrency.py create mode 100644 tests/test_mempool.py create mode 100644 tests/test_node_module.py create mode 100644 tests/test_p2p.py create mode 100644 tests/test_transport.py create mode 100644 tests/test_wire_shapes.py diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py new file mode 100644 index 0000000..657c0ae --- /dev/null +++ b/mintlayer/_jsonrpc.py @@ -0,0 +1,108 @@ +"""Shared JSON-RPC 2.0 transport for the node and wallet clients. + +Mirrors the (duplicated) transports in go-sdk/node/client.go and +go-sdk/wallet/client.go: + +* one HTTP POST per call, no batching, params are always a JSON object + (``{}`` for no-arg methods), +* monotonically increasing integer request IDs starting at 1, +* HTTP Basic Auth applied only when a username is set (and never sourced + from the environment — ``.netrc`` lookup is suppressed for sessions the + client creates itself), +* no per-call cancellation: timeouts are configured on the client + (Go's per-call ``context`` has no direct requests equivalent), +* the HTTP status code is never inspected — a JSON-RPC ``error`` object in the + body is the error contract, +* JSON ``null`` results signal "not found" for pointer-returning methods. +""" + +from __future__ import annotations + +import threading +from typing import Any + +import requests + +__all__ = ["JSONRPCError", "RPCError", "JSONRPCClient"] + + +class _NoAuth(requests.auth.AuthBase): + """Explicit no-auth marker; prevents requests' .netrc environment fallback.""" + + def __call__(self, r: requests.PreparedRequest) -> requests.PreparedRequest: + return r + + +class JSONRPCError(Exception): + """Transport or codec failure (not a JSON-RPC error object).""" + + +class RPCError(Exception): + """JSON-RPC error returned by the daemon.""" + + def __init__(self, code: int, message: str) -> None: + super().__init__(f"RPC error {code}: {message}") + self.code = code + self.message = message + + +class JSONRPCClient: + """Minimal JSON-RPC 2.0 over HTTP POST client.""" + + def __init__( + self, + endpoint: str, + username: str = "", + password: str = "", + timeout: float = 30.0, + session: requests.Session | None = None, + ) -> None: + self.endpoint = endpoint + self.username = username + self.password = password + self.timeout = timeout + self._owns_session = session is None + self._session = session if session is not None else requests.Session() + self._lock = threading.Lock() + self._id = 0 + + def call(self, method: str, params: Any) -> Any: + """Execute a JSON-RPC call and return the parsed result. + + ``params`` must be a JSON-serialisable object (dict); no-arg methods + pass ``{}``. A JSON-RPC error object raises :class:`RPCError`. + """ + with self._lock: + self._id += 1 + request_id = self._id + payload = {"jsonrpc": "2.0", "id": request_id, "method": method, "params": params} + if self.username: + auth: requests.auth.AuthBase | tuple[str, str] | None = (self.username, self.password) + elif self._owns_session: + auth = _NoAuth() + else: + auth = None + try: + resp = self._session.post( + self.endpoint, + json=payload, + timeout=self.timeout, + auth=auth, + headers={"Content-Type": "application/json"}, + ) + except requests.RequestException as exc: + raise JSONRPCError(f"http request: {exc}") from exc + try: + body = resp.json() + except ValueError as exc: + raise JSONRPCError(f"decode response: {exc}") from exc + if not isinstance(body, dict): + raise JSONRPCError("decode response: unexpected JSON-RPC response shape") + error = body.get("error") + if error is not None: + raise RPCError(error.get("code", 0), error.get("message", "")) + return body.get("result") + + def close(self) -> None: + """Close the underlying HTTP session.""" + self._session.close() diff --git a/mintlayer/node/__init__.py b/mintlayer/node/__init__.py new file mode 100644 index 0000000..e072814 --- /dev/null +++ b/mintlayer/node/__init__.py @@ -0,0 +1,56 @@ +"""JSON-RPC client for the Mintlayer node daemon. + +Mirrors go-sdk/node (Go package ``node``). Default ports: 3030 (mainnet), +13030 (testnet). + + from mintlayer.node import Client + + c = Client("http://127.0.0.1:3030") + print(c.best_block_height()) +""" + +from __future__ import annotations + +from mintlayer._jsonrpc import JSONRPCError + +from .client import Client, RPCError +from .types import ( + Amount, + BannedPeer, + ChainstateInfo, + Currency, + FeeRate, + FeeRatePoint, + MempoolTx, + OrderInfo, + Outpoint, + OutpointSourceID, + PeerInfo, + Timestamp, + TokenInfo, + TrustPolicy, + block_source_content, + tx_source_content, +) + +__all__ = [ + "Client", + "RPCError", + "JSONRPCError", + "Amount", + "Timestamp", + "ChainstateInfo", + "OutpointSourceID", + "Outpoint", + "TokenInfo", + "OrderInfo", + "Currency", + "TrustPolicy", + "MempoolTx", + "FeeRate", + "FeeRatePoint", + "PeerInfo", + "BannedPeer", + "tx_source_content", + "block_source_content", +] diff --git a/mintlayer/node/_core.py b/mintlayer/node/_core.py new file mode 100644 index 0000000..f6b938f --- /dev/null +++ b/mintlayer/node/_core.py @@ -0,0 +1,61 @@ +"""Shared result-decoding helpers for the node client mixins.""" + +from __future__ import annotations + +from typing import Any + +from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError + + +class _NodeCore: + """Thin wrapper over the JSON-RPC transport with typed result helpers.""" + + _rpc: JSONRPCClient + + def _call(self, method: str, params: Any) -> Any: + """Call and return the decoded JSON result (None for JSON null).""" + return self._rpc.call(method, params) + + def _call_ignore(self, method: str, params: Any) -> None: + """Call and discard the result (void methods).""" + self._rpc.call(method, params) + + def _call_str(self, method: str, params: Any) -> str: + result = self._rpc.call(method, params) + if not isinstance(result, str): + raise JSONRPCError(f"{method}: expected string result, got {result!r}") + return result + + def _call_opt_str(self, method: str, params: Any) -> str | None: + result = self._rpc.call(method, params) + return None if result is None else str(result) + + def _call_int(self, method: str, params: Any) -> int: + result = self._rpc.call(method, params) + if isinstance(result, bool) or not isinstance(result, int): + raise JSONRPCError(f"{method}: expected integer result, got {result!r}") + return result + + def _call_opt_int(self, method: str, params: Any) -> int | None: + result = self._rpc.call(method, params) + return None if result is None else int(result) + + def _call_bool(self, method: str, params: Any) -> bool: + result = self._rpc.call(method, params) + if not isinstance(result, bool): + raise JSONRPCError(f"{method}: expected boolean result, got {result!r}") + return result + + def _call_str_list(self, method: str, params: Any) -> list[str]: + result = self._rpc.call(method, params) + return [str(item) for item in result or []] + + def _call_opt_amount(self, method: str, params: Any) -> Any: + from .types import Amount + + result = self._rpc.call(method, params) + return Amount.from_json(result) if result is not None else None + + def close(self) -> None: + """Close the underlying HTTP session.""" + self._rpc.close() diff --git a/mintlayer/node/chainstate.py b/mintlayer/node/chainstate.py new file mode 100644 index 0000000..c3fbdcb --- /dev/null +++ b/mintlayer/node/chainstate.py @@ -0,0 +1,113 @@ +"""Chainstate methods (mirrors go-sdk/node/chainstate.go). + +Not-found results (JSON ``null``) map to ``None``. +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Any + +from ._core import _NodeCore +from .types import Amount, ChainstateInfo, Currency, OrderInfo, Outpoint, TokenInfo + +if TYPE_CHECKING: + pass + + +class ChainstateMixin(_NodeCore): + def chainstate_info(self) -> ChainstateInfo: + """Return the current chainstate summary.""" + return ChainstateInfo.from_json(self._call("chainstate_info", {})) + + def best_block_id(self) -> str: + """Return the best block ID (hex, no 0x prefix).""" + return self._call_str("chainstate_best_block_id", {}) + + def best_block_height(self) -> int: + """Return the best block height.""" + return self._call_int("chainstate_best_block_height", {}) + + def block_id_at_height(self, height: int) -> str | None: + """Return the block ID at ``height`` (None if the height is unknown).""" + return self._call_opt_str("chainstate_block_id_at_height", {"height": height}) + + def block_height_in_main_chain(self, block_id: str) -> int | None: + """Return the height of ``block_id`` in the mainchain (None if orphaned).""" + return self._call_opt_int("chainstate_block_height_in_main_chain", {"block_id": block_id}) + + def get_block(self, block_id: str) -> str | None: + """Return the hex-encoded block (None if unknown; genesis not retrievable).""" + return self._call_opt_str("chainstate_get_block", {"id": block_id}) + + def get_block_json(self, block_id: str) -> Any: + """Return the block as decoded JSON (None if unknown).""" + return self._call("chainstate_get_block_json", {"id": block_id}) + + def get_mainchain_blocks(self, from_height: int, max_count: int) -> list[str]: + """Return up to ``max_count`` mainchain block IDs starting at ``from_height``.""" + return self._call_str_list( + "chainstate_get_mainchain_blocks", + {"from": from_height, "max_count": max_count}, + ) + + def get_utxo(self, outpoint: Outpoint) -> Any: + """Return the UTXO at ``outpoint`` as decoded JSON (None if spent/unknown).""" + return self._call("chainstate_get_utxo", {"outpoint": outpoint.to_json()}) + + def stake_pool_balance(self, pool_address: str) -> Amount | None: + """Return the pledge balance of the pool (None if the pool is unknown).""" + return self._call_opt_amount( + "chainstate_stake_pool_balance", {"pool_address": pool_address} + ) + + def staker_balance(self, pool_address: str) -> Amount | None: + """Return the staker's balance of the pool (None if the pool is unknown).""" + return self._call_opt_amount("chainstate_staker_balance", {"pool_address": pool_address}) + + def pool_decommission_destination(self, pool_address: str) -> str | None: + """Return the address that receives funds on decommission.""" + return self._call_opt_str( + "chainstate_pool_decommission_destination", {"pool_address": pool_address} + ) + + def delegation_share(self, pool_address: str, delegation_address: str) -> Amount | None: + """Return the delegation share held by ``delegation_address``.""" + return self._call_opt_amount( + "chainstate_delegation_share", + {"pool_address": pool_address, "delegation_address": delegation_address}, + ) + + def token_info(self, token_id: str) -> TokenInfo | None: + """Return token info (tagged union; None if unknown).""" + data = self._call("chainstate_token_info", {"token_id": token_id}) + return TokenInfo.from_json(data) if data is not None else None + + def tokens_info(self, token_ids: list[str]) -> list[TokenInfo]: + """Return info for multiple token IDs.""" + data = self._call("chainstate_tokens_info", {"token_ids": token_ids}) + return [TokenInfo.from_json(item) for item in data or []] + + def order_info(self, order_id: str) -> OrderInfo | None: + """Return order info (None if unknown).""" + data = self._call("chainstate_order_info", {"order_id": order_id}) + return OrderInfo.from_json(data) if data is not None else None + + def orders_info_by_currencies( + self, ask: Currency | None, give: Currency | None + ) -> dict[str, OrderInfo]: + """Return orders matching the ask/give currency filters (None = any). + + Both keys are always sent; ``None`` serialises as JSON ``null``. + """ + data = self._call( + "chainstate_orders_info_by_currencies", + { + "ask_currency": ask.to_json() if ask is not None else None, + "give_currency": give.to_json() if give is not None else None, + }, + ) + return {k: OrderInfo.from_json(v) for k, v in (data or {}).items()} + + def submit_block(self, block_hex: str) -> None: + """Submit a fully serialized block (hex).""" + self._call_ignore("chainstate_submit_block", {"block_hex": block_hex}) diff --git a/mintlayer/node/client.py b/mintlayer/node/client.py new file mode 100644 index 0000000..9947220 --- /dev/null +++ b/mintlayer/node/client.py @@ -0,0 +1,58 @@ +"""JSON-RPC client for the Mintlayer node daemon (mirrors go-sdk/node). + +Default ports: 3030 (mainnet), 13030 (testnet). Errors from the daemon raise +:class:`RPCError` with a numeric ``code`` and ``message``. +""" + +from __future__ import annotations + +from requests import Session + +from mintlayer._jsonrpc import ( + JSONRPCClient, + JSONRPCError, # noqa: F401 (re-exported) + RPCError, +) + +from ._core import _NodeCore +from .chainstate import ChainstateMixin +from .mempool import MempoolMixin +from .node import NodeMixin +from .p2p import P2PMixin + +__all__ = ["Client", "RPCError", "JSONRPCError"] + + +class Client( + NodeMixin, + ChainstateMixin, + MempoolMixin, + P2PMixin, + _NodeCore, +): + """JSON-RPC 2.0 client for the Mintlayer node daemon. + + Safe for concurrent use from multiple threads. + """ + + def __init__( + self, + endpoint: str, + username: str = "", + password: str = "", + timeout: float = 30.0, + session: Session | None = None, + ) -> None: + """Create a node client. + + ``endpoint`` is the base URL of the daemon (e.g. + ``"http://127.0.0.1:3030"``); requests POST to it directly with no path + appended. Basic auth is applied only when ``username`` is non-empty. + """ + self._rpc = JSONRPCClient( + endpoint=endpoint, + username=username, + password=password, + timeout=timeout, + session=session, + ) diff --git a/mintlayer/node/mempool.py b/mintlayer/node/mempool.py new file mode 100644 index 0000000..c6360af --- /dev/null +++ b/mintlayer/node/mempool.py @@ -0,0 +1,52 @@ +"""Mempool methods (mirrors go-sdk/node/mempool.go).""" + +from __future__ import annotations + +from typing import TYPE_CHECKING + +from ._core import _NodeCore +from .types import FeeRate, FeeRatePoint, MempoolTx, TrustPolicy +from .types import policy_value as _policy_value + +if TYPE_CHECKING: + pass + + +class MempoolMixin(_NodeCore): + def contains_tx(self, tx_id: str) -> bool: + """Return whether the transaction is in the mempool.""" + return self._call_bool("mempool_contains_tx", {"tx_id": tx_id}) + + def contains_orphan_tx(self, tx_id: str) -> bool: + """Return whether the transaction is in the orphan pool.""" + return self._call_bool("mempool_contains_orphan_tx", {"tx_id": tx_id}) + + def get_transaction(self, tx_id: str) -> MempoolTx | None: + """Return the mempool transaction (None if not present).""" + data = self._call("mempool_get_transaction", {"tx_id": tx_id}) + return MempoolTx.from_json(data) if data is not None else None + + def mempool_submit_transaction(self, tx_hex: str, trust_policy: TrustPolicy | str) -> None: + """Submit a transaction to the local mempool only (no P2P broadcast). + + Use ``TrustPolicy.UNTRUSTED`` (recommended) for full validation; + ``TrustPolicy.TRUSTED`` skips some fee checks. + """ + self._call_ignore( + "mempool_submit_transaction", + {"tx": tx_hex, "options": {"trust_policy": _policy_value(trust_policy)}}, + ) + + def get_fee_rate(self, in_top_x_mb: int) -> FeeRate | None: + """Return the fee rate to land in the top ``in_top_x_mb`` MB of the mempool.""" + data = self._call("mempool_get_fee_rate", {"in_top_x_mb": in_top_x_mb}) + return FeeRate.from_json(data) if data is not None else None + + def get_fee_rate_points(self) -> list[FeeRatePoint]: + """Return the mempool fee rate histogram.""" + data = self._call("mempool_get_fee_rate_points", {}) + return [FeeRatePoint.from_json(item) for item in data or []] + + def memory_usage(self) -> int: + """Return the mempool memory usage in bytes.""" + return self._call_int("mempool_memory_usage", {}) diff --git a/mintlayer/node/node.py b/mintlayer/node/node.py new file mode 100644 index 0000000..73039f9 --- /dev/null +++ b/mintlayer/node/node.py @@ -0,0 +1,15 @@ +"""Node module methods (mirrors go-sdk/node/node.go).""" + +from __future__ import annotations + +from ._core import _NodeCore + + +class NodeMixin(_NodeCore): + def node_version(self) -> str: + """Return the node daemon version string.""" + return self._call_str("node_version", {}) + + def node_shutdown(self) -> None: + """Request a graceful node shutdown.""" + self._call_ignore("node_shutdown", {}) diff --git a/mintlayer/node/p2p.py b/mintlayer/node/p2p.py new file mode 100644 index 0000000..7e9c9b3 --- /dev/null +++ b/mintlayer/node/p2p.py @@ -0,0 +1,72 @@ +"""P2P methods (mirrors go-sdk/node/p2p.go).""" + +from __future__ import annotations + +from datetime import timedelta +from typing import TYPE_CHECKING + +from ._core import _NodeCore +from .types import BannedPeer, PeerInfo, TrustPolicy +from .types import policy_value as _policy_value + +if TYPE_CHECKING: + pass + + +def _duration_to_wire(duration: timedelta) -> list[int]: + """Split a duration into the daemon's [seconds, nanoseconds] wire form.""" + total_seconds = duration.total_seconds() + secs = int(total_seconds) + nanos = int(round((total_seconds - secs) * 1_000_000_000)) + return [secs, nanos] + + +class P2PMixin(_NodeCore): + def get_peer_count(self) -> int: + """Return the number of connected peers.""" + return self._call_int("p2p_get_peer_count", {}) + + def get_connected_peers(self) -> list[PeerInfo]: + """Return info about connected peers.""" + data = self._call("p2p_get_connected_peers", {}) + return [PeerInfo.from_json(item) for item in data or []] + + def get_bind_addresses(self) -> list[str]: + """Return the node's bind addresses.""" + return self._call_str_list("p2p_get_bind_addresses", {}) + + def add_reserved_node(self, addr: str) -> None: + """Add a reserved node (host:port).""" + self._call_ignore("p2p_add_reserved_node", {"addr": addr}) + + def remove_reserved_node(self, addr: str) -> None: + """Remove a reserved node (host:port).""" + self._call_ignore("p2p_remove_reserved_node", {"addr": addr}) + + def connect(self, addr: str) -> None: + """Connect to a peer (host:port).""" + self._call_ignore("p2p_connect", {"addr": addr}) + + def disconnect(self, peer_id: int) -> None: + """Disconnect the peer with the given ID.""" + self._call_ignore("p2p_disconnect", {"peer_id": peer_id}) + + def list_banned(self) -> list[BannedPeer]: + """Return banned addresses with their ban expiry times.""" + data = self._call("p2p_list_banned", {}) + return [BannedPeer.from_json(item) for item in data or []] + + def ban(self, address: str, duration: timedelta) -> None: + """Ban an address for the given duration.""" + self._call_ignore("p2p_ban", {"address": address, "duration": _duration_to_wire(duration)}) + + def unban(self, address: str) -> None: + """Remove an address ban.""" + self._call_ignore("p2p_unban", {"address": address}) + + def p2p_submit_transaction(self, tx_hex: str, trust_policy: TrustPolicy | str) -> None: + """Submit a transaction to the mempool AND broadcast it via P2P.""" + self._call_ignore( + "p2p_submit_transaction", + {"tx": tx_hex, "options": {"trust_policy": _policy_value(trust_policy)}}, + ) diff --git a/mintlayer/node/types.py b/mintlayer/node/types.py new file mode 100644 index 0000000..9aa24b2 --- /dev/null +++ b/mintlayer/node/types.py @@ -0,0 +1,260 @@ +"""Types for the node JSON-RPC client (mirrors go-sdk/node/types.go). + +Amounts are decimal atom strings (1 ML = 1e11 atoms) — never JSON numbers. +Tagged unions (``OutpointSourceID``, ``TokenInfo``) keep their ``content`` as +raw decoded JSON. Custom wire shapes (``FeeRatePoint``, ``BannedPeer``) use +tuple encodings decoded in ``from_json``. +""" + +from __future__ import annotations + +import enum +from dataclasses import dataclass +from typing import Any + + +class TrustPolicy(str, enum.Enum): + """Mempool submission trust policy.""" + + TRUSTED = "Trusted" + UNTRUSTED = "Untrusted" + + +def policy_value(trust_policy: TrustPolicy | str) -> str: + """Normalise a TrustPolicy enum or plain string to its wire value.""" + if isinstance(trust_policy, TrustPolicy): + return trust_policy.value + return TrustPolicy(trust_policy).value + + +@dataclass(frozen=True) +class Amount: + """A coin or token quantity as a decimal atom string.""" + + atoms: str + + @classmethod + def from_json(cls, data: Any) -> Amount: + if not isinstance(data, dict) or "atoms" not in data: + raise ValueError(f"invalid amount payload: {data!r}") + return cls(atoms=data["atoms"]) + + def to_json(self) -> dict: + return {"atoms": self.atoms} + + +@dataclass(frozen=True) +class Timestamp: + """Unix seconds.""" + + timestamp: int + + @classmethod + def from_json(cls, data: Any) -> Timestamp: + return cls(timestamp=int(data["timestamp"])) + + +@dataclass(frozen=True) +class ChainstateInfo: + best_block_height: int + best_block_id: str + best_block_timestamp: Timestamp + median_time: Timestamp + is_initial_block_download: bool + + @classmethod + def from_json(cls, data: dict) -> ChainstateInfo: + return cls( + best_block_height=data["best_block_height"], + best_block_id=data["best_block_id"], + best_block_timestamp=Timestamp.from_json(data["best_block_timestamp"]), + median_time=Timestamp.from_json(data["median_time"]), + is_initial_block_download=data["is_initial_block_download"], + ) + + +@dataclass +class OutpointSourceID: + """Tagged union: ``type`` is ``"Transaction"`` or ``"BlockReward"``. + + ``content`` is raw JSON: ``{"tx_id": ""}`` or ``{"block_id": ""}`` + (see :func:`tx_source_content` / :func:`block_source_content`). Mirrors the + Go struct's missing ``omitempty``: an unset content serialises as ``null``. + """ + + type: str + content: Any = None + + def to_json(self) -> dict: + return {"type": self.type, "content": self.content} + + @classmethod + def from_json(cls, data: dict) -> OutpointSourceID: + return cls(type=data["type"], content=data.get("content")) + + +def tx_source_content(tx_id: str) -> dict: + """Content payload for a transaction outpoint source.""" + return {"tx_id": tx_id} + + +def block_source_content(block_id: str) -> dict: + """Content payload for a block-reward outpoint source.""" + return {"block_id": block_id} + + +@dataclass(frozen=True) +class Outpoint: + source_id: OutpointSourceID + index: int + + def to_json(self) -> dict: + return {"source_id": self.source_id.to_json(), "index": self.index} + + +@dataclass +class TokenInfo: + """Tagged union: ``type`` is ``"FungibleToken"`` or ``"NonFungibleToken"``. + + ``content`` is left as raw decoded JSON. + """ + + type: str + content: Any = None + + @classmethod + def from_json(cls, data: dict) -> TokenInfo: + return cls(type=data["type"], content=data.get("content")) + + +@dataclass +class OrderInfo: + """Node-side order info. + + Note: ``nonce`` is ``None`` for active orders (the daemon sends ``null``), + fixing a known Go SDK incompatibility. + """ + + conclude_key: str + initially_asked: Any + initially_given: Any + ask_balance: Amount + give_balance: Amount + nonce: int | None + is_frozen: bool + + @classmethod + def from_json(cls, data: dict) -> OrderInfo: + return cls( + conclude_key=data["conclude_key"], + initially_asked=data.get("initially_asked"), + initially_given=data.get("initially_given"), + ask_balance=Amount.from_json(data["ask_balance"]), + give_balance=Amount.from_json(data["give_balance"]), + nonce=data.get("nonce"), + is_frozen=data["is_frozen"], + ) + + +@dataclass(frozen=True) +class Currency: + """Tagged union query parameter: ``"Coin"`` or ``"Token"``. + + ``content`` carries the bech32 token ID for tokens and is omitted for coins + (mirrors the Go struct's ``omitempty``). + """ + + type: str + content: str | None = None + + def to_json(self) -> dict: + out: dict = {"type": self.type} + if self.content is not None: + out["content"] = self.content + return out + + @classmethod + def coin(cls) -> Currency: + return cls(type="Coin") + + @classmethod + def token(cls, token_id: str) -> Currency: + return cls(type="Token", content=token_id) + + +@dataclass(frozen=True) +class MempoolTx: + id: str + status: str + transaction: str + + @classmethod + def from_json(cls, data: dict) -> MempoolTx: + return cls(id=data["id"], status=data["status"], transaction=data["transaction"]) + + +@dataclass(frozen=True) +class FeeRate: + """Atoms per kilobyte.""" + + amount_per_kb: Amount + + @classmethod + def from_json(cls, data: dict) -> FeeRate: + return cls(amount_per_kb=Amount.from_json(data["amount_per_kb"])) + + +@dataclass(frozen=True) +class FeeRatePoint: + """Wire shape: ``[size, {"amount_per_kb": {...}}]``.""" + + size: int + rate: FeeRate + + @classmethod + def from_json(cls, data: Any) -> FeeRatePoint: + size, rate = data + return cls(size=size, rate=FeeRate.from_json(rate)) + + +@dataclass(frozen=True) +class PeerInfo: + peer_id: int + address: str + peer_role: str + ban_score: int + user_agent: str + software_version: str + ping_wait: int | None = None + ping_last: int | None = None + ping_min: int | None = None + last_tip_block_time: int | None = None + + @classmethod + def from_json(cls, data: dict) -> PeerInfo: + return cls( + peer_id=data["peer_id"], + address=data["address"], + peer_role=data["peer_role"], + ban_score=data["ban_score"], + user_agent=data["user_agent"], + software_version=data["software_version"], + ping_wait=data.get("ping_wait"), + ping_last=data.get("ping_last"), + ping_min=data.get("ping_min"), + last_tip_block_time=data.get("last_tip_block_time"), + ) + + +@dataclass(frozen=True) +class BannedPeer: + """Wire shape: ``["", {"time": [secs, nanos]}]``.""" + + address: str + ban_time: tuple[int, int] + + @classmethod + def from_json(cls, data: Any) -> BannedPeer: + address, payload = data + secs, nanos = payload["time"] + return cls(address=address, ban_time=(secs, nanos)) diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..ef3386f --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,235 @@ +"""In-process JSON-RPC test servers for the Mintlayer node client tests. + +Mirrors the httptest helpers in go-sdk/node/client_test.go, using the stdlib +``http.server`` + threading instead of httptest: + +* :func:`make_rpc_server` -- answers every JSON-RPC POST with + ``{"jsonrpc": "2.0", "id": , "result": }``. + ``result=None`` produces a JSON ``null`` result (void / not-found methods). +* :func:`make_rpc_error_server` -- answers with a JSON-RPC error object. +* :func:`make_raw_rpc_server` -- embeds raw JSON *text* verbatim as the + result, pinning exact wire shapes (mirrors Go's ``json.RawMessage``). +* :class:`Capture` -- records the last request (method name, params, headers, + path, raw body, request count) plus every echoed request id, so tests can + pin exact wire shapes. + +Prefer the :func:`rpc_server` fixture: it is a factory that starts servers +(threading daemons) and guarantees shutdown in teardown. +""" + +from __future__ import annotations + +import json +import threading +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from typing import Any + +import pytest + +_HOST = "127.0.0.1" + + +class Capture: + """Thread-safe recorder for the requests hitting a test server.""" + + def __init__(self) -> None: + self._lock = threading.Lock() + # Last request seen. + self.method: str | None = None + self.params: Any = None + self.headers: dict[str, str] = {} + self.path: str | None = None + self.raw_body: bytes | None = None + # All requests seen. + self.request_count = 0 + self.request_ids: list[Any] = [] + self.payloads: list[dict[str, Any]] = [] + self.protocol_errors: list[str] = [] + + def record( + self, + *, + method: str | None, + params: Any, + headers: dict[str, str], + path: str | None, + raw_body: bytes, + request_id: Any, + payload: dict[str, Any], + ) -> None: + with self._lock: + self.method = method + self.params = params + self.headers = dict(headers) + self.path = path + self.raw_body = raw_body + self.request_count += 1 + self.request_ids.append(request_id) + self.payloads.append(payload) + + def record_protocol_error(self, message: str) -> None: + with self._lock: + self.protocol_errors.append(message) + + +def _result_responder(result: Any): + def respond(payload: dict[str, Any]) -> tuple[int, Any]: + return 200, {"jsonrpc": "2.0", "id": payload.get("id"), "result": result} + + return respond + + +def _error_responder(code: int, message: str): + def respond(payload: dict[str, Any]) -> tuple[int, Any]: + return 200, { + "jsonrpc": "2.0", + "id": payload.get("id"), + "error": {"code": code, "message": message}, + } + + return respond + + +def _raw_responder(raw_result: str): + def respond(payload: dict[str, Any]) -> tuple[int, Any]: + body = f'{{"jsonrpc":"2.0","id":{json.dumps(payload.get("id"))},"result":{raw_result}}}' + return 200, body.encode("utf-8") + + return respond + + +class ServerHandle: + """A running in-process JSON-RPC server plus its request capture.""" + + def __init__( + self, + httpd: ThreadingHTTPServer, + capture: Capture, + thread: threading.Thread, + ) -> None: + self.httpd = httpd + self.capture = capture + self._thread = thread + + @property + def url(self) -> str: + host, port = self.httpd.server_address[:2] + return f"http://{host}:{port}" + + def stop(self) -> None: + self.httpd.shutdown() + self.httpd.server_close() + self._thread.join(timeout=5) + + +def _make_handler(capture: Capture, responder): + class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + + def do_POST(self) -> None: + length = int(self.headers.get("Content-Length") or 0) + raw_body = self.rfile.read(length) + try: + payload = json.loads(raw_body.decode("utf-8")) + except ValueError: + capture.record_protocol_error("request body is not valid JSON") + self._respond(400, b"bad request") + return + if payload.get("jsonrpc") != "2.0": + capture.record_protocol_error( + f"expected jsonrpc 2.0, got {payload.get('jsonrpc')!r}" + ) + self._respond(400, b"bad request") + return + capture.record( + method=payload.get("method"), + params=payload.get("params"), + headers={str(k).lower(): str(v) for k, v in self.headers.items()}, + path=self.path, + raw_body=raw_body, + request_id=payload.get("id"), + payload=payload, + ) + status, body = responder(payload) + encoded = body if isinstance(body, bytes) else json.dumps(body).encode("utf-8") + self._respond(status, encoded) + + def _respond(self, status: int, body: bytes) -> None: + self.send_response(status) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + def log_message(self, format: str, *args: object) -> None: + pass # keep test output clean + + return Handler + + +def _start_server(capture: Capture, responder) -> ServerHandle: + httpd = ThreadingHTTPServer((_HOST, 0), _make_handler(capture, responder)) + thread = threading.Thread( + target=httpd.serve_forever, + daemon=True, + name="json-rpc-test-server", + ) + thread.start() + return ServerHandle(httpd=httpd, capture=capture, thread=thread) + + +def make_rpc_server(result: Any = None) -> ServerHandle: + """Start a server answering every JSON-RPC POST with ``result``. + + ``result=None`` produces a JSON ``null`` result (void / not-found methods). + Prefer the :func:`rpc_server` fixture so servers are always stopped. + """ + return _start_server(Capture(), _result_responder(result)) + + +def make_rpc_error_server(code: int, message: str) -> ServerHandle: + """Start a server answering every JSON-RPC POST with an error object.""" + return _start_server(Capture(), _error_responder(code, message)) + + +def make_raw_rpc_server(raw_result: str) -> ServerHandle: + """Start a server embedding ``raw_result`` verbatim as the JSON-RPC result.""" + return _start_server(Capture(), _raw_responder(raw_result)) + + +@pytest.fixture +def rpc_server(): + """Factory fixture that starts/stops in-process JSON-RPC test servers. + + Usage:: + + srv = rpc_server(result={"atoms": "1"}) + client = Client(srv.url) # srv.url is the base URL + ... + srv.capture.method # last request's method name + + Keyword alternatives: ``error=(code, message)`` for a JSON-RPC error + server and ``raw=""`` to pin an exact wire shape. Every server + started through the factory is shut down in teardown. + """ + handles: list[ServerHandle] = [] + + def _start( + *, + result: Any = None, + error: tuple[int, str] | None = None, + raw: str | None = None, + ) -> ServerHandle: + if error is not None: + handle = make_rpc_error_server(*error) + elif raw is not None: + handle = make_raw_rpc_server(raw) + else: + handle = make_rpc_server(result) + handles.append(handle) + return handle + + yield _start + + for handle in handles: + handle.stop() diff --git a/tests/test_chainstate.py b/tests/test_chainstate.py new file mode 100644 index 0000000..cea107b --- /dev/null +++ b/tests/test_chainstate.py @@ -0,0 +1,192 @@ +"""Tests for the chainstate module methods. + +Mirrors the "chainstate module" section of go-sdk/node/client_test.go, plus +the order-info tests covering the deliberate Go-bug fix (``nonce: null``). +""" + +from __future__ import annotations + +from typing import Any + +import pytest + +from mintlayer.node import ( + Amount, + ChainstateInfo, + Client, + Currency, + JSONRPCError, + OrderInfo, + Outpoint, + OutpointSourceID, + Timestamp, + tx_source_content, +) + + +def test_chainstate_info(rpc_server) -> None: + result = { + "best_block_height": 123456, + "best_block_id": "aabbccdd", + "best_block_timestamp": {"timestamp": 1700000000}, + "median_time": {"timestamp": 1699999500}, + "is_initial_block_download": False, + } + srv = rpc_server(result=result) + client = Client(srv.url) + info = client.chainstate_info() + assert isinstance(info, ChainstateInfo) + assert info.best_block_height == 123456 + assert info.best_block_id == "aabbccdd" + assert info.best_block_timestamp == Timestamp(timestamp=1700000000) + assert info.median_time == Timestamp(timestamp=1699999500) + assert info.is_initial_block_download is False + assert srv.capture.method == "chainstate_info" + client.close() + + +def test_best_block_id(rpc_server) -> None: + srv = rpc_server(result="deadbeef01020304") + client = Client(srv.url) + assert client.best_block_id() == "deadbeef01020304" + assert srv.capture.method == "chainstate_best_block_id" + client.close() + + +def test_best_block_id_null_result_raises(rpc_server) -> None: + """A JSON null result for a non-optional str method raises JSONRPCError. + + The null guard must raise a type error mentioning "expected string result" + rather than silently returning the string "None". + """ + srv = rpc_server(result=None) + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="expected string result"): + client.best_block_id() + client.close() + + +def test_best_block_height(rpc_server) -> None: + srv = rpc_server(result=999) + client = Client(srv.url) + assert client.best_block_height() == 999 + assert srv.capture.method == "chainstate_best_block_height" + client.close() + + +def test_block_id_at_height_null(rpc_server) -> None: + """A JSON null result maps to None (unknown height).""" + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.block_id_at_height(9999999) is None + assert srv.capture.method == "chainstate_block_id_at_height" + assert srv.capture.params == {"height": 9999999} + client.close() + + +def test_stake_pool_balance(rpc_server) -> None: + srv = rpc_server(result={"atoms": "100000000000"}) + client = Client(srv.url) + balance = client.stake_pool_balance("mpool1abc") + assert balance == Amount(atoms="100000000000") + assert balance.atoms == "100000000000" + assert srv.capture.method == "chainstate_stake_pool_balance" + assert srv.capture.params == {"pool_address": "mpool1abc"} + client.close() + + +def test_stake_pool_balance_not_found(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.stake_pool_balance("mpool1missing") is None + client.close() + + +def test_get_utxo_serializes_outpoint(rpc_server) -> None: + """The Outpoint serialises to the daemon's tagged-union wire shape.""" + tx_id = "beefcafe01" + outpoint = Outpoint( + source_id=OutpointSourceID(type="Transaction", content=tx_source_content(tx_id)), + index=0, + ) + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.get_utxo(outpoint) is None # not found -> None + assert srv.capture.method == "chainstate_get_utxo" + assert srv.capture.params == { + "outpoint": { + "source_id": {"type": "Transaction", "content": {"tx_id": tx_id}}, + "index": 0, + } + } + client.close() + + +def _order_payload(nonce: Any) -> dict[str, Any]: + return { + "conclude_key": "tql1conclude", + "initially_asked": {"Coin": {"amount": {"atoms": "100"}}}, + "initially_given": {"Token": {"token_id": "tok1", "amount": {"atoms": "200"}}}, + "ask_balance": {"atoms": "900"}, + "give_balance": {"atoms": "700"}, + "nonce": nonce, + "is_frozen": False, + } + + +def test_order_info_nonce_null(rpc_server) -> None: + """The daemon sends ``nonce: null`` for active orders -> None (Go SDK bug fix).""" + srv = rpc_server(result=_order_payload(nonce=None)) + client = Client(srv.url) + info = client.order_info("ord1xyz") + assert info is not None + assert info.nonce is None + assert info.conclude_key == "tql1conclude" + assert info.ask_balance == Amount(atoms="900") + assert info.give_balance == Amount(atoms="700") + assert info.is_frozen is False + # Tagged-union payloads pass through as raw decoded JSON. + assert info.initially_asked == {"Coin": {"amount": {"atoms": "100"}}} + assert info.initially_given == {"Token": {"token_id": "tok1", "amount": {"atoms": "200"}}} + client.close() + + +def test_order_info_nonce_present(rpc_server) -> None: + srv = rpc_server(result=_order_payload(nonce=7)) + client = Client(srv.url) + info = client.order_info("ord1xyz") + assert isinstance(info, OrderInfo) + assert info.nonce == 7 + client.close() + + +def test_order_info_not_found(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.order_info("ord1missing") is None + client.close() + + +def test_orders_info_by_currencies_none_filters(rpc_server) -> None: + """Both filter keys are always sent, as JSON null, when filters are None.""" + srv = rpc_server(result={}) + client = Client(srv.url) + assert client.orders_info_by_currencies(None, None) == {} + assert srv.capture.method == "chainstate_orders_info_by_currencies" + assert srv.capture.params == {"ask_currency": None, "give_currency": None} + client.close() + + +def test_orders_info_by_currencies_with_filters(rpc_server) -> None: + srv = rpc_server(result={"ord1": _order_payload(nonce=None)}) + client = Client(srv.url) + orders = client.orders_info_by_currencies(Currency.coin(), Currency.token("tok1")) + assert set(orders) == {"ord1"} + assert isinstance(orders["ord1"], OrderInfo) + assert orders["ord1"].nonce is None + # Coin omits content; Token carries the token id. + assert srv.capture.params == { + "ask_currency": {"type": "Coin"}, + "give_currency": {"type": "Token", "content": "tok1"}, + } + client.close() diff --git a/tests/test_concurrency.py b/tests/test_concurrency.py new file mode 100644 index 0000000..95e1bec --- /dev/null +++ b/tests/test_concurrency.py @@ -0,0 +1,40 @@ +"""Concurrent-use test: one client shared by many threads. + +Mirrors the "concurrent ID generation" section of go-sdk/node/client_test.go, +additionally asserting that request ids stay unique and increasing. +""" + +from __future__ import annotations + +import threading + +from mintlayer.node import Client + + +def test_concurrent_calls_unique_increasing_ids(rpc_server) -> None: + srv = rpc_server(result="1.0.0") + client = Client(srv.url) + results: list[str] = [] + errors: list[Exception] = [] + + def call() -> None: + try: + results.append(client.node_version()) + except Exception as exc: # noqa: BLE001 - collected and asserted below + errors.append(exc) + + threads = [threading.Thread(target=call) for _ in range(10)] + for thread in threads: + thread.start() + for thread in threads: + thread.join(timeout=10) + + assert errors == [] + assert results == ["1.0.0"] * 10 + assert srv.capture.request_count == 10 + assert srv.capture.protocol_errors == [] + + ids = srv.capture.request_ids + assert len(set(ids)) == 10, f"expected 10 unique request ids, got {ids}" + assert sorted(ids) == list(range(1, 11)), f"ids not 1..10: {sorted(ids)}" + client.close() diff --git a/tests/test_mempool.py b/tests/test_mempool.py new file mode 100644 index 0000000..b4f531f --- /dev/null +++ b/tests/test_mempool.py @@ -0,0 +1,140 @@ +"""Tests for the mempool module methods. + +Mirrors the "mempool module" section of go-sdk/node/client_test.go. +""" + +from __future__ import annotations + +import pytest + +from mintlayer.node import Amount, Client, FeeRate, FeeRatePoint, MempoolTx, TrustPolicy + +_FEE_RATE_POINTS_WIRE = ( + '[[1024,{"amount_per_kb":{"atoms":"500"}}],[2048,{"amount_per_kb":{"atoms":"750"}}]]' +) + + +def test_contains_tx(rpc_server) -> None: + srv = rpc_server(result=True) + client = Client(srv.url) + assert client.contains_tx("aabb1234") is True + assert srv.capture.method == "mempool_contains_tx" + assert srv.capture.params == {"tx_id": "aabb1234"} + client.close() + + +def test_contains_orphan_tx(rpc_server) -> None: + srv = rpc_server(result=False) + client = Client(srv.url) + assert client.contains_orphan_tx("aabb1234") is False + assert srv.capture.method == "mempool_contains_orphan_tx" + assert srv.capture.params == {"tx_id": "aabb1234"} + client.close() + + +def test_get_transaction_found(rpc_server) -> None: + srv = rpc_server(result={"id": "aabb1234", "status": "InMempool", "transaction": "cafebabe"}) + client = Client(srv.url) + tx = client.get_transaction("aabb1234") + assert tx == MempoolTx(id="aabb1234", status="InMempool", transaction="cafebabe") + assert tx is not None + assert tx.status == "InMempool" + assert srv.capture.method == "mempool_get_transaction" + assert srv.capture.params == {"tx_id": "aabb1234"} + client.close() + + +def test_get_transaction_not_found(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.get_transaction("deadbeef") is None + client.close() + + +def test_mempool_submit_transaction_untrusted(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.mempool_submit_transaction("cafebabe", TrustPolicy.UNTRUSTED) is None + assert srv.capture.method == "mempool_submit_transaction" + assert srv.capture.params == { + "tx": "cafebabe", + "options": {"trust_policy": "Untrusted"}, + } + client.close() + + +def test_mempool_submit_transaction_trusted(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.mempool_submit_transaction("cafebabe", TrustPolicy.TRUSTED) + assert srv.capture.params == { + "tx": "cafebabe", + "options": {"trust_policy": "Trusted"}, + } + client.close() + + +def test_mempool_submit_transaction_accepts_plain_string(rpc_server) -> None: + """A plain "Untrusted" string is normalised to the enum's wire value.""" + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.mempool_submit_transaction("cafebabe", "Untrusted") is None + assert srv.capture.method == "mempool_submit_transaction" + assert srv.capture.params == { + "tx": "cafebabe", + "options": {"trust_policy": "Untrusted"}, + } + client.close() + + +def test_mempool_submit_transaction_rejects_invalid_string(rpc_server) -> None: + """An invalid policy string raises ValueError before any request is sent.""" + srv = rpc_server(result=None) + client = Client(srv.url) + with pytest.raises(ValueError): + client.mempool_submit_transaction("cafebabe", "Bogus") + assert srv.capture.request_count == 0 + client.close() + + +def test_get_fee_rate(rpc_server) -> None: + srv = rpc_server(result={"amount_per_kb": {"atoms": "1000"}}) + client = Client(srv.url) + rate = client.get_fee_rate(5) + assert rate == FeeRate(amount_per_kb=Amount(atoms="1000")) + assert rate is not None + assert rate.amount_per_kb.atoms == "1000" + assert srv.capture.method == "mempool_get_fee_rate" + assert srv.capture.params == {"in_top_x_mb": 5} + client.close() + + +def test_get_fee_rate_not_found(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.get_fee_rate(5) is None + client.close() + + +def test_get_fee_rate_points(rpc_server) -> None: + """Wire format: array of [size, feeRate] pairs (raw JSON result).""" + srv = rpc_server(raw=_FEE_RATE_POINTS_WIRE) + client = Client(srv.url) + points = client.get_fee_rate_points() + assert points == [ + FeeRatePoint(size=1024, rate=FeeRate(amount_per_kb=Amount(atoms="500"))), + FeeRatePoint(size=2048, rate=FeeRate(amount_per_kb=Amount(atoms="750"))), + ] + assert points[0].size == 1024 + assert points[0].rate.amount_per_kb.atoms == "500" + assert points[1].rate.amount_per_kb.atoms == "750" + assert srv.capture.method == "mempool_get_fee_rate_points" + client.close() + + +def test_memory_usage(rpc_server) -> None: + srv = rpc_server(result=4096) + client = Client(srv.url) + assert client.memory_usage() == 4096 + assert srv.capture.method == "mempool_memory_usage" + client.close() diff --git a/tests/test_node_module.py b/tests/test_node_module.py new file mode 100644 index 0000000..cf23fc8 --- /dev/null +++ b/tests/test_node_module.py @@ -0,0 +1,27 @@ +"""Tests for the node module methods (node_version, node_shutdown). + +Mirrors the "node module" section of go-sdk/node/client_test.go. +""" + +from __future__ import annotations + +from mintlayer.node import Client + + +def test_node_version(rpc_server) -> None: + srv = rpc_server(result="v0.9.7") + client = Client(srv.url) + assert client.node_version() == "v0.9.7" + assert srv.capture.method == "node_version" + assert srv.capture.params == {} + client.close() + + +def test_node_shutdown(rpc_server) -> None: + """A null result (void method) returns None.""" + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.node_shutdown() is None + assert srv.capture.method == "node_shutdown" + assert srv.capture.params == {} + client.close() diff --git a/tests/test_p2p.py b/tests/test_p2p.py new file mode 100644 index 0000000..33588e6 --- /dev/null +++ b/tests/test_p2p.py @@ -0,0 +1,101 @@ +"""Tests for the p2p module methods. + +Mirrors the "p2p module" section of go-sdk/node/client_test.go. +""" + +from __future__ import annotations + +from datetime import timedelta + +from mintlayer.node import BannedPeer, Client, PeerInfo, TrustPolicy + +_LIST_BANNED_WIRE = '[["1.2.3.4",{"time":[1700000000,0]}]]' + + +def test_get_peer_count(rpc_server) -> None: + srv = rpc_server(result=7) + client = Client(srv.url) + assert client.get_peer_count() == 7 + assert srv.capture.method == "p2p_get_peer_count" + client.close() + + +def test_get_connected_peers(rpc_server) -> None: + """PeerInfo decodes with a null ping_wait (optional fields absent/null).""" + srv = rpc_server( + result=[ + { + "peer_id": 42, + "address": "1.2.3.4:3031", + "peer_role": "OutboundFullRelay", + "ban_score": 0, + "user_agent": "mintlayer-node/1.3.0", + "software_version": "1.3.0", + "ping_wait": None, + } + ] + ) + client = Client(srv.url) + peers = client.get_connected_peers() + assert peers == [ + PeerInfo( + peer_id=42, + address="1.2.3.4:3031", + peer_role="OutboundFullRelay", + ban_score=0, + user_agent="mintlayer-node/1.3.0", + software_version="1.3.0", + ping_wait=None, + ) + ] + assert len(peers) == 1 + assert peers[0].peer_id == 42 + assert peers[0].ping_wait is None + assert srv.capture.method == "p2p_get_connected_peers" + client.close() + + +def test_list_banned(rpc_server) -> None: + """Wire format: [["addr", {"time": [secs, nanos]}], ...] (raw JSON result).""" + srv = rpc_server(raw=_LIST_BANNED_WIRE) + client = Client(srv.url) + banned = client.list_banned() + assert banned == [BannedPeer(address="1.2.3.4", ban_time=(1700000000, 0))] + assert banned[0].address == "1.2.3.4" + assert banned[0].ban_time == (1700000000, 0) + assert banned[0].ban_time[0] == 1700000000 + assert srv.capture.method == "p2p_list_banned" + client.close() + + +def test_ban_duration_wire_format(rpc_server) -> None: + """Durations are sent as the daemon's two-element [seconds, nanos] array.""" + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.ban("5.6.7.8", timedelta(hours=24)) is None + assert srv.capture.method == "p2p_ban" + duration = srv.capture.params["duration"] + assert isinstance(duration, list) + assert len(duration) == 2 + assert srv.capture.params == {"address": "5.6.7.8", "duration": [86400, 0]} + client.close() + + +def test_ban_sub_second_duration(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.ban("5.6.7.8", timedelta(seconds=1, microseconds=500_000)) + assert srv.capture.params == {"address": "5.6.7.8", "duration": [1, 500000000]} + client.close() + + +def test_p2p_submit_transaction(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.p2p_submit_transaction("cafebabe", TrustPolicy.UNTRUSTED) is None + assert srv.capture.method == "p2p_submit_transaction" + assert srv.capture.params == { + "tx": "cafebabe", + "options": {"trust_policy": "Untrusted"}, + } + client.close() diff --git a/tests/test_transport.py b/tests/test_transport.py new file mode 100644 index 0000000..261cb7a --- /dev/null +++ b/tests/test_transport.py @@ -0,0 +1,88 @@ +"""Transport-level tests: client construction, auth, errors, and wire shape. + +Mirrors the "Transport" and "Error path" sections of go-sdk/node/client_test.go. +""" + +from __future__ import annotations + +import base64 +import json + +import pytest + +from mintlayer.node import Client, RPCError + +_DUMMY_ENDPOINT = "http://127.0.0.1:3030" + + +class TestClientConstruction: + def test_defaults(self) -> None: + client = Client(_DUMMY_ENDPOINT) + assert client._rpc.endpoint == _DUMMY_ENDPOINT + assert client._rpc.username == "" + assert client._rpc.password == "" + assert client._rpc.timeout == 30.0 + client.close() + + def test_timeout_parameter(self) -> None: + client = Client(_DUMMY_ENDPOINT, timeout=5.0) + assert client._rpc.timeout == 5.0 + client.close() + + +def test_basic_auth_header(rpc_server) -> None: + """The Authorization header is sent when a username is set.""" + srv = rpc_server(result="1.0.0") + client = Client(srv.url, username="alice", password="secret") + assert client.node_version() == "1.0.0" + expected = "Basic " + base64.b64encode(b"alice:secret").decode("ascii") + assert srv.capture.headers.get("authorization") == expected + client.close() + + +def test_no_auth_header_without_username(rpc_server) -> None: + """No Authorization header when the username is empty.""" + srv = rpc_server(result="1.0.0") + client = Client(srv.url) + assert client.node_version() == "1.0.0" + assert "authorization" not in srv.capture.headers + client.close() + + +def test_rpc_error(rpc_server) -> None: + srv = rpc_server(error=(-32601, "method not found")) + client = Client(srv.url) + with pytest.raises(RPCError) as excinfo: + client.node_version() + err = excinfo.value + assert err.code == -32601 + assert err.message == "method not found" + assert str(err) == "RPC error -32601: method not found" + client.close() + + +def test_request_wire_shape(rpc_server) -> None: + """Requests POST the full JSON-RPC 2.0 envelope straight to the endpoint.""" + srv = rpc_server(result="ok") + client = Client(srv.url) + client.node_version() + assert srv.capture.method == "node_version" + assert srv.capture.params == {} + assert srv.capture.path == "/" + assert srv.capture.request_count == 1 + assert json.loads(srv.capture.raw_body) == { + "jsonrpc": "2.0", + "id": 1, + "method": "node_version", + "params": {}, + } + client.close() + + +def test_request_ids_increment(rpc_server) -> None: + srv = rpc_server(result="ok") + client = Client(srv.url) + client.node_version() + client.node_version() + assert [payload["id"] for payload in srv.capture.payloads] == [1, 2] + client.close() diff --git a/tests/test_wire_shapes.py b/tests/test_wire_shapes.py new file mode 100644 index 0000000..c4224a1 --- /dev/null +++ b/tests/test_wire_shapes.py @@ -0,0 +1,128 @@ +"""Wire-shape tests for node client methods lacking dedicated coverage. + +Pins the exact RPC method name and params dict sent on the wire for the +chainstate/p2p methods without their own request-shape assertion elsewhere, +mirroring the request-shape checks of go-sdk/node/client_test.go. +""" + +from __future__ import annotations + +from collections.abc import Callable + +import pytest + +from mintlayer.node import Client + +_WIRE_CASES = [ + pytest.param(lambda c: c.get_block("aa"), "chainstate_get_block", {"id": "aa"}, id="get_block"), + pytest.param( + lambda c: c.get_block_json("aa"), + "chainstate_get_block_json", + {"id": "aa"}, + id="get_block_json", + ), + pytest.param( + lambda c: c.block_height_in_main_chain("bb"), + "chainstate_block_height_in_main_chain", + {"block_id": "bb"}, + id="block_height_in_main_chain", + ), + pytest.param( + lambda c: c.get_mainchain_blocks(1, 5), + "chainstate_get_mainchain_blocks", + {"from": 1, "max_count": 5}, + id="get_mainchain_blocks", + ), + pytest.param( + lambda c: c.staker_balance("pool1"), + "chainstate_staker_balance", + {"pool_address": "pool1"}, + id="staker_balance", + ), + pytest.param( + lambda c: c.pool_decommission_destination("pool1"), + "chainstate_pool_decommission_destination", + {"pool_address": "pool1"}, + id="pool_decommission_destination", + ), + pytest.param( + lambda c: c.delegation_share("pool1", "addr1"), + "chainstate_delegation_share", + {"pool_address": "pool1", "delegation_address": "addr1"}, + id="delegation_share", + ), + pytest.param( + lambda c: c.token_info("t1"), + "chainstate_token_info", + {"token_id": "t1"}, + id="token_info", + ), + pytest.param( + lambda c: c.tokens_info(["t1", "t2"]), + "chainstate_tokens_info", + {"token_ids": ["t1", "t2"]}, + id="tokens_info", + ), + pytest.param( + lambda c: c.submit_block("c0ffee"), + "chainstate_submit_block", + {"block_hex": "c0ffee"}, + id="submit_block", + ), + pytest.param( + lambda c: c.get_bind_addresses(), + "p2p_get_bind_addresses", + {}, + id="get_bind_addresses", + ), + pytest.param( + lambda c: c.add_reserved_node("h:1"), + "p2p_add_reserved_node", + {"addr": "h:1"}, + id="add_reserved_node", + ), + pytest.param( + lambda c: c.remove_reserved_node("h:1"), + "p2p_remove_reserved_node", + {"addr": "h:1"}, + id="remove_reserved_node", + ), + pytest.param( + lambda c: c.connect("h:1"), + "p2p_connect", + {"addr": "h:1"}, + id="connect", + ), + pytest.param( + lambda c: c.disconnect(7), + "p2p_disconnect", + {"peer_id": 7}, + id="disconnect", + ), + pytest.param( + lambda c: c.unban("1.2.3.4"), + "p2p_unban", + {"address": "1.2.3.4"}, + id="unban", + ), +] + + +@pytest.mark.parametrize(("invoke", "rpc_method", "expected_params"), _WIRE_CASES) +def test_method_wire_shapes( + rpc_server, + invoke: Callable[[Client], object], + rpc_method: str, + expected_params: dict, +) -> None: + """Each method posts its exact RPC method name and params object. + + The canned server answers JSON null, which every covered method tolerates + (optional -> None, void -> None, list -> [], raw decode -> None). + """ + srv = rpc_server(result=None) + client = Client(srv.url) + invoke(client) + assert srv.capture.method == rpc_method + assert srv.capture.params == expected_params + client.close() From 9e2e69208d23d2a23fbf1399e0022e3ee142cd21 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 02:44:46 +0400 Subject: [PATCH 03/31] Add indexer REST client (port of go-sdk/indexer) All 33 routes under /api/v2: chain, blocks, transactions (incl. the text/plain submit route), addresses, delegations, pools, tokens/NFTs, orders, statistics and fee rate. HTTPError for status >= 400 with trimmed body; base URL trailing-slash trimmed. Lenient numeric decoding per server behavior: uint64 fields arrive as numbers or strings, margin_ratio_per_thousand carries a trailing '%'. Strict uint64 parsing (no negatives/underscores), finite per-thousand values, path segments URL-encoded against traversal, and malformed payloads surface as IndexerError instead of KeyError. Zero-valued pagination params are omitted; block-stats from/to always sent. 59 new tests mirroring Go's indexer client_test.go (116 total passing). ruff + mypy clean. --- mintlayer/_jsonrpc.py | 5 +- mintlayer/indexer/__init__.py | 115 +++++++ mintlayer/indexer/_core.py | 25 ++ mintlayer/indexer/_http.py | 83 +++++ mintlayer/indexer/address.py | 31 ++ mintlayer/indexer/block.py | 28 ++ mintlayer/indexer/chain.py | 21 ++ mintlayer/indexer/delegation.py | 12 + mintlayer/indexer/number.py | 56 ++++ mintlayer/indexer/order.py | 30 ++ mintlayer/indexer/pool.py | 32 ++ mintlayer/indexer/statistics.py | 25 ++ mintlayer/indexer/token.py | 29 ++ mintlayer/indexer/transaction.py | 32 ++ mintlayer/indexer/types.py | 538 ++++++++++++++++++++++++++++++ tests/conftest.py | 147 +++++++- tests/test_indexer_address.py | 104 ++++++ tests/test_indexer_block.py | 100 ++++++ tests/test_indexer_chain.py | 58 ++++ tests/test_indexer_delegation.py | 55 +++ tests/test_indexer_http.py | 106 ++++++ tests/test_indexer_order.py | 74 ++++ tests/test_indexer_pool.py | 141 ++++++++ tests/test_indexer_statistics.py | 61 ++++ tests/test_indexer_token.py | 126 +++++++ tests/test_indexer_transaction.py | 128 +++++++ 26 files changed, 2159 insertions(+), 3 deletions(-) create mode 100644 mintlayer/indexer/__init__.py create mode 100644 mintlayer/indexer/_core.py create mode 100644 mintlayer/indexer/_http.py create mode 100644 mintlayer/indexer/address.py create mode 100644 mintlayer/indexer/block.py create mode 100644 mintlayer/indexer/chain.py create mode 100644 mintlayer/indexer/delegation.py create mode 100644 mintlayer/indexer/number.py create mode 100644 mintlayer/indexer/order.py create mode 100644 mintlayer/indexer/pool.py create mode 100644 mintlayer/indexer/statistics.py create mode 100644 mintlayer/indexer/token.py create mode 100644 mintlayer/indexer/transaction.py create mode 100644 mintlayer/indexer/types.py create mode 100644 tests/test_indexer_address.py create mode 100644 tests/test_indexer_block.py create mode 100644 tests/test_indexer_chain.py create mode 100644 tests/test_indexer_delegation.py create mode 100644 tests/test_indexer_http.py create mode 100644 tests/test_indexer_order.py create mode 100644 tests/test_indexer_pool.py create mode 100644 tests/test_indexer_statistics.py create mode 100644 tests/test_indexer_token.py create mode 100644 tests/test_indexer_transaction.py diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 657c0ae..5810d4c 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -104,5 +104,6 @@ def call(self, method: str, params: Any) -> Any: return body.get("result") def close(self) -> None: - """Close the underlying HTTP session.""" - self._session.close() + """Close the HTTP session (only if the client created it).""" + if self._owns_session: + self._session.close() diff --git a/mintlayer/indexer/__init__.py b/mintlayer/indexer/__init__.py new file mode 100644 index 0000000..bf785a0 --- /dev/null +++ b/mintlayer/indexer/__init__.py @@ -0,0 +1,115 @@ +"""REST client for the Mintlayer indexer. + +Mirrors go-sdk/indexer (Go package ``indexer``). Default port: 3000. +All paths are relative to ``/api/v2``. + + from mintlayer.indexer import Client + + c = Client("http://127.0.0.1:3000") + tip = c.get_tip() + print(tip.block_height, tip.block_id) +""" + +from __future__ import annotations + +import requests + +from ._http import HTTPError, IndexerError, IndexerHTTP +from .address import AddressMixin +from .block import BlockMixin +from .chain import ChainMixin +from .delegation import DelegationMixin +from .order import OrderMixin +from .pool import PoolMixin +from .statistics import StatisticsMixin +from .token import TokenMixin +from .transaction import TransactionMixin +from .types import ( + UTXO, + AddressInfo, + Amount, + Block, + BlockHeader, + ChainTip, + CoinStats, + Delegation, + DelegationInfo, + GenesisInfo, + MerklePath, + NFTInfo, + NFTMetadata, + Order, + PageOpts, + Pool, + PoolDelegation, + PoolListOpts, + Timestamp, + TokenBalance, + TokenInfo, + TokenTx, + Transaction, + UTXOOutpoint, +) + +__all__ = [ + "Client", + "HTTPError", + "IndexerError", + "Amount", + "AddressInfo", + "Block", + "BlockHeader", + "ChainTip", + "CoinStats", + "Delegation", + "DelegationInfo", + "GenesisInfo", + "MerklePath", + "Timestamp", + "NFTInfo", + "NFTMetadata", + "Order", + "PageOpts", + "Pool", + "PoolDelegation", + "PoolListOpts", + "TokenBalance", + "TokenInfo", + "TokenTx", + "Transaction", + "UTXO", + "UTXOOutpoint", +] + + +class Client( + ChainMixin, + BlockMixin, + TransactionMixin, + AddressMixin, + DelegationMixin, + PoolMixin, + TokenMixin, + OrderMixin, + StatisticsMixin, +): + """REST client for the indexer (api-web-server). + + Safe for concurrent use from multiple threads. Any HTTP status >= 400 + raises :class:`HTTPError`. + """ + + def __init__( + self, + base_url: str, + timeout: float = 30.0, + session: requests.Session | None = None, + ) -> None: + """Create an indexer client; trailing slashes on ``base_url`` are trimmed.""" + IndexerHTTP.__init__(self, base_url=base_url, timeout=timeout, session=session) + + def __enter__(self) -> Client: + return self + + def __exit__(self, *_exc: object) -> None: + self.close() diff --git a/mintlayer/indexer/_core.py b/mintlayer/indexer/_core.py new file mode 100644 index 0000000..1baa7ec --- /dev/null +++ b/mintlayer/indexer/_core.py @@ -0,0 +1,25 @@ +"""Shared request helpers for the indexer client mixins.""" + +from __future__ import annotations + +from typing import Any +from urllib.parse import quote + +from ._http import IndexerHTTP + +__all__ = ["IndexerCore", "_seg"] + + +def _seg(value: Any) -> str: + """URL-encode a path segment (defense against path traversal/injection).""" + return quote(str(value), safe="") + + +class IndexerCore(IndexerHTTP): + """Base class providing the typed request helpers used by the mixins.""" + + def _get(self, path: str, query: dict[str, Any] | None = None) -> Any: + return self.get(path, query) + + def _post_text(self, path: str, body: str) -> Any: + return self.post_text(path, body) diff --git a/mintlayer/indexer/_http.py b/mintlayer/indexer/_http.py new file mode 100644 index 0000000..ad91b50 --- /dev/null +++ b/mintlayer/indexer/_http.py @@ -0,0 +1,83 @@ +"""REST client for the Mintlayer indexer (mirrors go-sdk/indexer). + +All paths are relative to the ``/api/v2`` base appended to the configured URL. +Errors: any HTTP status >= 400 raises :class:`HTTPError` with the response +body; transport/decode failures raise :class:`IndexerError`. +""" + +from __future__ import annotations + +from typing import Any + +import requests + +__all__ = ["HTTPError", "IndexerError", "IndexerHTTP"] + + +class IndexerError(Exception): + """Transport or codec failure.""" + + +class HTTPError(Exception): + """Non-2xx HTTP response from the indexer.""" + + def __init__(self, status_code: int, body: str) -> None: + super().__init__(f"HTTP {status_code}: {body}") + self.status_code = status_code + self.body = body + + +class IndexerHTTP: + """HTTP layer for the indexer client (GET + one text/plain POST route).""" + + def __init__( + self, + base_url: str, + timeout: float = 30.0, + session: requests.Session | None = None, + ) -> None: + self.api_base = base_url.rstrip("/") + "/api/v2" + self.timeout = timeout + self._owns_session = session is None + self._session = session if session is not None else requests.Session() + + def get(self, path: str, query: dict[str, Any] | None = None) -> Any: + """GET ``path`` and return the decoded JSON body.""" + url = self.api_base + path + try: + resp = self._session.get( + url, + params=query or None, + timeout=self.timeout, + headers={"Accept": "application/json"}, + ) + except requests.RequestException as exc: + raise IndexerError(f"http request: {exc}") from exc + return self._decode(path, resp) + + def post_text(self, path: str, body: str) -> Any: + """POST ``body`` verbatim as ``text/plain`` and return decoded JSON.""" + url = self.api_base + path + try: + resp = self._session.post( + url, + data=body, + timeout=self.timeout, + headers={"Content-Type": "text/plain", "Accept": "application/json"}, + ) + except requests.RequestException as exc: + raise IndexerError(f"http request: {exc}") from exc + return self._decode(path, resp) + + def _decode(self, path: str, resp: requests.Response) -> Any: + if resp.status_code >= 400: + raise HTTPError(resp.status_code, resp.text.strip()) + try: + return resp.json() + except ValueError as exc: + raise IndexerError(f"decode response for {path}: {exc}") from exc + + def close(self) -> None: + """Close the HTTP session (only if the client created it).""" + if self._owns_session: + self._session.close() diff --git a/mintlayer/indexer/address.py b/mintlayer/indexer/address.py new file mode 100644 index 0000000..3dee833 --- /dev/null +++ b/mintlayer/indexer/address.py @@ -0,0 +1,31 @@ +"""Address endpoints (mirrors go-sdk/indexer/address.go).""" + +from __future__ import annotations + +from ._core import IndexerCore, _seg +from .types import UTXO, AddressInfo, DelegationInfo + + +class AddressMixin(IndexerCore): + def get_address_info(self, address: str) -> AddressInfo: + """Return address balances and history (404 if the address has none).""" + return AddressInfo.from_json(self._get(f"/address/{_seg(address)}")) + + def get_spendable_utxos(self, address: str) -> list[UTXO]: + """Return the address's spendable UTXOs.""" + data = self._get(f"/address/{_seg(address)}/spendable-utxos") + return [UTXO.from_json(u) for u in data or []] + + def get_all_utxos(self, address: str) -> list[UTXO]: + """Return all UTXOs for the address (including timelocked).""" + data = self._get(f"/address/{_seg(address)}/all-utxos") + return [UTXO.from_json(u) for u in data or []] + + def get_delegations(self, address: str) -> list[DelegationInfo]: + """Return the delegations created by the address.""" + data = self._get(f"/address/{_seg(address)}/delegations") + return [DelegationInfo.from_json(d) for d in data or []] + + def get_token_authority(self, address: str) -> list[str]: + """Return the bech32 token IDs the address has authority over.""" + return self._get(f"/address/{_seg(address)}/token-authority") or [] diff --git a/mintlayer/indexer/block.py b/mintlayer/indexer/block.py new file mode 100644 index 0000000..562b6a3 --- /dev/null +++ b/mintlayer/indexer/block.py @@ -0,0 +1,28 @@ +"""Block endpoints (mirrors go-sdk/indexer/block.go).""" + +from __future__ import annotations + +from ._core import IndexerCore, _seg +from .types import ( + Block, + BlockHeader, + Transaction, # noqa: F401 (re-exported for callers) +) + + +class BlockMixin(IndexerCore): + def get_block(self, block_id: str) -> Block: + """Return a block with header and body.""" + return Block.from_json(self._get(f"/block/{_seg(block_id)}")) + + def get_block_header(self, block_id: str) -> BlockHeader: + """Return a block header.""" + return BlockHeader.from_json(self._get(f"/block/{_seg(block_id)}/header")) + + def get_block_reward(self, block_id: str) -> list: + """Return the block reward outputs (raw JSON list).""" + return self._get(f"/block/{_seg(block_id)}/reward") or [] + + def get_block_transaction_ids(self, block_id: str) -> list[str]: + """Return the transaction IDs included in a block.""" + return self._get(f"/block/{_seg(block_id)}/transaction-ids") or [] diff --git a/mintlayer/indexer/chain.py b/mintlayer/indexer/chain.py new file mode 100644 index 0000000..8a68a13 --- /dev/null +++ b/mintlayer/indexer/chain.py @@ -0,0 +1,21 @@ +"""Chain endpoints (mirrors go-sdk/indexer/chain.go).""" + +from __future__ import annotations + +from ._core import IndexerCore, _seg +from .types import ChainTip, GenesisInfo + + +class ChainMixin(IndexerCore): + def get_tip(self) -> ChainTip: + """Return the current chain tip.""" + return ChainTip.from_json(self._get("/chain/tip")) + + def get_genesis(self) -> GenesisInfo: + """Return genesis block info.""" + return GenesisInfo.from_json(self._get("/chain/genesis")) + + def get_block_id_at_height(self, height: int) -> str: + """Return the block ID at ``height`` (raises HTTPError 404 if unknown).""" + result = self._get(f"/chain/{_seg(height)}") + return "" if result is None else str(result) diff --git a/mintlayer/indexer/delegation.py b/mintlayer/indexer/delegation.py new file mode 100644 index 0000000..75a41db --- /dev/null +++ b/mintlayer/indexer/delegation.py @@ -0,0 +1,12 @@ +"""Delegation endpoints (mirrors go-sdk/indexer/delegation.go).""" + +from __future__ import annotations + +from ._core import IndexerCore, _seg +from .types import Delegation + + +class DelegationMixin(IndexerCore): + def get_delegation(self, delegation_id: str) -> Delegation: + """Return a delegation by ID.""" + return Delegation.from_json(self._get(f"/delegation/{_seg(delegation_id)}")) diff --git a/mintlayer/indexer/number.py b/mintlayer/indexer/number.py new file mode 100644 index 0000000..d5f7a36 --- /dev/null +++ b/mintlayer/indexer/number.py @@ -0,0 +1,56 @@ +"""Lenient numeric decoding for indexer payloads (mirrors go-sdk/indexer/number.go). + +The indexer documents several fields as integers/floats but the server +sometimes serialises them as strings (and even with a trailing ``%``). +""" + +from __future__ import annotations + +import math +import re +from typing import Any + +from ._http import IndexerError + +_DIGITS = re.compile(r"\d+") + +__all__ = ["parse_uint64", "parse_per_thousand"] + + +def parse_uint64(data: Any) -> int: + """Accept a bare JSON number or a decimal string; return an int.""" + if isinstance(data, bool): + raise IndexerError(f"Uint64: invalid value {data!r}") + if isinstance(data, int): + if data < 0: + raise IndexerError(f"Uint64: negative value {data!r}") + return data + if isinstance(data, str): + if not _DIGITS.fullmatch(data): + raise IndexerError(f"Uint64: invalid value {data!r}") + return int(data, 10) + raise IndexerError(f"Uint64: invalid value {data!r}") + + +def parse_per_thousand(data: Any) -> float: + """Accept a bare number, a decimal string, or a string with a trailing %.""" + if isinstance(data, bool): + raise IndexerError(f"PerThousand: invalid value {data!r}") + if isinstance(data, (int, float)): + value = float(data) + if not math.isfinite(value): + raise IndexerError(f"PerThousand: non-finite value {data!r}") + return value + if isinstance(data, str): + stripped = data.strip('"') + if stripped.endswith("%"): + stripped = stripped[:-1] + try: + value = float(stripped) + except ValueError as exc: + raise IndexerError(f"PerThousand: {exc}") from exc + else: + value = float(data) + if not math.isfinite(value): + raise IndexerError(f"PerThousand: non-finite value {data!r}") + return value diff --git a/mintlayer/indexer/order.py b/mintlayer/indexer/order.py new file mode 100644 index 0000000..4494678 --- /dev/null +++ b/mintlayer/indexer/order.py @@ -0,0 +1,30 @@ +"""Order endpoints (mirrors go-sdk/indexer/order.go).""" + +from __future__ import annotations + +from ._core import IndexerCore, _seg +from .types import Order, PageOpts + + +class OrderMixin(IndexerCore): + def list_orders(self, opts: PageOpts | None = None) -> list[Order]: + """List DEX orders with pagination.""" + data = self._get("/order", (opts or PageOpts()).query()) + return [Order.from_json(o) for o in data or []] + + def get_order(self, order_id: str) -> Order: + """Return a DEX order by ID.""" + return Order.from_json(self._get(f"/order/{_seg(order_id)}")) + + def list_orders_by_pair( + self, ask_currency: str, give_currency: str, opts: PageOpts | None = None + ) -> list[Order]: + """List orders for a currency pair. + + Currencies are the coin ticker (e.g. ``"ML"``) or a bech32 token ID; + the path is ``/order/pair/{ask}_{give}``. + """ + data = self._get( + f"/order/pair/{_seg(ask_currency)}_{_seg(give_currency)}", (opts or PageOpts()).query() + ) + return [Order.from_json(o) for o in data or []] diff --git a/mintlayer/indexer/pool.py b/mintlayer/indexer/pool.py new file mode 100644 index 0000000..1332743 --- /dev/null +++ b/mintlayer/indexer/pool.py @@ -0,0 +1,32 @@ +"""Pool endpoints (mirrors go-sdk/indexer/pool.go).""" + +from __future__ import annotations + +from datetime import datetime + +from ._core import IndexerCore, _seg +from .types import Pool, PoolDelegation, PoolListOpts + + +class PoolMixin(IndexerCore): + def list_pools(self, opts: PoolListOpts | None = None) -> list[Pool]: + """List staking pools with pagination and optional sort.""" + data = self._get("/pool", (opts or PoolListOpts()).query()) + return [Pool.from_json(p) for p in data or []] + + def get_pool(self, pool_id: str) -> Pool: + """Return a staking pool by ID.""" + return Pool.from_json(self._get(f"/pool/{_seg(pool_id)}")) + + def get_pool_block_stats(self, pool_id: str, from_time: datetime, to_time: datetime) -> int: + """Return the block count produced in the half-open interval [from, to).""" + data = self._get( + f"/pool/{_seg(pool_id)}/block-stats", + {"from": int(from_time.timestamp()), "to": int(to_time.timestamp())}, + ) + return int(data["block_count"]) + + def get_pool_delegations(self, pool_id: str) -> list[PoolDelegation]: + """Return the delegations to a pool.""" + data = self._get(f"/pool/{_seg(pool_id)}/delegations") + return [PoolDelegation.from_json(d) for d in data or []] diff --git a/mintlayer/indexer/statistics.py b/mintlayer/indexer/statistics.py new file mode 100644 index 0000000..904eec9 --- /dev/null +++ b/mintlayer/indexer/statistics.py @@ -0,0 +1,25 @@ +"""Statistics endpoints (mirrors go-sdk/indexer/statistics.go).""" + +from __future__ import annotations + +from ._core import IndexerCore +from .types import CoinStats + + +class StatisticsMixin(IndexerCore): + def get_coin_statistics(self) -> CoinStats: + """Return circulating/preminted/burned/staked coin totals.""" + return CoinStats.from_json(self._get("/statistics/coin")) + + def get_token_statistics(self, token_id: str) -> CoinStats: + """Return the same statistics for a token.""" + return CoinStats.from_json(self._get(f"/statistics/token/{token_id}")) + + def get_fee_rate(self, in_top_x_mb: int = 0) -> str: + """Return the fee rate (atoms per KB) as a decimal string. + + ``in_top_x_mb`` is omitted when zero, using the server default (5 MB). + """ + query = {"in_top_x_mb": in_top_x_mb} if in_top_x_mb > 0 else None + result = self._get("/feerate", query) + return "" if result is None else str(result) diff --git a/mintlayer/indexer/token.py b/mintlayer/indexer/token.py new file mode 100644 index 0000000..9352286 --- /dev/null +++ b/mintlayer/indexer/token.py @@ -0,0 +1,29 @@ +"""Token / NFT endpoints (mirrors go-sdk/indexer/token.go).""" + +from __future__ import annotations + +from ._core import IndexerCore, _seg +from .types import NFTInfo, PageOpts, TokenInfo, TokenTx + + +class TokenMixin(IndexerCore): + def list_tokens(self, opts: PageOpts | None = None) -> list[str]: + """List token IDs with pagination.""" + return self._get("/token", (opts or PageOpts()).query()) or [] + + def get_token(self, token_id: str) -> TokenInfo: + """Return token info by ID.""" + return TokenInfo.from_json(self._get(f"/token/{_seg(token_id)}")) + + def get_token_transactions(self, token_id: str, opts: PageOpts | None = None) -> list[TokenTx]: + """List transactions involving the token.""" + data = self._get(f"/token/{_seg(token_id)}/transactions", (opts or PageOpts()).query()) + return [TokenTx.from_json(t) for t in data or []] + + def find_tokens_by_ticker(self, ticker: str, opts: PageOpts | None = None) -> list[str]: + """Find token IDs by ticker symbol.""" + return self._get(f"/token/ticker/{_seg(ticker)}", (opts or PageOpts()).query()) or [] + + def get_nft(self, token_id: str) -> NFTInfo: + """Return NFT info by token ID.""" + return NFTInfo.from_json(self._get(f"/nft/{_seg(token_id)}")) diff --git a/mintlayer/indexer/transaction.py b/mintlayer/indexer/transaction.py new file mode 100644 index 0000000..231dbc6 --- /dev/null +++ b/mintlayer/indexer/transaction.py @@ -0,0 +1,32 @@ +"""Transaction endpoints (mirrors go-sdk/indexer/transaction.go).""" + +from __future__ import annotations + +from typing import Any + +from ._core import IndexerCore, _seg +from .types import MerklePath, PageOpts, Transaction + + +class TransactionMixin(IndexerCore): + def list_transactions(self, opts: PageOpts | None = None) -> list[Transaction]: + """List transactions with pagination.""" + data = self._get("/transaction", (opts or PageOpts()).query()) + return [Transaction.from_json(t) for t in data or []] + + def get_transaction(self, tx_id: str) -> Transaction: + """Return a transaction by ID.""" + return Transaction.from_json(self._get(f"/transaction/{_seg(tx_id)}")) + + def get_transaction_merkle_path(self, tx_id: str) -> MerklePath: + """Return the merkle path of a transaction (404 until it is in a block).""" + return MerklePath.from_json(self._get(f"/transaction/{_seg(tx_id)}/merkle-path")) + + def get_transaction_output(self, tx_id: str, output_index: int) -> Any: + """Return a transaction output as raw JSON (includes spent_at_block_height).""" + return self._get(f"/transaction/{_seg(tx_id)}/output/{output_index}") + + def submit_transaction(self, signed_tx_hex: str) -> str: + """Submit a signed transaction (hex) — requires ``--enable-post-routes``.""" + data = self._post_text("/transaction", signed_tx_hex) + return str(data["tx_id"]) diff --git a/mintlayer/indexer/types.py b/mintlayer/indexer/types.py new file mode 100644 index 0000000..8688f45 --- /dev/null +++ b/mintlayer/indexer/types.py @@ -0,0 +1,538 @@ +"""Types for the indexer REST client (mirrors go-sdk/indexer/types.go). + +Amounts carry both ``atoms`` and ``decimal`` as plain strings. Fields the +server serialises leniently (numbers-as-strings) are parsed via +:mod:`mintlayer.indexer.number`. Raw JSON passthroughs are typed ``Any``. +""" + +from __future__ import annotations + +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any, TypeVar + +from ._http import IndexerError +from .number import parse_per_thousand, parse_uint64 + +_T = TypeVar("_T") + +__all__ = [ + "Amount", + "Timestamp", + "ChainTip", + "GenesisInfo", + "BlockHeader", + "BlockBody", + "Block", + "Transaction", + "MerklePath", + "TokenBalance", + "AddressInfo", + "UTXOOutpoint", + "UTXO", + "DelegationInfo", + "Pool", + "Delegation", + "PoolDelegation", + "TokenInfo", + "TokenTx", + "NFTMetadata", + "NFTInfo", + "Order", + "CoinStats", + "PageOpts", + "PoolListOpts", +] + + +@dataclass(frozen=True) +class Amount: + """Coin/token amount in atoms and decimal form (both plain strings).""" + + atoms: str + decimal: str + + @classmethod + def from_json(cls, data: dict) -> Amount: + return cls(atoms=data.get("atoms", ""), decimal=data.get("decimal", "")) + + +@dataclass(frozen=True) +class Timestamp: + """Unix seconds.""" + + timestamp: int + + @classmethod + def from_json(cls, data: dict) -> Timestamp: + return cls(timestamp=int(data["timestamp"])) + + +@dataclass(frozen=True) +class ChainTip: + block_height: int + block_id: str + + @classmethod + def from_json(cls, data: dict) -> ChainTip: + return cls( + block_height=parse_uint64(data["block_height"]), + block_id=data["block_id"], + ) + + +@dataclass(frozen=True) +class GenesisInfo: + block_id: str + genesis_message: str + timestamp: Timestamp + utxos: Any + + @classmethod + def from_json(cls, data: dict) -> GenesisInfo: + return cls( + block_id=data["block_id"], + genesis_message=data["genesis_message"], + timestamp=Timestamp.from_json(data["timestamp"]), + utxos=data.get("utxos"), + ) + + +@dataclass(frozen=True) +class BlockHeader: + previous_block_id: str + timestamp: Timestamp + merkle_root: str + witness_merkle_root: str + consensus_data: Any + + @classmethod + def from_json(cls, data: dict) -> BlockHeader: + return cls( + previous_block_id=data["previous_block_id"], + timestamp=Timestamp.from_json(data["timestamp"]), + merkle_root=data["merkle_root"], + witness_merkle_root=data["witness_merkle_root"], + consensus_data=data.get("consensus_data"), + ) + + +@dataclass(frozen=True) +class BlockBody: + reward: Any + transactions: list[Transaction] + + @classmethod + def from_json(cls, data: dict) -> BlockBody: + return cls( + reward=data.get("reward"), + transactions=[Transaction.from_json(t) for t in data.get("transactions") or []], + ) + + +@dataclass(frozen=True) +class Block: + height: int + header: BlockHeader + body: BlockBody + + @classmethod + def from_json(cls, data: dict) -> Block: + return cls( + height=parse_uint64(data["height"]), + header=BlockHeader.from_json(data["header"]), + body=BlockBody.from_json(data["body"]), + ) + + +@dataclass(frozen=True) +class Transaction: + """Block ID / timestamp / confirmations are empty strings when unconfirmed.""" + + id: str + inputs: Any + outputs: Any + block_id: str + timestamp: str + confirmations: str + + @classmethod + def from_json(cls, data: dict) -> Transaction: + return cls( + id=data["id"], + inputs=data.get("inputs"), + outputs=data.get("outputs"), + block_id=data.get("block_id", ""), + timestamp=data.get("timestamp", ""), + confirmations=data.get("confirmations", ""), + ) + + +@dataclass(frozen=True) +class MerklePath: + block_id: str + transaction_index: int + merkle_root: str + path: list[str] + + @classmethod + def from_json(cls, data: dict) -> MerklePath: + return cls( + block_id=data["block_id"], + merkle_root=data["merkle_root"], + transaction_index=parse_uint64(data["transaction_index"]), + path=data.get("merkle_path") or [], + ) + + +@dataclass(frozen=True) +class TokenBalance: + token_id: str + amount: Amount + + @classmethod + def from_json(cls, data: dict) -> TokenBalance: + return cls(token_id=data["token_id"], amount=Amount.from_json(data["amount"])) + + +@dataclass(frozen=True) +class AddressInfo: + coin_balance: Amount + locked_coin_balance: Amount + transaction_history: list[str] + tokens: list[TokenBalance] + + @classmethod + def from_json(cls, data: dict) -> AddressInfo: + return cls( + coin_balance=Amount.from_json(data["coin_balance"]), + locked_coin_balance=Amount.from_json(data["locked_coin_balance"]), + transaction_history=data.get("transaction_history") or [], + tokens=[TokenBalance.from_json(t) for t in data.get("tokens") or []], + ) + + +@dataclass(frozen=True) +class UTXOOutpoint: + source_id: str + index: int + + @classmethod + def from_json(cls, data: dict) -> UTXOOutpoint: + return cls( + source_id=data["source_id"], + index=parse_uint64(data["index"]), + ) + + +@dataclass(frozen=True) +class UTXO: + """Field/JSON-tag note: the output payload lives under the key ``utxo``.""" + + outpoint: UTXOOutpoint + output: Any + + @classmethod + def from_json(cls, data: dict) -> UTXO: + return cls( + outpoint=UTXOOutpoint.from_json(data["outpoint"]), + output=data.get("utxo"), + ) + + +@dataclass(frozen=True) +class DelegationInfo: + """Address-scoped delegation (no creation height).""" + + delegation_id: str + pool_id: str + next_nonce: int + spend_destination: str + balance: Amount + + @classmethod + def from_json(cls, data: dict) -> DelegationInfo: + return cls( + delegation_id=data["delegation_id"], + pool_id=data["pool_id"], + next_nonce=parse_uint64(data["next_nonce"]), + spend_destination=data["spend_destination"], + balance=Amount.from_json(data["balance"]), + ) + + +@dataclass(frozen=True) +class Pool: + pool_id: str + decommission_destination: str + staker_balance: Amount + margin_ratio_per_thousand: float + cost_per_block: Amount + vrf_public_key: str + delegations_balance: Amount + + @classmethod + def from_json(cls, data: dict) -> Pool: + return cls( + pool_id=data["pool_id"], + decommission_destination=data["decommission_destination"], + staker_balance=Amount.from_json(data["staker_balance"]), + margin_ratio_per_thousand=parse_per_thousand(data["margin_ratio_per_thousand"]), + cost_per_block=Amount.from_json(data["cost_per_block"]), + vrf_public_key=data["vrf_public_key"], + delegations_balance=Amount.from_json(data["delegations_balance"]), + ) + + +@dataclass(frozen=True) +class Delegation: + delegation_id: str + pool_id: str + next_nonce: int + spend_destination: str + balance: Amount + creation_block_height: int + + @classmethod + def from_json(cls, data: dict) -> Delegation: + return cls( + delegation_id=data["delegation_id"], + pool_id=data["pool_id"], + next_nonce=parse_uint64(data["next_nonce"]), + spend_destination=data["spend_destination"], + balance=Amount.from_json(data["balance"]), + creation_block_height=parse_uint64(data["creation_block_height"]), + ) + + +@dataclass(frozen=True) +class PoolDelegation: + """Delegation as seen from a pool (no pool ID field).""" + + delegation_id: str + next_nonce: int + spend_destination: str + balance: Amount + creation_block_height: int + + @classmethod + def from_json(cls, data: dict) -> PoolDelegation: + return cls( + delegation_id=data["delegation_id"], + next_nonce=parse_uint64(data["next_nonce"]), + spend_destination=data["spend_destination"], + balance=Amount.from_json(data["balance"]), + creation_block_height=parse_uint64(data["creation_block_height"]), + ) + + +@dataclass(frozen=True) +class TokenInfo: + """Indexer token info. + + ``is_token_unfreezable`` is set only when frozen; ``is_token_freezable`` + only when not frozen (mirrors the Go pointer semantics). + """ + + authority: str + is_locked: bool + circulating_supply: Amount + token_ticker: str + metadata_uri: str + number_of_decimals: int + total_supply: Any + frozen: bool + is_token_unfreezable: bool | None + is_token_freezable: bool | None + next_nonce: int + + @classmethod + def from_json(cls, data: dict) -> TokenInfo: + return cls( + authority=data["authority"], + is_locked=data["is_locked"], + circulating_supply=Amount.from_json(data["circulating_supply"]), + token_ticker=data["token_ticker"], + metadata_uri=data["metadata_uri"], + number_of_decimals=parse_uint64(data["number_of_decimals"]), + total_supply=data.get("total_supply"), + frozen=data["frozen"], + is_token_unfreezable=data.get("is_token_unfreezable"), + is_token_freezable=data.get("is_token_freezable"), + next_nonce=parse_uint64(data["next_nonce"]), + ) + + +@dataclass(frozen=True) +class TokenTx: + tx_global_index: int + tx_id: str + + @classmethod + def from_json(cls, data: dict) -> TokenTx: + return cls( + tx_global_index=parse_uint64(data["tx_global_index"]), + tx_id=data["tx_id"], + ) + + +@dataclass(frozen=True) +class NFTMetadata: + creator: str | None + name: str + description: str + ticker: str + icon_uri: str | None + additional_metadata_uri: str | None + media_uri: str | None + media_hash: str + + @classmethod + def from_json(cls, data: dict) -> NFTMetadata: + return cls( + creator=data.get("creator"), + name=data["name"], + description=data["description"], + ticker=data["ticker"], + icon_uri=data.get("icon_uri"), + additional_metadata_uri=data.get("additional_metadata_uri"), + media_uri=data.get("media_uri"), + media_hash=data["media_hash"], + ) + + +@dataclass(frozen=True) +class NFTInfo: + owner: str + token_id: str + metadata: NFTMetadata + + @classmethod + def from_json(cls, data: dict) -> NFTInfo: + return cls( + owner=data["owner"], + token_id=data["token_id"], + metadata=NFTMetadata.from_json(data["metadata"]), + ) + + +@dataclass(frozen=True) +class Order: + order_id: str + conclude_destination: str + give_currency: Any + initially_given: Amount + give_balance: Amount + ask_currency: Any + initially_asked: Amount + ask_balance: Amount + nonce: int + + @classmethod + def from_json(cls, data: dict) -> Order: + return cls( + order_id=data["order_id"], + conclude_destination=data["conclude_destination"], + give_currency=data.get("give_currency"), + initially_given=Amount.from_json(data["initially_given"]), + give_balance=Amount.from_json(data["give_balance"]), + ask_currency=data.get("ask_currency"), + initially_asked=Amount.from_json(data["initially_asked"]), + ask_balance=Amount.from_json(data["ask_balance"]), + nonce=parse_uint64(data["nonce"]), + ) + + +@dataclass(frozen=True) +class CoinStats: + circulating_supply: Amount + preminted: Amount + burned: Amount + staked: Amount + + @classmethod + def from_json(cls, data: dict) -> CoinStats: + return cls( + circulating_supply=Amount.from_json(data["circulating_supply"]), + preminted=Amount.from_json(data["preminted"]), + burned=Amount.from_json(data["burned"]), + staked=Amount.from_json(data["staked"]), + ) + + +@dataclass(frozen=True) +class PageOpts: + """Pagination; zero values use the server defaults (offset=0, items=10).""" + + offset: int = 0 + items: int = 0 + + def query(self) -> dict[str, Any]: + q: dict[str, Any] = {} + if self.offset > 0: + q["offset"] = self.offset + if self.items > 0: + q["items"] = self.items + return q + + +@dataclass(frozen=True) +class PoolListOpts: + """Pool listing options: pagination plus an optional sort order. + + ``sort`` is ``"by_height"`` (default, newest first) or ``"by_pledge"`` + (largest staker balance first); omitted when empty. + """ + + offset: int = 0 + items: int = 0 + sort: str = "" + + def query(self) -> dict[str, Any]: + q = PageOpts(offset=self.offset, items=self.items).query() + if self.sort: + q["sort"] = self.sort + return q + + +def _safe_from_json(cls: type[_T]) -> classmethod: + """Wrap a from_json classmethod so malformed payloads raise IndexerError.""" + original: Callable[[type[_T], Any], _T] = cls.from_json.__func__ # type: ignore[attr-defined] + + def from_json(cls_: type[_T], data: Any) -> _T: + try: + return original(cls_, data) + except IndexerError: + raise + except (KeyError, TypeError, ValueError) as exc: + raise IndexerError(f"{cls_.__name__}: malformed payload ({exc!r})") from exc + + return classmethod(from_json) + + +for _cls in ( + Amount, + Timestamp, + ChainTip, + GenesisInfo, + BlockHeader, + BlockBody, + Block, + Transaction, + MerklePath, + TokenBalance, + AddressInfo, + UTXOOutpoint, + UTXO, + DelegationInfo, + Pool, + Delegation, + PoolDelegation, + TokenInfo, + TokenTx, + NFTMetadata, + NFTInfo, + Order, + CoinStats, +): + _cls.from_json = _safe_from_json(_cls) # type: ignore[assignment,method-assign] diff --git a/tests/conftest.py b/tests/conftest.py index ef3386f..272cd13 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -12,9 +12,14 @@ * :class:`Capture` -- records the last request (method name, params, headers, path, raw body, request count) plus every echoed request id, so tests can pin exact wire shapes. +* :func:`make_rest_server` -- plain REST server for the indexer client: + answers GET *and* POST with a canned JSON payload (or verbatim raw text), + any HTTP status, and records the HTTP verb, path, query string, headers, + and raw body on a :class:`RESTCapture`. Prefer the :func:`rpc_server` fixture: it is a factory that starts servers -(threading daemons) and guarantees shutdown in teardown. +(threading daemons) and guarantees shutdown in teardown. The indexer REST +tests use the :func:`rest_server` factory fixture, which works the same way. """ from __future__ import annotations @@ -233,3 +238,143 @@ def _start( for handle in handles: handle.stop() + + +# --- REST servers (indexer client) ------------------------------------------- + + +class RESTCapture(Capture): + """Capture for the REST servers. + + The inherited ``method`` field holds the *HTTP verb* (``"GET"`` / + ``"POST"``), ``path`` the path *without* the query string, and ``query`` + the raw query string (``""`` when absent). ``raw_body`` carries the + verbatim request body (empty for GET). + """ + + def __init__(self) -> None: + super().__init__() + self.query: str | None = None + self.verbs: list[str] = [] + self.paths: list[str] = [] + self.queries: list[str] = [] + + def record_rest( + self, + *, + verb: str, + path: str, + query: str, + headers: dict[str, str], + raw_body: bytes, + ) -> None: + with self._lock: + self.method = verb + self.params = None + self.headers = dict(headers) + self.path = path + self.query = query + self.raw_body = raw_body + self.request_count += 1 + self.request_ids.append(None) + self.payloads.append({}) + self.verbs.append(verb) + self.paths.append(path) + self.queries.append(query) + + +def _make_rest_handler(capture: RESTCapture, body: bytes, status: int, content_type: str): + class Handler(BaseHTTPRequestHandler): + protocol_version = "HTTP/1.1" + + def _handle(self) -> None: + length = int(self.headers.get("Content-Length") or 0) + raw_body = self.rfile.read(length) if length else b"" + path, _, query = self.path.partition("?") + capture.record_rest( + verb=self.command, + path=path, + query=query, + headers={str(k).lower(): str(v) for k, v in self.headers.items()}, + raw_body=raw_body, + ) + self._respond(status, body) + + do_GET = _handle + do_POST = _handle + + def _respond(self, status: int, body: bytes) -> None: + self.send_response(status) + self.send_header("Content-Type", content_type) + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + def log_message(self, format: str, *args: object) -> None: + pass # keep test output clean + + return Handler + + +def make_rest_server( + payload: Any = None, + *, + raw: str | bytes | None = None, + status: int = 200, + content_type: str = "application/json", +) -> ServerHandle: + """Start a REST server answering every GET/POST identically. + + ``payload`` is JSON-encoded; ``raw`` (string or bytes) is served verbatim + instead, pinning exact wire shapes. ``status`` may be any code, e.g. 404 + or 500, to exercise the error paths. Prefer the :func:`rest_server` + fixture so servers are always stopped. + """ + if raw is not None: + body = raw if isinstance(raw, bytes) else str(raw).encode("utf-8") + else: + body = json.dumps(payload).encode("utf-8") + capture = RESTCapture() + httpd = ThreadingHTTPServer((_HOST, 0), _make_rest_handler(capture, body, status, content_type)) + thread = threading.Thread( + target=httpd.serve_forever, + daemon=True, + name="rest-test-server", + ) + thread.start() + return ServerHandle(httpd=httpd, capture=capture, thread=thread) + + +@pytest.fixture +def rest_server(): + """Factory fixture that starts/stops in-process REST test servers. + + Usage:: + + srv = rest_server(payload={"block_height": 1}) + client = indexer.Client(srv.url) + client.get_tip() + assert srv.capture.path == "/api/v2/chain/tip" + + Keyword alternatives: ``raw=""`` to serve a verbatim body, ``status`` + for arbitrary HTTP status codes (404/500), and ``content_type`` to pin the + response Content-Type. Every server started through the factory is shut + down in teardown. + """ + handles: list[ServerHandle] = [] + + def _start( + payload: Any = None, + *, + raw: str | bytes | None = None, + status: int = 200, + content_type: str = "application/json", + ) -> ServerHandle: + handle = make_rest_server(payload, raw=raw, status=status, content_type=content_type) + handles.append(handle) + return handle + + yield _start + + for handle in handles: + handle.stop() diff --git a/tests/test_indexer_address.py b/tests/test_indexer_address.py new file mode 100644 index 0000000..577e436 --- /dev/null +++ b/tests/test_indexer_address.py @@ -0,0 +1,104 @@ +"""Tests for the indexer address endpoints. + +Mirrors the "Address (3e)" section of go-sdk/indexer/client_test.go. Note the +wire quirk: a UTXO's output payload lives under the key ``utxo``. +""" + +from __future__ import annotations + +from mintlayer.indexer import UTXO, AddressInfo, Client, DelegationInfo, TokenBalance + + +def test_get_address_info(rest_server) -> None: + srv = rest_server( + payload={ + "coin_balance": {"atoms": "100000000000", "decimal": "1.0"}, + "locked_coin_balance": {"atoms": "0", "decimal": "0"}, + "transaction_history": ["tx1", "tx2"], + "tokens": [ + { + "token_id": "mmltk1tok", + "amount": {"atoms": "700", "decimal": "0.0000007"}, + } + ], + } + ) + client = Client(srv.url) + info = client.get_address_info("mtc1abc") + assert isinstance(info, AddressInfo) + assert info.coin_balance.atoms == "100000000000" + assert info.coin_balance.decimal == "1.0" + assert info.locked_coin_balance.atoms == "0" + assert len(info.transaction_history) == 2 + assert isinstance(info.tokens[0], TokenBalance) + assert info.tokens[0].token_id == "mmltk1tok" + assert info.tokens[0].amount.atoms == "700" + assert srv.capture.path == "/api/v2/address/mtc1abc" + client.close() + + +def _utxo(source_id: str, index: int) -> dict: + return { + "outpoint": {"source_id": source_id, "index": index}, + "utxo": {"Transfer": {"destination": "mtc1abc", "amount": {"atoms": "100"}}}, + } + + +def test_get_spendable_utxos(rest_server) -> None: + """UTXOs decode with the output payload taken from the wire key ``utxo``.""" + srv = rest_server(payload=[_utxo("tx1", 0), _utxo("tx2", 1)]) + client = Client(srv.url) + utxos = client.get_spendable_utxos("mtc1abc") + assert len(utxos) == 2 + assert all(isinstance(u, UTXO) for u in utxos) + assert utxos[0].outpoint.source_id == "tx1" + assert utxos[0].outpoint.index == 0 + assert utxos[1].outpoint.source_id == "tx2" + assert utxos[1].outpoint.index == 1 + assert utxos[0].output == {"Transfer": {"destination": "mtc1abc", "amount": {"atoms": "100"}}} + assert srv.capture.path == "/api/v2/address/mtc1abc/spendable-utxos" + client.close() + + +def test_get_all_utxos(rest_server) -> None: + srv = rest_server(payload=[_utxo("tx1", 0)]) + client = Client(srv.url) + utxos = client.get_all_utxos("mtc1abc") + assert len(utxos) == 1 + assert utxos[0].outpoint.source_id == "tx1" + assert srv.capture.path == "/api/v2/address/mtc1abc/all-utxos" + client.close() + + +def test_get_delegations(rest_server) -> None: + srv = rest_server( + payload=[ + { + "delegation_id": "mdelg1abc", + "pool_id": "mpool1xyz", + "next_nonce": 3, + "spend_destination": "mtc1dest", + "balance": {"atoms": "500000000000", "decimal": "5.0"}, + } + ] + ) + client = Client(srv.url) + delegations = client.get_delegations("mtc1abc") + assert len(delegations) == 1 + assert isinstance(delegations[0], DelegationInfo) + assert delegations[0].delegation_id == "mdelg1abc" + assert delegations[0].pool_id == "mpool1xyz" + assert delegations[0].next_nonce == 3 + assert delegations[0].balance.atoms == "500000000000" + assert srv.capture.path == "/api/v2/address/mtc1abc/delegations" + client.close() + + +def test_get_token_authority(rest_server) -> None: + srv = rest_server(payload=["mmltk1aaa", "mmltk1bbb"]) + client = Client(srv.url) + token_ids = client.get_token_authority("mtc1abc") + assert len(token_ids) == 2 + assert token_ids[0] == "mmltk1aaa" + assert srv.capture.path == "/api/v2/address/mtc1abc/token-authority" + client.close() diff --git a/tests/test_indexer_block.py b/tests/test_indexer_block.py new file mode 100644 index 0000000..4049617 --- /dev/null +++ b/tests/test_indexer_block.py @@ -0,0 +1,100 @@ +"""Tests for the indexer block endpoints. + +Mirrors the "Block (3c)" section of go-sdk/indexer/client_test.go, plus a +full Block/BlockHeader/BlockBody/Transaction decode pin. +""" + +from __future__ import annotations + +from mintlayer.indexer import Block, BlockHeader, Client, Transaction + + +def _block_payload() -> dict: + return { + "height": 5, + "header": { + "previous_block_id": "prevblock01", + "timestamp": {"timestamp": 1700000000}, + "merkle_root": "merkleroot01", + "witness_merkle_root": "witnessroot01", + "consensus_data": {"PoS": {"vrf_output": "vrf01"}}, + }, + "body": { + "reward": [{"Transfer": {"amount": {"atoms": "100"}}}], + "transactions": [ + { + "id": "tx01", + "inputs": [], + "outputs": [], + "block_id": "block01", + "timestamp": "1700000000", + "confirmations": "3", + } + ], + }, + } + + +def test_get_block_full_decode(rest_server) -> None: + srv = rest_server(payload=_block_payload()) + client = Client(srv.url) + block = client.get_block("aabbccdd") + assert isinstance(block, Block) + assert block.height == 5 + assert isinstance(block.header, BlockHeader) + assert block.header.previous_block_id == "prevblock01" + assert block.header.timestamp.timestamp == 1700000000 + assert block.header.merkle_root == "merkleroot01" + assert block.header.witness_merkle_root == "witnessroot01" + assert block.header.consensus_data == {"PoS": {"vrf_output": "vrf01"}} + assert isinstance(block.body.transactions[0], Transaction) + assert block.body.transactions[0].id == "tx01" + assert block.body.transactions[0].confirmations == "3" + assert srv.capture.path == "/api/v2/block/aabbccdd" + client.close() + + +def test_get_block_header(rest_server) -> None: + srv = rest_server( + payload={ + "previous_block_id": "prevblock", + "timestamp": {"timestamp": 1700000000}, + "merkle_root": "merkleroot", + "witness_merkle_root": "witnessroot", + } + ) + client = Client(srv.url) + header = client.get_block_header("blockid01") + assert isinstance(header, BlockHeader) + assert header.previous_block_id == "prevblock" + assert header.merkle_root == "merkleroot" + assert srv.capture.path == "/api/v2/block/blockid01/header" + client.close() + + +def test_get_block_reward_raw_list(rest_server) -> None: + """The reward is returned as raw JSON (no typed decode).""" + reward = [{"Transfer": {"amount": {"atoms": "1000000000000"}}}] + srv = rest_server(payload=reward) + client = Client(srv.url) + assert client.get_block_reward("aabbccdd") == reward + assert srv.capture.path == "/api/v2/block/aabbccdd/reward" + client.close() + + +def test_get_block_transaction_ids(rest_server) -> None: + srv = rest_server(payload=["tx1", "tx2", "tx3"]) + client = Client(srv.url) + ids = client.get_block_transaction_ids("aabbccdd") + assert len(ids) == 3 + assert ids[0] == "tx1" + assert srv.capture.path == "/api/v2/block/aabbccdd/transaction-ids" + client.close() + + +def test_get_block_transaction_ids_null_result(rest_server) -> None: + """A JSON null result maps to an empty list.""" + srv = rest_server(payload=None) + client = Client(srv.url) + assert client.get_block_transaction_ids("aabbccdd") == [] + client.close() diff --git a/tests/test_indexer_chain.py b/tests/test_indexer_chain.py new file mode 100644 index 0000000..e8f40af --- /dev/null +++ b/tests/test_indexer_chain.py @@ -0,0 +1,58 @@ +"""Tests for the indexer chain endpoints. + +Mirrors the "Chain (3b)" section of go-sdk/indexer/client_test.go. +""" + +from __future__ import annotations + +from mintlayer.indexer import ChainTip, Client, GenesisInfo +from mintlayer.indexer.types import Timestamp # not re-exported by the package + + +def test_get_tip(rest_server) -> None: + srv = rest_server(payload={"block_height": 123456, "block_id": "aabbccdd"}) + client = Client(srv.url) + tip = client.get_tip() + assert isinstance(tip, ChainTip) + assert tip.block_height == 123456 + assert tip.block_id == "aabbccdd" + assert srv.capture.path == "/api/v2/chain/tip" + client.close() + + +def test_get_genesis(rest_server) -> None: + """The genesis timestamp is a nested ``{"timestamp": }``.""" + srv = rest_server( + payload={ + "block_id": "genesisid", + "genesis_message": "mintlayer", + "timestamp": {"timestamp": 1700000000}, + } + ) + client = Client(srv.url) + genesis = client.get_genesis() + assert isinstance(genesis, GenesisInfo) + assert genesis.block_id == "genesisid" + assert genesis.genesis_message == "mintlayer" + assert genesis.timestamp == Timestamp(timestamp=1700000000) + assert genesis.timestamp.timestamp == 1700000000 + assert srv.capture.path == "/api/v2/chain/genesis" + client.close() + + +def test_get_block_id_at_height(rest_server) -> None: + """The endpoint returns a bare JSON string block ID.""" + srv = rest_server(payload="deadbeef0102") + client = Client(srv.url) + assert client.get_block_id_at_height(100000) == "deadbeef0102" + assert srv.capture.path == "/api/v2/chain/100000" + client.close() + + +def test_get_block_id_at_height_path_contains_height(rest_server) -> None: + srv = rest_server(payload="aabb") + client = Client(srv.url) + client.get_block_id_at_height(12345) + assert srv.capture.path.endswith("/chain/12345") + assert "12345" in srv.capture.path + client.close() diff --git a/tests/test_indexer_delegation.py b/tests/test_indexer_delegation.py new file mode 100644 index 0000000..7c5f9ce --- /dev/null +++ b/tests/test_indexer_delegation.py @@ -0,0 +1,55 @@ +"""Tests for the indexer delegation endpoint. + +Mirrors the lenient-numeric raw-wire cases of go-sdk/indexer/client_test.go +(TestDelegation_NextNonce_StringForm): the server serialises several numeric +fields as strings. +""" + +from __future__ import annotations + +import json + +from mintlayer.indexer import Client, Delegation + + +def _delegation_payload(**overrides: object) -> dict: + payload = { + "delegation_id": "mdelg1abc", + "pool_id": "mpool1xyz", + "next_nonce": 7, + "spend_destination": "mtc1dest", + "balance": {"atoms": "500000000000", "decimal": "5.0"}, + "creation_block_height": 10000, + } + payload.update(overrides) + return payload + + +def test_get_delegation(rest_server) -> None: + """Plain numeric wire values decode to ints.""" + srv = rest_server(payload=_delegation_payload()) + client = Client(srv.url) + delegation = client.get_delegation("mdelg1abc") + assert isinstance(delegation, Delegation) + assert delegation.delegation_id == "mdelg1abc" + assert delegation.pool_id == "mpool1xyz" + assert delegation.next_nonce == 7 + assert delegation.spend_destination == "mtc1dest" + assert delegation.balance.atoms == "500000000000" + assert delegation.creation_block_height == 10000 + assert srv.capture.path == "/api/v2/delegation/mdelg1abc" + client.close() + + +def test_get_delegation_string_encoded_numerics(rest_server) -> None: + """``next_nonce``/``creation_block_height`` as strings parse to ints.""" + srv = rest_server( + raw=json.dumps(_delegation_payload(next_nonce="7", creation_block_height="10000")) + ) + client = Client(srv.url) + delegation = client.get_delegation("mdelg1abc") + assert delegation.next_nonce == 7 + assert delegation.creation_block_height == 10000 + assert isinstance(delegation.next_nonce, int) + assert isinstance(delegation.creation_block_height, int) + client.close() diff --git a/tests/test_indexer_http.py b/tests/test_indexer_http.py new file mode 100644 index 0000000..00c132c --- /dev/null +++ b/tests/test_indexer_http.py @@ -0,0 +1,106 @@ +"""Transport-level tests for the indexer REST client. + +Mirrors the "Transport" and "HTTP error path" sections of +go-sdk/indexer/client_test.go, plus base-URL handling. +""" + +from __future__ import annotations + +import pytest +import requests + +from mintlayer.indexer import Client, HTTPError, IndexerError + + +class TestClientConstruction: + def test_defaults(self) -> None: + client = Client("http://127.0.0.1:3000") + assert client.api_base == "http://127.0.0.1:3000/api/v2" + assert client.timeout == 30.0 + client.close() + + def test_timeout_parameter(self) -> None: + client = Client("http://127.0.0.1:3000", timeout=5.0) + assert client.timeout == 5.0 + client.close() + + def test_custom_session(self, rest_server) -> None: + """A caller-supplied session is used for requests.""" + session = requests.Session() + srv = rest_server(payload={"block_height": 1, "block_id": "x"}) + client = Client(srv.url, session=session) + assert client._session is session + assert client.get_tip().block_height == 1 + client.close() + session.close() + + +def test_trailing_slash_trimmed(rest_server) -> None: + """A trailing slash on the base URL must not produce a double slash.""" + srv = rest_server(payload="deadbeef0102") + client = Client(srv.url + "/") + assert client.get_block_id_at_height(1) == "deadbeef0102" + assert srv.capture.path == "/api/v2/chain/1" + client.close() + + +def test_paths_land_under_api_v2(rest_server) -> None: + srv = rest_server(payload={"block_height": 123456, "block_id": "aabbccdd"}) + client = Client(srv.url) + client.get_tip() + assert srv.capture.path == "/api/v2/chain/tip" + assert srv.capture.method == "GET" + client.close() + + +def test_http_error_404(rest_server) -> None: + srv = rest_server(raw='{"error":"NotFound"}\n', status=404) + client = Client(srv.url) + with pytest.raises(HTTPError) as excinfo: + client.get_tip() + err = excinfo.value + assert err.status_code == 404 + assert err.body == '{"error":"NotFound"}' # trailing newline trimmed + client.close() + + +def test_http_error_500(rest_server) -> None: + srv = rest_server(raw="internal error\n", status=500, content_type="text/plain; charset=utf-8") + client = Client(srv.url) + with pytest.raises(HTTPError) as excinfo: + client.get_pool("mpool1abc") + err = excinfo.value + assert err.status_code == 500 + assert err.body == "internal error" + assert str(err) == "HTTP 500: internal error" + client.close() + + +def test_block_id_at_height_404(rest_server) -> None: + """Unknown height -> HTTPError 404 (no JSON body).""" + srv = rest_server(raw="not found\n", status=404) + client = Client(srv.url) + with pytest.raises(HTTPError) as excinfo: + client.get_block_id_at_height(9999999) + assert excinfo.value.status_code == 404 + assert excinfo.value.body == "not found" + client.close() + + +def test_transaction_merkle_path_404(rest_server) -> None: + """Merkle path is 404 until the transaction is included in a block.""" + srv = rest_server(raw='{"error":"NotFound"}', status=404) + client = Client(srv.url) + with pytest.raises(HTTPError) as excinfo: + client.get_transaction_merkle_path("tx01") + assert excinfo.value.status_code == 404 + client.close() + + +def test_invalid_json_raises_indexer_error(rest_server) -> None: + """A 200 response with a non-JSON body raises IndexerError, not HTTPError.""" + srv = rest_server(raw="this is not json", status=200) + client = Client(srv.url) + with pytest.raises(IndexerError, match="decode response"): + client.get_tip() + client.close() diff --git a/tests/test_indexer_order.py b/tests/test_indexer_order.py new file mode 100644 index 0000000..a501fd9 --- /dev/null +++ b/tests/test_indexer_order.py @@ -0,0 +1,74 @@ +"""Tests for the indexer DEX order endpoints. + +Mirrors the "Order (3h)" section of go-sdk/indexer/client_test.go, including +the string-encoded nonce forms. +""" + +from __future__ import annotations + +import json + +from mintlayer.indexer import Client, Order, PageOpts + + +def _order_payload(**overrides: object) -> dict: + payload = { + "order_id": "mord1abc", + "conclude_destination": "mtc1dest", + "give_currency": {}, + "initially_given": {"atoms": "100000000000", "decimal": "1.0"}, + "give_balance": {"atoms": "90000000000", "decimal": "0.9"}, + "ask_currency": {}, + "initially_asked": {"atoms": "80000000000", "decimal": "0.8"}, + "ask_balance": {"atoms": "70000000000", "decimal": "0.7"}, + "nonce": 5, + } + payload.update(overrides) + return payload + + +def test_list_orders(rest_server) -> None: + """Orders decode, including a nonce serialised as a string.""" + srv = rest_server(raw=json.dumps([_order_payload(nonce="5")])) + client = Client(srv.url) + orders = client.list_orders(PageOpts()) + assert len(orders) == 1 + assert isinstance(orders[0], Order) + assert orders[0].order_id == "mord1abc" + assert orders[0].nonce == 5 + assert orders[0].initially_given.atoms == "100000000000" + assert orders[0].give_balance.decimal == "0.9" + assert orders[0].ask_balance.atoms == "70000000000" + assert srv.capture.path == "/api/v2/order" + assert srv.capture.query == "" + client.close() + + +def test_get_order(rest_server) -> None: + srv = rest_server(payload=_order_payload()) + client = Client(srv.url) + order = client.get_order("mord1abc") + assert isinstance(order, Order) + assert order.order_id == "mord1abc" + assert order.conclude_destination == "mtc1dest" + assert order.nonce == 5 + assert srv.capture.path == "/api/v2/order/mord1abc" + client.close() + + +def test_get_order_string_encoded_nonce(rest_server) -> None: + srv = rest_server(raw=json.dumps(_order_payload(nonce="5"))) + client = Client(srv.url) + assert client.get_order("mord1abc").nonce == 5 + client.close() + + +def test_list_orders_by_pair_path_and_query(rest_server) -> None: + """The pair route is /order/pair/{ask}_{give} and forwards PageOpts.""" + srv = rest_server(payload=[]) + client = Client(srv.url) + assert client.list_orders_by_pair("ML", "mmltk1abc", PageOpts(offset=10, items=20)) == [] + assert srv.capture.path == "/api/v2/order/pair/ML_mmltk1abc" + assert "offset=10" in srv.capture.query + assert "items=20" in srv.capture.query + client.close() diff --git a/tests/test_indexer_pool.py b/tests/test_indexer_pool.py new file mode 100644 index 0000000..b459fef --- /dev/null +++ b/tests/test_indexer_pool.py @@ -0,0 +1,141 @@ +"""Tests for the indexer pool endpoints. + +Mirrors the "Pool (3f)" section of go-sdk/indexer/client_test.go, including +the margin-ratio lenient forms ("3.5%", "10%", bare numbers) and the block +stats query-parameter pin. +""" + +from __future__ import annotations + +import json +from datetime import datetime, timezone + +import pytest + +from mintlayer.indexer import Client, Pool, PoolDelegation, PoolListOpts + + +def _pool_payload(**margin_overrides: object) -> dict: + payload = { + "pool_id": "mpool1abc", + "decommission_destination": "mtc1dest", + "staker_balance": {"atoms": "40000000000000", "decimal": "400000.0"}, + "margin_ratio_per_thousand": 100, + "cost_per_block": {"atoms": "1000000000", "decimal": "10.0"}, + "vrf_public_key": "vrf01", + "delegations_balance": {"atoms": "500000000000", "decimal": "5.0"}, + } + payload.update(margin_overrides) + return payload + + +def test_list_pools(rest_server) -> None: + srv = rest_server(payload=[_pool_payload()]) + client = Client(srv.url) + pools = client.list_pools(PoolListOpts()) + assert len(pools) == 1 + assert isinstance(pools[0], Pool) + assert pools[0].pool_id == "mpool1abc" + assert pools[0].staker_balance.atoms == "40000000000000" + assert pools[0].margin_ratio_per_thousand == 100.0 + assert isinstance(pools[0].margin_ratio_per_thousand, float) + assert srv.capture.path == "/api/v2/pool" + client.close() + + +def test_list_pools_sort_param(rest_server) -> None: + """sort=by_pledge and items=20 are sent; zero offset is omitted.""" + srv = rest_server(payload=[]) + client = Client(srv.url) + assert client.list_pools(PoolListOpts(sort="by_pledge", offset=0, items=20)) == [] + assert "sort=by_pledge" in srv.capture.query + assert "items=20" in srv.capture.query + assert "offset" not in srv.capture.query + client.close() + + +def test_get_pool(rest_server) -> None: + srv = rest_server(payload=_pool_payload()) + client = Client(srv.url) + pool = client.get_pool("mpool1abc") + assert pool.pool_id == "mpool1abc" + assert pool.decommission_destination == "mtc1dest" + assert pool.cost_per_block.atoms == "1000000000" + assert pool.delegations_balance.decimal == "5.0" + assert srv.capture.path == "/api/v2/pool/mpool1abc" + client.close() + + +@pytest.mark.parametrize( + ("margin_value", "expected"), + [ + pytest.param("3.5%", 3.5, id="float-percent"), + pytest.param("10%", 10.0, id="integer-percent"), + pytest.param(35, 35.0, id="bare-number"), + pytest.param("10", 10.0, id="string-form"), + ], +) +def test_get_pool_margin_ratio_lenient_forms( + rest_server, margin_value: str | int, expected: float +) -> None: + """The margin ratio accepts bare numbers, strings, and trailing %.""" + srv = rest_server(payload=_pool_payload(margin_ratio_per_thousand=margin_value)) + client = Client(srv.url) + pool = client.get_pool("mpool1abc") + assert pool.margin_ratio_per_thousand == expected + assert isinstance(pool.margin_ratio_per_thousand, float) + client.close() + + +def test_list_pools_margin_ratio_float_percent_wire(rest_server) -> None: + """Go-parity check: percent-encoded margins decode through list_pools.""" + srv = rest_server(raw=json.dumps([_pool_payload(margin_ratio_per_thousand="3.5%")])) + client = Client(srv.url) + pools = client.list_pools(PoolListOpts()) + assert pools[0].margin_ratio_per_thousand == 3.5 + client.close() + + +_FROM = datetime.fromtimestamp(1700000000, tz=timezone.utc) +_TO = datetime.fromtimestamp(1700086400, tz=timezone.utc) + + +def test_get_pool_block_stats(rest_server) -> None: + srv = rest_server(payload={"block_count": 42}) + client = Client(srv.url) + assert client.get_pool_block_stats("mpool1abc", _FROM, _TO) == 42 + assert srv.capture.path == "/api/v2/pool/mpool1abc/block-stats" + client.close() + + +def test_get_pool_block_stats_query_params(rest_server) -> None: + """from/to unix seconds are always sent.""" + srv = rest_server(payload={"block_count": 0}) + client = Client(srv.url) + client.get_pool_block_stats("mpool1abc", _FROM, _TO) + assert "from=1700000000" in srv.capture.query + assert "to=1700086400" in srv.capture.query + client.close() + + +def test_get_pool_delegations(rest_server) -> None: + srv = rest_server( + payload=[ + { + "delegation_id": "mdelg1abc", + "next_nonce": 5, + "spend_destination": "mtc1dest", + "balance": {"atoms": "500000000000", "decimal": "5.0"}, + "creation_block_height": 10000, + } + ] + ) + client = Client(srv.url) + delegations = client.get_pool_delegations("mpool1abc") + assert len(delegations) == 1 + assert isinstance(delegations[0], PoolDelegation) + assert delegations[0].delegation_id == "mdelg1abc" + assert delegations[0].next_nonce == 5 + assert delegations[0].creation_block_height == 10000 + assert srv.capture.path == "/api/v2/pool/mpool1abc/delegations" + client.close() diff --git a/tests/test_indexer_statistics.py b/tests/test_indexer_statistics.py new file mode 100644 index 0000000..e206e98 --- /dev/null +++ b/tests/test_indexer_statistics.py @@ -0,0 +1,61 @@ +"""Tests for the indexer statistics endpoints. + +Mirrors the "Statistics (3i)" section of go-sdk/indexer/client_test.go, +including the fee-rate query-parameter behaviour and bare-string decode. +""" + +from __future__ import annotations + +from mintlayer.indexer import Client, CoinStats + +_COIN_STATS = { + "circulating_supply": {"atoms": "1000000000000000", "decimal": "10000000.0"}, + "preminted": {"atoms": "400000000000000", "decimal": "4000000.0"}, + "burned": {"atoms": "0", "decimal": "0"}, + "staked": {"atoms": "500000000000000", "decimal": "5000000.0"}, +} + + +def test_get_coin_statistics(rest_server) -> None: + srv = rest_server(payload=_COIN_STATS) + client = Client(srv.url) + stats = client.get_coin_statistics() + assert isinstance(stats, CoinStats) + assert stats.circulating_supply.atoms == "1000000000000000" + assert stats.preminted.decimal == "4000000.0" + assert stats.burned.atoms == "0" + assert stats.staked.decimal == "5000000.0" + assert srv.capture.path == "/api/v2/statistics/coin" + client.close() + + +def test_get_token_statistics(rest_server) -> None: + srv = rest_server(payload=_COIN_STATS) + client = Client(srv.url) + stats = client.get_token_statistics("mmltk1abc") + assert isinstance(stats, CoinStats) + assert stats.circulating_supply.atoms == "1000000000000000" + assert srv.capture.path == "/api/v2/statistics/token/mmltk1abc" + client.close() + + +def test_get_fee_rate_in_top_x_mb(rest_server) -> None: + """in_top_x_mb=5 is sent and the bare JSON string result is returned.""" + srv = rest_server(payload="1000") + client = Client(srv.url) + rate = client.get_fee_rate(5) + assert rate == "1000" + assert isinstance(rate, str) + assert "in_top_x_mb=5" in srv.capture.query + assert srv.capture.path == "/api/v2/feerate" + client.close() + + +def test_get_fee_rate_default_omits_param(rest_server) -> None: + """The default call sends no in_top_x_mb param (server default 5 MB).""" + srv = rest_server(payload="500") + client = Client(srv.url) + assert client.get_fee_rate() == "500" + assert "in_top_x_mb" not in srv.capture.query + assert srv.capture.query == "" + client.close() diff --git a/tests/test_indexer_token.py b/tests/test_indexer_token.py new file mode 100644 index 0000000..85452e1 --- /dev/null +++ b/tests/test_indexer_token.py @@ -0,0 +1,126 @@ +"""Tests for the indexer token / NFT endpoints. + +Mirrors the "Token / NFT (3g)" section of go-sdk/indexer/client_test.go, +plus wire-shape pins for the freeze-flag pointer semantics and the +string-encoded tx_global_index. +""" + +from __future__ import annotations + +from mintlayer.indexer import Client, NFTInfo, TokenInfo + + +def test_list_tokens(rest_server) -> None: + srv = rest_server(payload=["mmltk1aaa", "mmltk1bbb"]) + client = Client(srv.url) + assert client.list_tokens() == ["mmltk1aaa", "mmltk1bbb"] + assert srv.capture.path == "/api/v2/token" + assert srv.capture.query == "" # zero PageOpts -> no params + client.close() + + +def _token_payload(**overrides: object) -> dict: + payload = { + "authority": "mtc1abc", + "is_locked": False, + "circulating_supply": {"atoms": "1000000", "decimal": "0.001"}, + "token_ticker": "TKN", + "metadata_uri": "https://example.com/token.json", + "number_of_decimals": 8, + "total_supply": None, + "frozen": False, + "is_token_freezable": True, + "next_nonce": 2, + } + payload.update(overrides) + return payload + + +def test_get_token_not_frozen(rest_server) -> None: + """total_supply may be null; is_token_freezable present when not frozen.""" + srv = rest_server(payload=_token_payload()) + client = Client(srv.url) + info = client.get_token("mmltk1abc") + assert isinstance(info, TokenInfo) + assert info.authority == "mtc1abc" + assert info.token_ticker == "TKN" + assert info.number_of_decimals == 8 + assert info.total_supply is None + assert info.circulating_supply.atoms == "1000000" + assert info.frozen is False + assert info.is_token_freezable is True + assert info.is_token_unfreezable is None + assert info.next_nonce == 2 + assert srv.capture.path == "/api/v2/token/mmltk1abc" + client.close() + + +def test_get_token_frozen_flags_are_exclusive(rest_server) -> None: + """Frozen tokens carry is_token_unfreezable and no is_token_freezable.""" + payload = _token_payload(frozen=True, is_token_unfreezable=False) + del payload["is_token_freezable"] # absent on the wire when frozen + srv = rest_server(payload=payload) + client = Client(srv.url) + info = client.get_token("mmltk1abc") + assert info.frozen is True + assert info.is_token_freezable is None + assert info.is_token_unfreezable is False + client.close() + + +def test_get_token_transactions_string_encoded_index(rest_server) -> None: + """tx_global_index arrives as a string and parses to an int.""" + srv = rest_server( + payload=[ + {"tx_global_index": "12345", "tx_id": "tx01"}, + {"tx_global_index": "12346", "tx_id": "tx02"}, + ] + ) + client = Client(srv.url) + txs = client.get_token_transactions("mmltk1abc") + assert len(txs) == 2 + assert txs[0].tx_global_index == 12345 + assert txs[0].tx_id == "tx01" + assert txs[1].tx_global_index == 12346 + assert srv.capture.path == "/api/v2/token/mmltk1abc/transactions" + client.close() + + +def test_find_tokens_by_ticker(rest_server) -> None: + srv = rest_server(payload=["mmltk1aaa"]) + client = Client(srv.url) + assert client.find_tokens_by_ticker("TKN") == ["mmltk1aaa"] + assert srv.capture.path == "/api/v2/token/ticker/TKN" + client.close() + + +def test_get_nft(rest_server) -> None: + """NFT metadata decodes with null creator / media_uri fields.""" + srv = rest_server( + payload={ + "owner": "mtc1abc", + "token_id": "mmltk1nft", + "metadata": { + "creator": None, + "name": "My NFT", + "description": "A test NFT", + "ticker": "NFT", + "icon_uri": None, + "additional_metadata_uri": None, + "media_uri": None, + "media_hash": "mediahash01", + }, + } + ) + client = Client(srv.url) + nft = client.get_nft("mmltk1nft") + assert isinstance(nft, NFTInfo) + assert nft.owner == "mtc1abc" + assert nft.token_id == "mmltk1nft" + assert nft.metadata.name == "My NFT" + assert nft.metadata.ticker == "NFT" + assert nft.metadata.creator is None + assert nft.metadata.media_uri is None + assert nft.metadata.media_hash == "mediahash01" + assert srv.capture.path == "/api/v2/nft/mmltk1nft" + client.close() diff --git a/tests/test_indexer_transaction.py b/tests/test_indexer_transaction.py new file mode 100644 index 0000000..4980e62 --- /dev/null +++ b/tests/test_indexer_transaction.py @@ -0,0 +1,128 @@ +"""Tests for the indexer transaction endpoints. + +Mirrors the "Transaction (3d)" section of go-sdk/indexer/client_test.go, +including pagination, zero-value PageOpts, and the text/plain submit route. +""" + +from __future__ import annotations + +from mintlayer.indexer import Client, MerklePath, PageOpts, Transaction + + +def test_list_transactions_pagination(rest_server) -> None: + srv = rest_server(payload=[]) + client = Client(srv.url) + assert client.list_transactions(PageOpts(offset=10, items=20)) == [] + assert srv.capture.path == "/api/v2/transaction" + assert "offset=10" in srv.capture.query + assert "items=20" in srv.capture.query + client.close() + + +def test_list_transactions_zero_page_opts_no_params(rest_server) -> None: + """Zero PageOpts sends NO offset/items params (server defaults apply).""" + srv = rest_server(payload=[]) + client = Client(srv.url) + client.list_transactions(PageOpts()) + assert "offset" not in srv.capture.query + assert "items" not in srv.capture.query + assert srv.capture.query == "" + client.close() + + +def test_list_transactions_decodes_entries(rest_server) -> None: + srv = rest_server( + payload=[ + { + "id": "tx01", + "block_id": "block01", + "timestamp": "1700000000", + "confirmations": "10", + } + ] + ) + client = Client(srv.url) + txs = client.list_transactions(PageOpts(offset=0, items=5)) + assert len(txs) == 1 + assert isinstance(txs[0], Transaction) + assert txs[0].id == "tx01" + assert "items=5" in srv.capture.query + assert "offset" not in srv.capture.query # zero offset omitted + client.close() + + +def test_get_transaction(rest_server) -> None: + srv = rest_server( + payload={ + "id": "aabbccdd", + "block_id": "blockid01", + "timestamp": "1700000000", + "confirmations": "100", + } + ) + client = Client(srv.url) + tx = client.get_transaction("aabbccdd") + assert isinstance(tx, Transaction) + assert tx.id == "aabbccdd" + assert tx.block_id == "blockid01" + assert tx.timestamp == "1700000000" + assert tx.confirmations == "100" + assert srv.capture.path == "/api/v2/transaction/aabbccdd" + client.close() + + +def test_get_transaction_unconfirmed(rest_server) -> None: + """Block ID / timestamp / confirmations default to empty strings.""" + srv = rest_server(payload={"id": "pending01"}) + client = Client(srv.url) + tx = client.get_transaction("pending01") + assert tx.block_id == "" + assert tx.timestamp == "" + assert tx.confirmations == "" + client.close() + + +def test_get_transaction_merkle_path(rest_server) -> None: + srv = rest_server( + payload={ + "block_id": "block01", + "transaction_index": 3, + "merkle_root": "root01", + "merkle_path": ["hash1", "hash2"], + } + ) + client = Client(srv.url) + mp = client.get_transaction_merkle_path("tx01") + assert isinstance(mp, MerklePath) + assert mp.block_id == "block01" + assert mp.transaction_index == 3 + assert mp.merkle_root == "root01" + assert mp.path == ["hash1", "hash2"] + assert srv.capture.path == "/api/v2/transaction/tx01/merkle-path" + client.close() + + +def test_get_transaction_output_raw(rest_server) -> None: + """Transaction outputs pass through as raw JSON.""" + output = { + "output": {"Transfer": {"destination": "mtc1abc", "amount": {"atoms": "100"}}}, + "spent_at_block_height": 42, + } + srv = rest_server(payload=output) + client = Client(srv.url) + assert client.get_transaction_output("tx01", 0) == output + assert srv.capture.path == "/api/v2/transaction/tx01/output/0" + client.close() + + +def test_submit_transaction(rest_server) -> None: + """Submit POSTs the hex verbatim as text/plain and returns the tx id.""" + srv = rest_server(payload={"tx_id": "newtxid"}) + client = Client(srv.url) + tx_id = client.submit_transaction("cafebabe") + assert tx_id == "newtxid" + assert srv.capture.method == "POST" + assert srv.capture.path == "/api/v2/transaction" + assert srv.capture.raw_body == b"cafebabe" + assert srv.capture.headers.get("content-type", "").startswith("text/plain") + client.close() From 32c62a297f5fc7201449041b85f61a20ec990642 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 03:21:07 +0400 Subject: [PATCH 04/31] Add wallet JSON-RPC client (port of go-sdk/wallet) All 56 daemon routes across management/transactions/tokens/staking/orders mixins with exact wire fidelity: TxOptions always-both-keys null pattern, selected_utxos omitempty for nil and empty, OutputValue/CurrencyFilter custom encodings with client-side validation before any HTTP request, account_index wire key for lock_token_supply, account dropped for get_pool_balance, hardcoded Trusted trust policy and Confirmed-only balances, empty-string-to-null coercion, CoinFilter without content key. Mnemonic/passphrase fields redacted from dataclass reprs. 101 new tests mirror Go's wallet client_test.go and orders_test.go (217 total passing); wallet package at 100% statement coverage. ruff + mypy clean. --- mintlayer/_jsonrpc.py | 3 +- mintlayer/wallet/__init__.py | 137 ++++ mintlayer/wallet/_core.py | 35 + mintlayer/wallet/client.py | 62 ++ mintlayer/wallet/management.py | 104 +++ mintlayer/wallet/orders.py | 54 ++ mintlayer/wallet/staking.py | 70 ++ mintlayer/wallet/tokens.py | 56 ++ mintlayer/wallet/transactions.py | 99 +++ mintlayer/wallet/types.py | 1076 +++++++++++++++++++++++++++++ tests/test_wallet_concurrency.py | 41 ++ tests/test_wallet_management.py | 305 ++++++++ tests/test_wallet_orders.py | 396 +++++++++++ tests/test_wallet_staking.py | 239 +++++++ tests/test_wallet_tokens.py | 243 +++++++ tests/test_wallet_transactions.py | 310 +++++++++ tests/test_wallet_transport.py | 102 +++ 17 files changed, 3331 insertions(+), 1 deletion(-) create mode 100644 mintlayer/wallet/__init__.py create mode 100644 mintlayer/wallet/_core.py create mode 100644 mintlayer/wallet/client.py create mode 100644 mintlayer/wallet/management.py create mode 100644 mintlayer/wallet/orders.py create mode 100644 mintlayer/wallet/staking.py create mode 100644 mintlayer/wallet/tokens.py create mode 100644 mintlayer/wallet/transactions.py create mode 100644 mintlayer/wallet/types.py create mode 100644 tests/test_wallet_concurrency.py create mode 100644 tests/test_wallet_management.py create mode 100644 tests/test_wallet_orders.py create mode 100644 tests/test_wallet_staking.py create mode 100644 tests/test_wallet_tokens.py create mode 100644 tests/test_wallet_transactions.py create mode 100644 tests/test_wallet_transport.py diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 5810d4c..45275eb 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -8,7 +8,8 @@ * monotonically increasing integer request IDs starting at 1, * HTTP Basic Auth applied only when a username is set (and never sourced from the environment — ``.netrc`` lookup is suppressed for sessions the - client creates itself), + client creates itself; caller-supplied sessions keep their own + ``trust_env`` behavior), * no per-call cancellation: timeouts are configured on the client (Go's per-call ``context`` has no direct requests equivalent), * the HTTP status code is never inspected — a JSON-RPC ``error`` object in the diff --git a/mintlayer/wallet/__init__.py b/mintlayer/wallet/__init__.py new file mode 100644 index 0000000..d8c833a --- /dev/null +++ b/mintlayer/wallet/__init__.py @@ -0,0 +1,137 @@ +"""JSON-RPC client for the Mintlayer wallet daemon. + +Mirrors go-sdk/wallet (Go package ``wallet``). Default ports: 3034 (mainnet), +13034 (testnet). + + from mintlayer.wallet import Client, SendParams, Amount + + c = Client("http://127.0.0.1:3034") + c.open_wallet("/path/to/wallet.dat") + result = c.address_send(SendParams( + account=0, address="mtc1q...", amount=Amount(atoms="100000000000"), + )) + print(result.tx_id) +""" + +from __future__ import annotations + +from mintlayer._jsonrpc import JSONRPCError + +from .client import Client, RPCError +from .orders import coin_filter, token_filter +from .types import ( + AccountInfo, + ActiveOrder, + AddressWithUsage, + Amount, + Balance, + BestBlock, + ChangeAuthorityParams, + ComposedTx, + ComposeParams, + ConcludeOrderParams, + CreateDelegationParams, + CreateDelegationResult, + CreateOrderParams, + CreatePoolParams, + CreateWalletParams, + CreateWalletResult, + CurrencyFilter, + DecommissionParams, + DelegateParams, + DelegationInfo, + FeesBreakdown, + FillOrderParams, + FreezeOrderParams, + FreezeParams, + IssueNFTParams, + IssueTokenParams, + IssueTokenResult, + ListOrdersParams, + LockSupplyParams, + MintParams, + MnemonicResult, + NFTMetadata, + OrderCreated, + OutputValue, + OwnedPool, + RecoverWalletParams, + SendParams, + SendResult, + SignedTx, + StakingStatus, + SubmitResult, + SweepParams, + TokenMetadata, + TokenSendParams, + TokenSupply, + TxInspection, + TxOptions, + UnfreezeParams, + UnmintParams, + UTXOSpendParams, + WalletInfo, + WalletTx, + WithdrawParams, +) + +__all__ = [ + "Client", + "RPCError", + "JSONRPCError", + "coin_filter", + "token_filter", + "Amount", + "AccountInfo", + "ActiveOrder", + "AddressWithUsage", + "Balance", + "BestBlock", + "ChangeAuthorityParams", + "ComposeParams", + "ComposedTx", + "ConcludeOrderParams", + "CreateDelegationParams", + "CreateDelegationResult", + "CreateOrderParams", + "CreatePoolParams", + "CreateWalletParams", + "CreateWalletResult", + "CurrencyFilter", + "DelegateParams", + "DelegationInfo", + "DecommissionParams", + "FillOrderParams", + "FreezeOrderParams", + "FreezeParams", + "FeesBreakdown", + "IssueNFTParams", + "IssueTokenParams", + "IssueTokenResult", + "ListOrdersParams", + "LockSupplyParams", + "MintParams", + "MnemonicResult", + "NFTMetadata", + "OrderCreated", + "OutputValue", + "OwnedPool", + "RecoverWalletParams", + "SendParams", + "SendResult", + "SignedTx", + "StakingStatus", + "SubmitResult", + "SweepParams", + "TokenMetadata", + "TokenSendParams", + "TokenSupply", + "TxInspection", + "TxOptions", + "UTXOSpendParams", + "UnfreezeParams", + "UnmintParams", + "WalletInfo", + "WalletTx", + "WithdrawParams", +] diff --git a/mintlayer/wallet/_core.py b/mintlayer/wallet/_core.py new file mode 100644 index 0000000..c2ab010 --- /dev/null +++ b/mintlayer/wallet/_core.py @@ -0,0 +1,35 @@ +"""Shared result-decoding helpers for the wallet client mixins.""" + +from __future__ import annotations + +from typing import Any, TypeVar + +from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError + +_T = TypeVar("_T") + + +class _WalletCore: + """Thin wrapper over the JSON-RPC transport with typed result helpers.""" + + _rpc: JSONRPCClient + + def _call(self, method: str, params: Any) -> Any: + return self._rpc.call(method, params) + + def _call_ignore(self, method: str, params: Any) -> None: + self._rpc.call(method, params) + + def _call_model(self, method: str, params: Any, cls: type[_T]) -> _T: + data = self._rpc.call(method, params) + if data is None: + raise JSONRPCError(f"{method}: expected object result, got null") + return cls.from_json(data) # type: ignore[attr-defined] + + def _call_model_list(self, method: str, params: Any, cls: type[_T]) -> list[_T]: + data = self._rpc.call(method, params) + return [cls.from_json(item) for item in data or []] # type: ignore[attr-defined] + + def close(self) -> None: + """Close the underlying HTTP session.""" + self._rpc.close() diff --git a/mintlayer/wallet/client.py b/mintlayer/wallet/client.py new file mode 100644 index 0000000..7377f15 --- /dev/null +++ b/mintlayer/wallet/client.py @@ -0,0 +1,62 @@ +"""JSON-RPC client for the Mintlayer wallet daemon (mirrors go-sdk/wallet).""" + +from __future__ import annotations + +import requests + +from mintlayer._jsonrpc import ( # noqa: F401 (JSONRPCError re-exported) + JSONRPCClient, + JSONRPCError, + RPCError, +) + +from ._core import _WalletCore +from .management import ManagementMixin +from .orders import OrdersMixin +from .staking import StakingMixin +from .tokens import TokensMixin +from .transactions import TransactionsMixin + +__all__ = ["Client", "RPCError", "JSONRPCError"] + + +class Client( + ManagementMixin, + TransactionsMixin, + TokensMixin, + StakingMixin, + OrdersMixin, + _WalletCore, +): + """JSON-RPC 2.0 client for the wallet-rpc-daemon. + + Default ports: 3034 (mainnet), 13034 (testnet). Safe for concurrent use + from multiple threads. + """ + + def __init__( + self, + endpoint: str, + username: str = "", + password: str = "", + timeout: float = 30.0, + session: requests.Session | None = None, + ) -> None: + """Create a wallet client; requests POST directly to ``endpoint``. + + Basic auth is applied only when ``username`` is non-empty. Per-call + cancellation is not supported; use ``timeout`` for deadlines. + """ + self._rpc = JSONRPCClient( + endpoint=endpoint, + username=username, + password=password, + timeout=timeout, + session=session, + ) + + def __enter__(self) -> Client: + return self + + def __exit__(self, *_exc: object) -> None: + self.close() diff --git a/mintlayer/wallet/management.py b/mintlayer/wallet/management.py new file mode 100644 index 0000000..37f7f66 --- /dev/null +++ b/mintlayer/wallet/management.py @@ -0,0 +1,104 @@ +"""Wallet lifecycle management (mirrors go-sdk/wallet/management.go).""" + +from __future__ import annotations + +from ._core import _WalletCore +from .types import ( + AccountInfo, + AddressWithUsage, + Balance, + BestBlock, + CreateWalletParams, + CreateWalletResult, + RecoverWalletParams, + WalletInfo, +) + + +class ManagementMixin(_WalletCore): + def create_wallet(self, params: CreateWalletParams) -> CreateWalletResult: + """Create a new wallet file (optionally returning a generated mnemonic).""" + data = self._call("wallet_create", params.to_json()) + return CreateWalletResult.from_json(data or {}) + + def recover_wallet(self, params: RecoverWalletParams) -> None: + """Recover a wallet from an existing mnemonic.""" + self._call_ignore("wallet_recover", params.to_json()) + + def open_wallet(self, path: str, password: str = "") -> None: + """Open a wallet file; an empty password is sent as JSON null.""" + self._call_ignore( + "wallet_open", + { + "path": path, + "password": password if password else None, + "force_migrate_wallet_type": None, + "hardware_wallet": None, + }, + ) + + def close_wallet(self) -> None: + """Close the currently open wallet.""" + self._call_ignore("wallet_close", {}) + + def get_wallet_info(self) -> WalletInfo: + """Return info about the open wallet.""" + return self._call_model("wallet_info", {}, WalletInfo) + + def sync_wallet(self) -> None: + """Trigger a wallet sync.""" + self._call_ignore("wallet_sync", {}) + + def rescan_wallet(self) -> None: + """Trigger a full chain rescan for the wallet.""" + self._call_ignore("wallet_rescan", {}) + + def best_block(self) -> BestBlock: + """Return the best block the wallet is aware of.""" + return self._call_model("wallet_best_block", {}, BestBlock) + + def create_account(self, name: str) -> AccountInfo: + """Create a new account.""" + return self._call_model("account_create", {"name": name}, AccountInfo) + + def rename_account(self, account: int, name: str = "") -> None: + """Rename an account; an empty name is sent as null (removes the name).""" + self._call_ignore("account_rename", {"account": account, "name": name if name else None}) + + def get_balance(self, account: int) -> Balance: + """Return the confirmed balance of an account.""" + data = self._call( + "account_balance", + {"account": account, "utxo_states": ["Confirmed"], "with_locked": None}, + ) + return Balance.from_json(data or {}) + + def new_address(self, account: int) -> str: + """Derive a new receiving address for the account.""" + data = self._call("address_new", {"account": account}) + return str(data["address"]) + + def show_receive_addresses(self, account: int) -> list[AddressWithUsage]: + """Return the account's receive addresses with usage info.""" + data = self._call( + "address_show", + {"account": account, "include_change_addresses": False}, + ) + return [AddressWithUsage.from_json(a) for a in data or []] + + def reveal_public_key(self, account: int, address: str) -> str: + """Reveal the hex public key backing an address.""" + data = self._call("address_reveal_public_key", {"account": account, "address": address}) + return str(data["public_key_hex"]) + + def encrypt_private_keys(self, password: str) -> None: + """Encrypt the wallet's private keys with a password.""" + self._call_ignore("wallet_encrypt_private_keys", {"password": password}) + + def unlock_private_keys(self, password: str) -> None: + """Unlock the wallet's private keys.""" + self._call_ignore("wallet_unlock_private_keys", {"password": password}) + + def lock_private_keys(self) -> None: + """Re-lock the wallet's private keys.""" + self._call_ignore("wallet_lock_private_keys", {}) diff --git a/mintlayer/wallet/orders.py b/mintlayer/wallet/orders.py new file mode 100644 index 0000000..9f42cd0 --- /dev/null +++ b/mintlayer/wallet/orders.py @@ -0,0 +1,54 @@ +"""DEX order methods (mirrors go-sdk/wallet/orders.go).""" + +from __future__ import annotations + +from ._core import _WalletCore +from .types import ( + ActiveOrder, + ConcludeOrderParams, + CreateOrderParams, + CurrencyFilter, + FillOrderParams, + FreezeOrderParams, + ListOrdersParams, + OrderCreated, + OwnOrder, + SendResult, +) + + +class OrdersMixin(_WalletCore): + def create_order(self, params: CreateOrderParams) -> OrderCreated: + """Create a new DEX order.""" + return self._call_model("order_create", params.to_json(), OrderCreated) + + def conclude_order(self, params: ConcludeOrderParams) -> SendResult: + """Conclude an order owned by the account.""" + return self._call_model("order_conclude", params.to_json(), SendResult) + + def fill_order(self, params: FillOrderParams) -> SendResult: + """Fill (partially or fully) an existing order.""" + return self._call_model("order_fill", params.to_json(), SendResult) + + def freeze_order(self, params: FreezeOrderParams) -> SendResult: + """Freeze an order (orders V1 fork only).""" + return self._call_model("order_freeze", params.to_json(), SendResult) + + def list_own_orders(self, account: int) -> list[OwnOrder]: + """List the account's own orders.""" + return self._call_model_list("order_list_own", {"account": account}, OwnOrder) + + def list_all_active_orders(self, params: ListOrdersParams) -> list[ActiveOrder]: + """List all active orders, optionally filtered by currency pair + (``None`` filters match any).""" + return self._call_model_list("order_list_all_active", params.to_json(), ActiveOrder) + + +def coin_filter() -> CurrencyFilter: + """Currency filter matching the native coin (wire: ``{"type":"Coin"}``).""" + return CurrencyFilter.coin_filter() + + +def token_filter(token_id: str) -> CurrencyFilter: + """Currency filter matching a token (wire: ``{"type":"Token","content":id}``).""" + return CurrencyFilter.token_filter(token_id) diff --git a/mintlayer/wallet/staking.py b/mintlayer/wallet/staking.py new file mode 100644 index 0000000..98d72ba --- /dev/null +++ b/mintlayer/wallet/staking.py @@ -0,0 +1,70 @@ +"""Staking and delegation methods (mirrors go-sdk/wallet/staking.go).""" + +from __future__ import annotations + +from ._core import _WalletCore +from .types import ( + Amount, + CreateDelegationParams, + CreateDelegationResult, + CreatePoolParams, + DecommissionParams, + DelegateParams, + DelegationInfo, + OwnedPool, + SendResult, + StakingStatus, + WithdrawParams, +) + + +class StakingMixin(_WalletCore): + def create_stake_pool(self, params: CreatePoolParams) -> SendResult: + """Create a new staking pool.""" + return self._call_model("staking_create_pool", params.to_json(), SendResult) + + def decommission_stake_pool(self, params: DecommissionParams) -> SendResult: + """Decommission a stake pool the account owns.""" + return self._call_model("staking_decommission_pool", params.to_json(), SendResult) + + def list_owned_pools(self, account: int) -> list[OwnedPool]: + """List the pools owned by the account.""" + return self._call_model_list("staking_list_pools", {"account": account}, OwnedPool) + + def get_pool_balance(self, account: int, pool_id: str) -> Amount: + """Return a pool's balance. + + Note: matching the daemon route, ``account`` is accepted for API + consistency but NOT sent on the wire. + """ + data = self._call("staking_pool_balance", {"pool_id": pool_id}) + return Amount.from_json((data or {}).get("balance", {})) + + def start_staking(self, account: int) -> None: + """Start staking with all of the account's pools.""" + self._call_ignore("staking_start", {"account": account}) + + def stop_staking(self, account: int) -> None: + """Stop staking for the account.""" + self._call_ignore("staking_stop", {"account": account}) + + def get_staking_status(self, account: int) -> StakingStatus: + """Return whether the account is currently staking.""" + result = self._call("staking_status", {"account": account}) + return StakingStatus(str(result)) + + def create_delegation(self, params: CreateDelegationParams) -> CreateDelegationResult: + """Create a delegation ID for delegating to a pool.""" + return self._call_model("delegation_create", params.to_json(), CreateDelegationResult) + + def delegate_staking(self, params: DelegateParams) -> SendResult: + """Delegate coins to a pool via a delegation ID.""" + return self._call_model("delegation_stake", params.to_json(), SendResult) + + def withdraw_from_delegation(self, params: WithdrawParams) -> SendResult: + """Withdraw from a delegation to an address.""" + return self._call_model("delegation_withdraw", params.to_json(), SendResult) + + def list_delegations(self, account: int) -> list[DelegationInfo]: + """List the account's delegation IDs and balances.""" + return self._call_model_list("delegation_list_ids", {"account": account}, DelegationInfo) diff --git a/mintlayer/wallet/tokens.py b/mintlayer/wallet/tokens.py new file mode 100644 index 0000000..9212b01 --- /dev/null +++ b/mintlayer/wallet/tokens.py @@ -0,0 +1,56 @@ +"""Token methods (mirrors go-sdk/wallet/tokens.go).""" + +from __future__ import annotations + +from ._core import _WalletCore +from .types import ( + ChangeAuthorityParams, + FreezeParams, + IssueNFTParams, + IssueTokenParams, + IssueTokenResult, + LockSupplyParams, + MintParams, + SendResult, + TokenSendParams, + UnfreezeParams, + UnmintParams, +) + + +class TokensMixin(_WalletCore): + def issue_token(self, params: IssueTokenParams) -> IssueTokenResult: + """Issue a new fungible token.""" + return self._call_model("token_issue_new", params.to_json(), IssueTokenResult) + + def issue_nft(self, params: IssueNFTParams) -> IssueTokenResult: + """Issue a new NFT (returns the token ID).""" + return self._call_model("token_nft_issue_new", params.to_json(), IssueTokenResult) + + def mint_tokens(self, params: MintParams) -> SendResult: + """Mint additional supply of a token.""" + return self._call_model("token_mint", params.to_json(), SendResult) + + def unmint_tokens(self, params: UnmintParams) -> SendResult: + """Burn token supply.""" + return self._call_model("token_unmint", params.to_json(), SendResult) + + def lock_token_supply(self, params: LockSupplyParams) -> SendResult: + """Permanently lock a token's supply (wire key: ``account_index``).""" + return self._call_model("token_lock_supply", params.to_json(), SendResult) + + def freeze_token(self, params: FreezeParams) -> SendResult: + """Freeze a token, choosing whether it can later be unfrozen.""" + return self._call_model("token_freeze", params.to_json(), SendResult) + + def unfreeze_token(self, params: UnfreezeParams) -> SendResult: + """Unfreeze a token.""" + return self._call_model("token_unfreeze", params.to_json(), SendResult) + + def change_token_authority(self, params: ChangeAuthorityParams) -> SendResult: + """Transfer a token's authority to a new address.""" + return self._call_model("token_change_authority", params.to_json(), SendResult) + + def send_token(self, params: TokenSendParams) -> SendResult: + """Send tokens (alias of :meth:`TransactionsMixin.token_send`).""" + return self._call_model("token_send", params.to_json(), SendResult) diff --git a/mintlayer/wallet/transactions.py b/mintlayer/wallet/transactions.py new file mode 100644 index 0000000..ea4a4ed --- /dev/null +++ b/mintlayer/wallet/transactions.py @@ -0,0 +1,99 @@ +"""Transaction methods (mirrors go-sdk/wallet/transactions.go).""" + +from __future__ import annotations + +from typing import Any + +from ._core import _WalletCore +from .types import ( + ComposedTx, + ComposeParams, + SendParams, + SendResult, + SignedTx, + SubmitResult, + SweepParams, + TokenSendParams, + TxInspection, + TxOptions, + UTXOSpendParams, + WalletTx, +) + + +class TransactionsMixin(_WalletCore): + def address_send(self, params: SendParams) -> SendResult: + """Send coins from the account to an address.""" + return self._call_model("address_send", params.to_json(), SendResult) + + def token_send(self, params: TokenSendParams) -> SendResult: + """Send tokens from the account to an address.""" + return self._call_model("token_send", params.to_json(), SendResult) + + def sweep_spendable(self, params: SweepParams) -> SendResult: + """Sweep all spendable UTXOs to a destination address.""" + return self._call_model("address_sweep_spendable", params.to_json(), SendResult) + + def spend_utxo(self, params: UTXOSpendParams) -> SendResult: + """Spend a specific UTXO.""" + return self._call_model("utxo_spend", params.to_json(), SendResult) + + def compose_transaction(self, params: ComposeParams) -> ComposedTx: + """Compose (but do not sign) a transaction from inputs and raw outputs.""" + return self._call_model("transaction_compose", params.to_json(), ComposedTx) + + def sign_raw_transaction(self, account: int, raw_tx: str) -> SignedTx: + """Sign a composed raw transaction with the account's keys.""" + return self._call_model( + "account_sign_raw_transaction", + {"account": account, "raw_tx": raw_tx, "options": TxOptions().to_json()}, + SignedTx, + ) + + def inspect_transaction(self, tx_hex: str) -> TxInspection: + """Inspect a raw transaction (input/signature counts, estimated fees).""" + return self._call_model("transaction_inspect", {"transaction": tx_hex}, TxInspection) + + def submit_transaction(self, tx_hex: str, do_not_store: bool = False) -> SubmitResult: + """Submit a signed transaction to the node (trust policy is hardcoded + to ``"Trusted"`` by the daemon route).""" + return self._call_model( + "node_submit_transaction", + { + "tx": tx_hex, + "do_not_store": do_not_store, + "options": {"trust_policy": "Trusted"}, + }, + SubmitResult, + ) + + def list_transactions_by_address( + self, account: int, address: str | None, limit: int + ) -> list[WalletTx]: + """List account transactions; ``address=None`` filters to all addresses.""" + data = self._call( + "transaction_list_by_address", + {"account": account, "address": address, "limit": limit}, + ) + return [WalletTx.from_json(t) for t in data or []] + + def list_pending_transactions(self, account: int) -> list[str]: + """List the account's pending (unconfirmed) transaction IDs.""" + data = self._call("transaction_list_pending", {"account": account}) + return [str(t) for t in data or []] + + def get_transaction(self, account: int, tx_id: str) -> Any: + """Return a wallet transaction as raw decoded JSON.""" + return self._call("transaction_get", {"account": account, "transaction_id": tx_id}) + + def abandon_transaction(self, account: int, tx_id: str) -> None: + """Abandon a pending transaction.""" + self._call_ignore("transaction_abandon", {"account": account, "transaction_id": tx_id}) + + def deposit_data(self, account: int, data_hex: str) -> SendResult: + """Create a DataDeposit output carrying arbitrary hex data.""" + return self._call_model( + "address_deposit_data", + {"account": account, "data": data_hex, "options": TxOptions().to_json()}, + SendResult, + ) diff --git a/mintlayer/wallet/types.py b/mintlayer/wallet/types.py new file mode 100644 index 0000000..0f3ae91 --- /dev/null +++ b/mintlayer/wallet/types.py @@ -0,0 +1,1076 @@ +"""Types for the wallet JSON-RPC client (mirrors go-sdk/wallet/types.go and friends). + +Wire-fidelity notes (all verified against the Go structs): + +* pointer fields WITHOUT ``omitempty`` serialise as JSON ``null`` when unset — + the dominant pattern for optional strings; +* ``omitempty`` applies only to: ``Amount.atoms``/``Amount.decimal``, + ``SendParams.selected_utxos``, ``MnemonicResult.content``, + ``CreateWalletResult.mnemonic``, ``TokenSupply.content``, ``TxInspection.fees``; +* ``TxOptions`` always serialises both keys (null when unset); +* ``OutputValue`` and ``CurrencyFilter`` use fully custom encodings. +""" + +from __future__ import annotations + +import enum +from dataclasses import dataclass, field +from typing import Any + +__all__ = [ + "Amount", + "Timestamp", + "TxOptions", + "OutpointSourceID", + "Outpoint", + "FeesBreakdown", + "SendResult", + "SubmitResult", + "ComposedTx", + "SignedTx", + "TxStats", + "TxInspection", + "WalletTx", + "MnemonicContent", + "MnemonicResult", + "CreateWalletResult", + "CreateWalletParams", + "RecoverWalletParams", + "WalletExtraInfo", + "WalletInfo", + "BestBlock", + "AccountInfo", + "Balance", + "AddressWithUsage", + "RevealPublicKeyResult", + "SendParams", + "SweepParams", + "UTXOSpendParams", + "ComposeParams", + "StakingStatus", + "CreatePoolParams", + "DecommissionParams", + "OwnedPool", + "CreateDelegationParams", + "CreateDelegationResult", + "DelegateParams", + "WithdrawParams", + "DelegationInfo", + "TokenSupply", + "TokenMetadata", + "IssueTokenParams", + "IssueTokenResult", + "NFTMetadata", + "IssueNFTParams", + "MintParams", + "UnmintParams", + "LockSupplyParams", + "FreezeParams", + "UnfreezeParams", + "ChangeAuthorityParams", + "TokenSendParams", + "OutputValue", + "CurrencyFilter", + "OrderState", + "OwnOrder", + "ActiveOrder", + "OrderCreated", + "CreateOrderParams", + "ConcludeOrderParams", + "FillOrderParams", + "FreezeOrderParams", + "ListOrdersParams", +] + + +@dataclass(frozen=True) +class Amount: + """Coin/token amount; at least one of atoms/decimal must be set when sending.""" + + atoms: str = "" + decimal: str = "" + + def to_json(self) -> dict: + out: dict[str, str] = {} + if self.atoms: + out["atoms"] = self.atoms + if self.decimal: + out["decimal"] = self.decimal + return out + + @classmethod + def from_json(cls, data: dict) -> Amount: + return cls(atoms=data.get("atoms", ""), decimal=data.get("decimal", "")) + + +@dataclass(frozen=True) +class Timestamp: + timestamp: int + + @classmethod + def from_json(cls, data: dict) -> Timestamp: + return cls(timestamp=int(data["timestamp"])) + + +@dataclass(frozen=True) +class TxOptions: + """Fee/broadcast options; both keys are always present on the wire.""" + + in_top_x_mb: int | None = None + broadcast_to_mempool: bool | None = None + + def to_json(self) -> dict: + return {"in_top_x_mb": self.in_top_x_mb, "broadcast_to_mempool": self.broadcast_to_mempool} + + +@dataclass +class OutpointSourceID: + """Tagged union: ``"Transaction"`` (content ``{"tx_id": hex}``) or + ``"BlockReward"`` (content ``{"block_id": hex}``). Content is raw JSON and + always serialised (null when unset), mirroring the Go struct.""" + + type: str + content: Any = None + + def to_json(self) -> dict: + return {"type": self.type, "content": self.content} + + @classmethod + def from_json(cls, data: dict) -> OutpointSourceID: + return cls(type=data["type"], content=data.get("content")) + + +@dataclass(frozen=True) +class Outpoint: + source_id: OutpointSourceID + index: int + + def to_json(self) -> dict: + return {"source_id": self.source_id.to_json(), "index": self.index} + + @classmethod + def from_json(cls, data: dict) -> Outpoint: + return cls( + source_id=OutpointSourceID.from_json(data["source_id"]), + index=data["index"], + ) + + +@dataclass(frozen=True) +class FeesBreakdown: + coins: Amount + tokens: dict[str, Amount] + + @classmethod + def from_json(cls, data: dict) -> FeesBreakdown: + return cls( + coins=Amount.from_json(data.get("coins", {})), + tokens={k: Amount.from_json(v) for k, v in (data.get("tokens") or {}).items()}, + ) + + +@dataclass(frozen=True) +class SendResult: + tx_id: str + fees: FeesBreakdown + broadcasted: bool + + @classmethod + def from_json(cls, data: dict) -> SendResult: + return cls( + tx_id=data["tx_id"], + fees=FeesBreakdown.from_json(data["fees"]), + broadcasted=data["broadcasted"], + ) + + +@dataclass(frozen=True) +class SubmitResult: + tx_id: str + + @classmethod + def from_json(cls, data: dict) -> SubmitResult: + return cls(tx_id=data["tx_id"]) + + +@dataclass(frozen=True) +class ComposedTx: + """Hex-encoded PartiallySignedTransaction plus its fee breakdown.""" + + hex: str + fees: FeesBreakdown + + @classmethod + def from_json(cls, data: dict) -> ComposedTx: + return cls(hex=data["hex"], fees=FeesBreakdown.from_json(data["fees"])) + + +@dataclass(frozen=True) +class SignedTx: + hex: str + current_signatures: Any + + @classmethod + def from_json(cls, data: dict) -> SignedTx: + return cls(hex=data["hex"], current_signatures=data.get("current_signatures")) + + +@dataclass(frozen=True) +class TxStats: + num_inputs: int + total_signatures: int + + @classmethod + def from_json(cls, data: dict) -> TxStats: + return cls(num_inputs=data["num_inputs"], total_signatures=data["total_signatures"]) + + +@dataclass(frozen=True) +class TxInspection: + stats: TxStats + fees: FeesBreakdown | None = None + + @classmethod + def from_json(cls, data: dict) -> TxInspection: + return cls( + stats=TxStats.from_json(data["stats"]), + fees=FeesBreakdown.from_json(data["fees"]) if data.get("fees") else None, + ) + + +@dataclass(frozen=True) +class WalletTx: + id: str + height: int + timestamp: Timestamp + + @classmethod + def from_json(cls, data: dict) -> WalletTx: + return cls( + id=data["id"], + height=data["height"], + timestamp=Timestamp.from_json(data["timestamp"]), + ) + + +# ── wallet management ──────────────────────────────────────────────────────── + + +@dataclass(frozen=True) +class MnemonicContent: + mnemonic: str + + +@dataclass(frozen=True) +class MnemonicResult: + type: str + content: MnemonicContent | None = None + + @classmethod + def from_json(cls, data: dict) -> MnemonicResult: + content = data.get("content") + return cls( + type=data["type"], + content=MnemonicContent(**content) if content else None, + ) + + +@dataclass(frozen=True) +class CreateWalletResult: + mnemonic: MnemonicResult | None = None + + @classmethod + def from_json(cls, data: dict) -> CreateWalletResult: + mnemonic = data.get("mnemonic") + return cls(mnemonic=MnemonicResult.from_json(mnemonic) if mnemonic else None) + + +@dataclass(frozen=True) +class CreateWalletParams: + path: str + store_seed_phrase: bool + mnemonic: str | None = None + passphrase: str | None = None + hardware_wallet: str | None = None + + def to_json(self) -> dict: + return { + "path": self.path, + "store_seed_phrase": self.store_seed_phrase, + "mnemonic": self.mnemonic, + "passphrase": self.passphrase, + "hardware_wallet": self.hardware_wallet, + } + + +@dataclass(frozen=True) +class RecoverWalletParams: + path: str + store_seed_phrase: bool + mnemonic: str + passphrase: str | None = None + hardware_wallet: str | None = None + + def to_json(self) -> dict: + return { + "path": self.path, + "store_seed_phrase": self.store_seed_phrase, + "mnemonic": self.mnemonic, + "passphrase": self.passphrase, + "hardware_wallet": self.hardware_wallet, + } + + +@dataclass(frozen=True) +class WalletExtraInfo: + type: str + + @classmethod + def from_json(cls, data: dict) -> WalletExtraInfo: + return cls(type=data["type"]) + + +@dataclass(frozen=True) +class WalletInfo: + wallet_id: str + account_names: list[str] + extra_info: WalletExtraInfo + + @classmethod + def from_json(cls, data: dict) -> WalletInfo: + return cls( + wallet_id=data["wallet_id"], + account_names=data.get("account_names") or [], + extra_info=WalletExtraInfo.from_json(data["extra_info"]), + ) + + +@dataclass(frozen=True) +class BestBlock: + height: int + id: str + + @classmethod + def from_json(cls, data: dict) -> BestBlock: + return cls(height=data["height"], id=data["id"]) + + +@dataclass(frozen=True) +class AccountInfo: + account: int + name: str + + @classmethod + def from_json(cls, data: dict) -> AccountInfo: + return cls(account=data["account"], name=data["name"]) + + +@dataclass(frozen=True) +class Balance: + coins: Amount + tokens: dict[str, Amount] + + @classmethod + def from_json(cls, data: dict) -> Balance: + return cls( + coins=Amount.from_json(data.get("coins", {})), + tokens={k: Amount.from_json(v) for k, v in (data.get("tokens") or {}).items()}, + ) + + +@dataclass(frozen=True) +class AddressWithUsage: + address: str + used: bool + coins: Amount + + @classmethod + def from_json(cls, data: dict) -> AddressWithUsage: + return cls( + address=data["address"], + used=data["used"], + coins=Amount.from_json(data["coins"]), + ) + + +@dataclass(frozen=True) +class RevealPublicKeyResult: + public_key_hex: str + public_key_address: str + + @classmethod + def from_json(cls, data: dict) -> RevealPublicKeyResult: + return cls( + public_key_hex=data["public_key_hex"], public_key_address=data["public_key_address"] + ) + + +# ── transactions ───────────────────────────────────────────────────────────── + + +@dataclass(frozen=True) +class SendParams: + account: int + address: str + amount: Amount + selected_utxos: list[Outpoint] | None = None + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + out: dict[str, Any] = { + "account": self.account, + "address": self.address, + "amount": self.amount.to_json(), + "options": self.options.to_json(), + } + # omitempty: nil OR empty selected_utxos is omitted from the wire. + if self.selected_utxos: + out["selected_utxos"] = [u.to_json() for u in self.selected_utxos] + return out + + +@dataclass(frozen=True) +class SweepParams: + account: int + destination_address: str + from_addresses: list[str] = field(default_factory=list) + all: bool = False + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "destination_address": self.destination_address, + "from_addresses": self.from_addresses, + "all": self.all, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class UTXOSpendParams: + account: int + utxo: Outpoint + output_address: str + htlc_secret: str | None = None + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "utxo": self.utxo.to_json(), + "output_address": self.output_address, + "htlc_secret": self.htlc_secret, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class ComposeParams: + inputs: list[Outpoint] = field(default_factory=list) + outputs: list[Any] = field(default_factory=list) + htlc_secrets: Any = None + only_transaction: bool = False + + def to_json(self) -> dict: + return { + "inputs": [i.to_json() for i in self.inputs], + "outputs": self.outputs, + "htlc_secrets": self.htlc_secrets, + "only_transaction": self.only_transaction, + } + + +# ── staking ────────────────────────────────────────────────────────────────── + + +class StakingStatus(str, enum.Enum): + ACTIVE = "Staking" + INACTIVE = "NotStaking" + + +@dataclass(frozen=True) +class CreatePoolParams: + account: int + amount: Amount + cost_per_block: Amount + margin_ratio_per_thousand: str + decommission_address: str + staker_address: str | None = None + vrf_public_key: str | None = None + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "amount": self.amount.to_json(), + "cost_per_block": self.cost_per_block.to_json(), + "margin_ratio_per_thousand": self.margin_ratio_per_thousand, + "decommission_address": self.decommission_address, + "staker_address": self.staker_address, + "vrf_public_key": self.vrf_public_key, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class DecommissionParams: + account: int + pool_id: str + output_address: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "pool_id": self.pool_id, + "output_address": self.output_address, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class OwnedPool: + pool_id: str + pledge: Amount + balance: Amount + margin_ratio_per_thousand: str + cost_per_block: Amount + + @classmethod + def from_json(cls, data: dict) -> OwnedPool: + return cls( + pool_id=data["pool_id"], + pledge=Amount.from_json(data["pledge"]), + balance=Amount.from_json(data["balance"]), + margin_ratio_per_thousand=data["margin_ratio_per_thousand"], + cost_per_block=Amount.from_json(data["cost_per_block"]), + ) + + +@dataclass(frozen=True) +class CreateDelegationParams: + account: int + address: str + pool_id: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "address": self.address, + "pool_id": self.pool_id, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class CreateDelegationResult: + delegation_id: str + tx_id: str + + @classmethod + def from_json(cls, data: dict) -> CreateDelegationResult: + return cls(delegation_id=data["delegation_id"], tx_id=data["tx_id"]) + + +@dataclass(frozen=True) +class DelegateParams: + account: int + amount: Amount + delegation_id: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "amount": self.amount.to_json(), + "delegation_id": self.delegation_id, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class WithdrawParams: + account: int + address: str + amount: Amount + delegation_id: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "address": self.address, + "amount": self.amount.to_json(), + "delegation_id": self.delegation_id, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class DelegationInfo: + delegation_id: str + pool_id: str + balance: Amount + + @classmethod + def from_json(cls, data: dict) -> DelegationInfo: + return cls( + delegation_id=data["delegation_id"], + pool_id=data["pool_id"], + balance=Amount.from_json(data["balance"]), + ) + + +# ── tokens ─────────────────────────────────────────────────────────────────── + + +@dataclass(frozen=True) +class TokenSupply: + """``"Fixed"`` | ``"Lockable"`` | ``"Unlimited"``; content only for Fixed.""" + + type: str + content: Amount | None = None + + def to_json(self) -> dict: + out: dict[str, Any] = {"type": self.type} + if self.content is not None: + out["content"] = self.content.to_json() + return out + + +@dataclass(frozen=True) +class TokenMetadata: + token_ticker: str + number_of_decimals: int + metadata_uri: str + token_supply: TokenSupply + is_freezable: bool + + def to_json(self) -> dict: + return { + "token_ticker": self.token_ticker, + "number_of_decimals": self.number_of_decimals, + "metadata_uri": self.metadata_uri, + "token_supply": self.token_supply.to_json(), + "is_freezable": self.is_freezable, + } + + +@dataclass(frozen=True) +class IssueTokenParams: + account: int + destination_address: str + metadata: TokenMetadata + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "destination_address": self.destination_address, + "metadata": self.metadata.to_json(), + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class IssueTokenResult: + token_id: str + tx_id: str + + @classmethod + def from_json(cls, data: dict) -> IssueTokenResult: + return cls(token_id=data["token_id"], tx_id=data["tx_id"]) + + +@dataclass(frozen=True) +class NFTMetadata: + media_hash: str + name: str + description: str + ticker: str + creator: str | None = None + icon_uri: str | None = None + media_uri: str | None = None + additional_metadata_uri: str | None = None + + def to_json(self) -> dict: + return { + "media_hash": self.media_hash, + "name": self.name, + "description": self.description, + "ticker": self.ticker, + "creator": self.creator, + "icon_uri": self.icon_uri, + "media_uri": self.media_uri, + "additional_metadata_uri": self.additional_metadata_uri, + } + + +@dataclass(frozen=True) +class IssueNFTParams: + account: int + destination_address: str + metadata: NFTMetadata + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "destination_address": self.destination_address, + "metadata": self.metadata.to_json(), + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class MintParams: + account: int + token_id: str + address: str + amount: Amount + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "token_id": self.token_id, + "address": self.address, + "amount": self.amount.to_json(), + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class UnmintParams: + account: int + token_id: str + amount: Amount + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "token_id": self.token_id, + "amount": self.amount.to_json(), + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class LockSupplyParams: + """Wire key note: the account field is sent as ``account_index``.""" + + account_index: int + token_id: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account_index": self.account_index, + "token_id": self.token_id, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class FreezeParams: + account: int + token_id: str + is_unfreezable: bool + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "token_id": self.token_id, + "is_unfreezable": self.is_unfreezable, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class UnfreezeParams: + account: int + token_id: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "token_id": self.token_id, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class ChangeAuthorityParams: + account: int + token_id: str + address: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "token_id": self.token_id, + "address": self.address, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class TokenSendParams: + account: int + token_id: str + address: str + amount: Amount + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "token_id": self.token_id, + "address": self.address, + "amount": self.amount.to_json(), + "options": self.options.to_json(), + } + + +# ── DEX orders ─────────────────────────────────────────────────────────────── + + +@dataclass(frozen=True) +class OutputValue: + """Custom wire encoding for one side of an order. + + * Coin: ``{"type":"Coin","content":{"amount":{"atoms":...,"decimal":...}}}`` + * Token: ``{"type":"Token","content":{"id":"","amount":{...}}}`` + + Validation errors (missing amount / missing token id) are raised before + any HTTP request is sent. + """ + + coin: bool + token_id: str + amount: Amount + + @classmethod + def coins(cls, atoms: str, decimal: str = "") -> OutputValue: + return cls(coin=True, token_id="", amount=Amount(atoms=atoms, decimal=decimal)) + + @classmethod + def tokens(cls, token_id: str, atoms: str, decimal: str = "") -> OutputValue: + return cls(coin=False, token_id=token_id, amount=Amount(atoms=atoms, decimal=decimal)) + + def to_json(self) -> dict: + if not self.amount.atoms and not self.amount.decimal: + raise ValueError("wallet: output value requires an amount") + if self.coin: + return {"type": "Coin", "content": {"amount": self.amount.to_json()}} + if not self.token_id: + raise ValueError("wallet: token OutputValue requires TokenID") + return { + "type": "Token", + "content": {"id": self.token_id, "amount": self.amount.to_json()}, + } + + @classmethod + def from_json(cls, data: dict) -> OutputValue: + kind = data.get("type") + if not kind: + raise ValueError("wallet: output value requires a type") + content = data.get("content") or {} + amount = Amount.from_json(content.get("amount") or {}) + if not amount.atoms and not amount.decimal: + raise ValueError("wallet: output value requires an amount") + if kind == "Coin": + return cls(coin=True, token_id="", amount=amount) + if kind == "Token": + token_id = content.get("id", "") + if not token_id: + raise ValueError("wallet: token OutputValue requires TokenID") + return cls(coin=False, token_id=token_id, amount=amount) + raise ValueError(f"wallet: unknown OutputValue type {kind!r}") + + +@dataclass(frozen=True) +class CurrencyFilter: + """Custom wire encoding: ``CoinFilter()`` → ``{"type":"Coin"}`` (no content + key); ``TokenFilter(id)`` → ``{"type":"Token","content":""}``.""" + + coin: bool + content: str = "" + + @classmethod + def coin_filter(cls) -> CurrencyFilter: + return cls(coin=True) + + @classmethod + def token_filter(cls, token_id: str) -> CurrencyFilter: + if not token_id: + raise ValueError( + "wallet: TokenFilter requires a token id (use CoinFilter for the native coin)" + ) + return cls(coin=False, content=token_id) + + def to_json(self) -> dict: + if self.coin: + return {"type": "Coin"} + return {"type": "Token", "content": self.content} + + +@dataclass(frozen=True) +class OrderState: + ask_balance: Amount + give_balance: Amount + is_frozen: bool + creation_timestamp: Timestamp + + @classmethod + def from_json(cls, data: dict) -> OrderState: + return cls( + ask_balance=Amount.from_json(data["ask_balance"]), + give_balance=Amount.from_json(data["give_balance"]), + is_frozen=data["is_frozen"], + creation_timestamp=Timestamp.from_json(data["creation_timestamp"]), + ) + + +@dataclass(frozen=True) +class OwnOrder: + order_id: str + initially_asked: OutputValue + initially_given: OutputValue + existing_order_data: OrderState | None + is_marked_as_frozen_in_wallet: bool + is_marked_as_concluded_in_wallet: bool + + @classmethod + def from_json(cls, data: dict) -> OwnOrder: + existing = data.get("existing_order_data") + return cls( + order_id=data["order_id"], + initially_asked=OutputValue.from_json(data["initially_asked"]), + initially_given=OutputValue.from_json(data["initially_given"]), + existing_order_data=OrderState.from_json(existing) if existing else None, + is_marked_as_frozen_in_wallet=data["is_marked_as_frozen_in_wallet"], + is_marked_as_concluded_in_wallet=data["is_marked_as_concluded_in_wallet"], + ) + + +@dataclass(frozen=True) +class ActiveOrder: + order_id: str + initially_asked: OutputValue + initially_given: OutputValue + ask_balance: Amount + give_balance: Amount + is_own: bool + + @classmethod + def from_json(cls, data: dict) -> ActiveOrder: + return cls( + order_id=data["order_id"], + initially_asked=OutputValue.from_json(data["initially_asked"]), + initially_given=OutputValue.from_json(data["initially_given"]), + ask_balance=Amount.from_json(data["ask_balance"]), + give_balance=Amount.from_json(data["give_balance"]), + is_own=data["is_own"], + ) + + +@dataclass(frozen=True) +class OrderCreated: + order_id: str + tx_id: str + broadcasted: bool + + @classmethod + def from_json(cls, data: dict) -> OrderCreated: + return cls( + order_id=data["order_id"], + tx_id=data["tx_id"], + broadcasted=data["broadcasted"], + ) + + +@dataclass(frozen=True) +class CreateOrderParams: + account: int + ask: OutputValue + give: OutputValue + conclude_address: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "ask": self.ask.to_json(), + "give": self.give.to_json(), + "conclude_address": self.conclude_address, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class ConcludeOrderParams: + account: int + order_id: str + output_address: str | None = None + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "order_id": self.order_id, + "output_address": self.output_address, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class FillOrderParams: + account: int + order_id: str + fill_amount_in_ask_currency: Amount + output_address: str | None = None + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "order_id": self.order_id, + "fill_amount_in_ask_currency": self.fill_amount_in_ask_currency.to_json(), + "output_address": self.output_address, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class FreezeOrderParams: + account: int + order_id: str + options: TxOptions = field(default_factory=TxOptions) + + def to_json(self) -> dict: + return { + "account": self.account, + "order_id": self.order_id, + "options": self.options.to_json(), + } + + +@dataclass(frozen=True) +class ListOrdersParams: + account: int + ask_currency: CurrencyFilter | None = None + give_currency: CurrencyFilter | None = None + + def to_json(self) -> dict: + return { + "account": self.account, + "ask_currency": self.ask_currency.to_json() if self.ask_currency else None, + "give_currency": self.give_currency.to_json() if self.give_currency else None, + } diff --git a/tests/test_wallet_concurrency.py b/tests/test_wallet_concurrency.py new file mode 100644 index 0000000..edce565 --- /dev/null +++ b/tests/test_wallet_concurrency.py @@ -0,0 +1,41 @@ +"""Concurrent-use test: one wallet client shared by many threads. + +Mirrors the "Concurrent ID generation" section of +go-sdk/wallet/client_test.go, additionally asserting that request ids stay +unique and increasing. +""" + +from __future__ import annotations + +import threading + +from mintlayer.wallet import BestBlock, Client + + +def test_concurrent_calls_unique_increasing_ids(rpc_server) -> None: + srv = rpc_server(result={"height": 1, "id": "aa"}) + client = Client(srv.url) + results: list[BestBlock] = [] + errors: list[Exception] = [] + + def call() -> None: + try: + results.append(client.best_block()) + except Exception as exc: # noqa: BLE001 - collected and asserted below + errors.append(exc) + + threads = [threading.Thread(target=call) for _ in range(10)] + for thread in threads: + thread.start() + for thread in threads: + thread.join(timeout=10) + + assert errors == [] + assert results == [BestBlock(height=1, id="aa")] * 10 + assert srv.capture.request_count == 10 + assert srv.capture.protocol_errors == [] + + ids = srv.capture.request_ids + assert len(set(ids)) == 10, f"expected 10 unique request ids, got {ids}" + assert sorted(ids) == list(range(1, 11)), f"ids not 1..10: {sorted(ids)}" + client.close() diff --git a/tests/test_wallet_management.py b/tests/test_wallet_management.py new file mode 100644 index 0000000..2ea5a43 --- /dev/null +++ b/tests/test_wallet_management.py @@ -0,0 +1,305 @@ +"""Wallet lifecycle management tests. + +Mirrors the "Wallet management" section of go-sdk/wallet/client_test.go, +pinning the exact RPC method names and params shapes on the wire. +""" + +from __future__ import annotations + +import pytest + +from mintlayer.wallet import ( + AccountInfo, + AddressWithUsage, + Amount, + Balance, + BestBlock, + Client, + CreateWalletParams, + CreateWalletResult, + JSONRPCError, + RecoverWalletParams, + WalletInfo, +) +from mintlayer.wallet.types import RevealPublicKeyResult + +_MNEMONIC = "word1 word2 word3 word4 word5 word6 word7 word8 word9 word10 word11 word12" + + +def test_create_wallet_newly_generated(rpc_server) -> None: + result = {"mnemonic": {"type": "NewlyGenerated", "content": {"mnemonic": _MNEMONIC}}} + srv = rpc_server(result=result) + client = Client(srv.url) + got = client.create_wallet(CreateWalletParams(path="/tmp/test.db", store_seed_phrase=True)) + assert srv.capture.method == "wallet_create" + assert got.mnemonic is not None + assert got.mnemonic.type == "NewlyGenerated" + assert got.mnemonic.content is not None + assert got.mnemonic.content.mnemonic == _MNEMONIC + client.close() + + +def test_create_wallet_user_provided_content_null(rpc_server) -> None: + srv = rpc_server(result={"mnemonic": {"type": "UserProvided", "content": None}}) + client = Client(srv.url) + got = client.create_wallet(CreateWalletParams(path="/tmp/test.db", store_seed_phrase=False)) + assert got.mnemonic is not None + assert got.mnemonic.type == "UserProvided" + assert got.mnemonic.content is None + client.close() + + +def test_create_wallet_without_mnemonic(rpc_server) -> None: + srv = rpc_server(result={}) + client = Client(srv.url) + got = client.create_wallet(CreateWalletParams(path="/tmp/test.db", store_seed_phrase=True)) + assert got == CreateWalletResult(mnemonic=None) + client.close() + + +def test_create_wallet_wire_shape(rpc_server) -> None: + srv = rpc_server(result={}) + client = Client(srv.url) + client.create_wallet(CreateWalletParams(path="/tmp/test.db", store_seed_phrase=True)) + assert srv.capture.params == { + "path": "/tmp/test.db", + "store_seed_phrase": True, + "mnemonic": None, + "passphrase": None, + "hardware_wallet": None, + } + client.close() + + +def test_recover_wallet(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.recover_wallet( + RecoverWalletParams( + path="/tmp/recovered.db", + store_seed_phrase=False, + mnemonic=_MNEMONIC, + ) + ) + assert srv.capture.method == "wallet_recover" + assert srv.capture.params == { + "path": "/tmp/recovered.db", + "store_seed_phrase": False, + "mnemonic": _MNEMONIC, + "passphrase": None, + "hardware_wallet": None, + } + client.close() + + +@pytest.mark.parametrize( + ("password", "wire_password"), + [("", None), ("hunter2", "hunter2")], + ids=["empty_password_null", "password_sent_verbatim"], +) +def test_open_wallet(rpc_server, password: str, wire_password: str | None) -> None: + """An empty password is sent as JSON null; a real one verbatim.""" + srv = rpc_server(result=None) + client = Client(srv.url) + client.open_wallet("/tmp/test.db", password) + assert srv.capture.method == "wallet_open" + assert srv.capture.params == { + "path": "/tmp/test.db", + "password": wire_password, + "force_migrate_wallet_type": None, + "hardware_wallet": None, + } + client.close() + + +def test_close_wallet(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.close_wallet() + assert srv.capture.method == "wallet_close" + assert srv.capture.params == {} + client.close() + + +def test_get_wallet_info(rpc_server) -> None: + srv = rpc_server( + result={ + "wallet_id": "aabb1234", + "account_names": ["Main", "Savings"], + "extra_info": {"type": "SoftwareWallet"}, + } + ) + client = Client(srv.url) + got = client.get_wallet_info() + assert isinstance(got, WalletInfo) + assert got.wallet_id == "aabb1234" + assert got.account_names == ["Main", "Savings"] + assert got.extra_info.type == "SoftwareWallet" + assert srv.capture.method == "wallet_info" + assert srv.capture.params == {} + client.close() + + +def test_get_wallet_info_null_result_raises(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="expected object result"): + client.get_wallet_info() + client.close() + + +def test_sync_wallet(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.sync_wallet() + assert srv.capture.method == "wallet_sync" + assert srv.capture.params == {} + client.close() + + +def test_rescan_wallet(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.rescan_wallet() + assert srv.capture.method == "wallet_rescan" + assert srv.capture.params == {} + client.close() + + +def test_best_block(rpc_server) -> None: + srv = rpc_server(result={"height": 42000, "id": "deadbeef"}) + client = Client(srv.url) + got = client.best_block() + assert got == BestBlock(height=42000, id="deadbeef") + assert srv.capture.method == "wallet_best_block" + assert srv.capture.params == {} + client.close() + + +def test_create_account(rpc_server) -> None: + srv = rpc_server(result={"account": 1, "name": "Savings"}) + client = Client(srv.url) + got = client.create_account("Savings") + assert got == AccountInfo(account=1, name="Savings") + assert srv.capture.method == "account_create" + assert srv.capture.params == {"name": "Savings"} + client.close() + + +def test_rename_account(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.rename_account(0, "Main") + assert srv.capture.method == "account_rename" + assert srv.capture.params == {"account": 0, "name": "Main"} + client.close() + + +def test_rename_account_empty_name_sent_as_null(rpc_server) -> None: + """An empty name is sent as null (clears the account name).""" + srv = rpc_server(result=None) + client = Client(srv.url) + client.rename_account(0) + assert srv.capture.method == "account_rename" + assert srv.capture.params == {"account": 0, "name": None} + client.close() + + +def test_get_balance(rpc_server) -> None: + result = { + "coins": {"atoms": "1000000000000", "decimal": "10000.0"}, + "tokens": {"tok1abc": {"atoms": "500000000"}}, + } + srv = rpc_server(result=result) + client = Client(srv.url) + got = client.get_balance(0) + assert isinstance(got, Balance) + assert got.coins == Amount(atoms="1000000000000", decimal="10000.0") + assert got.tokens == {"tok1abc": Amount(atoms="500000000")} + assert srv.capture.method == "account_balance" + # Pinned option keys: confirmed-only UTXO states, locked UTXOs not merged. + assert srv.capture.params == { + "account": 0, + "utxo_states": ["Confirmed"], + "with_locked": None, + } + client.close() + + +def test_new_address(rpc_server) -> None: + srv = rpc_server(result={"address": "tmltool1abc"}) + client = Client(srv.url) + assert client.new_address(0) == "tmltool1abc" + assert srv.capture.method == "address_new" + assert srv.capture.params == {"account": 0} + client.close() + + +def test_show_receive_addresses(rpc_server) -> None: + result = [ + {"address": "tmltool1abc", "used": False, "coins": {"atoms": "0"}}, + {"address": "tmltool1def", "used": True, "coins": {"atoms": "5000000000"}}, + ] + srv = rpc_server(result=result) + client = Client(srv.url) + got = client.show_receive_addresses(0) + assert got == [ + AddressWithUsage(address="tmltool1abc", used=False, coins=Amount(atoms="0")), + AddressWithUsage(address="tmltool1def", used=True, coins=Amount(atoms="5000000000")), + ] + assert srv.capture.method == "address_show" + # Change addresses are never included. + assert srv.capture.params == {"account": 0, "include_change_addresses": False} + client.close() + + +def test_show_receive_addresses_null_result_returns_empty(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.show_receive_addresses(0) == [] + client.close() + + +def test_reveal_public_key(rpc_server) -> None: + result = {"public_key_hex": "02aabbccdd", "public_key_address": "tmltool1pubkey"} + srv = rpc_server(result=result) + client = Client(srv.url) + assert client.reveal_public_key(0, "tmltool1abc") == "02aabbccdd" + assert srv.capture.method == "address_reveal_public_key" + assert srv.capture.params == {"account": 0, "address": "tmltool1abc"} + client.close() + + +def test_reveal_public_key_result_decode() -> None: + got = RevealPublicKeyResult.from_json( + {"public_key_hex": "02aabbccdd", "public_key_address": "tmltool1pubkey"} + ) + assert got.public_key_hex == "02aabbccdd" + assert got.public_key_address == "tmltool1pubkey" + + +def test_encrypt_private_keys(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.encrypt_private_keys("s3cr3t") + assert srv.capture.method == "wallet_encrypt_private_keys" + assert srv.capture.params == {"password": "s3cr3t"} + client.close() + + +def test_unlock_private_keys(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.unlock_private_keys("s3cr3t") + assert srv.capture.method == "wallet_unlock_private_keys" + assert srv.capture.params == {"password": "s3cr3t"} + client.close() + + +def test_lock_private_keys(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.lock_private_keys() + assert srv.capture.method == "wallet_lock_private_keys" + assert srv.capture.params == {} + client.close() diff --git a/tests/test_wallet_orders.py b/tests/test_wallet_orders.py new file mode 100644 index 0000000..96c1a2a --- /dev/null +++ b/tests/test_wallet_orders.py @@ -0,0 +1,396 @@ +"""DEX order tests for the wallet client. + +Mirrors go-sdk/wallet/orders_test.go: OutputValue wire shapes, the client-side +validation that never reaches the HTTP server, the order action params shapes, +and the CurrencyFilter encodings for list_all_active_orders. +""" + +from __future__ import annotations + +from collections.abc import Callable + +import pytest + +from mintlayer.wallet import ( + Amount, + Client, + ConcludeOrderParams, + CreateOrderParams, + FillOrderParams, + FreezeOrderParams, + ListOrdersParams, + OrderCreated, + OutputValue, + RPCError, + coin_filter, + token_filter, +) + +_ZERO_OPTIONS = {"in_top_x_mb": None, "broadcast_to_mempool": None} + + +def _send_result(tx_id: str) -> dict: + return { + "tx_id": tx_id, + "fees": {"coins": {"atoms": "10000", "decimal": "0.0001"}, "tokens": {}}, + "broadcasted": True, + } + + +_OWN_ORDERS = [ + { + "order_id": "ord1owned", + "initially_asked": { + "type": "Token", + "content": {"id": "tok1askedabc", "amount": {"atoms": "100000000", "decimal": "1.0"}}, + }, + "initially_given": { + "type": "Coin", + "content": {"amount": {"atoms": "5000000000", "decimal": "50.0"}}, + }, + "existing_order_data": { + "ask_balance": {"atoms": "90000000", "decimal": "0.9"}, + "give_balance": {"atoms": "4500000000", "decimal": "45.0"}, + "is_frozen": True, + "creation_timestamp": {"timestamp": 1700000000}, + }, + "is_marked_as_frozen_in_wallet": True, + "is_marked_as_concluded_in_wallet": False, + }, + { + "order_id": "ord2owned", + "initially_asked": {"type": "Coin", "content": {"amount": {"atoms": "10"}}}, + "initially_given": { + "type": "Token", + "content": {"id": "tok2given", "amount": {"atoms": "20"}}, + }, + "existing_order_data": None, + "is_marked_as_frozen_in_wallet": False, + "is_marked_as_concluded_in_wallet": True, + }, +] + +_ACTIVE_ORDERS = [ + { + "order_id": "ord1active", + "initially_asked": {"type": "Coin", "content": {"amount": {"atoms": "1000000000000"}}}, + "initially_given": { + "type": "Token", + "content": {"id": "tok1givenabc", "amount": {"atoms": "2500000000"}}, + }, + "ask_balance": {"atoms": "1000000000000"}, + "give_balance": {"atoms": "2500000000"}, + "is_own": True, + } +] + + +# --- OutputValue wire encoding ------------------------------------------------ + + +def test_output_value_coin_wire_shape() -> None: + value = OutputValue.coins(atoms="1000000000000") + assert value.to_json() == {"type": "Coin", "content": {"amount": {"atoms": "1000000000000"}}} + # Coin values carry no token id key at all. + assert "id" not in value.to_json()["content"] + + +def test_output_value_token_wire_shape() -> None: + value = OutputValue.tokens("tok1abc", atoms="250000000") + assert value.to_json() == { + "type": "Token", + "content": {"id": "tok1abc", "amount": {"atoms": "250000000"}}, + } + + +def test_output_value_token_without_id_raises() -> None: + value = OutputValue.tokens("", atoms="2") + with pytest.raises(ValueError, match="requires TokenID"): + value.to_json() + + +def test_output_value_without_amount_raises() -> None: + with pytest.raises(ValueError, match="requires an amount"): + OutputValue.coins(atoms="").to_json() + + +def test_output_value_unknown_type_from_json_raises() -> None: + with pytest.raises(ValueError, match="unknown OutputValue type"): + OutputValue.from_json({"type": "NFT", "content": {"amount": {"atoms": "1"}}}) + + +@pytest.mark.parametrize( + "value", + [ + OutputValue.coins(atoms="1000000000000", decimal="10000.0"), + OutputValue.tokens("tok1roundtrip", atoms="999", decimal="0.000000999"), + ], + ids=["coin", "token"], +) +def test_output_value_round_trip(value: OutputValue) -> None: + assert OutputValue.from_json(value.to_json()) == value + + +# --- CreateOrder --------------------------------------------------------------- + + +def test_create_order_wire_shape(rpc_server) -> None: + srv = rpc_server(result={"order_id": "ord1created", "tx_id": "tx1created", "broadcasted": True}) + client = Client(srv.url) + got = client.create_order( + CreateOrderParams( + account=0, + ask=OutputValue.coins(atoms="1000000000000"), + give=OutputValue.tokens("tok1giveabc", atoms="250000000"), + conclude_address="tmltool1conclude", + ) + ) + assert got == OrderCreated(order_id="ord1created", tx_id="tx1created", broadcasted=True) + assert srv.capture.method == "order_create" + assert srv.capture.params == { + "account": 0, + "ask": {"type": "Coin", "content": {"amount": {"atoms": "1000000000000"}}}, + "give": { + "type": "Token", + "content": {"id": "tok1giveabc", "amount": {"atoms": "250000000"}}, + }, + "conclude_address": "tmltool1conclude", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_create_order_token_side_without_id_no_request(rpc_server) -> None: + """A token side missing its TokenID fails before any HTTP request.""" + srv = rpc_server(result=None) + client = Client(srv.url) + params = CreateOrderParams( + account=0, + ask=OutputValue.coins(atoms="1"), + give=OutputValue.tokens("", atoms="2"), + conclude_address="tmltool1conclude", + ) + with pytest.raises(ValueError, match="requires TokenID"): + client.create_order(params) + assert srv.capture.request_count == 0 + client.close() + + +def test_create_order_missing_amount_no_request(rpc_server) -> None: + """An OutputValue with no amount fails before any HTTP request.""" + srv = rpc_server(result=None) + client = Client(srv.url) + params = CreateOrderParams( + account=0, + ask=OutputValue.coins(atoms=""), + give=OutputValue.coins(atoms="2"), + conclude_address="tmltool1conclude", + ) + with pytest.raises(ValueError, match="requires an amount"): + client.create_order(params) + assert srv.capture.request_count == 0 + client.close() + + +# --- ConcludeOrder / FillOrder / FreezeOrder ----------------------------------- + + +def test_conclude_order_output_address_null(rpc_server) -> None: + srv = rpc_server(result=_send_result("tx1c2")) + client = Client(srv.url) + got = client.conclude_order(ConcludeOrderParams(account=0, order_id="ord1c2")) + assert got.tx_id == "tx1c2" + assert got.broadcasted is True + assert srv.capture.method == "order_conclude" + # The key stays on the wire with an explicit null (never omitted). + assert srv.capture.params == { + "account": 0, + "order_id": "ord1c2", + "output_address": None, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_conclude_order_with_output_address(rpc_server) -> None: + srv = rpc_server(result=_send_result("tx1conclude")) + client = Client(srv.url) + got = client.conclude_order( + ConcludeOrderParams(account=0, order_id="ord1conclude", output_address="tmltool1remainder") + ) + assert got.tx_id == "tx1conclude" + assert srv.capture.params["output_address"] == "tmltool1remainder" + client.close() + + +def test_fill_order_wire_shape(rpc_server) -> None: + srv = rpc_server(result=_send_result("tx1fill")) + client = Client(srv.url) + got = client.fill_order( + FillOrderParams( + account=0, + order_id="ord1fill", + fill_amount_in_ask_currency=Amount(atoms="100000000", decimal="1.0"), + ) + ) + assert got.tx_id == "tx1fill" + assert srv.capture.method == "order_fill" + # Key name "fill_amount_in_ask_currency" is pinned; output_address null. + assert srv.capture.params == { + "account": 0, + "order_id": "ord1fill", + "fill_amount_in_ask_currency": {"atoms": "100000000", "decimal": "1.0"}, + "output_address": None, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_freeze_order_wire_shape(rpc_server) -> None: + srv = rpc_server(result=_send_result("tx1freeze")) + client = Client(srv.url) + got = client.freeze_order(FreezeOrderParams(account=0, order_id="ord1freeze")) + assert got.tx_id == "tx1freeze" + assert srv.capture.method == "order_freeze" + assert srv.capture.params == { + "account": 0, + "order_id": "ord1freeze", + "options": _ZERO_OPTIONS, + } + client.close() + + +# --- Listings ------------------------------------------------------------------ + + +def test_list_own_orders_decoding(rpc_server) -> None: + srv = rpc_server(result=_OWN_ORDERS) + client = Client(srv.url) + got = client.list_own_orders(0) + assert srv.capture.method == "order_list_own" + assert srv.capture.params == {"account": 0} + assert len(got) == 2 + + first = got[0] + assert first.order_id == "ord1owned" + # initially_asked: Token carrying both atoms and decimal. + assert first.initially_asked == OutputValue.tokens( + "tok1askedabc", atoms="100000000", decimal="1.0" + ) + # initially_given: Coin with no token id. + assert first.initially_given == OutputValue.coins(atoms="5000000000", decimal="50.0") + existing = first.existing_order_data + assert existing is not None + assert existing.ask_balance == Amount(atoms="90000000", decimal="0.9") + assert existing.give_balance == Amount(atoms="4500000000", decimal="45.0") + assert existing.is_frozen is True + assert existing.creation_timestamp.timestamp == 1700000000 + assert first.is_marked_as_frozen_in_wallet is True + assert first.is_marked_as_concluded_in_wallet is False + + second = got[1] + assert second.order_id == "ord2owned" + # A null existing_order_data decodes to None. + assert second.existing_order_data is None + assert second.is_marked_as_concluded_in_wallet is True + client.close() + + +def test_list_own_orders_null_result_returns_empty(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.list_own_orders(0) == [] + client.close() + + +def test_list_all_active_orders_nil_filters(rpc_server) -> None: + srv = rpc_server(result=[]) + client = Client(srv.url) + got = client.list_all_active_orders(ListOrdersParams(account=3)) + assert got == [] + assert srv.capture.method == "order_list_all_active" + # Nil filters are encoded as JSON null on both keys. + assert srv.capture.params == {"account": 3, "ask_currency": None, "give_currency": None} + client.close() + + +def test_list_all_active_orders_with_filters(rpc_server) -> None: + srv = rpc_server(result=_ACTIVE_ORDERS) + client = Client(srv.url) + got = client.list_all_active_orders( + ListOrdersParams( + account=0, + ask_currency=coin_filter(), + give_currency=token_filter("tok1givenabc"), + ) + ) + assert len(got) == 1 + order = got[0] + assert order.order_id == "ord1active" + assert order.initially_asked == OutputValue.coins(atoms="1000000000000") + assert order.initially_given == OutputValue.tokens("tok1givenabc", atoms="2500000000") + assert order.ask_balance == Amount(atoms="1000000000000") + assert order.give_balance == Amount(atoms="2500000000") + assert order.is_own is True + # Coin filters carry no content; token filters carry the id as content. + assert srv.capture.params == { + "account": 0, + "ask_currency": {"type": "Coin"}, + "give_currency": {"type": "Token", "content": "tok1givenabc"}, + } + client.close() + + +def test_token_filter_empty_id_raises() -> None: + with pytest.raises(ValueError, match="token id"): + token_filter("") + + +# --- Error propagation --------------------------------------------------------- + + +@pytest.mark.parametrize( + "invoke", + [ + pytest.param( + lambda c: c.create_order( + CreateOrderParams( + account=0, + ask=OutputValue.coins(atoms="1"), + give=OutputValue.coins(atoms="2"), + conclude_address="tmltool1conclude", + ) + ), + id="create_order", + ), + pytest.param( + lambda c: c.conclude_order(ConcludeOrderParams(account=0, order_id="ord1")), + id="conclude_order", + ), + pytest.param( + lambda c: c.fill_order( + FillOrderParams( + account=0, order_id="ord1", fill_amount_in_ask_currency=Amount(atoms="1") + ) + ), + id="fill_order", + ), + pytest.param( + lambda c: c.freeze_order(FreezeOrderParams(account=0, order_id="ord1")), + id="freeze_order", + ), + pytest.param(lambda c: c.list_own_orders(0), id="list_own_orders"), + pytest.param( + lambda c: c.list_all_active_orders(ListOrdersParams(account=0)), + id="list_all_active_orders", + ), + ], +) +def test_order_methods_rpc_error_propagates(rpc_server, invoke: Callable[[Client], object]) -> None: + srv = rpc_server(error=(-32000, "order failure")) + client = Client(srv.url) + with pytest.raises(RPCError) as excinfo: + invoke(client) + assert excinfo.value.code == -32000 + assert excinfo.value.message == "order failure" + client.close() diff --git a/tests/test_wallet_staking.py b/tests/test_wallet_staking.py new file mode 100644 index 0000000..3a94870 --- /dev/null +++ b/tests/test_wallet_staking.py @@ -0,0 +1,239 @@ +"""Staking and delegation tests for the wallet client. + +Mirrors the "Staking" section of go-sdk/wallet/client_test.go, pinning the +pool params wire shape, the account-less pool-balance route, and the bare +string -> enum mapping of the staking status. +""" + +from __future__ import annotations + +from mintlayer.wallet import ( + Amount, + Client, + CreateDelegationParams, + CreateDelegationResult, + CreatePoolParams, + DecommissionParams, + DelegateParams, + DelegationInfo, + OwnedPool, + StakingStatus, + WithdrawParams, +) + +_ZERO_OPTIONS = {"in_top_x_mb": None, "broadcast_to_mempool": None} + + +def _send_result(tx_id: str) -> dict: + return { + "tx_id": tx_id, + "fees": {"coins": {"atoms": "10000", "decimal": "0.0001"}, "tokens": {}}, + "broadcasted": True, + } + + +def test_create_stake_pool(rpc_server) -> None: + srv = rpc_server(result=_send_result("pool01")) + client = Client(srv.url) + got = client.create_stake_pool( + CreatePoolParams( + account=0, + amount=Amount(decimal="40000"), + cost_per_block=Amount(decimal="1"), + margin_ratio_per_thousand="5%", + decommission_address="tmltool1decom", + ) + ) + assert got.tx_id == "pool01" + assert got.broadcasted is True + assert srv.capture.method == "staking_create_pool" + # The margin ratio string passes through untouched; optional addresses + # stay explicit nulls. + assert srv.capture.params == { + "account": 0, + "amount": {"decimal": "40000"}, + "cost_per_block": {"decimal": "1"}, + "margin_ratio_per_thousand": "5%", + "decommission_address": "tmltool1decom", + "staker_address": None, + "vrf_public_key": None, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_decommission_stake_pool(rpc_server) -> None: + srv = rpc_server(result=_send_result("decom01")) + client = Client(srv.url) + got = client.decommission_stake_pool( + DecommissionParams(account=0, pool_id="pool1abc", output_address="tmltool1dest") + ) + assert got.tx_id == "decom01" + assert srv.capture.method == "staking_decommission_pool" + assert srv.capture.params == { + "account": 0, + "pool_id": "pool1abc", + "output_address": "tmltool1dest", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_list_owned_pools(rpc_server) -> None: + result = [ + { + "pool_id": "pool1abc", + "pledge": {"atoms": "40000000000000"}, + "balance": {"atoms": "50000000000000"}, + "margin_ratio_per_thousand": "5%", + "cost_per_block": {"atoms": "100000000"}, + } + ] + srv = rpc_server(result=result) + client = Client(srv.url) + got = client.list_owned_pools(0) + assert got == [ + OwnedPool( + pool_id="pool1abc", + pledge=Amount(atoms="40000000000000"), + balance=Amount(atoms="50000000000000"), + margin_ratio_per_thousand="5%", + cost_per_block=Amount(atoms="100000000"), + ) + ] + assert srv.capture.method == "staking_list_pools" + assert srv.capture.params == {"account": 0} + client.close() + + +def test_list_owned_pools_null_result_returns_empty(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + assert client.list_owned_pools(0) == [] + client.close() + + +def test_get_pool_balance_account_not_sent(rpc_server) -> None: + srv = rpc_server(result={"balance": {"atoms": "50000000000000", "decimal": "500000.0"}}) + client = Client(srv.url) + got = client.get_pool_balance(0, "pool1abc") + assert got == Amount(atoms="50000000000000", decimal="500000.0") + assert srv.capture.method == "staking_pool_balance" + # The daemon route takes only the pool id: the account argument is + # accepted for API consistency but never serialised. + assert srv.capture.params == {"pool_id": "pool1abc"} + client.close() + + +def test_start_staking(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.start_staking(0) + assert srv.capture.method == "staking_start" + assert srv.capture.params == {"account": 0} + client.close() + + +def test_stop_staking(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.stop_staking(0) + assert srv.capture.method == "staking_stop" + assert srv.capture.params == {"account": 0} + client.close() + + +def test_get_staking_status_active(rpc_server) -> None: + srv = rpc_server(result="Staking") + client = Client(srv.url) + assert client.get_staking_status(0) is StakingStatus.ACTIVE + assert srv.capture.method == "staking_status" + assert srv.capture.params == {"account": 0} + client.close() + + +def test_get_staking_status_inactive(rpc_server) -> None: + srv = rpc_server(result="NotStaking") + client = Client(srv.url) + assert client.get_staking_status(0) is StakingStatus.INACTIVE + client.close() + + +def test_create_delegation(rpc_server) -> None: + srv = rpc_server(result={"delegation_id": "deleg1abc", "tx_id": "delegtx01"}) + client = Client(srv.url) + got = client.create_delegation( + CreateDelegationParams(account=0, address="tmltool1owner", pool_id="pool1abc") + ) + assert got == CreateDelegationResult(delegation_id="deleg1abc", tx_id="delegtx01") + assert srv.capture.method == "delegation_create" + assert srv.capture.params == { + "account": 0, + "address": "tmltool1owner", + "pool_id": "pool1abc", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_delegate_staking(rpc_server) -> None: + srv = rpc_server(result=_send_result("stake01")) + client = Client(srv.url) + got = client.delegate_staking( + DelegateParams(account=0, amount=Amount(decimal="1000"), delegation_id="deleg1abc") + ) + assert got.tx_id == "stake01" + assert srv.capture.method == "delegation_stake" + assert srv.capture.params == { + "account": 0, + "amount": {"decimal": "1000"}, + "delegation_id": "deleg1abc", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_withdraw_from_delegation(rpc_server) -> None: + srv = rpc_server(result=_send_result("withdraw01")) + client = Client(srv.url) + got = client.withdraw_from_delegation( + WithdrawParams( + account=0, + address="tmltool1dest", + amount=Amount(decimal="500"), + delegation_id="deleg1abc", + ) + ) + assert got.tx_id == "withdraw01" + assert srv.capture.method == "delegation_withdraw" + assert srv.capture.params == { + "account": 0, + "address": "tmltool1dest", + "amount": {"decimal": "500"}, + "delegation_id": "deleg1abc", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_list_delegations(rpc_server) -> None: + result = [ + { + "delegation_id": "deleg1abc", + "pool_id": "pool1abc", + "balance": {"atoms": "1000000000000"}, + } + ] + srv = rpc_server(result=result) + client = Client(srv.url) + got = client.list_delegations(0) + assert got == [ + DelegationInfo( + delegation_id="deleg1abc", + pool_id="pool1abc", + balance=Amount(atoms="1000000000000"), + ) + ] + assert srv.capture.method == "delegation_list_ids" + assert srv.capture.params == {"account": 0} + client.close() diff --git a/tests/test_wallet_tokens.py b/tests/test_wallet_tokens.py new file mode 100644 index 0000000..cab8c6a --- /dev/null +++ b/tests/test_wallet_tokens.py @@ -0,0 +1,243 @@ +"""Token method tests for the wallet client. + +Mirrors the "Tokens" section of go-sdk/wallet/client_test.go, pinning the +nested metadata wire shapes, both TokenSupply encodings, and the deliberate +``account_index`` key of lock_token_supply. +""" + +from __future__ import annotations + +from mintlayer.wallet import ( + Amount, + ChangeAuthorityParams, + Client, + FreezeParams, + IssueNFTParams, + IssueTokenParams, + IssueTokenResult, + LockSupplyParams, + MintParams, + NFTMetadata, + TokenMetadata, + TokenSendParams, + TokenSupply, + UnfreezeParams, + UnmintParams, +) + +_ZERO_OPTIONS = {"in_top_x_mb": None, "broadcast_to_mempool": None} + + +def _send_result(tx_id: str) -> dict: + return { + "tx_id": tx_id, + "fees": {"coins": {"atoms": "10000", "decimal": "0.0001"}, "tokens": {}}, + "broadcasted": True, + } + + +def test_issue_token_lockable_supply(rpc_server) -> None: + srv = rpc_server(result={"token_id": "tok1abc", "tx_id": "issue01"}) + client = Client(srv.url) + got = client.issue_token( + IssueTokenParams( + account=0, + destination_address="tmltool1auth", + metadata=TokenMetadata( + token_ticker="MYTKN", + number_of_decimals=8, + metadata_uri="https://example.com/token", + token_supply=TokenSupply(type="Lockable"), + is_freezable=False, + ), + ) + ) + assert got == IssueTokenResult(token_id="tok1abc", tx_id="issue01") + assert srv.capture.method == "token_issue_new" + # Lockable supply serialises without a content key. + assert srv.capture.params["metadata"]["token_supply"] == {"type": "Lockable"} + client.close() + + +def test_issue_token_fixed_supply_wire_shape(rpc_server) -> None: + srv = rpc_server(result={"token_id": "tok1abc", "tx_id": "issue01"}) + client = Client(srv.url) + client.issue_token( + IssueTokenParams( + account=0, + destination_address="tmltool1auth", + metadata=TokenMetadata( + token_ticker="MYTKN", + number_of_decimals=8, + metadata_uri="https://example.com/token", + token_supply=TokenSupply(type="Fixed", content=Amount(atoms="1000000")), + is_freezable=True, + ), + ) + ) + assert srv.capture.method == "token_issue_new" + # Fixed supply carries its amount inside a content object. + assert srv.capture.params == { + "account": 0, + "destination_address": "tmltool1auth", + "metadata": { + "token_ticker": "MYTKN", + "number_of_decimals": 8, + "metadata_uri": "https://example.com/token", + "token_supply": {"type": "Fixed", "content": {"atoms": "1000000"}}, + "is_freezable": True, + }, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_issue_nft_metadata_nulls(rpc_server) -> None: + srv = rpc_server(result={"token_id": "nft1abc", "tx_id": "nftissue01"}) + client = Client(srv.url) + got = client.issue_nft( + IssueNFTParams( + account=0, + destination_address="tmltool1dest", + metadata=NFTMetadata( + media_hash="a3f1e2d9c4", + name="Sunset #1", + description="A photograph of a sunset", + ticker="SUNST", + ), + ) + ) + assert got.token_id == "nft1abc" + assert srv.capture.method == "token_nft_issue_new" + # Optional NFT metadata keys are always present, null when unset. + assert srv.capture.params["metadata"] == { + "media_hash": "a3f1e2d9c4", + "name": "Sunset #1", + "description": "A photograph of a sunset", + "ticker": "SUNST", + "creator": None, + "icon_uri": None, + "media_uri": None, + "additional_metadata_uri": None, + } + client.close() + + +def test_mint_tokens(rpc_server) -> None: + srv = rpc_server(result=_send_result("mint01")) + client = Client(srv.url) + got = client.mint_tokens( + MintParams( + account=0, + token_id="tok1abc", + address="tmltool1dest", + amount=Amount(decimal="1000000"), + ) + ) + assert got.tx_id == "mint01" + assert srv.capture.method == "token_mint" + assert srv.capture.params == { + "account": 0, + "token_id": "tok1abc", + "address": "tmltool1dest", + "amount": {"decimal": "1000000"}, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_unmint_tokens(rpc_server) -> None: + srv = rpc_server(result=_send_result("unmint01")) + client = Client(srv.url) + got = client.unmint_tokens( + UnmintParams(account=0, token_id="tok1abc", amount=Amount(decimal="5000")) + ) + assert got.tx_id == "unmint01" + assert srv.capture.method == "token_unmint" + assert srv.capture.params == { + "account": 0, + "token_id": "tok1abc", + "amount": {"decimal": "5000"}, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_lock_token_supply_uses_account_index_key(rpc_server) -> None: + srv = rpc_server(result=_send_result("lock01")) + client = Client(srv.url) + got = client.lock_token_supply(LockSupplyParams(account_index=0, token_id="tok1abc")) + assert got.tx_id == "lock01" + assert srv.capture.method == "token_lock_supply" + # The daemon route expects "account_index", never "account". + assert srv.capture.params == { + "account_index": 0, + "token_id": "tok1abc", + "options": _ZERO_OPTIONS, + } + assert "account" not in srv.capture.params + client.close() + + +def test_freeze_token(rpc_server) -> None: + srv = rpc_server(result=_send_result("freeze01")) + client = Client(srv.url) + got = client.freeze_token(FreezeParams(account=0, token_id="tok1abc", is_unfreezable=True)) + assert got.tx_id == "freeze01" + assert srv.capture.method == "token_freeze" + assert srv.capture.params == { + "account": 0, + "token_id": "tok1abc", + "is_unfreezable": True, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_unfreeze_token(rpc_server) -> None: + srv = rpc_server(result=_send_result("unfreeze01")) + client = Client(srv.url) + got = client.unfreeze_token(UnfreezeParams(account=0, token_id="tok1abc")) + assert got.tx_id == "unfreeze01" + assert srv.capture.method == "token_unfreeze" + assert srv.capture.params == { + "account": 0, + "token_id": "tok1abc", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_change_token_authority(rpc_server) -> None: + srv = rpc_server(result=_send_result("chauth01")) + client = Client(srv.url) + got = client.change_token_authority( + ChangeAuthorityParams(account=0, token_id="tok1abc", address="tmltool1newauth") + ) + assert got.tx_id == "chauth01" + assert srv.capture.method == "token_change_authority" + assert srv.capture.params == { + "account": 0, + "token_id": "tok1abc", + "address": "tmltool1newauth", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_send_token_alias_shares_token_send_method(rpc_server) -> None: + srv = rpc_server(result=_send_result("sendtok01")) + client = Client(srv.url) + got = client.send_token( + TokenSendParams( + account=0, + token_id="tok1abc", + address="tmltool1dest", + amount=Amount(decimal="100"), + ) + ) + assert got.tx_id == "sendtok01" + # Both spellings hit the same daemon route. + assert srv.capture.method == "token_send" + assert srv.capture.params["token_id"] == "tok1abc" + client.close() diff --git a/tests/test_wallet_transactions.py b/tests/test_wallet_transactions.py new file mode 100644 index 0000000..0dd37c4 --- /dev/null +++ b/tests/test_wallet_transactions.py @@ -0,0 +1,310 @@ +"""Transaction method tests for the wallet client. + +Mirrors the "Transactions" section of go-sdk/wallet/client_test.go, pinning +the exact RPC method names, the always-present TxOptions keys, and the +omitempty behaviour of ``selected_utxos``. +""" + +from __future__ import annotations + +import pytest + +from mintlayer.wallet import ( + Amount, + Client, + ComposeParams, + FeesBreakdown, + SendParams, + SendResult, + SignedTx, + SubmitResult, + SweepParams, + TokenSendParams, + UTXOSpendParams, + WalletTx, +) +from mintlayer.wallet.types import Outpoint, OutpointSourceID, Timestamp, TxStats + +_ZERO_OPTIONS = {"in_top_x_mb": None, "broadcast_to_mempool": None} + + +def test_outpoint_round_trip() -> None: + outpoint = Outpoint( + source_id=OutpointSourceID(type="Transaction", content={"tx_id": "beefcafe01"}), + index=3, + ) + assert Outpoint.from_json(outpoint.to_json()) == outpoint + + +def test_outpoint_source_id_block_reward_round_trip() -> None: + source = OutpointSourceID(type="BlockReward", content={"block_id": "aabb0102"}) + assert OutpointSourceID.from_json(source.to_json()) == source + + +def _send_result(tx_id: str = "cafebabe") -> dict: + return { + "tx_id": tx_id, + "fees": {"coins": {"atoms": "10000", "decimal": "0.0001"}, "tokens": {}}, + "broadcasted": True, + } + + +def test_address_send(rpc_server) -> None: + srv = rpc_server(result=_send_result()) + client = Client(srv.url) + got = client.address_send( + SendParams(account=0, address="tmltool1dest", amount=Amount(decimal="10.5")) + ) + assert got == SendResult( + tx_id="cafebabe", + fees=FeesBreakdown(coins=Amount(atoms="10000", decimal="0.0001"), tokens={}), + broadcasted=True, + ) + assert srv.capture.method == "address_send" + client.close() + + +@pytest.mark.parametrize("selected", [None, []], ids=["none", "empty_list"]) +def test_address_send_selected_utxos_key_absent(rpc_server, selected) -> None: + """None and [] both omit ``selected_utxos`` from the wire (omitempty).""" + srv = rpc_server(result=_send_result()) + client = Client(srv.url) + client.address_send( + SendParams( + account=0, + address="tmltool1dest", + amount=Amount(atoms="1000000000000"), + selected_utxos=selected, + ) + ) + assert srv.capture.method == "address_send" + assert srv.capture.params == { + "account": 0, + "address": "tmltool1dest", + "amount": {"atoms": "1000000000000"}, + "options": _ZERO_OPTIONS, + } + assert "selected_utxos" not in srv.capture.params + client.close() + + +def test_address_send_selected_utxos_outpoint_shape(rpc_server) -> None: + srv = rpc_server(result=_send_result()) + client = Client(srv.url) + tx_id = "beefcafe01" + client.address_send( + SendParams( + account=0, + address="tmltool1dest", + amount=Amount(atoms="1000000000000"), + selected_utxos=[ + Outpoint( + source_id=OutpointSourceID(type="Transaction", content={"tx_id": tx_id}), + index=0, + ) + ], + ) + ) + assert srv.capture.params["selected_utxos"] == [ + {"source_id": {"type": "Transaction", "content": {"tx_id": tx_id}}, "index": 0} + ] + client.close() + + +def test_token_send(rpc_server) -> None: + srv = rpc_server( + result={"tx_id": "aabbccdd", "fees": {"coins": {}, "tokens": {}}, "broadcasted": True} + ) + client = Client(srv.url) + got = client.token_send( + TokenSendParams( + account=0, + token_id="mytoken1abc", + address="tmltool1dest", + amount=Amount(decimal="100"), + ) + ) + assert got.tx_id == "aabbccdd" + assert got.broadcasted is True + assert srv.capture.method == "token_send" + assert srv.capture.params == { + "account": 0, + "token_id": "mytoken1abc", + "address": "tmltool1dest", + "amount": {"decimal": "100"}, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_sweep_spendable(rpc_server) -> None: + srv = rpc_server(result=_send_result("sweep01")) + client = Client(srv.url) + got = client.sweep_spendable( + SweepParams(account=0, destination_address="tmltool1dest", all=True) + ) + assert got.tx_id == "sweep01" + assert got.broadcasted is True + assert srv.capture.method == "address_sweep_spendable" + # from_addresses stays an explicit empty list on the wire. + assert srv.capture.params == { + "account": 0, + "destination_address": "tmltool1dest", + "from_addresses": [], + "all": True, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_spend_utxo(rpc_server) -> None: + srv = rpc_server(result=_send_result("utxo01")) + client = Client(srv.url) + got = client.spend_utxo( + UTXOSpendParams( + account=0, + utxo=Outpoint( + source_id=OutpointSourceID(type="Transaction", content={"tx_id": "beefcafe01"}), + index=1, + ), + output_address="tmltool1dest", + ) + ) + assert got.tx_id == "utxo01" + assert srv.capture.method == "utxo_spend" + assert srv.capture.params == { + "account": 0, + "utxo": { + "source_id": {"type": "Transaction", "content": {"tx_id": "beefcafe01"}}, + "index": 1, + }, + "output_address": "tmltool1dest", + "htlc_secret": None, + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_compose_transaction(rpc_server) -> None: + srv = rpc_server(result={"hex": "deadbeef", "fees": {"coins": {"atoms": "5000"}, "tokens": {}}}) + client = Client(srv.url) + got = client.compose_transaction( + ComposeParams(outputs=[{"output": "raw"}], only_transaction=True) + ) + assert got.hex == "deadbeef" + assert got.fees == FeesBreakdown(coins=Amount(atoms="5000"), tokens={}) + assert srv.capture.method == "transaction_compose" + assert srv.capture.params == { + "inputs": [], + "outputs": [{"output": "raw"}], + "htlc_secrets": None, + "only_transaction": True, + } + client.close() + + +def test_sign_raw_transaction(rpc_server) -> None: + srv = rpc_server(result={"hex": "signed01", "current_signatures": []}) + client = Client(srv.url) + got = client.sign_raw_transaction(0, "unsigned01") + assert got == SignedTx(hex="signed01", current_signatures=[]) + assert srv.capture.method == "account_sign_raw_transaction" + # The zero TxOptions shape is pinned on the wire. + assert srv.capture.params == { + "account": 0, + "raw_tx": "unsigned01", + "options": _ZERO_OPTIONS, + } + client.close() + + +def test_inspect_transaction_fees_null(rpc_server) -> None: + srv = rpc_server(result={"stats": {"num_inputs": 2, "total_signatures": 2}, "fees": None}) + client = Client(srv.url) + got = client.inspect_transaction("cafebabe") + assert got.stats == TxStats(num_inputs=2, total_signatures=2) + assert got.fees is None + assert srv.capture.method == "transaction_inspect" + assert srv.capture.params == {"transaction": "cafebabe"} + client.close() + + +def test_inspect_transaction_with_fees(rpc_server) -> None: + srv = rpc_server( + result={ + "stats": {"num_inputs": 2, "total_signatures": 2}, + "fees": {"coins": {"atoms": "10000", "decimal": "0.0001"}, "tokens": {}}, + } + ) + client = Client(srv.url) + got = client.inspect_transaction("cafebabe") + assert got.fees == FeesBreakdown(coins=Amount(atoms="10000", decimal="0.0001"), tokens={}) + client.close() + + +def test_submit_transaction(rpc_server) -> None: + srv = rpc_server(result={"tx_id": "submitted01"}) + client = Client(srv.url) + got = client.submit_transaction("cafebabe01020304") + assert got == SubmitResult(tx_id="submitted01") + assert srv.capture.method == "node_submit_transaction" + # Trust policy is hardcoded to "Trusted" by the daemon route. + assert srv.capture.params == { + "tx": "cafebabe01020304", + "do_not_store": False, + "options": {"trust_policy": "Trusted"}, + } + client.close() + + +def test_list_transactions_by_address(rpc_server) -> None: + result = [{"id": "tx1", "height": 100, "timestamp": {"timestamp": 1700000000}}] + srv = rpc_server(result=result) + client = Client(srv.url) + got = client.list_transactions_by_address(0, None, 20) + assert got == [WalletTx(id="tx1", height=100, timestamp=Timestamp(timestamp=1700000000))] + assert srv.capture.method == "transaction_list_by_address" + assert srv.capture.params == {"account": 0, "address": None, "limit": 20} + client.close() + + +def test_list_pending_transactions(rpc_server) -> None: + srv = rpc_server(result=["tx1", "tx2"]) + client = Client(srv.url) + assert client.list_pending_transactions(0) == ["tx1", "tx2"] + assert srv.capture.method == "transaction_list_pending" + assert srv.capture.params == {"account": 0} + client.close() + + +def test_get_transaction_raw_passthrough(rpc_server) -> None: + result = {"id": "tx1", "height": 100} + srv = rpc_server(result=result) + client = Client(srv.url) + assert client.get_transaction(0, "tx1") == result + assert srv.capture.method == "transaction_get" + assert srv.capture.params == {"account": 0, "transaction_id": "tx1"} + client.close() + + +def test_abandon_transaction(rpc_server) -> None: + srv = rpc_server(result=None) + client = Client(srv.url) + client.abandon_transaction(0, "tx1") + assert srv.capture.method == "transaction_abandon" + assert srv.capture.params == {"account": 0, "transaction_id": "tx1"} + client.close() + + +def test_deposit_data(rpc_server) -> None: + srv = rpc_server(result=_send_result("data01")) + client = Client(srv.url) + got = client.deposit_data(0, "68656c6c6f") + assert got.tx_id == "data01" + assert srv.capture.method == "address_deposit_data" + assert srv.capture.params == { + "account": 0, + "data": "68656c6c6f", + "options": _ZERO_OPTIONS, + } + client.close() diff --git a/tests/test_wallet_transport.py b/tests/test_wallet_transport.py new file mode 100644 index 0000000..6a684da --- /dev/null +++ b/tests/test_wallet_transport.py @@ -0,0 +1,102 @@ +"""Transport-level tests for the wallet client. + +Mirrors the "Transport" and "Error path" sections of +go-sdk/wallet/client_test.go: basic auth, JSON-RPC error objects, and +monotonically increasing request ids. +""" + +from __future__ import annotations + +import base64 +import json + +import pytest + +from mintlayer.wallet import BestBlock, Client, RPCError + +_BLOCK_RESULT = {"height": 100, "id": "aabbccdd"} + + +class TestClientConstruction: + def test_defaults(self) -> None: + client = Client("http://127.0.0.1:3034") + assert client._rpc.endpoint == "http://127.0.0.1:3034" + assert client._rpc.username == "" + assert client._rpc.password == "" + assert client._rpc.timeout == 30.0 + client.close() + + def test_timeout_parameter(self) -> None: + client = Client("http://127.0.0.1:3034", timeout=5.0) + assert client._rpc.timeout == 5.0 + client.close() + + +def test_basic_auth_header(rpc_server) -> None: + """The Authorization header is sent when a username is set.""" + srv = rpc_server(result=_BLOCK_RESULT) + client = Client(srv.url, username="alice", password="secret") + assert client.best_block() == BestBlock(height=100, id="aabbccdd") + expected = "Basic " + base64.b64encode(b"alice:secret").decode("ascii") + assert srv.capture.headers.get("authorization") == expected + client.close() + + +def test_no_auth_header_without_username(rpc_server) -> None: + """No Authorization header when the username is empty.""" + srv = rpc_server(result=_BLOCK_RESULT) + client = Client(srv.url) + client.best_block() + assert "authorization" not in srv.capture.headers + client.close() + + +def test_rpc_error(rpc_server) -> None: + """A JSON-RPC error object in the body raises RPCError.""" + srv = rpc_server(error=(-32601, "method not found")) + client = Client(srv.url) + with pytest.raises(RPCError) as excinfo: + client.best_block() + err = excinfo.value + assert err.code == -32601 + assert err.message == "method not found" + assert str(err) == "RPC error -32601: method not found" + client.close() + + +def test_request_wire_shape(rpc_server) -> None: + """Requests POST the full JSON-RPC 2.0 envelope straight to the endpoint.""" + srv = rpc_server(result=_BLOCK_RESULT) + client = Client(srv.url) + client.best_block() + assert srv.capture.method == "wallet_best_block" + assert srv.capture.params == {} + assert srv.capture.path == "/" + assert srv.capture.request_count == 1 + assert json.loads(srv.capture.raw_body) == { + "jsonrpc": "2.0", + "id": 1, + "method": "wallet_best_block", + "params": {}, + } + client.close() + + +def test_request_ids_monotonic(rpc_server) -> None: + srv = rpc_server(result=_BLOCK_RESULT) + client = Client(srv.url) + client.best_block() + client.best_block() + assert [payload["id"] for payload in srv.capture.payloads] == [1, 2] + client.close() + + +def test_context_manager_calls_close(rpc_server, monkeypatch) -> None: + srv = rpc_server(result=_BLOCK_RESULT) + client = Client(srv.url) + closed: list[bool] = [] + monkeypatch.setattr(client, "close", lambda: closed.append(True)) + with client as entered: + assert entered is client + entered.best_block() + assert closed == [True] From 9b3b9ad41b46595fe8291ecd0b9c432dac3af360 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 03:32:01 +0400 Subject: [PATCH 05/31] Add top-level client and examples Top-level mintlayer.Client(Config) constructs only the sub-clients whose URL is set, with lazy WASM init (init_wasm) and convenience re-exports mirroring the Go SDK root package (Amount, Network, sighash/source constants). Examples ported from go-sdk/examples: send_coins.py (full manual transaction flow: key derivation, UTXO fetch, tx build, witness signing, submit) and issue_token.py (wallet-daemon token issuance + mint). 15 new top-level client tests (232 total passing). ruff + mypy clean. --- examples/issue_token.py | 164 +++++++++++++++++++++++++++++++++++++ examples/send_coins.py | 173 ++++++++++++++++++++++++++++++++++++++++ mintlayer/__init__.py | 86 +++++++++++++++++++- mintlayer/client.py | 153 +++++++++++++++++++++++++++++++++++ tests/test_client.py | 130 ++++++++++++++++++++++++++++++ 5 files changed, 704 insertions(+), 2 deletions(-) create mode 100644 examples/issue_token.py create mode 100644 examples/send_coins.py create mode 100644 mintlayer/client.py create mode 100644 tests/test_client.py diff --git a/examples/issue_token.py b/examples/issue_token.py new file mode 100644 index 0000000..134b5bb --- /dev/null +++ b/examples/issue_token.py @@ -0,0 +1,164 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026 Mintlayer Institutional FZCO +# Contact: hello@mintlayer.org +# +# Use of this source code is governed by an MIT license +# that can be found in the LICENSE file. + +"""issue-token: issue a new fungible token and mint initial supply via the +Mintlayer wallet daemon. + +The flow: + +1. Open the wallet (or connect to an already-open one). +2. Sync the wallet with the chain. +3. Derive a new receiving address to be the token authority. +4. Issue the token — the wallet signs, pays fees, and broadcasts the tx. +5. Mint an initial supply to the same address. + +Usage: + + uv run python examples/issue_token.py \ + --wallet /path/to/wallet.dat \ + --ticker MYTOKEN \ + --decimals 2 \ + --supply 1000000 \ + --uri "https://example.com/token-metadata.json" \ + --wallet-rpc http://127.0.0.1:3034 + +Requirements: +- wallet-rpc-daemon must be running (or pass --wallet to open one). +- The wallet account must hold enough ML to pay issuance fees. +""" + +from __future__ import annotations + +import argparse +import logging +import sys + +from mintlayer.wallet import ( + Amount, + IssueTokenParams, + MintParams, + TokenMetadata, + TokenSupply, +) +from mintlayer.wallet import ( + Client as WalletClient, +) + +log = logging.getLogger("issue-token") + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--wallet", default="", help="path to wallet file (skip if already open)") + parser.add_argument("--password", default="", help="wallet password (empty for unencrypted)") + parser.add_argument("--ticker", required=True, help="token ticker symbol, e.g. MYTOKEN") + parser.add_argument("--decimals", type=int, default=2, help="number of decimal places (0-18)") + parser.add_argument("--supply", default="1000000", help="initial mint supply in smallest unit") + parser.add_argument("--uri", default="", help="URL pointing to token metadata JSON") + parser.add_argument("--wallet-rpc", default="http://127.0.0.1:3034", help="wallet RPC endpoint") + parser.add_argument("--account", type=int, default=0, help="wallet account index") + args = parser.parse_args() + + logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") + + # ── 1. Connect to the wallet daemon ────────────────────────────────────── + wallet = WalletClient(args.wallet_rpc) + + # Open the wallet if a path was provided. Skip if the daemon already has + # a wallet open (e.g. from a previous session). + if args.wallet: + try: + wallet.open_wallet(args.wallet, args.password) + except Exception as exc: + log.fatal("open wallet: %s", exc) + sys.exit(1) + log.info("wallet opened: %s", args.wallet) + + # ── 2. Sync the wallet ─────────────────────────────────────────────────── + try: + wallet.sync_wallet() + except Exception as exc: + # Non-fatal: the daemon may already be syncing. + log.info("sync wallet: %s (continuing)", exc) + + # ── 3. Derive a fresh address to act as the token authority ────────────── + # + # The authority address is the address whose private key can later mint, + # burn, freeze, or transfer the authority of the token. + try: + authority_addr = wallet.new_address(args.account) + except Exception as exc: + log.fatal("new address: %s", exc) + sys.exit(1) + log.info("authority address: %s", authority_addr) + + # Show the current balance so the user can confirm there are enough funds. + try: + balance = wallet.get_balance(args.account) + log.info("account balance: %s atoms (%s ML)", balance.coins.atoms, balance.coins.decimal) + except Exception as exc: + log.info("get balance: %s (continuing)", exc) + + # ── 4. Issue the token ─────────────────────────────────────────────────── + # + # Token supply type "Lockable" means the supply is unlimited until you + # explicitly call lock_token_supply. Use "Fixed" (with a cap) or + # "Unlimited" to change the supply policy. + try: + issue_result = wallet.issue_token( + IssueTokenParams( + account=args.account, + destination_address=authority_addr, + metadata=TokenMetadata( + token_ticker=args.ticker, + number_of_decimals=args.decimals, + metadata_uri=args.uri, + token_supply=TokenSupply(type="Lockable"), + is_freezable=False, + ), + ) + ) + except Exception as exc: + log.fatal("issue token: %s", exc) + sys.exit(1) + + print("token issued") + print(f" token id: {issue_result.token_id}") + print(f" tx id: {issue_result.tx_id}") + + # ── 5. Mint initial supply ─────────────────────────────────────────────── + # + # MintTokens creates new tokens and sends them to the given address. + # The wallet must control the authority key. + # + # Note: wait for the issuance transaction to confirm before minting. + # In production, poll indexer.get_transaction until confirmations != "". + try: + mint_result = wallet.mint_tokens( + MintParams( + account=args.account, + token_id=issue_result.token_id, + address=authority_addr, + amount=Amount(atoms=args.supply), + ) + ) + except Exception as exc: + log.fatal( + "mint tokens: %s\n\n" + "Tip: the issuance tx may not have confirmed yet.\n" + "Wait for confirmation and re-run with the token id.", + exc, + ) + sys.exit(1) + + print("tokens minted") + print(f" tx id: {mint_result.tx_id}") + print(f" fees: {mint_result.fees.coins.atoms} atoms") + + +if __name__ == "__main__": + main() diff --git a/examples/send_coins.py b/examples/send_coins.py new file mode 100644 index 0000000..09f61d2 --- /dev/null +++ b/examples/send_coins.py @@ -0,0 +1,173 @@ +#!/usr/bin/env python3 +# Copyright (c) 2026 Mintlayer Institutional FZCO +# Contact: hello@mintlayer.org +# +# Use of this source code is governed by an MIT license +# that can be found in the LICENSE file. + +"""send-coins: the full manual transaction flow using the Mintlayer Python SDK. + +1. Derive an account key and receiving address from a BIP-39 mnemonic. +2. Fetch spendable UTXOs for that address from the indexer. +3. Build an unsigned transaction (encode inputs and outputs). +4. Sign each input with encode_witness. +5. Submit the signed transaction to the indexer. + +Usage: + + uv run python examples/send_coins.py \ + --mnemonic "word1 word2 ... word12" \ + --to mtc1qrecipient... \ + --amount 100000000000 \ + --indexer http://127.0.0.1:3000 + +NOTE: This example sends ALL spendable UTXOs to the recipient with no change +output. It is intentionally minimal. Production code should select UTXOs, +compute fees, add a change output, and handle errors more robustly. +""" + +from __future__ import annotations + +import argparse +import logging +import sys + +from mintlayer.indexer import Client as IndexerClient +from mintlayer.wasm import ( + SOURCE_TRANSACTION, + Amount, + Network, + SignatureHashType, + TxAdditionalInfo, +) +from mintlayer.wasm import ( + Client as WasmClient, +) + +log = logging.getLogger("send-coins") + + +def total_atoms(utxos: list) -> int: + """Sum the coin atoms across all Transfer/Coin UTXOs.""" + total = 0 + for u in utxos: + try: + if u.output.get("type") == "Transfer": + value = u.output.get("value") or {} + if value.get("type") == "Coin": + total += int(value["amount"]["atoms"]) + except (AttributeError, KeyError, TypeError, ValueError): + continue + return total + + +def encode_utxo_entry(wasm: WasmClient, utxo_json: dict, network: Network) -> bytes: + """Re-encode a JSON UTXO output into the binary form encode_witness expects. + + Format: 0x01 + when the output can be re-encoded, + 0x00 otherwise (signing still succeeds for many output types). + """ + try: + if utxo_json.get("type") == "Transfer": + value = utxo_json["value"] + if value.get("type") == "Coin": + encoded = wasm.encode_output_transfer( + Amount(atoms=value["amount"]["atoms"]), + value["destination"], + network, + ) + return b"\x01" + encoded + except (KeyError, TypeError, ValueError): + pass + return b"\x00" + + +def main() -> None: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--mnemonic", required=True, help="BIP-39 mnemonic (12 or 24 words)") + parser.add_argument("--to", required=True, help="recipient bech32m address") + parser.add_argument("--amount", required=True, help="amount to send in atoms (1 ML = 1e11)") + parser.add_argument("--indexer", default="http://127.0.0.1:3000", help="indexer base URL") + parser.add_argument("--key-index", type=int, default=0, help="receiving address key index") + parser.add_argument( + "--network", type=int, default=0, help="0=mainnet 1=testnet 2=regtest 3=signet" + ) + args = parser.parse_args() + + logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") + network = Network(args.network) + + # ── 1. Initialise the WASM cryptography runtime ────────────────────────── + wasm = WasmClient() + + # ── 2. Derive the spending key and address ─────────────────────────────── + account_key = wasm.make_default_account_privkey(args.mnemonic, network) + spend_key = wasm.make_receiving_address(account_key, args.key_index) + pub_key = wasm.public_key_from_private_key(spend_key) + from_addr = wasm.pubkey_to_pubkeyhash_address(pub_key, network) + log.info("spending from: %s", from_addr) + + # ── 3. Fetch spendable UTXOs ───────────────────────────────────────────── + indexer = IndexerClient(args.indexer) + utxos = indexer.get_spendable_utxos(from_addr) + + if not utxos: + log.fatal("no spendable UTXOs for %s", from_addr) + sys.exit(1) + log.info("found %d spendable UTXO(s)", len(utxos)) + + total = total_atoms(utxos) + send_amt = int(args.amount.strip()) + if total < send_amt: + log.fatal("insufficient balance: have %d atoms, need %d atoms", total, send_amt) + sys.exit(1) + + # ── 4. Encode inputs and collect per-input UTXO bytes ──────────────────── + encoded_inputs = b"" + all_utxo_bytes = b"" + for u in utxos: + tx_id_bytes = bytes.fromhex(u.outpoint.source_id) + src_id = wasm.encode_outpoint_source_id(tx_id_bytes, SOURCE_TRANSACTION) + inp = wasm.encode_input_for_utxo(src_id, u.outpoint.index) + encoded_inputs += inp + all_utxo_bytes += encode_utxo_entry(wasm, u.output, network) + + # ── 5. Encode the transfer output ──────────────────────────────────────── + output = wasm.encode_output_transfer(Amount(atoms=args.amount), args.to, network) + + # ── 6. Build the unsigned transaction ──────────────────────────────────── + tx = wasm.encode_transaction(encoded_inputs, output, 0) + tx_id = wasm.get_transaction_id(tx, True) + log.info("unsigned tx id: %s", tx_id) + + # ── 7. Sign each input and collect witnesses ───────────────────────────── + witness_bytes = b"" + for i in range(len(utxos)): + witness = wasm.encode_witness( + SignatureHashType.SIGHASH_ALL, + spend_key, + from_addr, + tx, + all_utxo_bytes, + i, + TxAdditionalInfo(), + 0, # block height (0 = no lock-time constraint) + network, + ) + witness_bytes += witness + + # ── 8. Assemble the signed transaction ─────────────────────────────────── + signed_tx = wasm.encode_signed_transaction(tx, witness_bytes) + log.info("signed tx (%d bytes)", len(signed_tx)) + + # ── 9. Submit ──────────────────────────────────────────────────────────── + submitted_tx_id = indexer.submit_transaction(signed_tx.hex()) + print(f"submitted: {submitted_tx_id}") + + # Informational: in production, call wasm.estimate_transaction_size and + # multiply by the fee rate from node.get_fee_rate or indexer.get_fee_rate + # to compute the exact fee before building outputs. + + +if __name__ == "__main__": + main() diff --git a/mintlayer/__init__.py b/mintlayer/__init__.py index d02cbcc..c85b095 100644 --- a/mintlayer/__init__.py +++ b/mintlayer/__init__.py @@ -1,7 +1,89 @@ -"""Mintlayer Python SDK: node, indexer, and wallet clients plus WASM cryptography.""" +"""Mintlayer Python SDK. + +A Python SDK for the Mintlayer blockchain, ported from the +`Mintlayer Go SDK `_. + + import mintlayer + + client = mintlayer.Client(mintlayer.Config( + node_url="http://127.0.0.1:3030", + indexer_url="http://127.0.0.1:3000", + wallet_url="http://127.0.0.1:3034", + )) + + tip = client.indexer.get_tip() + client.init_wasm() + priv = client.wasm.make_private_key() + +The four sub-clients are also importable directly: +``mintlayer.node``, ``mintlayer.indexer``, ``mintlayer.wallet`` and +``mintlayer.wasm``. +""" from __future__ import annotations +from . import indexer, node, wallet, wasm +from .client import Client, Config +from .wasm import ( + MAINNET, + REGTEST, + SIGHASH_ALL, + SIGHASH_ANYONECANPAY, + SIGHASH_NONE, + SIGHASH_SINGLE, + SIGNET, + SOURCE_BLOCK_REWARD, + SOURCE_TRANSACTION, + TESTNET, + Amount, + CurrencyAmountKind, + FreezableToken, + Network, + OrderBalance, + OrderInfo, + PoolInfo, + SignatureHashType, + SimpleCurrencyAmount, + SourceId, + TokenUnfreezable, + TotalSupply, + TxAdditionalInfo, + WasmError, +) + __version__ = "0.1.0" -__all__ = ["__version__"] +__all__ = [ + "__version__", + "Client", + "Config", + "node", + "indexer", + "wallet", + "wasm", + # convenience re-exports (mirrors the Go SDK root package) + "Amount", + "Network", + "MAINNET", + "TESTNET", + "REGTEST", + "SIGNET", + "SignatureHashType", + "SIGHASH_ALL", + "SIGHASH_NONE", + "SIGHASH_SINGLE", + "SIGHASH_ANYONECANPAY", + "SourceId", + "SOURCE_TRANSACTION", + "SOURCE_BLOCK_REWARD", + "TotalSupply", + "FreezableToken", + "TokenUnfreezable", + "CurrencyAmountKind", + "SimpleCurrencyAmount", + "OrderBalance", + "PoolInfo", + "OrderInfo", + "TxAdditionalInfo", + "WasmError", +] diff --git a/mintlayer/client.py b/mintlayer/client.py new file mode 100644 index 0000000..94ae563 --- /dev/null +++ b/mintlayer/client.py @@ -0,0 +1,153 @@ +"""Top-level Mintlayer SDK client (mirrors go-sdk/client.go). + +Constructs only the sub-clients whose URL is configured, wires the WASM +cryptography runtime lazily via :meth:`Client.init_wasm`, and re-exports the +common types so callers importing just ``mintlayer`` get the full surface. +""" + +from __future__ import annotations + +import threading +from dataclasses import dataclass + +from .indexer import Client as IndexerClient +from .node import Client as NodeClient +from .wallet import Client as WalletClient +from .wasm import ( + MAINNET, + REGTEST, + SIGHASH_ALL, + SIGHASH_ANYONECANPAY, + SIGHASH_NONE, + SIGHASH_SINGLE, + SIGNET, + SOURCE_BLOCK_REWARD, + SOURCE_TRANSACTION, + TESTNET, + Amount, + CurrencyAmountKind, + FreezableToken, + Network, + OrderBalance, + OrderInfo, + PoolInfo, + SignatureHashType, + SimpleCurrencyAmount, + SourceId, + TokenUnfreezable, + TotalSupply, + TxAdditionalInfo, + WasmError, +) +from .wasm import ( + Client as WASMClient, +) + +__all__ = [ + "Config", + "Client", + # re-exports (mirrors the Go SDK's convenience aliases) + "Amount", + "Network", + "MAINNET", + "TESTNET", + "REGTEST", + "SIGNET", + "SignatureHashType", + "SIGHASH_ALL", + "SIGHASH_NONE", + "SIGHASH_SINGLE", + "SIGHASH_ANYONECANPAY", + "SourceId", + "SOURCE_TRANSACTION", + "SOURCE_BLOCK_REWARD", + "TotalSupply", + "FreezableToken", + "TokenUnfreezable", + "CurrencyAmountKind", + "SimpleCurrencyAmount", + "OrderBalance", + "PoolInfo", + "OrderInfo", + "TxAdditionalInfo", + "WasmError", +] + + +@dataclass(frozen=True) +class Config: + """Top-level SDK configuration. + + Only sub-clients whose URL field is non-empty are constructed. + """ + + node_url: str = "" + indexer_url: str = "" + wallet_url: str = "" + username: str = "" + password: str = "" + timeout: float = 30.0 + + +class Client: + """The top-level Mintlayer SDK client. + + ``node``, ``indexer`` and ``wallet`` are ``None`` when their URL was not + set in the :class:`Config`; ``wasm`` is ``None`` until + :meth:`init_wasm` is called (~400 ms one-time cost). + """ + + def __init__(self, cfg: Config) -> None: + self._mu = threading.Lock() + self._wasm: WASMClient | None = None + + self.node: NodeClient | None = None + if cfg.node_url: + self.node = NodeClient( + cfg.node_url, + username=cfg.username, + password=cfg.password, + timeout=cfg.timeout, + ) + + self.indexer: IndexerClient | None = None + if cfg.indexer_url: + self.indexer = IndexerClient(cfg.indexer_url, timeout=cfg.timeout) + + self.wallet: WalletClient | None = None + if cfg.wallet_url: + self.wallet = WalletClient( + cfg.wallet_url, + username=cfg.username, + password=cfg.password, + timeout=cfg.timeout, + ) + + def init_wasm(self) -> None: + """Initialise the embedded WASM cryptography runtime (~400 ms). + + Subsequent calls are no-ops. Safe for concurrent use. + """ + with self._mu: + if self._wasm is None: + self._wasm = WASMClient() + + @property + def wasm(self) -> WASMClient: + """The WASM cryptography client; :meth:`init_wasm` must be called first.""" + if self._wasm is None: + raise WasmError("mintlayer: init_wasm() must be called before using client.wasm") + return self._wasm + + def close(self) -> None: + """Release WASM resources; HTTP sub-clients need no teardown.""" + with self._mu: + if self._wasm is not None: + self._wasm.close() + self._wasm = None + + def __enter__(self) -> Client: + return self + + def __exit__(self, *_exc: object) -> None: + self.close() diff --git a/tests/test_client.py b/tests/test_client.py new file mode 100644 index 0000000..edd727f --- /dev/null +++ b/tests/test_client.py @@ -0,0 +1,130 @@ +"""Tests for the top-level SDK client (mintlayer.client). + +Mirrors the construction/config sections of go-sdk/client.go usage: which +sub-clients get built from a Config, basic-auth wiring, the lazy WASM +runtime, and the package-level convenience re-exports. +""" + +from __future__ import annotations + +import base64 +import importlib + +import pytest + +import mintlayer +from mintlayer.client import Client, Config +from mintlayer.indexer import Client as IndexerClient +from mintlayer.node import Client as NodeClient +from mintlayer.wallet import BestBlock +from mintlayer.wallet import Client as WalletClient +from mintlayer.wasm import Client as WasmClient +from mintlayer.wasm import WasmError + +_BLOCK_RESULT = {"height": 100, "id": "aabbccdd"} + + +class TestConfigConstruction: + def test_node_only_config(self) -> None: + client = Client(Config(node_url="http://127.0.0.1:3030")) + assert client.node is not None + assert client.indexer is None + assert client.wallet is None + client.close() + + def test_full_config_constructs_sub_clients(self) -> None: + cfg = Config( + node_url="http://127.0.0.1:3030", + indexer_url="http://127.0.0.1:3000", + wallet_url="http://127.0.0.1:3034", + username="alice", + password="secret", + timeout=5.0, + ) + client = Client(cfg) + assert isinstance(client.node, NodeClient) + assert isinstance(client.indexer, IndexerClient) + assert isinstance(client.wallet, WalletClient) + # Basic-auth credentials flow into the JSON-RPC sub-clients. + assert client.node._rpc.endpoint == "http://127.0.0.1:3030" + assert client.node._rpc.username == "alice" + assert client.node._rpc.password == "secret" + assert client.node._rpc.timeout == 5.0 + assert client.wallet._rpc.endpoint == "http://127.0.0.1:3034" + assert client.wallet._rpc.username == "alice" + assert client.wallet._rpc.password == "secret" + # The indexer is plain REST (IndexerHTTP base): /api/v2 prefix + timeout. + assert client.indexer.api_base == "http://127.0.0.1:3000/api/v2" + assert client.indexer.timeout == 5.0 + client.close() + + def test_empty_config_constructs_nothing(self) -> None: + client = Client(Config()) + assert client.node is None + assert client.indexer is None + assert client.wallet is None + client.close() + + +def test_basic_auth_reaches_the_wire(rpc_server) -> None: + """A wallet call through the top-level client sends the Basic auth header.""" + srv = rpc_server(result=_BLOCK_RESULT) + client = Client( + Config(node_url=srv.url, wallet_url=srv.url, username="alice", password="secret") + ) + assert client.wallet.best_block() == BestBlock(height=100, id="aabbccdd") + expected = "Basic " + base64.b64encode(b"alice:secret").decode("ascii") + assert srv.capture.headers.get("authorization") == expected + client.close() + + +class TestWasmLifecycle: + def test_wasm_raises_before_init(self) -> None: + client = Client(Config(node_url="http://127.0.0.1:3030")) + with pytest.raises(WasmError, match="init_wasm"): + _ = client.wasm + client.close() + + def test_init_wasm_creates_client_and_close_releases_it(self) -> None: + """init_wasm() builds a real WasmClient; close() resets the property.""" + client = Client(Config(node_url="http://127.0.0.1:3030")) + client.init_wasm() + wasm = client.wasm + assert isinstance(wasm, WasmClient) + # Subsequent init_wasm calls are no-ops (same instance). + client.init_wasm() + assert client.wasm is wasm + client.close() + assert client._wasm is None + with pytest.raises(WasmError, match="init_wasm"): + _ = client.wasm + + +class TestContextManager: + def test_with_block_and_idempotent_close(self) -> None: + with mintlayer.Client(mintlayer.Config(node_url="http://127.0.0.1:3030")) as c: + assert isinstance(c, Client) + assert c.node is not None + # close() is idempotent -- no WASM runtime, nothing to release. + c.close() + c.close() + + +class TestPackageReExports: + def test_amount_reexport(self) -> None: + assert mintlayer.Amount.from_atoms("5").atoms == "5" + + def test_network_constants(self) -> None: + assert mintlayer.MAINNET == mintlayer.Network.MAINNET + assert mintlayer.TESTNET == mintlayer.Network.TESTNET + + def test_sighash_and_source_reexports(self) -> None: + assert mintlayer.SIGHASH_ALL == mintlayer.wasm.SignatureHashType.SIGHASH_ALL + assert mintlayer.SOURCE_TRANSACTION == mintlayer.wasm.SourceId.SOURCE_TRANSACTION + + def test_wasm_error_reexport(self) -> None: + assert mintlayer.WasmError is WasmError + + @pytest.mark.parametrize("module_name", ["node", "indexer", "wallet", "wasm"]) + def test_submodules_importable(self, module_name: str) -> None: + assert importlib.import_module(f"mintlayer.{module_name}") is not None From 6f665fbeedefe3529a8dff0ad99de6d0bc945bfa Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 04:10:31 +0400 Subject: [PATCH 06/31] Add documentation and security polish Port all 7 Go SDK guides to Python (node, indexer, wallet, wasm, transactions, staking, tokens) with verified-signature method references, wire-shape quirks and security guidance; full README with working quick-start and module references. Wallet params dataclasses redact mnemonic/passphrase in repr (6 regression tests). Misc: transport-security note in node docs, argv secrets warning in examples, dead code removal. 238 tests passing; ruff + mypy clean. --- README.md | 341 +++++++++++- docs/indexer.md | 569 +++++++++++++++++++ docs/node.md | 545 ++++++++++++++++++ docs/staking.md | 307 +++++++++++ docs/tokens.md | 359 ++++++++++++ docs/transactions.md | 276 ++++++++++ docs/wallet.md | 619 +++++++++++++++++++++ docs/wasm.md | 981 +++++++++++++++++++++++++++++++++ examples/send_coins.py | 3 + mintlayer/node/chainstate.py | 5 +- mintlayer/node/mempool.py | 5 - mintlayer/node/p2p.py | 4 - mintlayer/wallet/types.py | 21 + tests/test_wallet_redaction.py | 105 ++++ 14 files changed, 4116 insertions(+), 24 deletions(-) create mode 100644 docs/indexer.md create mode 100644 docs/node.md create mode 100644 docs/staking.md create mode 100644 docs/tokens.md create mode 100644 docs/transactions.md create mode 100644 docs/wallet.md create mode 100644 docs/wasm.md create mode 100644 tests/test_wallet_redaction.py diff --git a/README.md b/README.md index 7d37a53..2c04df9 100644 --- a/README.md +++ b/README.md @@ -1,31 +1,35 @@ # Mintlayer Python SDK -A Python SDK for the [Mintlayer](https://www.mintlayer.org/) blockchain. +A Python SDK for the [Mintlayer](https://www.mintlayer.org/) blockchain, +ported from the [Mintlayer Go SDK](https://github.com/mintlayer/go-sdk). ``` pip install mintlayer ``` -Requires Python 3.10+. The WASM cryptography runtime is bundled with the package. +Requires Python 3.10+. The WASM cryptography runtime (wasmtime) is bundled +with the package. -> Work in progress — ported from the [Mintlayer Go SDK](https://github.com/mintlayer/go-sdk). +--- ## Documentation | Guide | Description | |-------|-------------| -| [docs/indexer.md](docs/indexer.md) | Full indexer client reference | -| [docs/node.md](docs/node.md) | Full node client reference | -| [docs/wallet.md](docs/wallet.md) | Full wallet client reference | -| [docs/wasm.md](docs/wasm.md) | Full WASM client reference | -| [docs/transactions.md](docs/transactions.md) | Building and signing transactions without the wallet daemon | -| [docs/staking.md](docs/staking.md) | Staking pools and delegations | -| [docs/tokens.md](docs/tokens.md) | Fungible token and NFT lifecycle | +| [docs/indexer.md](docs/indexer.md) | Full indexer client reference: chain, blocks, transactions, addresses, pools, tokens, orders, statistics | +| [docs/node.md](docs/node.md) | Full node client reference: chainstate, mempool, P2P, block submission | +| [docs/wallet.md](docs/wallet.md) | Full wallet client reference: lifecycle, accounts, balances, transactions | +| [docs/wasm.md](docs/wasm.md) | Full WASM client reference: keys, addresses, inputs, outputs, signing, fees | +| [docs/transactions.md](docs/transactions.md) | Step-by-step guide to building and signing transactions without the wallet daemon | +| [docs/staking.md](docs/staking.md) | Staking pools and delegations: creation, funding, withdrawal, and read queries | +| [docs/tokens.md](docs/tokens.md) | Fungible token and NFT lifecycle: issuance, minting, freezing, authority, manual encoding | + +--- ## Overview The SDK is organised as four independent sub-clients plus a top-level `Client` -that wires them together: +that wires them together. | Module | Purpose | Default port | |---|---|---| @@ -34,6 +38,11 @@ that wires them together: | `mintlayer.wallet` | JSON-RPC 2.0 client for the wallet daemon | 3034 (mainnet) | | `mintlayer.wasm` | Cryptography & transaction-building via WASM | — | +Use the top-level client when you need multiple sub-clients, or import +sub-modules directly when you only need one. + +--- + ## Quick start ```python @@ -45,13 +54,323 @@ client = mintlayer.Client(mintlayer.Config( wallet_url="http://127.0.0.1:3034", )) +# Query the chain tip from the indexer. tip = client.indexer.get_tip() print(f"chain tip: height={tip.block_height} id={tip.block_id}") +# Optionally initialise the embedded WASM cryptography runtime (~400 ms). +# The first access triggers lazy construction; init_wasm() makes the cost +# explicit and is a no-op afterwards. client.init_wasm() + priv_key = client.wasm.make_private_key() +pub_key = client.wasm.public_key_from_private_key(priv_key) +addr = client.wasm.pubkey_to_pubkeyhash_address(pub_key, mintlayer.MAINNET) +print("address:", addr) + +client.close() # or use `with mintlayer.Client(cfg) as client:` +``` + +`Config` only constructs the sub-clients whose URL field is non-empty +(`node_url`, `indexer_url`, `wallet_url`, plus shared `username`, `password`, +`timeout`). + +--- + +## Node client (`mintlayer.node`) + +JSON-RPC 2.0 client for the Mintlayer node daemon. Supports Basic Auth for +nodes with authentication enabled. + +```python +from mintlayer.node import Client + +c = Client( + "http://127.0.0.1:3030", + username="user", # optional + password="pass", # optional + timeout=10.0, # optional, seconds +) + +# Chain state +info = c.chainstate_info() +height = c.best_block_height() +block_id = c.best_block_id() + +# Look up a block +block_hex = c.get_block(block_id) +block_json = c.get_block_json(block_id) + +# Token / order info +token_info = c.token_info("ttml1...") +order_info = c.order_info("mordr1...") + +# Mempool +c.mempool_submit_transaction(signed_tx_hex, "Untrusted") +fee_rate = c.get_fee_rate(1) + +# P2P +peer_count = c.get_peer_count() +peers = c.get_connected_peers() +``` + +Errors from the daemon are raised as `RPCError` with a numeric `code` and +`message`. + +--- + +## Indexer client (`mintlayer.indexer`) + +REST client for `api-web-server`. All paths are relative to `/api/v2`. + +```python +from mintlayer.indexer import Client, PageOpts, PoolListOpts + +c = Client("http://127.0.0.1:3000", timeout=15.0) + +# Chain +tip = c.get_tip() +block_id_at_height = c.get_block_id_at_height(100_000) + +# Block +block = c.get_block("00000000...") +tx_ids = c.get_block_transaction_ids("00000000...") + +# Transaction +tx = c.get_transaction("aabbcc...") +tx_id = c.submit_transaction(signed_tx_hex) # requires --enable-post-routes + +# Address +utxos = c.get_spendable_utxos("mtc1q...") +info = c.get_address_info("mtc1q...") + +# Pool / staking +pools = c.list_pools(PoolListOpts(sort="by_pledge")) +pool = c.get_pool("mpool1...") + +# Tokens +token = c.get_token("ttml1...") +tokens = c.find_tokens_by_ticker("MYTOKEN", PageOpts(items=10)) + +# Orders +orders = c.list_orders(PageOpts(offset=0, items=20)) +order = c.get_order("mordr1...") + +# Statistics +stats = c.get_coin_statistics() +``` + +Non-2xx responses are raised as `HTTPError` with a `status_code` and `body`. + +--- + +## Wallet client (`mintlayer.wallet`) + +JSON-RPC 2.0 client for `wallet-rpc-daemon`. The wallet daemon manages key +storage, signing, and broadcasting. + +```python +from mintlayer.wallet import ( + Amount, + ComposeParams, + Client, + IssueTokenParams, + MintParams, + SendParams, + TokenMetadata, + TokenSupply, +) + +c = Client("http://127.0.0.1:3034", username="user", password="pass") + +# Wallet lifecycle +c.open_wallet("/path/to/wallet.dat", password="") +c.sync_wallet() + +# Accounts and addresses +info = c.get_wallet_info() +addr = c.new_address(0) # account 0 +balance = c.get_balance(0) + +# Send coins (account 0, auto fee) +result = c.address_send(SendParams( + account=0, + address="mtc1q...", + amount=Amount(atoms="100000000000"), # 1 ML +)) +print("tx id:", result.tx_id) + +# Token operations +issue_result = c.issue_token(IssueTokenParams( + account=0, + destination_address=addr, + metadata=TokenMetadata( + token_ticker="MYTOKEN", + number_of_decimals=2, + metadata_uri="https://example.com/token", + token_supply=TokenSupply(type="Lockable"), + is_freezable=False, + ), +)) +mint_result = c.mint_tokens(MintParams( + account=0, + token_id=issue_result.token_id, + address=addr, + amount=Amount(atoms="1000"), +)) + +# Staking +c.start_staking(0) +pools = c.list_owned_pools(0) + +# Compose and sign a raw transaction (cold wallet flow) +composed = c.compose_transaction(ComposeParams(...)) +signed = c.sign_raw_transaction(0, composed.hex) +submit_result = c.submit_transaction(signed.hex) + +c.close_wallet() ``` +--- + +## WASM client (`mintlayer.wasm`) + +Cryptographic primitives and binary transaction encoding via an embedded +WebAssembly module. Instantiation takes ~400 ms; create the client once per +process. + +```python +from mintlayer.wasm import ( + Amount, + SOURCE_TRANSACTION, + SIGHASH_ALL, + Network, + TxAdditionalInfo, +) +from mintlayer.wasm import Client as WasmClient + +c = WasmClient() + +# Key derivation (BIP-44 path 44'/mintlayer_coin_type'/0') +mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" +account_key = c.make_default_account_privkey(mnemonic, Network.MAINNET) +recv_key = c.make_receiving_address(account_key, 0) +pub_key = c.public_key_from_private_key(recv_key) +addr = c.pubkey_to_pubkeyhash_address(pub_key, Network.MAINNET) + +# Transaction building +src_id = c.encode_outpoint_source_id(tx_id_bytes, SOURCE_TRANSACTION) +input_ = c.encode_input_for_utxo(src_id, output_index) + +output = c.encode_output_transfer( + Amount(atoms="100000000000"), # 1 ML + dest_addr, + Network.MAINNET, +) + +tx = c.encode_transaction(input_, output, 0) # flags = 0 +tx_id = c.get_transaction_id(tx, True) + +# Signing +witness = c.encode_witness( + SIGHASH_ALL, + recv_key, + addr, + tx, + utxo_bytes, # see docs/transactions.md for the encoding details + 0, # input index + TxAdditionalInfo(), + block_height, + Network.MAINNET, +) +signed_tx = c.encode_signed_transaction(tx, witness) + +c.close() +``` + +See [examples/send_coins.py](examples/send_coins.py) for a complete end-to-end +transaction flow, and [docs/transactions.md](docs/transactions.md) for the full +walkthrough. + +--- + +## Top-level client + +`mintlayer.Client` constructs only the sub-clients whose URL is non-empty. + +```python +# Node + WASM only — no wallet or indexer client is created. +client = mintlayer.Client(mintlayer.Config( + node_url="http://127.0.0.1:3030", + username="user", + password="pass", +)) + +# Call init_wasm() before using client.wasm (raises WasmError otherwise). +client.init_wasm() +``` + +Convenience re-exports (`mintlayer.Amount`, `mintlayer.Network`, +`mintlayer.MAINNET`, …) mirror the Go SDK's aliases, so callers that only +import the top-level package do not need to also import `mintlayer.wasm`. + +--- + +## Examples + +| Example | Description | +|---|---| +| [examples/send_coins.py](examples/send_coins.py) | Derive key → fetch UTXOs → build, sign, and submit a transaction | +| [examples/issue_token.py](examples/issue_token.py) | Issue a fungible token and mint an initial supply via the wallet daemon | + +--- + +## Amounts + +All coin and token amounts use the `Amount` type, which stores the value as a +decimal string of _atoms_ — the smallest indivisible unit. **1 ML = +100,000,000,000 atoms** (11 decimal places). + +```python +from mintlayer.wasm import Amount + +one = Amount.from_atoms("100000000000") # 1 ML +zero = Amount.zero() +print(one.atoms) # "100000000000" +``` + +The indexer and wallet clients use their own `Amount` dataclass with both +`atoms` and `decimal` fields populated by the server. + +--- + +## Networks + +| Constant | Value | Use | +|---|---|---| +| `MAINNET` | 0 | Production network | +| `TESTNET` | 1 | Public test network | +| `REGTEST` | 2 | Local regression testing | +| `SIGNET` | 3 | Signet | + +Pass the network constant (`mintlayer.Network` enum members or the +module-level aliases) to any function that derives addresses or encodes +transactions. + +--- + +## Error handling + +- `mintlayer.node.RPCError` — JSON-RPC error from the node daemon (`code`, + `message`); transport failures raise `JSONRPCError` +- `mintlayer.wallet.RPCError` — JSON-RPC error from the wallet daemon +- `mintlayer.indexer.HTTPError` — non-2xx HTTP response from the indexer + (`status_code`, `body`); transport failures raise `IndexerError` +- `mintlayer.wasm.WasmError` — WASM operation failures, with a message + prefixed by `mintlayer:` + +--- + ## License MIT — see [LICENSE](LICENSE). diff --git a/docs/indexer.md b/docs/indexer.md new file mode 100644 index 0000000..9782fb8 --- /dev/null +++ b/docs/indexer.md @@ -0,0 +1,569 @@ +# Indexer client + +The `mintlayer.indexer` module is a REST client for the Mintlayer indexer +(`api-web-server`). All paths are relative to the `/api/v2` base appended to +the configured URL. + +```python +from mintlayer.indexer import Client + +c = Client( + "http://127.0.0.1:3000", + timeout=15.0, # optional, seconds (default 30.0) + session=None, # optional requests.Session (client owns it otherwise) +) +``` + +**Default port:** 3000 (mainnet), 13000 (testnet). + +Non-2xx HTTP responses raise `HTTPError`; transport/decode failures raise +`IndexerError`: + +```python +from mintlayer.indexer import HTTPError, IndexerError + +try: + info = c.get_address_info("mtc1q...") +except HTTPError as e: + print(e.status_code, e.body) # e.g. 404 "address not found" +except IndexerError as e: + ... # connection failure or malformed JSON body +``` + +The client is safe for concurrent use from multiple threads and supports the +context-manager protocol (`with Client(...) as c: ...`). + +--- + +## Pagination + +List endpoints accept a `PageOpts` dataclass: + +```python +@dataclass(frozen=True) +class PageOpts: + offset: int = 0 # default: 0 + items: int = 0 # default: 10 (server-side default) +``` + +**Zero-omission rule:** zero values are omitted from the query string entirely, +so the server defaults apply. Only positive values are sent: + +```python +from mintlayer.indexer import PageOpts + +c.list_transactions(PageOpts(offset=20, items=50)) +c.list_orders() # server defaults +``` + +--- + +## Chain + +### `get_tip` + +```python +def get_tip(self) -> ChainTip: ... +``` + +Returns the highest confirmed block. + +```python +@dataclass(frozen=True) +class ChainTip: + block_height: int + block_id: str +``` + +### `get_genesis` + +```python +def get_genesis(self) -> GenesisInfo: ... +``` + +Returns genesis block information (`block_id`, `genesis_message`, +`timestamp`, `utxos`). + +### `get_block_id_at_height` + +```python +def get_block_id_at_height(self, height: int) -> str: ... +``` + +Returns the block ID at a given height. Raises a 404 `HTTPError` if no block +exists at that height (for example, when querying a height beyond the current +tip). + +--- + +## Blocks + +### `get_block` + +```python +def get_block(self, block_id: str) -> Block: ... +``` + +Returns the full block: `height`, `header` (`BlockHeader`) and `body` +(`BlockBody` with `reward` and `transactions`). + +### `get_block_header` + +```python +def get_block_header(self, block_id: str) -> BlockHeader: ... +``` + +Returns only the block header (`previous_block_id`, `timestamp`, `merkle_root`, +`witness_merkle_root`, `consensus_data`). Cheaper than `get_block` when you do +not need transaction data. + +### `get_block_reward` + +```python +def get_block_reward(self, block_id: str) -> list: ... +``` + +Returns the reward outputs of a block as raw decoded JSON values. + +### `get_block_transaction_ids` + +```python +def get_block_transaction_ids(self, block_id: str) -> list[str]: ... +``` + +Returns the transaction IDs included in a block. Use this to page through block +contents without fetching full transaction data. + +--- + +## Transactions + +### `list_transactions` + +```python +def list_transactions(self, opts: PageOpts | None = None) -> list[Transaction]: ... +``` + +Returns a paginated list of confirmed transactions across the entire chain. + +### `get_transaction` + +```python +def get_transaction(self, tx_id: str) -> Transaction: ... +``` + +Returns a transaction by ID. The `block_id`, `timestamp`, and `confirmations` +fields are empty strings for unconfirmed transactions. + +```python +@dataclass(frozen=True) +class Transaction: + id: str + inputs: Any # raw decoded JSON + outputs: Any # raw decoded JSON + block_id: str + timestamp: str + confirmations: str +``` + +### `get_transaction_merkle_path` + +```python +def get_transaction_merkle_path(self, tx_id: str) -> MerklePath: ... +``` + +Returns the Merkle inclusion proof for a transaction (`block_id`, +`transaction_index`, `merkle_root`, `path`). Raises a 404 `HTTPError` if the +transaction is not yet in a block. + +### `get_transaction_output` + +```python +def get_transaction_output(self, tx_id: str, output_index: int) -> Any: ... +``` + +Returns a single output from a transaction as raw decoded JSON. The shape is +determined by the `"type"` field. Common types: `"Transfer"`, +`"LockThenTransfer"`, `"Burn"`, `"CreateStakePool"`, `"CreateDelegationId"`, +`"DelegateStaking"`, `"IssueFungibleToken"`, `"IssueNft"`, `"DataDeposit"`, +`"Htlc"`, `"CreateOrder"`. + +### `submit_transaction` + +```python +def submit_transaction(self, signed_tx_hex: str) -> str: ... +``` + +Submits a hex-encoded signed transaction to the network. Returns the +transaction ID on success. The hex string is POSTed verbatim as +`text/plain` — the one non-GET route in the client. + +**Requires** the indexer to be started with `--enable-post-routes`. + +--- + +## Addresses + +### `get_address_info` + +```python +def get_address_info(self, address: str) -> AddressInfo: ... +``` + +Returns balance and transaction history for a bech32m address. Raises a 404 +`HTTPError` if the address has no on-chain history. + +```python +@dataclass(frozen=True) +class AddressInfo: + coin_balance: Amount + locked_coin_balance: Amount + transaction_history: list[str] + tokens: list[TokenBalance] # TokenBalance(token_id, amount) +``` + +### `get_spendable_utxos` + +```python +def get_spendable_utxos(self, address: str) -> list[UTXO]: ... +``` + +Returns confirmed, unspent UTXOs that can be spent immediately. + +### `get_all_utxos` + +```python +def get_all_utxos(self, address: str) -> list[UTXO]: ... +``` + +Returns all UTXOs including those that are locked or otherwise unspendable. + +```python +@dataclass(frozen=True) +class UTXO: + outpoint: UTXOOutpoint # UTXOOutpoint(source_id: str, index: int) + output: Any # raw JSON; note the payload key on the wire is "utxo" +``` + +### `get_delegations` + +```python +def get_delegations(self, address: str) -> list[DelegationInfo]: ... +``` + +Returns all staking delegations owned by an address. + +```python +@dataclass(frozen=True) +class DelegationInfo: + delegation_id: str + pool_id: str + next_nonce: int + spend_destination: str + balance: Amount +``` + +### `get_token_authority` + +```python +def get_token_authority(self, address: str) -> list[str]: ... +``` + +Returns the IDs (bech32m) of fungible tokens for which the address holds +authority (can mint, freeze, etc.). + +--- + +## Pools and delegations + +### `list_pools` + +```python +def list_pools(self, opts: PoolListOpts | None = None) -> list[Pool]: ... +``` + +Returns staking pools with optional pagination. The `sort` field accepts: + +- `"by_height"` (server default): newest pools first +- `"by_pledge"`: largest staker balance first + +```python +@dataclass(frozen=True) +class PoolListOpts: + offset: int = 0 + items: int = 0 + sort: str = "" # omitted from the query when empty (zero-omission rule) +``` + +```python +c.list_pools(PoolListOpts(sort="by_pledge", items=20)) +``` + +### `get_pool` + +```python +def get_pool(self, pool_id: str) -> Pool: ... +``` + +Returns a single staking pool by its bech32m pool ID. + +```python +@dataclass(frozen=True) +class Pool: + pool_id: str + decommission_destination: str + staker_balance: Amount + margin_ratio_per_thousand: float + cost_per_block: Amount + vrf_public_key: str + delegations_balance: Amount +``` + +### `get_pool_block_stats` + +```python +def get_pool_block_stats(self, pool_id: str, from_time: datetime, to_time: datetime) -> int: ... +``` + +Returns the number of blocks produced by a pool in the half-open interval +`[from_time, to_time)`. Datetimes are converted to Unix-seconds query +parameters. + +```python +from datetime import datetime, timedelta + +count = c.get_pool_block_stats( + "mpool1...", + datetime.now() - timedelta(hours=24), + datetime.now(), +) +``` + +### `get_delegation` + +```python +def get_delegation(self, delegation_id: str) -> Delegation: ... +``` + +Returns a single delegation by its bech32m delegation ID. + +```python +@dataclass(frozen=True) +class Delegation: + delegation_id: str + pool_id: str + next_nonce: int + spend_destination: str + balance: Amount + creation_block_height: int +``` + +### `get_pool_delegations` + +```python +def get_pool_delegations(self, pool_id: str) -> list[PoolDelegation]: ... +``` + +Returns all delegations in a pool. Each entry includes the +`creation_block_height` in addition to the standard delegation fields (but no +`pool_id`, since it is implied by the query). + +--- + +## Tokens and NFTs + +### `list_tokens` + +```python +def list_tokens(self, opts: PageOpts | None = None) -> list[str]: ... +``` + +Returns a paginated list of fungible token IDs (bech32m). + +### `get_token` + +```python +def get_token(self, token_id: str) -> TokenInfo: ... +``` + +Returns full information about a fungible token. + +```python +@dataclass(frozen=True) +class TokenInfo: + authority: str + is_locked: bool + circulating_supply: Amount + token_ticker: str + metadata_uri: str + number_of_decimals: int + total_supply: Any # raw JSON + frozen: bool + is_token_unfreezable: bool | None # non-None only when frozen + is_token_freezable: bool | None # non-None only when not frozen + next_nonce: int +``` + +### `get_token_transactions` + +```python +def get_token_transactions(self, token_id: str, opts: PageOpts | None = None) -> list[TokenTx]: ... +``` + +Returns the transaction history for a token (issuance, mints, transfers, +burns) as `TokenTx(tx_global_index, tx_id)` entries. + +### `find_tokens_by_ticker` + +```python +def find_tokens_by_ticker(self, ticker: str, opts: PageOpts | None = None) -> list[str]: ... +``` + +Returns token IDs whose ticker matches the given string. Tickers are not +unique, so this may return multiple results. + +### `get_nft` + +```python +def get_nft(self, token_id: str) -> NFTInfo: ... +``` + +Returns information about an NFT: `owner`, `token_id`, and `metadata` +(`NFTMetadata` with `creator`, `name`, `description`, `ticker`, `icon_uri`, +`additional_metadata_uri`, `media_uri`, `media_hash` — the URI/creator fields +are `None` when unset). + +--- + +## Orders + +### `list_orders` + +```python +def list_orders(self, opts: PageOpts | None = None) -> list[Order]: ... +``` + +Returns active orders. + +### `get_order` + +```python +def get_order(self, order_id: str) -> Order: ... +``` + +Returns a single order by its bech32m order ID. + +```python +@dataclass(frozen=True) +class Order: + order_id: str + conclude_destination: str + give_currency: Any # raw JSON, "type" of "Coin" or "Token" + initially_given: Amount + give_balance: Amount + ask_currency: Any # raw JSON, "type" of "Coin" or "Token" + initially_asked: Amount + ask_balance: Amount + nonce: int +``` + +### `list_orders_by_pair` + +```python +def list_orders_by_pair( + self, ask_currency: str, give_currency: str, opts: PageOpts | None = None +) -> list[Order]: ... +``` + +Returns orders filtered by a trading pair. Pass `"ML"` (the coin ticker) or a +bech32m token ID for each currency; the request path is +`/order/pair/{ask}_{give}`. + +--- + +## Statistics + +### `get_coin_statistics` + +```python +def get_coin_statistics(self) -> CoinStats: ... +``` + +Returns supply statistics for the native ML coin. + +```python +@dataclass(frozen=True) +class CoinStats: + circulating_supply: Amount + preminted: Amount + burned: Amount + staked: Amount +``` + +### `get_token_statistics` + +```python +def get_token_statistics(self, token_id: str) -> CoinStats: ... +``` + +Returns the same statistics for a fungible token. + +### `get_fee_rate` + +```python +def get_fee_rate(self, in_top_x_mb: int = 0) -> str: ... +``` + +Returns the current fee rate in atoms per kilobyte (a decimal string) needed to +place a transaction in the top `in_top_x_mb` megabytes of the mempool priority +queue. + +**Default-parameter quirk:** when `in_top_x_mb` is `0` (the default) the query +parameter is omitted entirely and the server default (5 MB) applies. + +```python +rate = int(c.get_fee_rate(1)) # atoms per KB, top 1 MB of the mempool +``` + +--- + +## Lenient numeric parsing + +The indexer documents several fields as integers but the server sometimes +serialises them as strings — and `margin_ratio_per_thousand` even arrives as a +string with a trailing `%` (e.g. `"10.0%"`). The client parses these +transparently (`mintlayer.indexer.number`): + +- `parse_uint64` — accepts a bare JSON number or a decimal string + (`block_height`, `next_nonce`, `number_of_decimals`, …), returns `int`. +- `parse_per_thousand` — accepts a bare number, a decimal string, or a string + with a trailing `%`; returns `float` (used for `Pool.margin_ratio_per_thousand`). + +Malformed values raise `IndexerError`; malformed payloads in `from_json` are +wrapped as `IndexerError` too rather than leaking `KeyError`/`TypeError`. + +--- + +## Amounts + +The `Amount` type carries both raw atoms and a human-readable decimal: + +```python +@dataclass(frozen=True) +class Amount: + atoms: str + decimal: str +``` + +All values populated by the server include both fields. When constructing +amounts to send to the server, you only need to set `atoms` +(`Amount(atoms="100000000000")`). + +--- + +## Related + +- [node.md](node.md) — node daemon JSON-RPC client +- [transactions.md](transactions.md) — building and signing transactions to submit here +- [staking.md](staking.md) — pools and delegations +- [tokens.md](tokens.md) — token and NFT lifecycle diff --git a/docs/node.md b/docs/node.md new file mode 100644 index 0000000..2198cea --- /dev/null +++ b/docs/node.md @@ -0,0 +1,545 @@ +# Node client + +The `mintlayer.node` module is a JSON-RPC 2.0 client for the Mintlayer node +daemon. Every method is synchronous and thread-safe. + +```python +from mintlayer.node import Client + +c = Client( + "http://127.0.0.1:3030", + username="user", # optional; Basic Auth applied only when set + password="pass", # optional + timeout=10.0, # optional, seconds (default 30.0) + session=None, # optional requests.Session (client owns it otherwise) +) +``` + +**Default ports:** 3030 (mainnet), 13030 (testnet). + +> **Transport security:** Basic Auth credentials travel in cleartext over +> plain `http://`. Bind the daemon to localhost or front it with an HTTPS +> reverse proxy / SSH tunnel when connecting over a network. + + +There is no per-call cancellation: configure `timeout` on the client (Go's +per-call `context` has no direct `requests` equivalent). Errors from the daemon +raise `RPCError`; transport and decode failures raise `JSONRPCError`: + +```python +from mintlayer.node import RPCError, JSONRPCError + +try: + height = c.best_block_height() +except RPCError as e: + print(e.code, e.message) +except JSONRPCError as e: + ... # HTTP failure or malformed response body +``` + +The HTTP status code is never inspected — a JSON-RPC `error` object in the body +is the error contract. JSON `null` results map to `None` for every +"not-found"-style method (`block_id_at_height`, `stake_pool_balance`, …). + +--- + +## Chain state + +### `chainstate_info` + +```python +def chainstate_info(self) -> ChainstateInfo: ... +``` + +Returns a summary of the current chain state. + +```python +@dataclass(frozen=True) +class ChainstateInfo: + best_block_height: int + best_block_id: str + best_block_timestamp: Timestamp # Timestamp(timestamp: int), Unix seconds + median_time: Timestamp + is_initial_block_download: bool +``` + +### `best_block_id` + +```python +def best_block_id(self) -> str: ... +``` + +Returns the hex block ID of the current tip. + +### `best_block_height` + +```python +def best_block_height(self) -> int: ... +``` + +Returns the height of the current tip. + +### `block_id_at_height` + +```python +def block_id_at_height(self, height: int) -> str | None: ... +``` + +Returns the block ID at a given height, or `None` if no block exists at that +height. + +### `block_height_in_main_chain` + +```python +def block_height_in_main_chain(self, block_id: str) -> int | None: ... +``` + +Returns the mainchain height for a block ID, or `None` if the block is not on +the main chain. + +### `get_block` + +```python +def get_block(self, block_id: str) -> str | None: ... +``` + +Returns the hex-encoded raw block (`None` if unknown; the genesis block is not +retrievable). + +### `get_block_json` + +```python +def get_block_json(self, block_id: str) -> Any: ... +``` + +Returns the block as decoded JSON. Useful for inspection without custom +deserialization. + +### `get_mainchain_blocks` + +```python +def get_mainchain_blocks(self, from_height: int, max_count: int) -> list[str]: ... +``` + +Returns up to `max_count` mainchain block IDs starting at `from_height`. + +### `get_utxo` + +```python +def get_utxo(self, outpoint: Outpoint) -> Any: ... +``` + +Returns the output at a given outpoint as decoded JSON (`None` if +spent/unknown). + +```python +@dataclass(frozen=True) +class Outpoint: + source_id: OutpointSourceID + index: int + +@dataclass +class OutpointSourceID: + type: str # "Transaction" or "BlockReward" + content: Any # {"tx_id": ""} or {"block_id": ""} +``` + +Build the `content` payloads with the helpers: + +```python +from mintlayer.node import Outpoint, OutpointSourceID, tx_source_content, block_source_content + +op = Outpoint( + source_id=OutpointSourceID(type="Transaction", content=tx_source_content(tx_id)), + index=0, +) +utxo = c.get_utxo(op) +``` + +### `submit_block` + +```python +def submit_block(self, block_hex: str) -> None: ... +``` + +Submits a hex-encoded block. Used by block producers. + +--- + +## Pool and delegation queries + +### `stake_pool_balance` + +```python +def stake_pool_balance(self, pool_address: str) -> Amount | None: ... +``` + +Returns the total balance of a pool (staker pledge plus all delegations). +Returns `None` if the pool is not found. + +### `staker_balance` + +```python +def staker_balance(self, pool_address: str) -> Amount | None: ... +``` + +Returns the staker's own balance, excluding delegations. Returns `None` if the +pool is not found. + +### `pool_decommission_destination` + +```python +def pool_decommission_destination(self, pool_address: str) -> str | None: ... +``` + +Returns the address that receives funds when the pool is decommissioned. + +### `delegation_share` + +```python +def delegation_share(self, pool_address: str, delegation_address: str) -> Amount | None: ... +``` + +Returns the amount owned by a specific delegation in a pool. + +--- + +## Token and order info + +Amounts are decimal atom strings — **1 ML = 100,000,000,000 atoms** (11 +decimal places). `Amount` is a frozen dataclass with a single `atoms: str` +field. + +### `token_info` + +```python +def token_info(self, token_id: str) -> TokenInfo | None: ... +``` + +Returns on-chain token metadata (`None` if unknown). + +```python +@dataclass +class TokenInfo: + type: str # "FungibleToken" or "NonFungibleToken" + content: Any # raw decoded JSON +``` + +### `tokens_info` + +```python +def tokens_info(self, token_ids: list[str]) -> list[TokenInfo]: ... +``` + +Batch version of `token_info`. More efficient than calling `token_info` in a +loop. + +### `order_info` + +```python +def order_info(self, order_id: str) -> OrderInfo | None: ... +``` + +Returns the current state of an order. + +```python +@dataclass +class OrderInfo: + conclude_key: str + initially_asked: Any + initially_given: Any + ask_balance: Amount + give_balance: Amount + nonce: int | None # None for active orders (daemon sends null) + is_frozen: bool +``` + +Quirk: `nonce` is `None` for active orders — the daemon sends JSON `null` for +the field. This fixes a known Go SDK incompatibility, where the `null` broke +`uint64` decoding. + +### `orders_info_by_currencies` + +```python +def orders_info_by_currencies( + self, ask: Currency | None, give: Currency | None +) -> dict[str, OrderInfo]: ... +``` + +Returns all orders matching the given currency pair, as a dict from order ID to +`OrderInfo`. Pass `None` for either currency to match any (both keys are always +sent; `None` serialises as JSON `null`). + +```python +@dataclass(frozen=True) +class Currency: + type: str # "Coin" or "Token" + content: str | None # bech32 token ID when type is "Token" +``` + +Construct with the helpers: + +```python +from mintlayer.node import Currency + +orders = c.orders_info_by_currencies(Currency.coin(), Currency.token("ttml1...")) +any_coin = c.orders_info_by_currencies(None, Currency.coin()) +``` + +--- + +## Mempool + +### `contains_tx` + +```python +def contains_tx(self, tx_id: str) -> bool: ... +``` + +Returns `True` if the mempool contains the transaction. + +### `contains_orphan_tx` + +```python +def contains_orphan_tx(self, tx_id: str) -> bool: ... +``` + +Returns `True` if the orphan pool contains the transaction. + +### `get_transaction` + +```python +def get_transaction(self, tx_id: str) -> MempoolTx | None: ... +``` + +Returns a mempool transaction (`None` if not present). + +```python +@dataclass(frozen=True) +class MempoolTx: + id: str + status: str + transaction: str +``` + +### `mempool_submit_transaction` + +```python +def mempool_submit_transaction( + self, tx_hex: str, trust_policy: TrustPolicy | str +) -> None: ... +``` + +Submits a transaction to the local mempool only, without broadcasting to peers. +Use `TrustPolicy.UNTRUSTED` for transactions you constructed yourself; use +`TrustPolicy.TRUSTED` to skip some fee checks. A plain string is accepted too: + +```python +from mintlayer.node import TrustPolicy + +c.mempool_submit_transaction(signed_hex, TrustPolicy.UNTRUSTED) +``` + +```python +class TrustPolicy(str, enum.Enum): + TRUSTED = "Trusted" + UNTRUSTED = "Untrusted" +``` + +### `get_fee_rate` + +```python +def get_fee_rate(self, in_top_x_mb: int) -> FeeRate | None: ... +``` + +Returns the fee rate needed to land in the top `in_top_x_mb` megabytes of the +mempool. + +```python +@dataclass(frozen=True) +class FeeRate: + amount_per_kb: Amount # atoms per kilobyte +``` + +### `get_fee_rate_points` + +```python +def get_fee_rate_points(self) -> list[FeeRatePoint]: ... +``` + +Returns the mempool fee-rate curve as a list of (size, rate) pairs. + +Wire quirk: the daemon sends each point as a two-element array +`[size, {"amount_per_kb": {...}}]`, decoded into: + +```python +@dataclass(frozen=True) +class FeeRatePoint: + size: int + rate: FeeRate +``` + +### `memory_usage` + +```python +def memory_usage(self) -> int: ... +``` + +Returns the current mempool memory usage in bytes. + +--- + +## P2P + +### `get_peer_count` + +```python +def get_peer_count(self) -> int: ... +``` + +Returns the number of currently connected peers. + +### `get_connected_peers` + +```python +def get_connected_peers(self) -> list[PeerInfo]: ... +``` + +Returns details about all connected peers. + +```python +@dataclass(frozen=True) +class PeerInfo: + peer_id: int + address: str + peer_role: str + ban_score: int + user_agent: str + software_version: str + ping_wait: int | None = None + ping_last: int | None = None + ping_min: int | None = None + last_tip_block_time: int | None = None +``` + +### `get_bind_addresses` + +```python +def get_bind_addresses(self) -> list[str]: ... +``` + +Returns the addresses the node is listening on for P2P connections. + +### `add_reserved_node` + +```python +def add_reserved_node(self, addr: str) -> None: ... +``` + +Adds a persistent peer that the node always attempts to reconnect to. + +### `remove_reserved_node` + +```python +def remove_reserved_node(self, addr: str) -> None: ... +``` + +Removes a persistent peer. + +### `connect` + +```python +def connect(self, addr: str) -> None: ... +``` + +Makes a one-time connection attempt to a peer address. + +### `disconnect` + +```python +def disconnect(self, peer_id: int) -> None: ... +``` + +Closes the connection to a peer by ID. + +### `list_banned` + +```python +def list_banned(self) -> list[BannedPeer]: ... +``` + +Returns the list of banned peers. + +Wire quirk: each entry is a two-element array +`["

", {"time": [secs, nanos]}]`, decoded into: + +```python +@dataclass(frozen=True) +class BannedPeer: + address: str + ban_time: tuple[int, int] # (seconds, nanoseconds) +``` + +### `ban` + +```python +def ban(self, address: str, duration: timedelta) -> None: ... +``` + +Bans a peer for the specified duration. Durations are `datetime.timedelta` +values, split into the daemon's `[seconds, nanoseconds]` wire form: + +```python +from datetime import timedelta + +c.ban("192.0.2.1", timedelta(hours=24)) +``` + +### `unban` + +```python +def unban(self, address: str) -> None: ... +``` + +Removes a peer from the ban list. + +### `p2p_submit_transaction` + +```python +def p2p_submit_transaction( + self, tx_hex: str, trust_policy: TrustPolicy | str +) -> None: ... +``` + +Submits a transaction to the mempool and broadcasts it to peers. This is the +normal path for publishing a transaction to the network (the alternative — the +indexer's `submit_transaction` — requires `--enable-post-routes`, see +[indexer.md](indexer.md)). + +--- + +## Node management + +### `node_version` + +```python +def node_version(self) -> str: ... +``` + +Returns the node software version string. + +### `node_shutdown` + +```python +def node_shutdown(self) -> None: ... +``` + +Initiates a graceful node shutdown. + +--- + +## Related + +- [indexer.md](indexer.md) — read-only chain queries and `submit_transaction` +- [transactions.md](transactions.md) — building and signing transactions +- [wallet.md](wallet.md) — the wallet daemon client diff --git a/docs/staking.md b/docs/staking.md new file mode 100644 index 0000000..5b66562 --- /dev/null +++ b/docs/staking.md @@ -0,0 +1,307 @@ +# Staking and delegations + +Mintlayer uses Proof of Stake. ML holders can earn staking rewards by either: + +- Running a **staking pool** directly (requires a node, VRF key, and pledge) +- **Delegating** to an existing pool (no node required) + +The wallet daemon manages both flows. The indexer provides read-only access to +pool and delegation state. The `mintlayer.wasm` module provides low-level +primitives for manual transaction flows. + +--- + +## Staking pools (wallet daemon) + +### Creating a pool + +```python +from mintlayer.wallet import Amount, Client, CreatePoolParams + +wc = Client("http://127.0.0.1:3034") + +result = wc.create_stake_pool(CreatePoolParams( + account=0, + amount=Amount(atoms="40000000000000"), # minimum pledge + cost_per_block=Amount(atoms="100000000"), # flat fee per block + margin_ratio_per_thousand="100", # 10% staker cut + decommission_address=decommission_addr, + # staker_address and vrf_public_key default to wallet-managed keys + # when None (sent as JSON null) +)) +print(f"tx id: {result.tx_id}") +``` + +`margin_ratio_per_thousand` is the staker's cut of block rewards expressed in +thousandths, as a **string**: `"100"` = 10%, `"50"` = 5%, `"1000"` = 100%. + +`cost_per_block` is a flat atom amount deducted from rewards before the margin +split. Delegators receive the remainder proportionally to their stake. + +The result is a `SendResult(tx_id, fees, broadcasted)` — the pool ID can be +predicted before broadcasting with `get_pool_id` (see below). + +### Starting and stopping block production + +```python +wc.start_staking(0) # account 0 + +status = wc.get_staking_status(0) +print(status) # StakingStatus.ACTIVE ("Staking") or StakingStatus.INACTIVE ("NotStaking") + +wc.stop_staking(0) +``` + +`stop_staking` stops block production but does not decommission the pool. +Delegations and staked funds remain untouched. + +### Listing owned pools + +```python +pools = wc.list_owned_pools(0) +for p in pools: + print(f"pool {p.pool_id} pledge={p.pledge.atoms} balance={p.balance.atoms}") +``` + +### Pool balance + +```python +balance = wc.get_pool_balance(0, "mpool1...") # Amount +``` + +Quirk: matching the daemon route, the `account` argument is accepted for API +consistency but **not sent on the wire** — the route only uses `pool_id`. + +### Decommissioning a pool + +```python +from mintlayer.wallet import DecommissionParams + +result = wc.decommission_stake_pool(DecommissionParams( + account=0, + pool_id="mpool1...", + output_address=return_addr, +)) +``` + +After decommissioning, the pledge is returned to `output_address` after the +maturity period. Delegators must withdraw their funds separately. + +### Reading pool state from the indexer + +```python +from datetime import datetime, timedelta + +from mintlayer.indexer import Client, PoolListOpts + +idx = Client("http://127.0.0.1:3000") + +# All pools sorted by pledge size +pools = idx.list_pools(PoolListOpts(sort="by_pledge")) + +# Single pool +pool = idx.get_pool("mpool1...") +print(f"staker balance: {pool.staker_balance.decimal}") +print(f"delegations: {pool.delegations_balance.decimal}") + +# Blocks produced in the last 24 hours +count = idx.get_pool_block_stats( + "mpool1...", + datetime.now() - timedelta(hours=24), + datetime.now(), +) + +# All delegations in the pool +delegations = idx.get_pool_delegations("mpool1...") +``` + +--- + +## Delegations (wallet daemon) + +### Creating a delegation + +A delegation ID is tied to a pool and an owner address. You create the +delegation record first, then fund it separately. + +```python +from mintlayer.wallet import Amount, CreateDelegationParams, DelegateParams + +# Step 1: create the delegation +create_result = wc.create_delegation(CreateDelegationParams( + account=0, + address=owner_addr, # address that can withdraw funds + pool_id="mpool1...", +)) +print(f"delegation id: {create_result.delegation_id}") + +# Step 2: fund the delegation (wait for the creation tx to confirm first) +delegate_result = wc.delegate_staking(DelegateParams( + account=0, + amount=Amount(atoms="10000000000000"), # 100 ML + delegation_id=create_result.delegation_id, +)) +``` + +You can send multiple `delegate_staking` transactions to the same delegation to +increase your stake. + +### Withdrawing from a delegation + +```python +from mintlayer.wallet import WithdrawParams + +result = wc.withdraw_from_delegation(WithdrawParams( + account=0, + address=recipient_addr, + amount=Amount(atoms="5000000000000"), # 50 ML + delegation_id="mdelg1...", +)) +``` + +Withdrawn funds arrive at `address` after the lock period (determined by +consensus rules). + +### Listing delegations + +```python +delegations = wc.list_delegations(0) +for d in delegations: + print(f"delegation {d.delegation_id} pool={d.pool_id} balance={d.balance.atoms}") +``` + +### Reading delegation state from the indexer + +```python +# All delegations owned by an address +delegation_infos = idx.get_delegations("mtc1qowner...") + +# Single delegation by ID +delegation = idx.get_delegation("mdelg1...") +print(f"pool: {delegation.pool_id}") +print(f"balance: {delegation.balance.decimal}") +print(f"nonce: {delegation.next_nonce}") +``` + +--- + +## Building delegation transactions manually + +The `mintlayer.wasm` module provides the low-level primitives when you need to +build delegation transactions without the wallet daemon. + +### Create a delegation + +```python +from mintlayer.wasm import Client, Network + +c = Client() +try: + # Predict the delegation ID before broadcasting + delegation_id_str = c.get_delegation_id(encoded_inputs, Network.MAINNET) + + # Encode the CreateDelegationId output + create_deleg_output = c.encode_output_create_delegation( + "mpool1...", + owner_address, + Network.MAINNET, + ) +finally: + c.close() +``` + +### Fund a delegation + +```python +delegate_output = c.encode_output_delegate_staking( + Amount.from_atoms("10000000000000"), + "mdelg1...", + Network.MAINNET, +) +``` + +### Withdraw from a delegation + +```python +# The nonce must match the current next_nonce from the indexer +delegation = idx.get_delegation("mdelg1...") + +withdraw_input = c.encode_input_for_withdraw_from_delegation( + "mdelg1...", + Amount.from_atoms("5000000000000"), + delegation.next_nonce, + Network.MAINNET, +) + +# The output receives the withdrawn coins after the lock period +withdraw_output = c.encode_output_lock_then_transfer( + Amount.from_atoms("5000000000000"), + recipient_address, + lock, # from encode_lock_for_block_count or similar + Network.MAINNET, +) +``` + +Assemble, sign, and submit the resulting inputs/outputs exactly as in +[transactions.md](transactions.md). + +--- + +## Manual pool creation + +For full-custody pool creation, encode the pool parameters and wrap them in a +`CreateStakePool` output. `encode_stake_pool_data` takes the pool value +(pledge), the staker/VRF/decommission keys, the margin ratio, and the per-block +cost: + +```python +from mintlayer.wasm import Amount, Network + +pool_id = c.get_pool_id(encoded_inputs, Network.MAINNET) + +pool_data = c.encode_stake_pool_data( + value=Amount.from_atoms("40000000000000"), + staker=staker_addr, + vrf_public_key=vrf_key, + decommission_key=decommission_addr, + margin_ratio_per_thousand=100, # int here (wallet daemon takes a string) + cost_per_block=Amount.from_atoms("100000000"), + network=Network.MAINNET, +) + +pool_output = c.encode_output_create_stake_pool(pool_id, pool_data, Network.MAINNET) +``` + +Two helpers are useful when planning a pool: + +```python +# Effective balance used in the slot lottery (diminishing returns for big pools) +eff = c.effective_pool_balance(Network.MAINNET, pledge_amount, pool_balance) + +# Blocks a pool output must mature after decommission before funds are spendable +maturity = c.staking_pool_spend_maturity_block_count(tip.block_height, Network.MAINNET) +``` + +--- + +## Checking rewards + +The indexer does not expose a rewards endpoint directly. To calculate staking +rewards: + +1. Get pool block stats for a time range (`get_pool_block_stats`) +2. Get the pool's cost per block and margin ratio (`get_pool`) +3. Get your delegation's share of the total pool balance (`get_delegation`) + +The staker receives `cost_per_block + margin_ratio_per_thousand/1000 * +(block_reward - cost_per_block)`. Delegators split the remainder +proportionally to their stake. + +--- + +## Related + +- [wallet.md](wallet.md) — wallet client reference +- [indexer.md](indexer.md) — pool/delegation read queries +- [wasm.md](wasm.md) — WASM encoding reference +- [transactions.md](transactions.md) — assembling and signing manual transactions diff --git a/docs/tokens.md b/docs/tokens.md new file mode 100644 index 0000000..af8048b --- /dev/null +++ b/docs/tokens.md @@ -0,0 +1,359 @@ +# Tokens and NFTs + +Mintlayer supports on-chain fungible tokens and NFTs. The wallet daemon manages +the full lifecycle. The `mintlayer.wasm` module provides low-level encoding for +manual transaction flows. + +--- + +## Fungible tokens (wallet daemon) + +### Supply policies + +When issuing a token you choose one of three supply policies +(`TokenSupply` dataclass, wire field `type`): + +| Policy | `TokenSupply.type` | Description | +|--------|--------------------|-------------| +| Lockable | `"Lockable"` | Unlimited minting until `lock_token_supply` is called, after which the supply is frozen permanently | +| Unlimited | `"Unlimited"` | Minting is always allowed with no cap | +| Fixed | `"Fixed"` | A cap is set at issuance; supply cannot exceed it | + +For a `Fixed` cap, set the `content` field to an `Amount`: + +```python +TokenSupply(type="Fixed", content=Amount(atoms="1000000")) # hard cap +``` + +`content` is omitted from the wire for the other two policies. + +### Issuing a token + +```python +from mintlayer.wallet import ( + Amount, + Client, + IssueTokenParams, + TokenMetadata, + TokenSupply, +) + +wc = Client("http://127.0.0.1:3034") + +authority_addr = wc.new_address(0) + +result = wc.issue_token(IssueTokenParams( + account=0, + destination_address=authority_addr, + metadata=TokenMetadata( + token_ticker="MYTOKEN", + number_of_decimals=2, + metadata_uri="https://example.com/token-metadata.json", + token_supply=TokenSupply(type="Lockable"), + is_freezable=True, + ), +)) +print(f"token id: {result.token_id}\ntx id: {result.tx_id}") +``` + +The `destination_address` becomes the **authority address**: the key that +controls future token operations (minting, freezing, authority transfer). Keep +it secure. + +### Minting + +Wait for the issuance transaction to confirm before minting. + +```python +from mintlayer.wallet import MintParams + +mint_result = wc.mint_tokens(MintParams( + account=0, + token_id=result.token_id, + address=recipient_addr, + amount=Amount(atoms="100000"), # in smallest token units +)) +print(f"minted tx id: {mint_result.tx_id}") +``` + +### Unminting + +Returns tokens to an unminted state (removes them from circulation without +burning). + +```python +from mintlayer.wallet import UnmintParams + +unmint_result = wc.unmint_tokens(UnmintParams( + account=0, + token_id="ttml1...", + amount=Amount(atoms="50000"), +)) +``` + +### Locking supply + +After locking, the supply policy becomes `Fixed` at the current circulating +supply. This operation is irreversible. + +```python +from mintlayer.wallet import LockSupplyParams + +lock_result = wc.lock_token_supply(LockSupplyParams( + account_index=0, + token_id="ttml1...", +)) +``` + +Quirk: the field is `account_index`, not `account` — the daemon route expects +the wire key `account_index` (every other token method uses `account`). + +### Freezing and unfreezing + +Freezing prevents all transfers. If `is_unfreezable` is `True`, the authority +can unfreeze later. + +```python +from mintlayer.wallet import FreezeParams, UnfreezeParams + +freeze_result = wc.freeze_token(FreezeParams( + account=0, + token_id="ttml1...", + is_unfreezable=True, +)) + +unfreeze_result = wc.unfreeze_token(UnfreezeParams( + account=0, + token_id="ttml1...", +)) +``` + +### Transferring authority + +```python +from mintlayer.wallet import ChangeAuthorityParams + +change_result = wc.change_token_authority(ChangeAuthorityParams( + account=0, + token_id="ttml1...", + address=new_authority_addr, +)) +``` + +### Sending tokens + +```python +from mintlayer.wallet import TokenSendParams + +send_result = wc.send_token(TokenSendParams( + account=0, + token_id="ttml1...", + address=recipient_addr, + amount=Amount(atoms="10000"), +)) +``` + +`send_token` is an alias of `token_send` on the transactions mixin — both call +the daemon's `token_send` route. + +--- + +## NFTs (wallet daemon) + +NFTs are non-fungible tokens. Each has unique on-chain metadata. + +### Issuing an NFT + +```python +from mintlayer.wallet import IssueNFTParams, NFTMetadata + +owner_addr = wc.new_address(0) + +result = wc.issue_nft(IssueNFTParams( + account=0, + destination_address=owner_addr, + metadata=NFTMetadata( + name="My NFT", + description="A unique digital collectible", + ticker="MYNFT", + media_hash="sha256hexhash...", + media_uri="https://example.com/media.png", + icon_uri="https://example.com/icon.png", + # creator and additional_metadata_uri default to None + ), +)) +print(f"nft id: {result.token_id}") +``` + +NFTs cannot be minted after issuance: each issuance transaction creates exactly +one NFT. + +--- + +## Reading token state from the indexer + +```python +from mintlayer.indexer import Client, PageOpts + +idx = Client("http://127.0.0.1:3000") + +# Find by ticker +ids = idx.find_tokens_by_ticker("MYTOKEN", PageOpts(items=10)) + +# Full token info +token = idx.get_token("ttml1...") +print(f"ticker: {token.token_ticker}") +print(f"supply: {token.circulating_supply.decimal}") +print(f"locked: {token.is_locked}") +print(f"frozen: {token.frozen}") + +# Transaction history +txs = idx.get_token_transactions("ttml1...", PageOpts(items=20)) + +# NFT +nft = idx.get_nft("nftid1...") +print(f"owner: {nft.owner}") +print(f"name: {nft.metadata.name}") + +# Tokens where address is authority +token_ids = idx.get_token_authority("mtc1qauthority...") +``` + +--- + +## Building token transactions manually + +Use the `mintlayer.wasm` module for full control over token transactions. + +### Issue a token + +```python +from mintlayer.wasm import Amount, Client, FreezableToken, Network, TotalSupply + +c = Client() +try: + tip = idx.get_tip() + + issuance_fee = c.fungible_token_issuance_fee(tip.block_height, Network.MAINNET) + + # Predict the token ID + token_id_str = c.get_token_id(encoded_inputs, tip.block_height, Network.MAINNET) + + issue_output = c.encode_output_issue_fungible_token( + authority_addr, + "MYTOKEN", + "https://example.com/metadata.json", + 2, # decimals + TotalSupply.LOCKABLE, + None, # supply_amount: only required for TotalSupply.FIXED + FreezableToken.YES, + tip.block_height, + Network.MAINNET, + ) +finally: + c.close() +``` + +For a capped supply, pass the cap as the `supply_amount`: + +```python +issue_output = c.encode_output_issue_fungible_token( + authority_addr, + "MYTOKEN", + "https://example.com/metadata.json", + 2, + TotalSupply.FIXED, + Amount.from_atoms("1000000"), # required exactly for TotalSupply.FIXED + FreezableToken.NO, + tip.block_height, + Network.MAINNET, +) +``` + +Include the issuance fee as a separate output or subtract it from an input +UTXO. + +### Issue an NFT + +```python +issue_nft_output = c.encode_output_issue_nft( + token_id=token_id_str, # derived with get_token_id (same scheme as FTs) + authority=owner_addr, + name="My NFT", + ticker="MYNFT", + description="A unique digital collectible", + media_hash=bytes.fromhex("..."), # 32-byte sha256 of the media + creator=bytes.fromhex("..."), # or None + media_uri="https://example.com/media.png", + icon_uri=None, + additional_metadata_uri=None, + current_block_height=tip.block_height, + network=Network.MAINNET, +) +``` + +### Mint tokens + +```python +# Get the current nonce from the indexer +token_info = idx.get_token(token_id_str) + +mint_input = c.encode_input_for_mint_tokens( + token_id_str, + Amount.from_atoms("100000"), + token_info.next_nonce, + Network.MAINNET, +) + +mint_output = c.encode_output_token_transfer( + Amount.from_atoms("100000"), + recipient_addr, + token_id_str, + Network.MAINNET, +) +``` + +### Freeze a token + +```python +from mintlayer.wasm import TokenUnfreezable + +freeze_input = c.encode_input_for_freeze_token( + token_id_str, + TokenUnfreezable.YES, # can be unfrozen later + token_info.next_nonce, + Network.MAINNET, +) +``` + +Assemble, sign, and submit manual token transactions exactly as in +[transactions.md](transactions.md). + +--- + +## Token fees + +Protocol fees apply to many token operations. Query them from the WASM client +before building transactions: + +```python +tip = idx.get_tip() + +issuance_fee = c.fungible_token_issuance_fee(tip.block_height, Network.MAINNET) +nft_fee = c.nft_issuance_fee(tip.block_height, Network.MAINNET) +mint_fee = c.token_supply_change_fee(tip.block_height, Network.MAINNET) +freeze_fee = c.token_freeze_fee(tip.block_height, Network.MAINNET) +authority_fee = c.token_change_authority_fee(tip.block_height, Network.MAINNET) +``` + +These fees must be included as coin inputs in the transaction (or deducted +from change). The `data_deposit_fee` applies to `DataDeposit` outputs. + +--- + +## Related + +- [wallet.md](wallet.md) — wallet client reference +- [indexer.md](indexer.md) — token read queries +- [wasm.md](wasm.md) — WASM encoding reference +- [transactions.md](transactions.md) — assembling and signing manual transactions diff --git a/docs/transactions.md b/docs/transactions.md new file mode 100644 index 0000000..147102a --- /dev/null +++ b/docs/transactions.md @@ -0,0 +1,276 @@ +# Building transactions manually + +The wallet daemon handles transaction building automatically for most use +cases. Use the `mintlayer.wasm` module directly when you need: + +- Full custody (no wallet daemon) +- Custom output types or complex spending conditions +- Integration testing or tooling + +The [examples/send_coins.py](../examples/send_coins.py) program demonstrates +this flow end to end. + +--- + +## Overview + +Building a transaction manually requires these steps: + +1. Derive the spending key and address from a mnemonic +2. Fetch spendable UTXOs from the indexer +3. Encode each input as binary +4. Encode each output as binary +5. Build the unsigned transaction +6. Sign each input to produce witness bytes +7. Assemble the signed transaction +8. Submit to the network + +--- + +## Step 1: Key derivation + +```python +from mintlayer.wasm import Client, Network + +c = Client() +try: + mnemonic = "word1 word2 ... word12" + + account_key = c.make_default_account_privkey(mnemonic, Network.MAINNET) + + # key index 0 = first receiving address + spend_key = c.make_receiving_address(account_key, 0) + pub_key = c.public_key_from_private_key(spend_key) + from_addr = c.pubkey_to_pubkeyhash_address(pub_key, Network.MAINNET) +finally: + c.close() +``` + +--- + +## Step 2: Fetch spendable UTXOs + +```python +from mintlayer.indexer import Client as IndexerClient + +idx = IndexerClient("http://127.0.0.1:3000") + +utxos = idx.get_spendable_utxos(from_addr) +if not utxos: + raise RuntimeError("no spendable UTXOs") +``` + +Each `UTXO` carries `outpoint` (`source_id` hex string + `index`) and `output` +(raw JSON). + +--- + +## Step 3: Encode inputs + +Each input requires: + +1. Hex-decode the source transaction ID +2. Encode the outpoint source ID (`encode_outpoint_source_id`) +3. Encode the input (`encode_input_for_utxo`) + +**Concatenation semantics:** inputs (and outputs, and witnesses) are plain +binary blobs — the concatenation of every per-item encoding **is** the +transaction field. There is no count prefix or separator; just append with +`+=`. + +```python +from mintlayer.wasm import SOURCE_TRANSACTION + +encoded_inputs = b"" +for u in utxos: + tx_id_bytes = bytes.fromhex(u.outpoint.source_id) + + src_id = c.encode_outpoint_source_id(tx_id_bytes, SOURCE_TRANSACTION) + inp = c.encode_input_for_utxo(src_id, u.outpoint.index) + encoded_inputs += inp +``` + +--- + +## Step 4: Encode outputs + +```python +from mintlayer.wasm import Amount + +output = c.encode_output_transfer( + Amount(atoms="100000000000"), # 1 ML in atoms + "mtc1qrecipient...", + Network.MAINNET, +) +``` + +For multiple outputs, concatenate them: + +```python +change_output = c.encode_output_transfer( + Amount(atoms=str(change_atoms)), + from_addr, # send change back to sender + Network.MAINNET, +) + +all_outputs = output + change_output +``` + +--- + +## Step 5: Build the unsigned transaction + +```python +tx = c.encode_transaction(encoded_inputs, output, 0) # flags = 0 + +tx_id = c.get_transaction_id(tx, True) +print(f"unsigned tx id: {tx_id}") +``` + +--- + +## Step 6: Prepare UTXO bytes for signing + +The sighash computation requires access to the UTXO being spent. Build a +per-input blob where each entry is prefixed with either: + +- `0x01` followed by the re-encoded output bytes (recommended for coin + transfers) +- `0x00` alone (acceptable for some output types) + +```python +def encode_utxo_entry(c: Client, utxo_json: dict, network: Network) -> bytes: + try: + if utxo_json.get("type") == "Transfer": + value = utxo_json["value"] + if value.get("type") == "Coin": + encoded = c.encode_output_transfer( + Amount(atoms=value["amount"]["atoms"]), + value["destination"], + network, + ) + return b"\x01" + encoded + except (KeyError, TypeError, ValueError): + pass + return b"\x00" + + +all_utxo_bytes = b"" +for u in utxos: + all_utxo_bytes += encode_utxo_entry(c, u.output, Network.MAINNET) +``` + +The order of these entries must match the input order exactly — witness `i` is +validated against entry `i`. + +--- + +## Step 7: Sign each input + +Call `encode_witness` once per input. Concatenate results. + +```python +from mintlayer.wasm import SignatureHashType, TxAdditionalInfo + +witness_bytes = b"" +for i in range(len(utxos)): + w = c.encode_witness( + SignatureHashType.SIGHASH_ALL, + spend_key, + from_addr, + tx, + all_utxo_bytes, + i, # input index + TxAdditionalInfo(), # empty for standard transfers + 0, # block height (0 when no timelock constraint) + Network.MAINNET, + ) + witness_bytes += w +``` + +--- + +## Step 8: Assemble and submit + +```python +signed_tx = c.encode_signed_transaction(tx, witness_bytes) +signed_hex = signed_tx.hex() + +# Submit via the indexer (requires --enable-post-routes) +submitted_tx_id = idx.submit_transaction(signed_hex) +print(f"submitted: {submitted_tx_id}") + +# Alternative: broadcast via the node daemon +# node_client.p2p_submit_transaction(signed_hex, TrustPolicy.UNTRUSTED) +``` + +See [indexer.md](indexer.md) for the submit route requirements and +[node.md](node.md) for the P2P alternative. + +--- + +## Fee estimation + +Compute the fee before constructing outputs so you can deduct it from the +change: + +```python +# Collect destination addresses (one per input, in input order) +dest_addresses = [from_addr] * len(utxos) + +estimated_size = c.estimate_transaction_size( + encoded_inputs, dest_addresses, all_outputs, Network.MAINNET +) + +# get_fee_rate returns atoms per KB for the top 1 MB of the mempool +fee_rate = int(idx.get_fee_rate(1)) + +fee = estimated_size * fee_rate // 1000 + +# Subtract fee from the amount going to the recipient or from the change output. +``` + +--- + +## Lock-then-transfer outputs + +To send coins that cannot be spent for a period of time: + +```python +# Unlock after 1000 blocks +lock = c.encode_lock_for_block_count(1000) + +output = c.encode_output_lock_then_transfer( + Amount(atoms="100000000000"), + "mtc1qrecipient...", + lock, + Network.MAINNET, +) +``` + +--- + +## Token transfers + +Sending fungible tokens uses the same flow, with a different output encoder: + +```python +token_output = c.encode_output_token_transfer( + Amount(atoms="1000"), # token amount in smallest units + "mtc1qrecipient...", + "ttml1tokenid...", + Network.MAINNET, +) +``` + +Note that a token transfer transaction must also include a coin output (or +coin inputs) to cover the network fee. + +--- + +## Related + +- [wasm.md](wasm.md) — full WASM client reference +- [staking.md](staking.md) — manual delegation/pool transactions +- [tokens.md](tokens.md) — manual token issuance/minting +- [wallet.md](wallet.md) — let the wallet daemon do all of this for you diff --git a/docs/wallet.md b/docs/wallet.md new file mode 100644 index 0000000..d4f9dbc --- /dev/null +++ b/docs/wallet.md @@ -0,0 +1,619 @@ +# Wallet client + +The `mintlayer.wallet` module is a JSON-RPC 2.0 client for the Mintlayer wallet +daemon (`wallet-rpc-daemon`). The daemon manages key storage, address +derivation, signing, and broadcasting. + +```python +from mintlayer.wallet import Client + +c = Client( + "http://127.0.0.1:3034", + username="user", # optional; Basic Auth applied only when set + password="pass", # optional + timeout=30.0, # optional, seconds (default 30.0) + session=None, # optional requests.Session (client owns it otherwise) +) +``` + +**Default ports:** 3034 (mainnet), 13034 (testnet). + +Errors returned by the daemon raise `RPCError`; transport/decode failures raise +`JSONRPCError`: + +```python +from mintlayer.wallet import RPCError, JSONRPCError + +try: + balance = c.get_balance(0) +except RPCError as e: + print(e.code, e.message) +except JSONRPCError as e: + ... +``` + +The client is safe for concurrent use from multiple threads and supports the +context-manager protocol (`with Client(...) as c: ...`). + +> **Security:** the daemon has no transport encryption. If it listens beyond +> localhost, put it behind an HTTPS reverse proxy or an SSH tunnel; only talk +> to `https://…` endpoints (or plain `http://127.0.0.1`/localhost) — never to a +> bare `http://` host over a network. Mnemonic and passphrase values are +> **redacted from `repr()`**: `CreateWalletParams`, `RecoverWalletParams` and +> the returned `MnemonicResult` print `` instead of the secret, so +> logging a params object never leaks the seed phrase. + +--- + +## Wallet lifecycle + +Typical flow: **create or recover → open → sync → use**. + +```python +from mintlayer.wallet import Client, CreateWalletParams + +c = Client("http://127.0.0.1:3034") + +# 1. Create a wallet file (a fresh 24-word BIP-39 phrase is generated +# when params.mnemonic is None). +result = c.create_wallet(CreateWalletParams( + path="/path/to/wallet.dat", + store_seed_phrase=False, # don't persist the phrase to disk +)) +if result.mnemonic: + print(result.mnemonic.content.mnemonic) # store it securely NOW + +# 2. (next session) Open the wallet. Empty password → sent as JSON null. +c.open_wallet("/path/to/wallet.dat", password="") + +# 3. Sync to the chain tip. +c.sync_wallet() + +# 4. ... accounts, addresses, sends ... + +c.close_wallet() +``` + +### `create_wallet` + +```python +def create_wallet(self, params: CreateWalletParams) -> CreateWalletResult: ... +``` + +Creates a new wallet file. If `mnemonic` is `None`, the daemon generates a +fresh 24-word BIP-39 phrase. + +```python +@dataclass(frozen=True) +class CreateWalletParams: + path: str + store_seed_phrase: bool + mnemonic: str | None = None + passphrase: str | None = None + hardware_wallet: str | None = None + +@dataclass(frozen=True) +class CreateWalletResult: + mnemonic: MnemonicResult | None = None +``` + +When `store_seed_phrase` is `False`, the mnemonic is returned in +`CreateWalletResult.mnemonic` and not persisted to disk. Store it securely. +Optional pointer fields are always sent, serialising as JSON `null` when unset +(wire-fidelity with the Go structs). + +### `recover_wallet` + +```python +def recover_wallet(self, params: RecoverWalletParams) -> None: ... +``` + +Recreates a wallet from an existing mnemonic (`RecoverWalletParams` has the +same fields as `CreateWalletParams` but `mnemonic` is required). The daemon +will rescan the chain to recover the balance. + +### `open_wallet` + +```python +def open_wallet(self, path: str, password: str = "") -> None: ... +``` + +Opens an existing wallet file. An empty `password` is sent as JSON `null` +(unencrypted wallets). + +### `close_wallet` + +```python +def close_wallet(self) -> None: ... +``` + +Closes the currently open wallet. + +### `get_wallet_info` + +```python +def get_wallet_info(self) -> WalletInfo: ... +``` + +Returns wallet metadata (`wallet_id`, `account_names`, `extra_info` — a +`WalletExtraInfo` carrying the software/hardware wallet type in its `type` +field). + +### `sync_wallet` + +```python +def sync_wallet(self) -> None: ... +``` + +Syncs the wallet to the current chain tip. + +### `rescan_wallet` + +```python +def rescan_wallet(self) -> None: ... +``` + +Rescans the entire chain from genesis. Use this after importing a wallet or +when balances appear incorrect. + +### `best_block` + +```python +def best_block(self) -> BestBlock: ... +``` + +Returns the block (`height`, `id`) the wallet is currently synced to. + +--- + +## Accounts + +### `create_account` + +```python +def create_account(self, name: str) -> AccountInfo: ... +``` + +Creates a new BIP-44 account within the wallet. Returns the account index +(`AccountInfo(account, name)`). + +### `rename_account` + +```python +def rename_account(self, account: int, name: str = "") -> None: ... +``` + +Renames an existing account. An empty `name` is sent as JSON `null`, which +removes the name. + +--- + +## Balances and addresses + +### `get_balance` + +```python +def get_balance(self, account: int) -> Balance: ... +``` + +Returns the confirmed coin and token balances for an account (the request pins +`utxo_states` to `["Confirmed"]`). + +```python +@dataclass(frozen=True) +class Balance: + coins: Amount + tokens: dict[str, Amount] # keyed by token ID +``` + +### `new_address` + +```python +def new_address(self, account: int) -> str: ... +``` + +Derives a fresh receiving address and marks it as used. + +### `show_receive_addresses` + +```python +def show_receive_addresses(self, account: int) -> list[AddressWithUsage]: ... +``` + +Lists all receiving addresses that have been derived for an account, with +their usage status and coin balance +(`AddressWithUsage(address, used, coins)`). Change addresses are excluded. + +### `reveal_public_key` + +```python +def reveal_public_key(self, account: int, address: str) -> str: ... +``` + +Returns the hex-encoded public key for an address controlled by the wallet. + +--- + +## Key encryption + +### `encrypt_private_keys` + +```python +def encrypt_private_keys(self, password: str) -> None: ... +``` + +Encrypts the wallet's private keys with a password. + +### `unlock_private_keys` + +```python +def unlock_private_keys(self, password: str) -> None: ... +``` + +Unlocks an encrypted wallet for signing. The keys remain unlocked until +`lock_private_keys` is called or the daemon restarts. + +### `lock_private_keys` + +```python +def lock_private_keys(self) -> None: ... +``` + +Locks the private keys without closing the wallet. + +--- + +## Transactions + +### `address_send` + +```python +def address_send(self, params: SendParams) -> SendResult: ... +``` + +Sends coins to an address. The wallet selects UTXOs, computes fees, and +broadcasts. + +```python +@dataclass(frozen=True) +class SendParams: + account: int + address: str + amount: Amount + selected_utxos: list[Outpoint] | None = None + options: TxOptions = field(default_factory=TxOptions) + +@dataclass(frozen=True) +class SendResult: + tx_id: str + fees: FeesBreakdown + broadcasted: bool +``` + +**Wire rules** (all params dataclasses serialise via `to_json()`): + +- `Amount(atoms="...", decimal="...")` omits empty fields; at least one must be + set when sending. +- `selected_utxos` is `omitempty`: `None` **or an empty list** is omitted from + the wire. +- `options` always serialises both keys (`null` when unset). +- Optional `str | None` fields (e.g. `htlc_secret`, `output_address`) always + serialise, as JSON `null` when unset. + +```python +from mintlayer.wallet import Amount, SendParams, TxOptions + +result = c.address_send(SendParams( + account=0, + address="mtc1q...", + amount=Amount(atoms="100000000000"), # 1 ML + options=TxOptions(in_top_x_mb=1), # high fee priority +)) +print(result.tx_id, result.fees.coins.atoms, result.broadcasted) +``` + +Set `options.broadcast_to_mempool=False` to build and sign without +broadcasting; the transaction is still returned via the wallet history. + +### `token_send` + +```python +def token_send(self, params: TokenSendParams) -> SendResult: ... +``` + +Sends tokens from the account to an address +(`TokenSendParams(account, token_id, address, amount, options)`). + +### `sweep_spendable` + +```python +def sweep_spendable(self, params: SweepParams) -> SendResult: ... +``` + +Sweeps all spendable funds to a destination. Set `all=True` to sweep the +entire account; set `from_addresses` to sweep specific addresses only +(`SweepParams(account, destination_address, from_addresses, all, options)`). + +### `spend_utxo` + +```python +def spend_utxo(self, params: UTXOSpendParams) -> SendResult: ... +``` + +Spends a specific UTXO, optionally providing an HTLC secret +(`UTXOSpendParams(account, utxo: Outpoint, output_address, htlc_secret, +options)`). + +### `compose_transaction` + +```python +def compose_transaction(self, params: ComposeParams) -> ComposedTx: ... +``` + +Composes an unsigned transaction from explicit inputs and outputs. Returns a +hex-encoded `PartiallySignedTransaction` (`ComposedTx(hex, fees)`). Use this +for advanced flows where you construct outputs manually. + +```python +@dataclass(frozen=True) +class ComposeParams: + inputs: list[Outpoint] = field(default_factory=list) + outputs: list[Any] = field(default_factory=list) # raw output objects + htlc_secrets: Any = None + only_transaction: bool = False +``` + +### `sign_raw_transaction` + +```python +def sign_raw_transaction(self, account: int, raw_tx: str) -> SignedTx: ... +``` + +Signs a hex-encoded transaction using keys from the given account +(`SignedTx(hex, current_signatures)`). Used in cold-wallet flows where +composition and signing happen separately. + +```python +composed = c.compose_transaction(ComposeParams(...)) +signed = c.sign_raw_transaction(0, composed.hex) +submit = c.submit_transaction(signed.hex) +``` + +### `inspect_transaction` + +```python +def inspect_transaction(self, tx_hex: str) -> TxInspection: ... +``` + +Inspects a hex-encoded transaction without broadcasting. Returns input count, +signature count, and fees (`TxInspection(stats: TxStats, fees: +FeesBreakdown | None)`). + +### `submit_transaction` + +```python +def submit_transaction(self, tx_hex: str, do_not_store: bool = False) -> SubmitResult: ... +``` + +Broadcasts a signed transaction. Set `do_not_store=True` to broadcast without +saving the transaction in the wallet history. + +Quirk: the daemon route hardcodes the trust policy to `"Trusted"` — the client +always sends `{"trust_policy": "Trusted"}`. + +### `list_transactions_by_address` + +```python +def list_transactions_by_address( + self, account: int, address: str | None, limit: int +) -> list[WalletTx]: ... +``` + +Lists confirmed transactions for an account. Pass `address=None` to list +across all addresses (sent as JSON `null`). The most recent transactions are +returned first (`WalletTx(id, height, timestamp)`). + +### `list_pending_transactions` + +```python +def list_pending_transactions(self, account: int) -> list[str]: ... +``` + +Lists transaction IDs that are in the mempool but not yet confirmed. + +### `get_transaction` + +```python +def get_transaction(self, account: int, tx_id: str) -> Any: ... +``` + +Returns a transaction as raw decoded JSON. + +### `abandon_transaction` + +```python +def abandon_transaction(self, account: int, tx_id: str) -> None: ... +``` + +Removes an unconfirmed transaction from the wallet. The transaction will no +longer be rebroadcast. The UTXOs it spent are returned to the available +balance. + +### `deposit_data` + +```python +def deposit_data(self, account: int, data_hex: str) -> SendResult: ... +``` + +Embeds arbitrary hex-encoded data in a transaction output (`DataDeposit` +output type). + +--- + +## Transaction options + +Most transaction methods embed a `TxOptions` in their params: + +```python +@dataclass(frozen=True) +class TxOptions: + in_top_x_mb: int | None = None + broadcast_to_mempool: bool | None = None +``` + +`in_top_x_mb` controls fee priority. Setting it to `1` targets the top 1 MB of +the mempool (highest priority). The default (`None`) lets the daemon choose. + +Setting `broadcast_to_mempool=False` builds and signs the transaction without +broadcasting it. The transaction hex is still returned in the result. + +Unlike the optional params fields, `TxOptions` **always** serialises both keys +on the wire (`null` when unset) — this matches the Go struct exactly. + +--- + +## Staking + +See [staking.md](staking.md) for a complete guide. Quick reference: + +| Method | Description | +|--------|-------------| +| `create_stake_pool` | Create and fund a new staking pool | +| `decommission_stake_pool` | Wind down a pool and recover the pledge | +| `list_owned_pools` | List pools owned by an account | +| `get_pool_balance` | Get pool balance | +| `start_staking` | Start block production | +| `stop_staking` | Stop block production | +| `get_staking_status` | Check whether staking is active | +| `create_delegation` | Create a delegation to a pool | +| `delegate_staking` | Send coins into a delegation | +| `withdraw_from_delegation` | Withdraw from a delegation | +| `list_delegations` | List delegations owned by an account | + +--- + +## Tokens and NFTs + +See [tokens.md](tokens.md) for a complete guide. Quick reference: + +| Method | Description | +|--------|-------------| +| `issue_token` | Issue a new fungible token | +| `issue_nft` | Issue a new NFT | +| `mint_tokens` | Mint additional supply | +| `unmint_tokens` | Remove supply (return to unminted state) | +| `lock_token_supply` | Permanently lock supply | +| `freeze_token` | Freeze all transfers | +| `unfreeze_token` | Unfreeze (if allowed) | +| `change_token_authority` | Transfer the authority key | +| `send_token` | Send tokens to an address (alias of `token_send`) | + +--- + +## DEX orders + +### `create_order` + +```python +def create_order(self, params: CreateOrderParams) -> OrderCreated: ... +``` + +Creates a new DEX order (`OrderCreated(order_id, tx_id, broadcasted)`). + +```python +@dataclass(frozen=True) +class CreateOrderParams: + account: int + ask: OutputValue + give: OutputValue + conclude_address: str + options: TxOptions = field(default_factory=TxOptions) +``` + +The two sides of the order use `OutputValue`, which has a fully custom wire +encoding. Construct with the helper constructors: + +```python +from mintlayer.wallet import CreateOrderParams, OutputValue, coin_filter, token_filter + +params = CreateOrderParams( + account=0, + ask=OutputValue.coins(atoms="500000000000"), # asking 5 ML + give=OutputValue.tokens("ttml1...", atoms="1000"), # giving 1000 tokens + conclude_address="mtc1q...", +) +created = c.create_order(params) +``` + +### `conclude_order` + +```python +def conclude_order(self, params: ConcludeOrderParams) -> SendResult: ... +``` + +Concludes an order owned by the account +(`ConcludeOrderParams(account, order_id, output_address=None, options)`). + +### `fill_order` + +```python +def fill_order(self, params: FillOrderParams) -> SendResult: ... +``` + +Fills (partially or fully) an existing order +(`FillOrderParams(account, order_id, fill_amount_in_ask_currency, +output_address=None, options)`). + +### `freeze_order` + +```python +def freeze_order(self, params: FreezeOrderParams) -> SendResult: ... +``` + +Freezes an order (orders V1 fork only) +(`FreezeOrderParams(account, order_id, options)`). + +### `list_own_orders` + +```python +def list_own_orders(self, account: int) -> list[OwnOrder]: ... +``` + +Lists the account's own orders (`OwnOrder(order_id, initially_asked, +initially_given, existing_order_data, is_marked_as_frozen_in_wallet, +is_marked_as_concluded_in_wallet)`). + +### `list_all_active_orders` + +```python +def list_all_active_orders(self, params: ListOrdersParams) -> list[ActiveOrder]: ... +``` + +Lists all active orders, optionally filtered by currency pair — `None` filters +match any (`ActiveOrder(order_id, initially_asked, initially_given, +ask_balance, give_balance, is_own)`). + +```python +from mintlayer.wallet import ListOrdersParams, coin_filter, token_filter + +# module-level helpers (same as CurrencyFilter.coin_filter() / .token_filter(id)) +orders = c.list_all_active_orders(ListOrdersParams( + account=0, + ask_currency=coin_filter(), + give_currency=token_filter("ttml1..."), +)) +``` + +`CurrencyFilter` (wire: `{"type":"Coin"}` with no content key, or +`{"type":"Token","content":""}`) and `OutputValue` raise `ValueError` +before any HTTP request is sent when constructed invalidly (missing token id / +missing amount). + +--- + +## Related + +- [transactions.md](transactions.md) — manual transaction building (no daemon) +- [staking.md](staking.md) — staking pools and delegations +- [tokens.md](tokens.md) — token and NFT lifecycle +- [node.md](node.md) — node daemon client diff --git a/docs/wasm.md b/docs/wasm.md new file mode 100644 index 0000000..846d7d5 --- /dev/null +++ b/docs/wasm.md @@ -0,0 +1,981 @@ +# WASM client + +The `mintlayer.wasm` module exposes cryptographic primitives and binary +transaction encoding via an embedded WebAssembly module (instantiated with +wasmtime, sha256-pinned at import). + +```python +from mintlayer.wasm import Client + +c = Client() # instantiation compiles the WASM binary: ~400 ms +... +c.close() # or use `with Client() as c:` +``` + +Call it once per process and reuse it. The `Client` is **safe for concurrent +use from multiple threads** — every public method serialises access to the +single WASM instance with a lock. + +All errors raise `WasmError` with a message prefixed `mintlayer: `: + +```python +from mintlayer.wasm import WasmError + +try: + addr = c.pubkey_to_pubkeyhash_address(pubkey, Network.MAINNET) +except WasmError as e: + print(e) # e.g. "mintlayer: invalid public key" +``` + +> **Key material in memory:** result buffers carrying private keys, derived +> keys and signatures are zeroed before being released, but input buffers and +> WASM-side intermediate copies of secrets persist in WASM linear memory until +> the allocator reuses them (inherited from the wasm-bindgen design; the host +> cannot reach them). Treat the process memory of a long-lived `Client` as +> sensitive. + +--- + +## Amounts + +```python +from mintlayer.wasm import Amount + +one = Amount.from_atoms("100000000000") # 1 ML +zero = Amount.zero() +print(one.atoms) # "100000000000" +print(str(one)) # "100000000000" +``` + +All amounts are decimal strings of atoms. **1 ML = 100,000,000,000 atoms** +(11 decimal places). + +--- + +## Networks and enums + +Enums are `enum.IntEnum` subclasses passed to WASM as their integer +discriminant: + +```python +from mintlayer.wasm import ( + Network, # MAINNET=0, TESTNET=1, REGTEST=2, SIGNET=3 + SignatureHashType, # SIGHASH_ALL=0, SIGHASH_NONE=1, SIGHASH_SINGLE=2, SIGHASH_ANYONECANPAY=3 + SourceId, # SOURCE_TRANSACTION=0, SOURCE_BLOCK_REWARD=1 + TotalSupply, # LOCKABLE=0, UNLIMITED=1, FIXED=2 + FreezableToken, # NO=0, YES=1 + TokenUnfreezable, # NO=0, YES=1 +) +``` + +Module-level aliases (`MAINNET`, `TESTNET`, `REGTEST`, `SIGNET`, +`SIGHASH_ALL`, …, `SOURCE_TRANSACTION`, `SOURCE_BLOCK_REWARD`) match the Go +constant names; `mintlayer.Mainnet` in Go is `mintlayer.MAINNET` (or +`Network.MAINNET`) in Python. + +Pass the appropriate constant to any function that generates addresses or +encodes transactions. + +--- + +## Key derivation + +### `make_private_key` + +```python +def make_private_key(self) -> bytes: ... +``` + +Generates a random private key. + +### `make_default_account_privkey` + +```python +def make_default_account_privkey(self, mnemonic: str, network: Network) -> bytes: ... +``` + +Derives the default account extended private key from a BIP-39 mnemonic. The +derivation path is `m/44'/coin_type'/0'` where `coin_type` depends on the +network. + +### `public_key_from_private_key` + +```python +def public_key_from_private_key(self, privkey: bytes) -> bytes: ... +``` + +Derives the compressed public key from a private key. + +### `extended_public_key_from_extended_private_key` + +```python +def extended_public_key_from_extended_private_key(self, privkey: bytes) -> bytes: ... +``` + +Derives the extended public key from an extended private key. Useful for +watch-only wallets. + +### `make_receiving_address` + +```python +def make_receiving_address(self, account_privkey: bytes, key_index: int) -> bytes: ... +``` + +Derives the private key for receiving address `key_index` within an account. + +### `make_change_address` + +```python +def make_change_address(self, account_privkey: bytes, key_index: int) -> bytes: ... +``` + +Derives the private key for change address `key_index` within an account. + +### `make_receiving_address_public_key` + +```python +def make_receiving_address_public_key(self, account_pubkey: bytes, key_index: int) -> bytes: ... +``` + +Derives the public key for receiving address `key_index` from an extended +public key. Does not require the private key. + +### `make_change_address_public_key` + +```python +def make_change_address_public_key(self, account_pubkey: bytes, key_index: int) -> bytes: ... +``` + +Derives the public key for change address `key_index` from an extended public +key. + +**Example: derive a receiving address from a mnemonic** + +```python +mnemonic = "abandon abandon abandon ... about" + +account_key = c.make_default_account_privkey(mnemonic, Network.MAINNET) +recv_key = c.make_receiving_address(account_key, 0) +pub_key = c.public_key_from_private_key(recv_key) +addr = c.pubkey_to_pubkeyhash_address(pub_key, Network.MAINNET) +``` + +--- + +## Addresses + +### `encode_destination` + +```python +def encode_destination(self, address: str, network: Network) -> bytes: ... +``` + +Encodes a bech32m address into its binary representation for use in +transaction outputs. + +### `pubkey_to_pubkeyhash_address` + +```python +def pubkey_to_pubkeyhash_address(self, pubkey: bytes, network: Network) -> str: ... +``` + +Derives a P2PKH bech32m address from a compressed public key. + +### `encode_multisig_challenge` + +```python +def encode_multisig_challenge( + self, pubkeys: bytes, min_required_signatures: int, network: Network +) -> bytes: ... +``` + +Encodes a multisig challenge (script) from a concatenation of compressed +public keys. + +### `multisig_challenge_to_address` + +```python +def multisig_challenge_to_address(self, challenge: bytes, network: Network) -> str: ... +``` + +Derives a bech32m address from a multisig challenge. + +--- + +## IDs + +These functions derive chain-assigned IDs from transaction inputs. The ID is +deterministic: the same inputs always produce the same ID. + +### `get_pool_id` + +```python +def get_pool_id(self, inputs: bytes, network: Network) -> str: ... +``` + +Derives the pool ID that will be assigned to a `CreateStakePool` transaction. + +### `get_token_id` + +```python +def get_token_id(self, inputs: bytes, current_block_height: int, network: Network) -> str: ... +``` + +Derives the token ID that will be assigned to an `IssueFungibleToken` (or NFT) +transaction. `current_block_height` selects the ID scheme for the active +network upgrade. + +### `get_delegation_id` + +```python +def get_delegation_id(self, inputs: bytes, network: Network) -> str: ... +``` + +Derives the delegation ID that will be assigned to a `CreateDelegationId` +transaction. + +### `get_order_id` + +```python +def get_order_id(self, inputs: bytes, network: Network) -> str: ... +``` + +Derives the order ID that will be assigned to a `CreateOrder` transaction. + +--- + +## Inputs + +Each input is a binary blob. Concatenate all input blobs to form the `inputs` +bytes passed to `encode_transaction`. + +### `encode_input_for_utxo` + +```python +def encode_input_for_utxo(self, outpoint_source_id: bytes, output_index: int) -> bytes: ... +``` + +Encodes a UTXO spending input. `outpoint_source_id` is the result of +`encode_outpoint_source_id`. + +### `encode_input_for_withdraw_from_delegation` + +```python +def encode_input_for_withdraw_from_delegation( + self, delegation_id: str, amount: Amount, nonce: int, network: Network +) -> bytes: ... +``` + +Encodes a delegation withdrawal input. `nonce` must match the current +`next_nonce` from the indexer's delegation record. + +### `encode_input_for_mint_tokens` + +```python +def encode_input_for_mint_tokens( + self, token_id: str, amount: Amount, nonce: int, network: Network +) -> bytes: ... +``` + +### `encode_input_for_unmint_tokens` + +```python +def encode_input_for_unmint_tokens(self, token_id: str, nonce: int, network: Network) -> bytes: ... +``` + +### `encode_input_for_lock_token_supply` + +```python +def encode_input_for_lock_token_supply(self, token_id: str, nonce: int, network: Network) -> bytes: ... +``` + +### `encode_input_for_freeze_token` + +```python +def encode_input_for_freeze_token( + self, token_id: str, is_token_unfreezable: TokenUnfreezable, nonce: int, network: Network +) -> bytes: ... +``` + +### `encode_input_for_unfreeze_token` + +```python +def encode_input_for_unfreeze_token(self, token_id: str, nonce: int, network: Network) -> bytes: ... +``` + +### `encode_input_for_change_token_authority` + +```python +def encode_input_for_change_token_authority( + self, token_id: str, new_authority: str, nonce: int, network: Network +) -> bytes: ... +``` + +### `encode_input_for_change_token_metadata_uri` + +```python +def encode_input_for_change_token_metadata_uri( + self, token_id: str, new_metadata_uri: str, nonce: int, network: Network +) -> bytes: ... +``` + +### `encode_input_for_conclude_order` + +```python +def encode_input_for_conclude_order( + self, order_id: str, nonce: int, current_block_height: int, network: Network +) -> bytes: ... +``` + +### `encode_input_for_fill_order` + +```python +def encode_input_for_fill_order( + self, + order_id: str, + fill_amount: Amount, + destination: str, + nonce: int, + current_block_height: int, + network: Network, +) -> bytes: ... +``` + +FillOrder inputs are not signed — use `encode_witness_no_signature`. + +### `encode_input_for_freeze_order` + +```python +def encode_input_for_freeze_order( + self, order_id: str, current_block_height: int, network: Network +) -> bytes: ... +``` + +Order freezing is available only after the orders V1 fork. + +--- + +## Outputs + +Each output is a binary blob. Concatenate all output blobs to form the +`outputs` bytes passed to `encode_transaction`. + +### `encode_output_transfer` + +```python +def encode_output_transfer(self, amount: Amount, address: str, network: Network) -> bytes: ... +``` + +Coin transfer to an address. This is the standard output type for sending ML. + +### `encode_output_token_transfer` + +```python +def encode_output_token_transfer( + self, amount: Amount, address: str, token_id: str, network: Network +) -> bytes: ... +``` + +Fungible token transfer to an address. + +### `encode_output_lock_then_transfer` + +```python +def encode_output_lock_then_transfer( + self, amount: Amount, address: str, lock: bytes, network: Network +) -> bytes: ... +``` + +Coin transfer with a timelock. The coins are sent to `address` but cannot be +spent until the lock expires. `lock` is the result of one of the +`encode_lock_*` functions. + +### `encode_output_token_lock_then_transfer` + +```python +def encode_output_token_lock_then_transfer( + self, amount: Amount, address: str, token_id: str, lock: bytes, network: Network +) -> bytes: ... +``` + +Token transfer with a timelock. + +### `encode_output_coin_burn` + +```python +def encode_output_coin_burn(self, amount: Amount) -> bytes: ... +``` + +Permanently destroys ML coins. + +### `encode_output_token_burn` + +```python +def encode_output_token_burn(self, amount: Amount, token_id: str, network: Network) -> bytes: ... +``` + +Permanently destroys fungible tokens. + +### `encode_output_create_delegation` + +```python +def encode_output_create_delegation( + self, pool_id: str, owner_address: str, network: Network +) -> bytes: ... +``` + +Creates a delegation for `owner_address` in `pool_id`. Use `get_delegation_id` +to predict the delegation ID before broadcasting. + +### `encode_output_delegate_staking` + +```python +def encode_output_delegate_staking( + self, amount: Amount, delegation_id: str, network: Network +) -> bytes: ... +``` + +Sends coins into an existing delegation. + +### `encode_output_create_stake_pool` + +```python +def encode_output_create_stake_pool( + self, pool_id: str, pool_data: bytes, network: Network +) -> bytes: ... +``` + +Creates a staking pool. `pool_data` is the result of `encode_stake_pool_data`. + +### `encode_output_produce_block_from_stake` + +```python +def encode_output_produce_block_from_stake( + self, pool_id: str, staker: str, network: Network +) -> bytes: ... +``` + +Reward output used in blocks produced by a pool. This UTXO is consumed when +decommissioning a pool (if the pool has staked at least once). Only relevant +for block producers. + +### `encode_output_data_deposit` + +```python +def encode_output_data_deposit(self, data: bytes) -> bytes: ... +``` + +Embeds arbitrary bytes on-chain. + +### `encode_output_htlc` + +```python +def encode_output_htlc( + self, + amount: Amount, + token_id: str | None, + secret_hash: str, + spend_address: str, + refund_address: str, + refund_timelock: bytes, + network: Network, +) -> bytes: ... +``` + +Hashed Time-Lock Contract output. Pass `None` for `token_id` to use coins. The +receiver can spend with the preimage; the sender can refund after the timelock +expires. + +### `encode_output_issue_fungible_token` + +```python +def encode_output_issue_fungible_token( + self, + authority: str, + token_ticker: str, + metadata_uri: str, + number_of_decimals: int, + total_supply: TotalSupply, + supply_amount: Amount | None, + is_token_freezable: FreezableToken, + current_block_height: int, + network: Network, +) -> bytes: ... +``` + +Issues a new fungible token. `supply_amount` is required only when +`total_supply` is `TotalSupply.FIXED` (pass `None` otherwise). + +### `encode_output_issue_nft` + +```python +def encode_output_issue_nft( + self, + token_id: str, + authority: str, + name: str, + ticker: str, + description: str, + media_hash: bytes, + creator: bytes | None, + media_uri: str | None, + icon_uri: str | None, + additional_metadata_uri: str | None, + current_block_height: int, + network: Network, +) -> bytes: ... +``` + +Issues a new NFT. `creator`, `media_uri`, `icon_uri` and +`additional_metadata_uri` may be `None`. The `token_id` is derived with +`get_token_id` (NFTs share the fungible-token ID scheme). + +### `encode_create_order_output` + +```python +def encode_create_order_output( + self, + ask_amount: Amount, + ask_token_id: str | None, + give_amount: Amount, + give_token_id: str | None, + conclude_address: str, + network: Network, +) -> bytes: ... +``` + +Creates a DEX order. Pass `None` for `ask_token_id` or `give_token_id` to use +the native coin. + +--- + +## Timelocks + +Timelocks are binary blobs passed to `encode_output_lock_then_transfer` and +`encode_output_token_lock_then_transfer`. + +```python +def encode_lock_for_block_count(self, block_count: int) -> bytes: ... +def encode_lock_for_seconds(self, seconds: int) -> bytes: ... +def encode_lock_until_height(self, block_height: int) -> bytes: ... +def encode_lock_until_time(self, timestamp_seconds: int) -> bytes: ... +``` + +| Function | Unlocks when | +|----------|-------------| +| `encode_lock_for_block_count(n)` | `n` blocks have been confirmed after the output | +| `encode_lock_for_seconds(s)` | `s` seconds have elapsed since the output was confirmed | +| `encode_lock_until_height(h)` | the chain tip reaches height `h` | +| `encode_lock_until_time(t)` | the median block time exceeds Unix timestamp `t` | + +--- + +## Transactions + +### `encode_outpoint_source_id` + +```python +def encode_outpoint_source_id(self, id_: bytes, source_id: SourceId) -> bytes: ... +``` + +Encodes an outpoint source. `id_` is the raw transaction or block hash +(hex-decoded); `source_id` is `SourceId.SOURCE_TRANSACTION` or +`SourceId.SOURCE_BLOCK_REWARD`. + +### `encode_transaction` + +```python +def encode_transaction(self, inputs: bytes, outputs: bytes, flags: int) -> bytes: ... +``` + +Encodes an unsigned transaction from concatenated input and output blobs. +`flags` should be `0` for standard transactions. + +### `get_transaction_id` + +```python +def get_transaction_id(self, transaction: bytes, strict_byte_size: bool) -> str: ... +``` + +Returns the hex transaction ID without broadcasting. Set +`strict_byte_size=True` to require the bytes to represent exactly one +Transaction object. + +### `estimate_transaction_size` + +```python +def estimate_transaction_size( + self, inputs: bytes, input_utxos_dests: list[str], outputs: bytes, network: Network +) -> int: ... +``` + +Estimates the byte size of the transaction after signing. +`input_utxos_dests` must contain one address string per input (the spending +destination of each UTXO), in input order. Use this to compute fees before +constructing the final output set — see [transactions.md](transactions.md). + +### `encode_signed_transaction` + +```python +def encode_signed_transaction(self, transaction: bytes, signatures: bytes) -> bytes: ... +``` + +Assembles a fully signed transaction from the unsigned transaction bytes and +the concatenated witness bytes. + +### `encode_partially_signed_transaction` + +```python +def encode_partially_signed_transaction( + self, + transaction: bytes, + signatures: bytes, + input_utxos: bytes, + input_destinations: bytes, + htlc_secrets: bytes, + additional_info: TxAdditionalInfo, + network: Network, +) -> bytes: ... +``` + +Creates a Partially Signed Transaction (PSBT)-style structure. Use this for +multi-party signing flows. + +### `decode_signed_transaction_to_js` + +```python +def decode_signed_transaction_to_js(self, transaction: bytes, network: Network) -> bytes: ... +``` + +Decodes a signed transaction to JSON (raw JSON bytes) for inspection. +`decode_partially_signed_transaction_to_js` does the same for partially signed +transactions. + +### `extract_htlc_secret` + +```python +def extract_htlc_secret( + self, + signed_tx: bytes, + strict_byte_size: bool, + htlc_outpoint_source_id: bytes, + htlc_output_index: int, +) -> bytes: ... +``` + +Extracts the HTLC preimage from a transaction that spends an HTLC output. Use +this to learn the secret after the counterparty reveals it on-chain. + +### `internal_verify_witness` + +```python +def internal_verify_witness( + self, + sighash_type: int, + input_owner_dest: str | None, + witness: bytes, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, +) -> None: ... +``` + +Verifies an input witness against the transaction (`input_owner_dest` may be +`None` where the destination is not required). Useful for testing signing +flows. + +--- + +## Signing + +### `encode_witness` + +```python +def encode_witness( + self, + sighash_type: SignatureHashType, + private_key: bytes, + input_owner_dest: str, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, +) -> bytes: ... +``` + +Signs one input and returns the witness bytes. Call once per input and +concatenate results. + +`input_owner_dest` is the bech32m address that owns the UTXO being spent. +`input_utxos` is a concatenation of per-input UTXO entries (see +[transactions.md](transactions.md) for the `0x00`/`0x01` prefix encoding). +`block_height` is the current block height (pass `0` for outputs without +time-lock constraints). + +Use `SignatureHashType.SIGHASH_ALL` for standard transactions. + +### `encode_witness_no_signature` + +```python +def encode_witness_no_signature(self) -> bytes: ... +``` + +Returns an empty witness. Required for `FillOrder` inputs, which do not need a +signature. + +### `encode_witness_htlc_spend` + +```python +def encode_witness_htlc_spend( + self, + sighash_type: SignatureHashType, + private_key: bytes, + input_owner_dest: str, + transaction: bytes, + input_utxos: bytes, + input_index: int, + secret: bytes, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, +) -> bytes: ... +``` + +Signs an HTLC spend input, embedding the preimage. + +### `encode_witness_htlc_refund_single_sig` + +```python +def encode_witness_htlc_refund_single_sig( + self, + sighash_type: SignatureHashType, + private_key: bytes, + input_owner_dest: str, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, +) -> bytes: ... +``` + +Signs an HTLC refund for a single-signature refund address. + +### `encode_witness_htlc_refund_multisig` + +```python +def encode_witness_htlc_refund_multisig( + self, + sighash_type: SignatureHashType, + private_key: bytes, + key_index: int, + input_witness: bytes, + multisig_challenge: bytes, + transaction: bytes, + input_utxos: bytes, + input_index: int, + additional_info: TxAdditionalInfo, + block_height: int, + network: Network, +) -> bytes: ... +``` + +Adds a partial signature to an HTLC refund witness for a multisig refund +address. `key_index` is the index of `private_key` within the multisig +challenge; `input_witness` may be empty (first signer) or a previous partial +result. + +### `sign_challenge` + +```python +def sign_challenge(self, private_key: bytes, message: bytes) -> bytes: ... +``` + +Signs an arbitrary message for use in challenge-response authentication. + +### `verify_challenge` + +```python +def verify_challenge( + self, address: str, network: Network, signed_challenge: bytes, message: bytes +) -> bool: ... +``` + +Verifies a challenge signature against a bech32m (pubkeyhash) address. + +### `sign_message_for_spending` + +```python +def sign_message_for_spending(self, private_key: bytes, message: bytes) -> bytes: ... +``` + +Signs a spending message (used in transaction intents). + +### `verify_signature_for_spending` + +```python +def verify_signature_for_spending( + self, public_key: bytes, signature: bytes, message: bytes +) -> bool: ... +``` + +Verifies a spending message signature against a public key. + +--- + +## Additional info for signing + +Some transaction types (pool operations, orders) require extra data not +present in the UTXO itself: + +```python +from mintlayer.wasm import Amount, OrderBalance, OrderInfo, PoolInfo, SimpleCurrencyAmount, TxAdditionalInfo + +info = TxAdditionalInfo( + pool_info={"mpool1...": PoolInfo(staker_balance=Amount.from_atoms("40000000000000"))}, + order_info={ + "mordr1...": OrderInfo( + initially_asked=SimpleCurrencyAmount.coins("500000000000"), + initially_given=SimpleCurrencyAmount.tokens("1000", "ttml1..."), + ask_balance=OrderBalance(atoms="500000000000"), + give_balance=OrderBalance(atoms="800", token_id="ttml1..."), + ) + }, +) +``` + +- Maps are keyed by the bech32m pool/order ID. Pass an empty `TxAdditionalInfo()` + for standard coin transfers. +- `SimpleCurrencyAmount` serialises as the externally tagged + `CurrencyAmount` enum — `{"coins":{"atoms":...}}` or + `{"tokens":{"amount":{"atoms":...},"token_id":...}}` — built with the + `.coins(atoms)` / `.tokens(atoms, token_id)` constructors. +- `OrderBalance` uses the redundant-but-required wire shape + `{"atoms":...,"amount":{"atoms":...},"token_id":null|"..."}`. +- The WASM module rejects `null` maps, so the `TxAdditionalInfo` defaults are + empty dicts rather than `None`. + +--- + +## Staking + +### `encode_stake_pool_data` + +```python +def encode_stake_pool_data( + self, + value: Amount, + staker: str, + vrf_public_key: str, + decommission_key: str, + margin_ratio_per_thousand: int, + cost_per_block: Amount, + network: Network, +) -> bytes: ... +``` + +Encodes the pool parameters for use in `encode_output_create_stake_pool`. +`staker` is the bech32m address allowed to produce blocks; `vrf_public_key` is +the bech32m VRF public key; `decommission_key` is the address that can +decommission the pool; `margin_ratio_per_thousand` is the staker's cut per +thousand (e.g. `100` = 10%); `cost_per_block` is a flat amount deducted from +rewards before the margin split. + +### `effective_pool_balance` + +```python +def effective_pool_balance( + self, network: Network, pledge_amount: Amount, pool_balance: Amount +) -> Amount: ... +``` + +Computes the effective balance used in the slot lottery, which applies +diminishing returns to large pools. + +### `staking_pool_spend_maturity_block_count` + +```python +def staking_pool_spend_maturity_block_count( + self, current_block_height: int, network: Network +) -> int: ... +``` + +Returns the number of blocks a pool output must mature before it can be spent +(after decommission). + +--- + +## Fees + +These functions return the minimum protocol fee for various operations at a +given block height: + +```python +def fungible_token_issuance_fee(self, current_block_height: int, network: Network) -> Amount: ... +def nft_issuance_fee(self, current_block_height: int, network: Network) -> Amount: ... +def data_deposit_fee(self, current_block_height: int, network: Network) -> Amount: ... +def token_supply_change_fee(self, current_block_height: int, network: Network) -> Amount: ... +def token_freeze_fee(self, current_block_height: int, network: Network) -> Amount: ... +def token_change_authority_fee(self, current_block_height: int, network: Network) -> Amount: ... +``` + +Add these fees to the transaction outputs when building the relevant +transaction types manually — see [tokens.md](tokens.md). + +--- + +## Transaction intents + +Transaction intents provide a signed declaration of what a transaction is +intended to do, independent of the transaction bytes themselves. + +### `make_transaction_intent_message_to_sign` + +```python +def make_transaction_intent_message_to_sign(self, intent: str, transaction_id: str) -> bytes: ... +``` + +Creates the message bytes that should be signed to bind an intent string to a +transaction ID (`transaction_id` is the hex ID from `get_transaction_id`). + +### `encode_signed_transaction_intent` + +```python +def encode_signed_transaction_intent( + self, signed_message: bytes, signatures: list[bytes] +) -> bytes: ... +``` + +Encodes a signed intent along with its signatures (one raw signature per +transaction input, each produced by `sign_challenge`). + +### `verify_transaction_intent` + +```python +def verify_transaction_intent( + self, + expected_signed_message: bytes, + encoded_signed_intent: bytes, + input_destinations: list[str], + network: Network, +) -> None: ... +``` + +Verifies that a signed intent matches the expected message and that the +signatures are valid for the given input destinations (one bech32m address per +transaction input). + +--- + +## Related + +- [transactions.md](transactions.md) — end-to-end manual transaction flow +- [staking.md](staking.md) — staking via wallet daemon and manual encoding +- [tokens.md](tokens.md) — token lifecycle via wallet daemon and manual encoding +- [wallet.md](wallet.md) — the wallet daemon client (does the encoding for you) diff --git a/examples/send_coins.py b/examples/send_coins.py index 09f61d2..6be2447 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -21,6 +21,9 @@ --amount 100000000000 \ --indexer http://127.0.0.1:3000 +NOTE: Secrets passed via command-line arguments are visible in +shell history and `ps` output; use stdin/env vars in production. + NOTE: This example sends ALL spendable UTXOs to the recipient with no change output. It is intentionally minimal. Production code should select UTXOs, compute fees, add a change output, and handle errors more robustly. diff --git a/mintlayer/node/chainstate.py b/mintlayer/node/chainstate.py index c3fbdcb..258de90 100644 --- a/mintlayer/node/chainstate.py +++ b/mintlayer/node/chainstate.py @@ -5,14 +5,11 @@ from __future__ import annotations -from typing import TYPE_CHECKING, Any +from typing import Any from ._core import _NodeCore from .types import Amount, ChainstateInfo, Currency, OrderInfo, Outpoint, TokenInfo -if TYPE_CHECKING: - pass - class ChainstateMixin(_NodeCore): def chainstate_info(self) -> ChainstateInfo: diff --git a/mintlayer/node/mempool.py b/mintlayer/node/mempool.py index c6360af..b30bec2 100644 --- a/mintlayer/node/mempool.py +++ b/mintlayer/node/mempool.py @@ -2,15 +2,10 @@ from __future__ import annotations -from typing import TYPE_CHECKING - from ._core import _NodeCore from .types import FeeRate, FeeRatePoint, MempoolTx, TrustPolicy from .types import policy_value as _policy_value -if TYPE_CHECKING: - pass - class MempoolMixin(_NodeCore): def contains_tx(self, tx_id: str) -> bool: diff --git a/mintlayer/node/p2p.py b/mintlayer/node/p2p.py index 7e9c9b3..2906c17 100644 --- a/mintlayer/node/p2p.py +++ b/mintlayer/node/p2p.py @@ -3,15 +3,11 @@ from __future__ import annotations from datetime import timedelta -from typing import TYPE_CHECKING from ._core import _NodeCore from .types import BannedPeer, PeerInfo, TrustPolicy from .types import policy_value as _policy_value -if TYPE_CHECKING: - pass - def _duration_to_wire(duration: timedelta) -> list[int]: """Split a duration into the daemon's [seconds, nanoseconds] wire form.""" diff --git a/mintlayer/wallet/types.py b/mintlayer/wallet/types.py index 0f3ae91..01a2d63 100644 --- a/mintlayer/wallet/types.py +++ b/mintlayer/wallet/types.py @@ -260,6 +260,9 @@ def from_json(cls, data: dict) -> WalletTx: class MnemonicContent: mnemonic: str + def __repr__(self) -> str: # pragma: no cover - trivial + return "MnemonicContent(mnemonic='')" + @dataclass(frozen=True) class MnemonicResult: @@ -302,6 +305,15 @@ def to_json(self) -> dict: "hardware_wallet": self.hardware_wallet, } + def __repr__(self) -> str: + return ( + f"CreateWalletParams(path={self.path!r}, " + f"store_seed_phrase={self.store_seed_phrase!r}, " + f"mnemonic={'' if self.mnemonic else None}, " + f"passphrase={'' if self.passphrase else None}, " + f"hardware_wallet={self.hardware_wallet!r})" + ) + @dataclass(frozen=True) class RecoverWalletParams: @@ -320,6 +332,15 @@ def to_json(self) -> dict: "hardware_wallet": self.hardware_wallet, } + def __repr__(self) -> str: + return ( + f"RecoverWalletParams(path={self.path!r}, " + f"store_seed_phrase={self.store_seed_phrase!r}, " + f"mnemonic='', " + f"passphrase={'' if self.passphrase else None}, " + f"hardware_wallet={self.hardware_wallet!r})" + ) + @dataclass(frozen=True) class WalletExtraInfo: diff --git a/tests/test_wallet_redaction.py b/tests/test_wallet_redaction.py new file mode 100644 index 0000000..16e723e --- /dev/null +++ b/tests/test_wallet_redaction.py @@ -0,0 +1,105 @@ +"""Security regression tests: repr() must never leak mnemonic/passphrase. + +These types carry secrets (BIP-39 mnemonics, wallet passphrases) that end up in +logs via repr()/str() (tracebacks, debug prints, repr of containing objects). +The custom ``__repr__`` implementations render ```` placeholders; +``to_json()`` still carries the real values for the JSON-RPC wire. +""" + +from __future__ import annotations + +from mintlayer.wallet import ( + CreateWalletParams, + CreateWalletResult, + MnemonicResult, + RecoverWalletParams, +) +from mintlayer.wallet.types import MnemonicContent + +_SECRET_MNEMONIC = "secret words" +_SECRET_PASSPHRASE = "pw" + + +def test_create_wallet_params_repr_redacts_secrets() -> None: + got = repr( + CreateWalletParams( + path="x", + store_seed_phrase=False, + mnemonic=_SECRET_MNEMONIC, + passphrase=_SECRET_PASSPHRASE, + ) + ) + assert "" in got + assert _SECRET_MNEMONIC not in got + assert _SECRET_PASSPHRASE not in got + + +def test_recover_wallet_params_repr_redacts_secrets() -> None: + got = repr( + RecoverWalletParams( + path="x", + store_seed_phrase=False, + mnemonic=_SECRET_MNEMONIC, + passphrase=_SECRET_PASSPHRASE, + ) + ) + assert got.count("") >= 2 + assert _SECRET_MNEMONIC not in got + assert _SECRET_PASSPHRASE not in got + + +def test_mnemonic_content_repr_is_fully_redacted() -> None: + assert repr(MnemonicContent(mnemonic="secret")) == "MnemonicContent(mnemonic='')" + + +def test_create_wallet_result_repr_redacts_nested_mnemonic() -> None: + """repr of a plain-dataclass container must redact transitively.""" + got = repr( + CreateWalletResult( + mnemonic=MnemonicResult( + type="Bip39", + content=MnemonicContent(mnemonic=_SECRET_MNEMONIC), + ) + ) + ) + assert "" in got + assert "MnemonicContent(mnemonic='')" in got + assert _SECRET_MNEMONIC not in got + + +def test_to_json_still_carries_real_values() -> None: + """The wire path is unaffected by repr redaction.""" + create = CreateWalletParams( + path="x", + store_seed_phrase=False, + mnemonic=_SECRET_MNEMONIC, + passphrase=_SECRET_PASSPHRASE, + ) + recover = RecoverWalletParams( + path="x", + store_seed_phrase=False, + mnemonic=_SECRET_MNEMONIC, + passphrase=_SECRET_PASSPHRASE, + ) + assert create.to_json() == { + "path": "x", + "store_seed_phrase": False, + "mnemonic": _SECRET_MNEMONIC, + "passphrase": _SECRET_PASSPHRASE, + "hardware_wallet": None, + } + assert recover.to_json() == { + "path": "x", + "store_seed_phrase": False, + "mnemonic": _SECRET_MNEMONIC, + "passphrase": _SECRET_PASSPHRASE, + "hardware_wallet": None, + } + + +def test_repr_unset_secrets_render_as_none_not_placeholder() -> None: + """Unset optional secrets show None; the placeholder is only for set values.""" + got = repr(CreateWalletParams(path="x", store_seed_phrase=False)) + assert "mnemonic=None" in got + assert "passphrase=None" in got + assert got.count("") == 0 From dd6063439338b25a610962a66feec8b0d4e5be8e Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 08:19:16 +0400 Subject: [PATCH 07/31] Deduplicate node/wallet RPC core into shared BaseJSONRPCClient Node and wallet _core mixins repeated _call/_call_ignore/close over JSONRPCClient; hoist them into a shared base in _jsonrpc.py. Also replaces node/_core's function-local Amount import with a module-level import (no cycle: node/types.py has no intra-package imports). --- mintlayer/_jsonrpc.py | 24 ++++++++++++++++++++++++ mintlayer/node/_core.py | 24 +++++------------------- mintlayer/wallet/_core.py | 18 +++--------------- 3 files changed, 32 insertions(+), 34 deletions(-) diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 45275eb..f8c18d2 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -108,3 +108,27 @@ def close(self) -> None: """Close the HTTP session (only if the client created it).""" if self._owns_session: self._session.close() + + +class BaseJSONRPCClient: + """Mixin base shared by the node and wallet clients. + + Both clients wrap a :class:`JSONRPCClient` as ``self._rpc`` and share the + raw-call and session-lifecycle helpers below. Typed result decoding stays + in each package's ``_core`` module (mirroring the separate Go node/wallet + packages). + """ + + _rpc: JSONRPCClient + + def _call(self, method: str, params: Any) -> Any: + """Call and return the decoded JSON result (None for JSON null).""" + return self._rpc.call(method, params) + + def _call_ignore(self, method: str, params: Any) -> None: + """Call and discard the result (void methods).""" + self._rpc.call(method, params) + + def close(self) -> None: + """Close the underlying HTTP session.""" + self._rpc.close() diff --git a/mintlayer/node/_core.py b/mintlayer/node/_core.py index f6b938f..73fa8d3 100644 --- a/mintlayer/node/_core.py +++ b/mintlayer/node/_core.py @@ -4,21 +4,13 @@ from typing import Any -from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError +from mintlayer._jsonrpc import BaseJSONRPCClient, JSONRPCError +from .types import Amount -class _NodeCore: - """Thin wrapper over the JSON-RPC transport with typed result helpers.""" - _rpc: JSONRPCClient - - def _call(self, method: str, params: Any) -> Any: - """Call and return the decoded JSON result (None for JSON null).""" - return self._rpc.call(method, params) - - def _call_ignore(self, method: str, params: Any) -> None: - """Call and discard the result (void methods).""" - self._rpc.call(method, params) +class _NodeCore(BaseJSONRPCClient): + """Node-specific typed result helpers over the shared JSON-RPC base.""" def _call_str(self, method: str, params: Any) -> str: result = self._rpc.call(method, params) @@ -50,12 +42,6 @@ def _call_str_list(self, method: str, params: Any) -> list[str]: result = self._rpc.call(method, params) return [str(item) for item in result or []] - def _call_opt_amount(self, method: str, params: Any) -> Any: - from .types import Amount - + def _call_opt_amount(self, method: str, params: Any) -> Amount | None: result = self._rpc.call(method, params) return Amount.from_json(result) if result is not None else None - - def close(self) -> None: - """Close the underlying HTTP session.""" - self._rpc.close() diff --git a/mintlayer/wallet/_core.py b/mintlayer/wallet/_core.py index c2ab010..24a4503 100644 --- a/mintlayer/wallet/_core.py +++ b/mintlayer/wallet/_core.py @@ -4,21 +4,13 @@ from typing import Any, TypeVar -from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError +from mintlayer._jsonrpc import BaseJSONRPCClient, JSONRPCError _T = TypeVar("_T") -class _WalletCore: - """Thin wrapper over the JSON-RPC transport with typed result helpers.""" - - _rpc: JSONRPCClient - - def _call(self, method: str, params: Any) -> Any: - return self._rpc.call(method, params) - - def _call_ignore(self, method: str, params: Any) -> None: - self._rpc.call(method, params) +class _WalletCore(BaseJSONRPCClient): + """Wallet-specific typed result helpers over the shared JSON-RPC base.""" def _call_model(self, method: str, params: Any, cls: type[_T]) -> _T: data = self._rpc.call(method, params) @@ -29,7 +21,3 @@ def _call_model(self, method: str, params: Any, cls: type[_T]) -> _T: def _call_model_list(self, method: str, params: Any, cls: type[_T]) -> list[_T]: data = self._rpc.call(method, params) return [cls.from_json(item) for item in data or []] # type: ignore[attr-defined] - - def close(self) -> None: - """Close the underlying HTTP session.""" - self._rpc.close() From 643bf0a0ace671e8ce390e1d6c5f2cd46a1a3d66 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 08:24:21 +0400 Subject: [PATCH 08/31] Collapse indexer _core pass-through into _http IndexerCore only aliased IndexerHTTP.get/post_text as _get/_post_text. Mixins now subclass IndexerHTTP directly and call the transport methods; the _seg path-segment encoder moves next to the HTTP layer it serves. --- mintlayer/indexer/_core.py | 25 ------------------------- mintlayer/indexer/_http.py | 6 ++++++ mintlayer/indexer/address.py | 14 +++++++------- mintlayer/indexer/block.py | 18 +++++++----------- mintlayer/indexer/chain.py | 10 +++++----- mintlayer/indexer/delegation.py | 6 +++--- mintlayer/indexer/order.py | 10 +++++----- mintlayer/indexer/pool.py | 12 ++++++------ mintlayer/indexer/statistics.py | 10 +++++----- mintlayer/indexer/token.py | 14 +++++++------- mintlayer/indexer/transaction.py | 14 +++++++------- 11 files changed, 58 insertions(+), 81 deletions(-) delete mode 100644 mintlayer/indexer/_core.py diff --git a/mintlayer/indexer/_core.py b/mintlayer/indexer/_core.py deleted file mode 100644 index 1baa7ec..0000000 --- a/mintlayer/indexer/_core.py +++ /dev/null @@ -1,25 +0,0 @@ -"""Shared request helpers for the indexer client mixins.""" - -from __future__ import annotations - -from typing import Any -from urllib.parse import quote - -from ._http import IndexerHTTP - -__all__ = ["IndexerCore", "_seg"] - - -def _seg(value: Any) -> str: - """URL-encode a path segment (defense against path traversal/injection).""" - return quote(str(value), safe="") - - -class IndexerCore(IndexerHTTP): - """Base class providing the typed request helpers used by the mixins.""" - - def _get(self, path: str, query: dict[str, Any] | None = None) -> Any: - return self.get(path, query) - - def _post_text(self, path: str, body: str) -> Any: - return self.post_text(path, body) diff --git a/mintlayer/indexer/_http.py b/mintlayer/indexer/_http.py index ad91b50..92e4e4c 100644 --- a/mintlayer/indexer/_http.py +++ b/mintlayer/indexer/_http.py @@ -8,6 +8,7 @@ from __future__ import annotations from typing import Any +from urllib.parse import quote import requests @@ -27,6 +28,11 @@ def __init__(self, status_code: int, body: str) -> None: self.body = body +def _seg(value: Any) -> str: + """URL-encode a path segment (defense against path traversal/injection).""" + return quote(str(value), safe="") + + class IndexerHTTP: """HTTP layer for the indexer client (GET + one text/plain POST route).""" diff --git a/mintlayer/indexer/address.py b/mintlayer/indexer/address.py index 3dee833..76d6745 100644 --- a/mintlayer/indexer/address.py +++ b/mintlayer/indexer/address.py @@ -2,30 +2,30 @@ from __future__ import annotations -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import UTXO, AddressInfo, DelegationInfo -class AddressMixin(IndexerCore): +class AddressMixin(IndexerHTTP): def get_address_info(self, address: str) -> AddressInfo: """Return address balances and history (404 if the address has none).""" - return AddressInfo.from_json(self._get(f"/address/{_seg(address)}")) + return AddressInfo.from_json(self.get(f"/address/{_seg(address)}")) def get_spendable_utxos(self, address: str) -> list[UTXO]: """Return the address's spendable UTXOs.""" - data = self._get(f"/address/{_seg(address)}/spendable-utxos") + data = self.get(f"/address/{_seg(address)}/spendable-utxos") return [UTXO.from_json(u) for u in data or []] def get_all_utxos(self, address: str) -> list[UTXO]: """Return all UTXOs for the address (including timelocked).""" - data = self._get(f"/address/{_seg(address)}/all-utxos") + data = self.get(f"/address/{_seg(address)}/all-utxos") return [UTXO.from_json(u) for u in data or []] def get_delegations(self, address: str) -> list[DelegationInfo]: """Return the delegations created by the address.""" - data = self._get(f"/address/{_seg(address)}/delegations") + data = self.get(f"/address/{_seg(address)}/delegations") return [DelegationInfo.from_json(d) for d in data or []] def get_token_authority(self, address: str) -> list[str]: """Return the bech32 token IDs the address has authority over.""" - return self._get(f"/address/{_seg(address)}/token-authority") or [] + return self.get(f"/address/{_seg(address)}/token-authority") or [] diff --git a/mintlayer/indexer/block.py b/mintlayer/indexer/block.py index 562b6a3..2b6dcac 100644 --- a/mintlayer/indexer/block.py +++ b/mintlayer/indexer/block.py @@ -2,27 +2,23 @@ from __future__ import annotations -from ._core import IndexerCore, _seg -from .types import ( - Block, - BlockHeader, - Transaction, # noqa: F401 (re-exported for callers) -) +from ._http import IndexerHTTP, _seg +from .types import Block, BlockHeader -class BlockMixin(IndexerCore): +class BlockMixin(IndexerHTTP): def get_block(self, block_id: str) -> Block: """Return a block with header and body.""" - return Block.from_json(self._get(f"/block/{_seg(block_id)}")) + return Block.from_json(self.get(f"/block/{_seg(block_id)}")) def get_block_header(self, block_id: str) -> BlockHeader: """Return a block header.""" - return BlockHeader.from_json(self._get(f"/block/{_seg(block_id)}/header")) + return BlockHeader.from_json(self.get(f"/block/{_seg(block_id)}/header")) def get_block_reward(self, block_id: str) -> list: """Return the block reward outputs (raw JSON list).""" - return self._get(f"/block/{_seg(block_id)}/reward") or [] + return self.get(f"/block/{_seg(block_id)}/reward") or [] def get_block_transaction_ids(self, block_id: str) -> list[str]: """Return the transaction IDs included in a block.""" - return self._get(f"/block/{_seg(block_id)}/transaction-ids") or [] + return self.get(f"/block/{_seg(block_id)}/transaction-ids") or [] diff --git a/mintlayer/indexer/chain.py b/mintlayer/indexer/chain.py index 8a68a13..61dc874 100644 --- a/mintlayer/indexer/chain.py +++ b/mintlayer/indexer/chain.py @@ -2,20 +2,20 @@ from __future__ import annotations -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import ChainTip, GenesisInfo -class ChainMixin(IndexerCore): +class ChainMixin(IndexerHTTP): def get_tip(self) -> ChainTip: """Return the current chain tip.""" - return ChainTip.from_json(self._get("/chain/tip")) + return ChainTip.from_json(self.get("/chain/tip")) def get_genesis(self) -> GenesisInfo: """Return genesis block info.""" - return GenesisInfo.from_json(self._get("/chain/genesis")) + return GenesisInfo.from_json(self.get("/chain/genesis")) def get_block_id_at_height(self, height: int) -> str: """Return the block ID at ``height`` (raises HTTPError 404 if unknown).""" - result = self._get(f"/chain/{_seg(height)}") + result = self.get(f"/chain/{_seg(height)}") return "" if result is None else str(result) diff --git a/mintlayer/indexer/delegation.py b/mintlayer/indexer/delegation.py index 75a41db..eed6731 100644 --- a/mintlayer/indexer/delegation.py +++ b/mintlayer/indexer/delegation.py @@ -2,11 +2,11 @@ from __future__ import annotations -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import Delegation -class DelegationMixin(IndexerCore): +class DelegationMixin(IndexerHTTP): def get_delegation(self, delegation_id: str) -> Delegation: """Return a delegation by ID.""" - return Delegation.from_json(self._get(f"/delegation/{_seg(delegation_id)}")) + return Delegation.from_json(self.get(f"/delegation/{_seg(delegation_id)}")) diff --git a/mintlayer/indexer/order.py b/mintlayer/indexer/order.py index 4494678..a90560f 100644 --- a/mintlayer/indexer/order.py +++ b/mintlayer/indexer/order.py @@ -2,19 +2,19 @@ from __future__ import annotations -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import Order, PageOpts -class OrderMixin(IndexerCore): +class OrderMixin(IndexerHTTP): def list_orders(self, opts: PageOpts | None = None) -> list[Order]: """List DEX orders with pagination.""" - data = self._get("/order", (opts or PageOpts()).query()) + data = self.get("/order", (opts or PageOpts()).query()) return [Order.from_json(o) for o in data or []] def get_order(self, order_id: str) -> Order: """Return a DEX order by ID.""" - return Order.from_json(self._get(f"/order/{_seg(order_id)}")) + return Order.from_json(self.get(f"/order/{_seg(order_id)}")) def list_orders_by_pair( self, ask_currency: str, give_currency: str, opts: PageOpts | None = None @@ -24,7 +24,7 @@ def list_orders_by_pair( Currencies are the coin ticker (e.g. ``"ML"``) or a bech32 token ID; the path is ``/order/pair/{ask}_{give}``. """ - data = self._get( + data = self.get( f"/order/pair/{_seg(ask_currency)}_{_seg(give_currency)}", (opts or PageOpts()).query() ) return [Order.from_json(o) for o in data or []] diff --git a/mintlayer/indexer/pool.py b/mintlayer/indexer/pool.py index 1332743..d2ac96e 100644 --- a/mintlayer/indexer/pool.py +++ b/mintlayer/indexer/pool.py @@ -4,23 +4,23 @@ from datetime import datetime -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import Pool, PoolDelegation, PoolListOpts -class PoolMixin(IndexerCore): +class PoolMixin(IndexerHTTP): def list_pools(self, opts: PoolListOpts | None = None) -> list[Pool]: """List staking pools with pagination and optional sort.""" - data = self._get("/pool", (opts or PoolListOpts()).query()) + data = self.get("/pool", (opts or PoolListOpts()).query()) return [Pool.from_json(p) for p in data or []] def get_pool(self, pool_id: str) -> Pool: """Return a staking pool by ID.""" - return Pool.from_json(self._get(f"/pool/{_seg(pool_id)}")) + return Pool.from_json(self.get(f"/pool/{_seg(pool_id)}")) def get_pool_block_stats(self, pool_id: str, from_time: datetime, to_time: datetime) -> int: """Return the block count produced in the half-open interval [from, to).""" - data = self._get( + data = self.get( f"/pool/{_seg(pool_id)}/block-stats", {"from": int(from_time.timestamp()), "to": int(to_time.timestamp())}, ) @@ -28,5 +28,5 @@ def get_pool_block_stats(self, pool_id: str, from_time: datetime, to_time: datet def get_pool_delegations(self, pool_id: str) -> list[PoolDelegation]: """Return the delegations to a pool.""" - data = self._get(f"/pool/{_seg(pool_id)}/delegations") + data = self.get(f"/pool/{_seg(pool_id)}/delegations") return [PoolDelegation.from_json(d) for d in data or []] diff --git a/mintlayer/indexer/statistics.py b/mintlayer/indexer/statistics.py index 904eec9..2274c98 100644 --- a/mintlayer/indexer/statistics.py +++ b/mintlayer/indexer/statistics.py @@ -2,18 +2,18 @@ from __future__ import annotations -from ._core import IndexerCore +from ._http import IndexerHTTP from .types import CoinStats -class StatisticsMixin(IndexerCore): +class StatisticsMixin(IndexerHTTP): def get_coin_statistics(self) -> CoinStats: """Return circulating/preminted/burned/staked coin totals.""" - return CoinStats.from_json(self._get("/statistics/coin")) + return CoinStats.from_json(self.get("/statistics/coin")) def get_token_statistics(self, token_id: str) -> CoinStats: """Return the same statistics for a token.""" - return CoinStats.from_json(self._get(f"/statistics/token/{token_id}")) + return CoinStats.from_json(self.get(f"/statistics/token/{token_id}")) def get_fee_rate(self, in_top_x_mb: int = 0) -> str: """Return the fee rate (atoms per KB) as a decimal string. @@ -21,5 +21,5 @@ def get_fee_rate(self, in_top_x_mb: int = 0) -> str: ``in_top_x_mb`` is omitted when zero, using the server default (5 MB). """ query = {"in_top_x_mb": in_top_x_mb} if in_top_x_mb > 0 else None - result = self._get("/feerate", query) + result = self.get("/feerate", query) return "" if result is None else str(result) diff --git a/mintlayer/indexer/token.py b/mintlayer/indexer/token.py index 9352286..7406387 100644 --- a/mintlayer/indexer/token.py +++ b/mintlayer/indexer/token.py @@ -2,28 +2,28 @@ from __future__ import annotations -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import NFTInfo, PageOpts, TokenInfo, TokenTx -class TokenMixin(IndexerCore): +class TokenMixin(IndexerHTTP): def list_tokens(self, opts: PageOpts | None = None) -> list[str]: """List token IDs with pagination.""" - return self._get("/token", (opts or PageOpts()).query()) or [] + return self.get("/token", (opts or PageOpts()).query()) or [] def get_token(self, token_id: str) -> TokenInfo: """Return token info by ID.""" - return TokenInfo.from_json(self._get(f"/token/{_seg(token_id)}")) + return TokenInfo.from_json(self.get(f"/token/{_seg(token_id)}")) def get_token_transactions(self, token_id: str, opts: PageOpts | None = None) -> list[TokenTx]: """List transactions involving the token.""" - data = self._get(f"/token/{_seg(token_id)}/transactions", (opts or PageOpts()).query()) + data = self.get(f"/token/{_seg(token_id)}/transactions", (opts or PageOpts()).query()) return [TokenTx.from_json(t) for t in data or []] def find_tokens_by_ticker(self, ticker: str, opts: PageOpts | None = None) -> list[str]: """Find token IDs by ticker symbol.""" - return self._get(f"/token/ticker/{_seg(ticker)}", (opts or PageOpts()).query()) or [] + return self.get(f"/token/ticker/{_seg(ticker)}", (opts or PageOpts()).query()) or [] def get_nft(self, token_id: str) -> NFTInfo: """Return NFT info by token ID.""" - return NFTInfo.from_json(self._get(f"/nft/{_seg(token_id)}")) + return NFTInfo.from_json(self.get(f"/nft/{_seg(token_id)}")) diff --git a/mintlayer/indexer/transaction.py b/mintlayer/indexer/transaction.py index 231dbc6..b796553 100644 --- a/mintlayer/indexer/transaction.py +++ b/mintlayer/indexer/transaction.py @@ -4,29 +4,29 @@ from typing import Any -from ._core import IndexerCore, _seg +from ._http import IndexerHTTP, _seg from .types import MerklePath, PageOpts, Transaction -class TransactionMixin(IndexerCore): +class TransactionMixin(IndexerHTTP): def list_transactions(self, opts: PageOpts | None = None) -> list[Transaction]: """List transactions with pagination.""" - data = self._get("/transaction", (opts or PageOpts()).query()) + data = self.get("/transaction", (opts or PageOpts()).query()) return [Transaction.from_json(t) for t in data or []] def get_transaction(self, tx_id: str) -> Transaction: """Return a transaction by ID.""" - return Transaction.from_json(self._get(f"/transaction/{_seg(tx_id)}")) + return Transaction.from_json(self.get(f"/transaction/{_seg(tx_id)}")) def get_transaction_merkle_path(self, tx_id: str) -> MerklePath: """Return the merkle path of a transaction (404 until it is in a block).""" - return MerklePath.from_json(self._get(f"/transaction/{_seg(tx_id)}/merkle-path")) + return MerklePath.from_json(self.get(f"/transaction/{_seg(tx_id)}/merkle-path")) def get_transaction_output(self, tx_id: str, output_index: int) -> Any: """Return a transaction output as raw JSON (includes spent_at_block_height).""" - return self._get(f"/transaction/{_seg(tx_id)}/output/{output_index}") + return self.get(f"/transaction/{_seg(tx_id)}/output/{output_index}") def submit_transaction(self, signed_tx_hex: str) -> str: """Submit a signed transaction (hex) — requires ``--enable-post-routes``.""" - data = self._post_text("/transaction", signed_tx_hex) + data = self.post_text("/transaction", signed_tx_hex) return str(data["tx_id"]) From 519730fb321b35abc66da8a6aed8e09dfcb4c201 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 08:24:21 +0400 Subject: [PATCH 09/31] Remove dead Transaction re-export and redundant noqa markers block.py re-exported Transaction with noqa F401 but nothing imports it from there (public path is mintlayer.indexer.Transaction). Drop the noqa comments on JSONRPCError imports: both modules list it in __all__, so F401 never fires. --- mintlayer/node/client.py | 6 +----- mintlayer/wallet/client.py | 6 +----- 2 files changed, 2 insertions(+), 10 deletions(-) diff --git a/mintlayer/node/client.py b/mintlayer/node/client.py index 9947220..af3bce8 100644 --- a/mintlayer/node/client.py +++ b/mintlayer/node/client.py @@ -8,11 +8,7 @@ from requests import Session -from mintlayer._jsonrpc import ( - JSONRPCClient, - JSONRPCError, # noqa: F401 (re-exported) - RPCError, -) +from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError, RPCError from ._core import _NodeCore from .chainstate import ChainstateMixin diff --git a/mintlayer/wallet/client.py b/mintlayer/wallet/client.py index 7377f15..15e9ac2 100644 --- a/mintlayer/wallet/client.py +++ b/mintlayer/wallet/client.py @@ -4,11 +4,7 @@ import requests -from mintlayer._jsonrpc import ( # noqa: F401 (JSONRPCError re-exported) - JSONRPCClient, - JSONRPCError, - RPCError, -) +from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError, RPCError from ._core import _WalletCore from .management import ManagementMixin From 0d7dc8684596db85a25d6eab42c0275f69f8936e Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 08:27:31 +0400 Subject: [PATCH 10/31] Add deletion log for DRY refactor session --- docs/DELETION_LOG.md | 60 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 docs/DELETION_LOG.md diff --git a/docs/DELETION_LOG.md b/docs/DELETION_LOG.md new file mode 100644 index 0000000..6c1d7b8 --- /dev/null +++ b/docs/DELETION_LOG.md @@ -0,0 +1,60 @@ +# Code Deletion Log + +## 2026-09-17 Refactor Session (DRY cleanup of `mintlayer/`) + +### Duplicates Consolidated + +- `mintlayer/node/_core.py` + `mintlayer/wallet/_core.py` — the `_call`, + `_call_ignore` and `close` helpers were duplicated across both packages. + Hoisted into a shared `BaseJSONRPCClient` mixin base in + `mintlayer/_jsonrpc.py:112`. `_NodeCore` and `_WalletCore` now subclass it + and keep only their package-specific typed decoders (`_call_str` / + `_call_opt_int` / ... vs `_call_model` / `_call_model_list`). +- `mintlayer/indexer/_core.py` (deleted) — `IndexerCore` was a pure + pass-through over `_http.IndexerHTTP` (`_get` → `get`, `_post_text` → + `post_text`). The nine endpoint mixins now subclass `IndexerHTTP` + directly and call the transport methods; the `_seg` path-segment encoder + moved to `mintlayer/indexer/_http.py:31` next to the URL construction it + serves. + +### Unused Files Deleted + +- `mintlayer/indexer/_core.py` — replaced by direct `IndexerHTTP` base class + (see above). + +### Unused Exports Removed + +- `mintlayer/indexer/block.py` — dropped the `Transaction` re-export + (`# noqa: F401`). Nothing imported `Transaction` from this module; the + public surface path `mintlayer.indexer.Transaction` (via `__init__.py`) + is unchanged. Go parity check: `go-sdk/indexer/block.go` never touches + `Transaction`. +- `mintlayer/node/client.py` / `mintlayer/wallet/client.py` — removed the + redundant `# noqa: F401` markers on the `JSONRPCError` imports; both + modules list it in `__all__`, so the suppression was dead (RUF100 not + enabled, hence undetected by lint). +- `mintlayer/node/_core.py` — replaced the function-local + `from .types import Amount` inside `_call_opt_amount` with a module-level + import (no cycle: `node/types.py` has no intra-package imports), and + tightened the return annotation `Any` → `Amount | None`. + +### Deliberately Left Alone + +- `from_json`/`to_json` boilerplate in `node|indexer|wallet/types.py` — + explicit field-by-field wire mapping mirrors the Go structs; wire-format + fidelity beats DRY here. +- WASM mixins (`mintlayer/wasm/`) — 1:1 mapping to Go files/exports is + intentional; audited for dead branches, none found. + +### Impact + +- Files deleted: 1 +- Net lines removed: 33 (6133 → 6100; +93/−126) +- Public API surface: unchanged (all `__init__.py` re-exports intact) + +### Testing + +- `uv run pytest tests/ -q` → 238 passed (zero test modifications) +- `uv run ruff check .` → All checks passed +- `uv run ruff format mintlayer/` → 50 files already formatted +- `uv run mypy mintlayer/` → no issues found in 50 source files From 4c43e6b7540e91b97ff1729352894fb03e723035 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 08:37:47 +0400 Subject: [PATCH 11/31] Add pytest-cov with coverage config Baseline: 77.5% (WASM module undertested in-suite; node/indexer/wallet at 96-100%). Threshold target: >80%. --- .gitignore | 1 + pyproject.toml | 9 +++++++++ 2 files changed, 10 insertions(+) diff --git a/.gitignore b/.gitignore index 4a542a9..1f413c4 100644 --- a/.gitignore +++ b/.gitignore @@ -25,3 +25,4 @@ id_rsa* id_ed25519* id_ecdsa* secrets/ +.coverage* diff --git a/pyproject.toml b/pyproject.toml index 741dc6d..dcd1bcd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -32,6 +32,7 @@ dev = [ "pytest>=8.0", "ruff>=0.6", "mypy>=1.11", + "pytest-cov>=7.1.0", ] [tool.hatch.build.targets.wheel] @@ -58,3 +59,11 @@ check_untyped_defs = true [[tool.mypy.overrides]] module = "wasmtime.*" ignore_missing_imports = true + +[tool.coverage.run] +source = ["mintlayer"] +omit = ["mintlayer/wasm/wasm_wrappers_bg.wasm"] + +[tool.coverage.report] +show_missing = true +precision = 1 From 60350978a81995a0c897fd39ec7d37224110e62a Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 14:57:24 +0400 Subject: [PATCH 12/31] Fix externref table slot double-dealloc in wasm array calls The wasm-bindgen callee takes ownership of the externref table slots referenced by passArrayJsValueToWasm0 index arrays and deallocs them itself; the host's post-call _dealloc_indices therefore double-freed free-list entries, corrupting later allocations ('array contains a value of the wrong type' on subsequent multi-element calls to estimate_transaction_size / encode_signed_transaction_intent / verify_transaction_intent). Host-side slot release is now restricted to pre-call rollback (where the callee never ran); post-call, only the host-malloc'd Uint8Array backing buffers are freed (the callee to_vec-copies and never frees the originals). Stale docstrings corrected; ownership contract documented, including the known wasm-bindgen failing-call slot leak. --- mintlayer/wasm/_core.py | 31 +++++++++++++++++++++++-------- mintlayer/wasm/intent.py | 27 +++++++++++++-------------- mintlayer/wasm/transactions.py | 26 +++++++++++++++----------- 3 files changed, 51 insertions(+), 33 deletions(-) diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 0991d79..16e869b 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -312,17 +312,27 @@ def _read_amount(self, wasm_ptr: int) -> Amount: # ── externref-index arrays (passArrayJsValueToWasm0 pattern) ───────────── # - # Ownership: the WASM callee takes ownership of BOTH the index array and - # the Uint8Array backing buffers during the call. Host-side cleanup must - # therefore only release the externref table slots (exactly once each) and - # must never re-read or free the array memory after the call. + # Ownership: during the call the WASM callee takes ownership of the index + # array, the externref table slots, and (for Uint8Array entries) reads and + # copies the backing buffers. The callee itself releases the index array + # and deallocs the table slots, so the host must never re-read the array + # or dealloc the slots after the call — doing so double-frees free-list + # entries and corrupts later allocations ("array contains a value of the + # wrong type" on subsequent multi-element calls). The Uint8Array backing + # buffers, however, are malloc'd host-side and only copied by the callee + # (to_vec): the host frees those after the call. + # + # Known wasm-bindgen trait: a FAILING array call leaks a few slots (the + # callee's error path skips part of its cleanup). Not soundly fixable + # host-side — never "compensate" by dealloc'ing, which is worse. def _write_string_array(self, strs: list[str]) -> tuple[int, list[int]]: """Write ``[string]`` as an array of externref table indices. - Returns (array_ptr, table_indices). Release the table slots with - :meth:`_dealloc_indices` after the call; the array itself is owned by - the callee (passArrayJsValueToWasm0 ownership transfer). + Returns (array_ptr, table_indices). The index array and the slots + become callee-owned once the call is made — never call + :meth:`_dealloc_indices` on them afterwards (only pre-call rollback, + which this method already handles internally). """ indices: list[int] = [] if not strs: @@ -396,7 +406,12 @@ def _invoke1(self, name: str, *params: Any) -> int: return ret[0] def _dealloc_indices(self, indices: list[int]) -> None: - """Release externref table slots (exactly once per slot).""" + """Release externref table slots. + + ONLY for pre-call rollback (a write failed before the callee ever ran). + After a call, the slots are callee-owned — deallocating them again + corrupts the table free list. + """ if not indices: return dealloc = self.get_export("__externref_table_dealloc") diff --git a/mintlayer/wasm/intent.py b/mintlayer/wasm/intent.py index ebd8ff4..5af111b 100644 --- a/mintlayer/wasm/intent.py +++ b/mintlayer/wasm/intent.py @@ -38,7 +38,8 @@ def encode_signed_transaction_intent( "encode_signed_transaction_intent", msg_ptr, msg_len, sigs_ptr, len(sigs_indices) ) finally: - self._dealloc_indices(sigs_indices) + # Slots and the index array are callee-owned; the backing buffers + # were host-malloc'd and only copied by the callee (to_vec). for ptr, length in sigs_buffers: self._free_wasm(ptr, length) @@ -57,16 +58,14 @@ def verify_transaction_intent( msg_ptr, msg_len = self._write_bytes(expected_signed_message) intent_ptr, intent_len = self._write_bytes(encoded_signed_intent) dests_ptr, dests_indices = self._write_string_array(input_destinations) - try: - self._call_void_fallible( - "verify_transaction_intent", - msg_ptr, - msg_len, - intent_ptr, - intent_len, - dests_ptr, - len(dests_indices), - int(network), - ) - finally: - self._dealloc_indices(dests_indices) + # Index array and slots are callee-owned; nothing to release. + self._call_void_fallible( + "verify_transaction_intent", + msg_ptr, + msg_len, + intent_ptr, + intent_len, + dests_ptr, + len(dests_indices), + int(network), + ) diff --git a/mintlayer/wasm/transactions.py b/mintlayer/wasm/transactions.py index 4320986..8aedc45 100644 --- a/mintlayer/wasm/transactions.py +++ b/mintlayer/wasm/transactions.py @@ -54,18 +54,22 @@ def estimate_transaction_size( dests_ptr, dests_indices = self._write_string_array(input_utxos_dests) try: out_ptr, out_len = self._write_bytes(outputs) - return self._call_return_u32( - "estimate_transaction_size", - in_ptr, - in_len, - dests_ptr, - len(dests_indices), - out_ptr, - out_len, - int(network), - ) - finally: + except BaseException: + # The callee never ran, so the host still owns the slots. self._dealloc_indices(dests_indices) + raise + # From here the callee owns the index array and the table slots (it + # deallocs both); no post-call cleanup is needed. + return self._call_return_u32( + "estimate_transaction_size", + in_ptr, + in_len, + dests_ptr, + len(dests_indices), + out_ptr, + out_len, + int(network), + ) @synchronized def encode_signed_transaction(self, transaction: bytes, signatures: bytes) -> bytes: From bb443377bb0f6cc8d73be96aef3b77d73d1c8824 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 14:57:24 +0400 Subject: [PATCH 13/31] Add WASM test suite: 95.5% total coverage, all edge cases 148 new offline tests covering the full wasm client: lifecycle (close, integrity pin fail-closed, unknown exports, memory errors, result-buffer zeroing via memory spy), the complete Go client_test.go matrix plus change-key/equality chains, all encode_input_for_* / encode_output_* / timelocks / fees with real mintlayer-core test vectors (VRF key), ids on real encoded inputs, transaction encode/sign/decode flows, witness and HTLC paths, intent roundtrips, types wire shapes, and fault-injected rollback branches (mutation-verified). Regression suite for the slot-ownership fix: multi-destination estimate calls, mixed-load table-stability stress, and dealloc rollback semantics. 386 tests passing; total coverage 95.5% (wasm/_core 92.5%, all other wasm modules 100%). --- tests/conftest.py | 19 ++ tests/test_wasm_addresses.py | 69 ++++++ tests/test_wasm_array_rollback.py | 219 +++++++++++++++++++ tests/test_wasm_ids.py | 83 +++++++ tests/test_wasm_inputs_fees.py | 210 ++++++++++++++++++ tests/test_wasm_intents.py | 75 +++++++ tests/test_wasm_keys.py | 90 ++++++++ tests/test_wasm_lifecycle.py | 201 +++++++++++++++++ tests/test_wasm_outputs.py | 278 ++++++++++++++++++++++++ tests/test_wasm_signing.py | 205 ++++++++++++++++++ tests/test_wasm_transactions.py | 344 ++++++++++++++++++++++++++++++ tests/test_wasm_types.py | 148 +++++++++++++ tests/wasm_helpers.py | 96 +++++++++ 13 files changed, 2037 insertions(+) create mode 100644 tests/test_wasm_addresses.py create mode 100644 tests/test_wasm_array_rollback.py create mode 100644 tests/test_wasm_ids.py create mode 100644 tests/test_wasm_inputs_fees.py create mode 100644 tests/test_wasm_intents.py create mode 100644 tests/test_wasm_keys.py create mode 100644 tests/test_wasm_lifecycle.py create mode 100644 tests/test_wasm_outputs.py create mode 100644 tests/test_wasm_signing.py create mode 100644 tests/test_wasm_transactions.py create mode 100644 tests/test_wasm_types.py create mode 100644 tests/wasm_helpers.py diff --git a/tests/conftest.py b/tests/conftest.py index 272cd13..d3a415f 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -378,3 +378,22 @@ def _start( for handle in handles: handle.stop() + + +# --- WASM client (fully offline) ---------------------------------------------- + + +@pytest.fixture(scope="session") +def wasm(): + """A session-wide offline WASM :class:`~mintlayer.wasm.Client`. + + Instantiating the client compiles the embedded WASM module, which is + relatively expensive, so one instance is shared across the whole session. + Every public method serialises on the client's own lock. Tests that need + to close a client (lifecycle tests) must instantiate their own. + """ + from mintlayer.wasm import Client as WasmClient + + client = WasmClient() + yield client + client.close() diff --git a/tests/test_wasm_addresses.py b/tests/test_wasm_addresses.py new file mode 100644 index 0000000..7584602 --- /dev/null +++ b/tests/test_wasm_addresses.py @@ -0,0 +1,69 @@ +"""Tests for WASM address encoding (mirrors go-sdk/wasm/addresses.go).""" + +from __future__ import annotations + +import pytest +from wasm_helpers import derive + +from mintlayer.wasm import Client, Network, WasmError + + +def test_pubkey_to_pubkeyhash_address(wasm: Client) -> None: + _acct, _recv, pub, addr = derive(wasm) + assert addr + again = wasm.pubkey_to_pubkeyhash_address(pub, Network.MAINNET) + assert addr == again # deterministic + assert addr.startswith("mtc1"), f"unexpected mainnet address prefix: {addr}" + + +def test_address_depends_on_network(wasm: Client) -> None: + _acct, _recv, pub, mainnet = derive(wasm) + testnet = wasm.pubkey_to_pubkeyhash_address(pub, Network.TESTNET) + assert mainnet != testnet + + +def test_encode_destination(wasm: Client) -> None: + _acct, _recv, _pub, addr = derive(wasm) + dest = wasm.encode_destination(addr, Network.MAINNET) + assert isinstance(dest, bytes) and len(dest) > 0 + assert dest == wasm.encode_destination(addr, Network.MAINNET) + + +def test_multisig_challenge_roundtrip(wasm: Client) -> None: + pub1 = wasm.public_key_from_private_key(wasm.make_private_key()) + pub2 = wasm.public_key_from_private_key(wasm.make_private_key()) + challenge = wasm.encode_multisig_challenge(pub1 + pub2, 2, Network.MAINNET) + assert isinstance(challenge, bytes) and len(challenge) > 0 + address = wasm.multisig_challenge_to_address(challenge, Network.MAINNET) + assert address.startswith("mmtc1"), f"unexpected multisig address prefix: {address}" + assert address == wasm.multisig_challenge_to_address(challenge, Network.MAINNET) + + +def test_multisig_address_differs_from_single_key_address(wasm: Client) -> None: + pub1 = wasm.public_key_from_private_key(wasm.make_private_key()) + pub2 = wasm.public_key_from_private_key(wasm.make_private_key()) + multisig = wasm.multisig_challenge_to_address( + wasm.encode_multisig_challenge(pub1 + pub2, 2, Network.MAINNET), Network.MAINNET + ) + single = wasm.pubkey_to_pubkeyhash_address(pub1, Network.MAINNET) + assert multisig != single + + +def test_invalid_public_key_address_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.pubkey_to_pubkeyhash_address(b"abc", Network.MAINNET) + + +def test_encode_destination_invalid_address_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_destination("not-an-address", Network.MAINNET) + + +def test_multisig_challenge_invalid_pubkeys_raise(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_multisig_challenge(b"\x00" * 10, 1, Network.MAINNET) + + +def test_multisig_challenge_to_address_garbage_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.multisig_challenge_to_address(b"\xff\xff", Network.MAINNET) diff --git a/tests/test_wasm_array_rollback.py b/tests/test_wasm_array_rollback.py new file mode 100644 index 0000000..33c592f --- /dev/null +++ b/tests/test_wasm_array_rollback.py @@ -0,0 +1,219 @@ +"""Tests for the pre-call rollback branches of the externref array writers. + +Fault injection (mirroring test_wasm_lifecycle.py) forces mid-loop failures +in ``_write_string_array`` / ``_write_uint8_array_array`` (``table.set`` +raising) and in ``estimate_transaction_size`` (``_write_bytes`` raising on +the outputs write) so the host-side rollback branches run: the +already-allocated externref table slots must be released via +``_dealloc_indices`` (reading back null and handed out again by the +allocator), backing buffers freed, the original exception re-raised, and the +client left fully usable. +""" + +from __future__ import annotations + +from typing import Any + +import pytest +from wasm_helpers import Wallet, fake_input +from wasmtime import Val + +from mintlayer.wasm import Amount, Client, Network + +# ── fault-injection helpers ─────────────────────────────────────────────────── + + +class TableSetFailsNth: + """Proxy for the externref table that fails the Nth ``set()`` call. + + Mirrors the ``MemorySpy`` pattern (instance attribute replacing the real + object): everything except ``set()`` is delegated to the real wasmtime + table. Slot indices are recorded for every ``set()`` attempt, including + the failing one, so tests know exactly which slots the rollback must + release. + """ + + def __init__(self, real: Any, fail_on: int) -> None: + self._real = real + self._fail_on = fail_on + self._calls = 0 + self.attempted_indices: list[int] = [] + self.error = RuntimeError("injected table.set failure") + + def set(self, store: Any, idx: int, value: Any) -> None: + self._calls += 1 + self.attempted_indices.append(idx) + if self._calls == self._fail_on: + raise self.error + self._real.set(store, idx, value) + + def __getattr__(self, name: str) -> Any: + return getattr(self._real, name) + + +def _is_null_anyref(value: object) -> bool: + """True when wasmtime reports a table slot as null/undefined (released).""" + if value is None: + return True + if isinstance(value, Val): + return value.__dict__.get("_val", object()) is None + return False + + +def _alloc_reusable_slot(c: Client) -> int: + """Allocate one externref-table slot from the reusable (recycled) region. + + Mirrors the helper in test_wasm_transactions.py: the module's lowest + table indices form a permanent slab that ``__externref_table_dealloc`` + deliberately does not recycle. Probing until a freed slot is handed out + again guarantees the free list is active, making later slot-reuse + assertions deterministic regardless of prior table state. + """ + for _ in range(512): + probe = c._invoke1("__externref_table_alloc") + c._dealloc_indices([probe]) + if c._invoke1("__externref_table_alloc") == probe: + return probe + raise AssertionError("no reusable externref table slot found") + + +def _assert_rolled_back_slots_released(c: Client, released: set[int]) -> None: + """Every rolled-back slot reads back null and is handed out again.""" + for idx in released: + assert _is_null_anyref(c.table.get(c.store, idx)), f"slot {idx} still holds a value" + for _ in range(512): + probe = c._invoke1("__externref_table_alloc") + c._dealloc_indices([probe]) + if probe in released: + return + raise AssertionError(f"none of the rolled-back slots {sorted(released)} was reused") + + +# ── _write_string_array rollback ────────────────────────────────────────────── + + +def test_write_string_array_rollback_releases_slots_on_mid_loop_failure( + wasm: Client, monkeypatch: pytest.MonkeyPatch +) -> None: + """``table.set`` raising on the 2nd element rolls back every slot so far.""" + _alloc_reusable_slot(wasm) # make slot-reuse assertions deterministic + table_spy = TableSetFailsNth(wasm.table, fail_on=2) + monkeypatch.setattr(wasm, "table", table_spy) + + with pytest.raises(RuntimeError) as excinfo: + wasm._write_string_array(["a", "b", "c"]) + + # The original injected exception propagated: the rollback neither + # swallowed nor replaced it. + assert excinfo.value is table_spy.error + # Two slots were allocated before the failure (2nd set() raised); both + # were appended to the indices list and must have been released. + assert len(table_spy.attempted_indices) == 2 + _assert_rolled_back_slots_released(wasm, set(table_spy.attempted_indices)) + + +# ── _write_uint8_array_array rollback ───────────────────────────────────────── + + +def test_write_uint8_array_array_rollback_releases_slots_and_buffers( + wasm: Client, monkeypatch: pytest.MonkeyPatch +) -> None: + """``table.set`` raising rolls back slots AND frees the backing buffers.""" + _alloc_reusable_slot(wasm) + table_spy = TableSetFailsNth(wasm.table, fail_on=2) + monkeypatch.setattr(wasm, "table", table_spy) + + writes: list[tuple[int, int]] = [] + frees: list[tuple[int, int]] = [] + original_write_bytes = wasm._write_bytes + original_free_wasm = wasm._free_wasm + + def recording_write_bytes(data: bytes) -> tuple[int, int]: + result = original_write_bytes(data) + writes.append(result) + return result + + def recording_free_wasm(ptr: int, size: int, align: int = 1) -> None: + frees.append((ptr, size)) + original_free_wasm(ptr, size, align) + + monkeypatch.setattr(wasm, "_write_bytes", recording_write_bytes) + monkeypatch.setattr(wasm, "_free_wasm", recording_free_wasm) + + with pytest.raises(RuntimeError) as excinfo: + wasm._write_uint8_array_array([b"slice-0", b"slice-1", b"slice-2"]) + + assert excinfo.value is table_spy.error + # One backing buffer per attempted slice: both were written before the + # failure and both must have been freed by the rollback (buffer free is + # best-effort host-side; the free call itself must have been made). + assert len(writes) == 2 + for buffer in writes: + assert buffer in frees + # Every externref slot touched before the failure is released too. + assert len(table_spy.attempted_indices) == 2 + _assert_rolled_back_slots_released(wasm, set(table_spy.attempted_indices)) + + +# ── estimate_transaction_size narrow rollback ───────────────────────────────── + + +def test_estimate_transaction_size_rollback_leaves_client_usable( + wasm: Client, monkeypatch: pytest.MonkeyPatch +) -> None: + """``_write_bytes`` failing on the outputs write rolls the dest slots back. + + The narrow rollback in ``estimate_transaction_size`` must release the + destination slots allocated by ``_write_string_array`` (the callee never + ran, so the host still owns them) and leave the client fully usable. + """ + wallet = Wallet(wasm) + inputs = fake_input(wasm) + outputs = wasm.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + tx = wasm.encode_transaction(inputs, outputs, 0) + + _alloc_reusable_slot(wasm) # make the table-size invariant deterministic + warm = wasm.estimate_transaction_size(tx, [wallet.addr], outputs, Network.MAINNET) + assert warm > 0 + baseline_table = wasm.table.size(wasm.store) + + boom = RuntimeError("injected outputs write failure") + calls = {"count": 0} + original_write_bytes = wasm._write_bytes + original_string_array = wasm._write_string_array + array_indices: list[list[int]] = [] + + def fail_on_second_write(data: bytes) -> tuple[int, int]: + calls["count"] += 1 + if calls["count"] == 2: + raise boom + return original_write_bytes(data) + + def recording_string_array(strs: list[str]) -> tuple[int, list[int]]: + result = original_string_array(strs) + array_indices.append(result[1]) + return result + + monkeypatch.setattr(wasm, "_write_bytes", fail_on_second_write) + monkeypatch.setattr(wasm, "_write_string_array", recording_string_array) + + # inputs write (1st call) succeeds, the destinations array write + # succeeds, outputs write (2nd call) fails → rollback must run. + with pytest.raises(RuntimeError) as excinfo: + wasm.estimate_transaction_size(tx, [wallet.addr], outputs, Network.MAINNET) + assert excinfo.value is boom + assert calls["count"] == 2 + assert len(array_indices) == 1 and len(array_indices[0]) == 1 + # The narrow rollback must have released the destination slot already: + # the callee never ran, so the host still owns it. It reads back null + # and is handed out again by the allocator — not leaked. + _assert_rolled_back_slots_released(wasm, set(array_indices[0])) + + # The client is fully usable afterwards: the next real estimate succeeds + # with the very same result, and the externref table did not grow — the + # rolled-back slot was recycled, not leaked. + recovered = wasm.estimate_transaction_size(tx, [wallet.addr], outputs, Network.MAINNET) + assert recovered == warm + assert wasm.table.size(wasm.store) == baseline_table diff --git a/tests/test_wasm_ids.py b/tests/test_wasm_ids.py new file mode 100644 index 0000000..2e1a68c --- /dev/null +++ b/tests/test_wasm_ids.py @@ -0,0 +1,83 @@ +"""Tests for WASM object-ID derivation (mirrors go-sdk/wasm/ids.go). + +Pool/token/delegation/order IDs are derived from the *encoded inputs* of the +issuance transaction; the tests use a real encoded UTXO input. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import HEIGHT, fake_input + +from mintlayer.wasm import Client, Network, WasmError + + +def test_pool_id(wasm: Client) -> None: + pool_id = wasm.get_pool_id(fake_input(wasm), Network.MAINNET) + assert pool_id.startswith("mpool1") + assert pool_id == wasm.get_pool_id(fake_input(wasm), Network.MAINNET) # deterministic + + +def test_token_id(wasm: Client) -> None: + token_id = wasm.get_token_id(fake_input(wasm), HEIGHT, Network.MAINNET) + assert token_id.startswith("mmltk1") + assert token_id == wasm.get_token_id(fake_input(wasm), HEIGHT, Network.MAINNET) + + +def test_delegation_id(wasm: Client) -> None: + delegation_id = wasm.get_delegation_id(fake_input(wasm), Network.MAINNET) + assert delegation_id.startswith("mdelg1") + assert delegation_id == wasm.get_delegation_id(fake_input(wasm), Network.MAINNET) + + +def test_order_id(wasm: Client) -> None: + order_id = wasm.get_order_id(fake_input(wasm), Network.MAINNET) + assert order_id.startswith("mordr1") + assert order_id == wasm.get_order_id(fake_input(wasm), Network.MAINNET) + + +def test_ids_are_distinct_per_object_kind(wasm: Client) -> None: + inp = fake_input(wasm) + ids = { + wasm.get_pool_id(inp, Network.MAINNET), + wasm.get_token_id(inp, HEIGHT, Network.MAINNET), + wasm.get_delegation_id(inp, Network.MAINNET), + wasm.get_order_id(inp, Network.MAINNET), + } + assert len(ids) == 4, "different object kinds must derive different ids" + + +def test_ids_differ_for_different_inputs(wasm: Client) -> None: + a = wasm.get_pool_id(fake_input(wasm, txid=b"\x01" * 32), Network.MAINNET) + b = wasm.get_pool_id(fake_input(wasm, txid=b"\x02" * 32), Network.MAINNET) + assert a != b + + +def test_ids_depend_on_network(wasm: Client) -> None: + inp = fake_input(wasm) + assert wasm.get_pool_id(inp, Network.MAINNET) != wasm.get_pool_id(inp, Network.TESTNET) + + +def test_pool_id_garbage_inputs_raise(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_pool_id(b"\xff\xff", Network.MAINNET) + + +def test_pool_id_empty_inputs_raise(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_pool_id(b"", Network.MAINNET) + + +def test_delegation_id_garbage_inputs_raise(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_delegation_id(b"\xff\xff", Network.MAINNET) + + +def test_order_id_garbage_inputs_raise(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_order_id(b"\xff\xff", Network.MAINNET) + + +def test_token_id_garbage_inputs_raise(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_token_id(b"\xff\xff", HEIGHT, Network.MAINNET) diff --git a/tests/test_wasm_inputs_fees.py b/tests/test_wasm_inputs_fees.py new file mode 100644 index 0000000..323cba7 --- /dev/null +++ b/tests/test_wasm_inputs_fees.py @@ -0,0 +1,210 @@ +"""Tests for WASM inputs, timelocks, fees and staking helpers. + +The VRF public key used for pool data is the real mainnet vector from +mintlayer-core; every error-path assertion pins the ``mintlayer: `` message +prefix required by the SDK's error contract. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import HEIGHT, ORDERS_HEIGHT, VRF_MAINNET, Wallet, fake_input + +from mintlayer.wasm import Amount, Client, Network, SourceId, TokenUnfreezable, WasmError + +# ── inputs ──────────────────────────────────────────────────────────────────── + + +def test_encode_input_for_utxo(wasm: Client) -> None: + inp = wasm.encode_input_for_utxo( + wasm.encode_outpoint_source_id(b"\x01" * 32, SourceId.SOURCE_TRANSACTION), 0 + ) + assert isinstance(inp, bytes) and len(inp) > 0 + assert inp == fake_input(wasm) # deterministic + + +def test_utxo_input_depends_on_index(wasm: Client) -> None: + assert fake_input(wasm, index=0) != fake_input(wasm, index=1) + + +def test_encode_input_for_withdraw_from_delegation(wasm: Client) -> None: + delegation_id = wasm.get_delegation_id(fake_input(wasm), Network.MAINNET) + inp = wasm.encode_input_for_withdraw_from_delegation( + delegation_id, Amount.from_atoms("1"), 3, Network.MAINNET + ) + assert len(inp) > 0 + + +def test_encode_input_for_mint_unmint_lock(wasm: Client) -> None: + token_id = wasm.get_token_id(fake_input(wasm), HEIGHT, Network.MAINNET) + assert ( + len(wasm.encode_input_for_mint_tokens(token_id, Amount.from_atoms("1"), 3, Network.MAINNET)) + > 0 + ) + assert len(wasm.encode_input_for_unmint_tokens(token_id, 3, Network.MAINNET)) > 0 + assert len(wasm.encode_input_for_lock_token_supply(token_id, 3, Network.MAINNET)) > 0 + + +def test_encode_input_for_freeze_unfreeze_token(wasm: Client) -> None: + token_id = wasm.get_token_id(fake_input(wasm), HEIGHT, Network.MAINNET) + freeze = wasm.encode_input_for_freeze_token(token_id, TokenUnfreezable.YES, 3, Network.MAINNET) + assert len(freeze) > 0 + assert len(wasm.encode_input_for_unfreeze_token(token_id, 3, Network.MAINNET)) > 0 + + +def test_encode_input_for_change_token_authority_and_metadata(wasm: Client) -> None: + token_id = wasm.get_token_id(fake_input(wasm), HEIGHT, Network.MAINNET) + wallet = Wallet(wasm) + assert ( + len(wasm.encode_input_for_change_token_authority(token_id, wallet.addr, 3, Network.MAINNET)) + > 0 + ) + assert ( + len( + wasm.encode_input_for_change_token_metadata_uri( + token_id, "https://example.com/meta.json", 3, Network.MAINNET + ) + ) + > 0 + ) + + +def test_encode_input_for_conclude_fill_freeze_order(wasm: Client) -> None: + order_id = wasm.get_order_id(fake_input(wasm), Network.MAINNET) + wallet = Wallet(wasm) + assert len(wasm.encode_input_for_conclude_order(order_id, 3, HEIGHT, Network.MAINNET)) > 0 + assert ( + len( + wasm.encode_input_for_fill_order( + order_id, Amount.from_atoms("1"), wallet.addr, 3, HEIGHT, Network.MAINNET + ) + ) + > 0 + ) + # Order freezing only exists after the orders V1 fork. + assert len(wasm.encode_input_for_freeze_order(order_id, ORDERS_HEIGHT, Network.MAINNET)) > 0 + + +def test_freeze_order_before_fork_raises(wasm: Client) -> None: + order_id = wasm.get_order_id(fake_input(wasm), Network.MAINNET) + with pytest.raises(WasmError, match="Orders V1 not activated"): + wasm.encode_input_for_freeze_order(order_id, 100, Network.MAINNET) + + +def test_input_error_paths(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_input_for_withdraw_from_delegation( + "bad-id", Amount.from_atoms("1"), 0, Network.MAINNET + ) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_input_for_mint_tokens("bad-token", Amount.from_atoms("1"), 0, Network.MAINNET) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_input_for_mint_tokens( + "mmltk1jh783nqq5cnm73kq5jnwg8g6rnnf53h3d90c6mtv0y408jp4quqq696z9s", + Amount.from_atoms("not-a-number"), + 0, + Network.MAINNET, + ) + + +# ── timelocks ───────────────────────────────────────────────────────────────── + + +def test_timelocks_encode_non_empty(wasm: Client) -> None: + assert len(wasm.encode_lock_for_block_count(100)) > 0 + assert len(wasm.encode_lock_for_seconds(86400)) > 0 + assert len(wasm.encode_lock_until_height(HEIGHT)) > 0 + assert len(wasm.encode_lock_until_time(1_700_000_000)) > 0 + + +def test_timelocks_are_deterministic_and_argument_sensitive(wasm: Client) -> None: + assert wasm.encode_lock_for_block_count(100) == wasm.encode_lock_for_block_count(100) + assert wasm.encode_lock_for_block_count(100) != wasm.encode_lock_for_block_count(101) + assert wasm.encode_lock_until_height(HEIGHT) != wasm.encode_lock_until_time(HEIGHT) + + +# ── fees ────────────────────────────────────────────────────────────────────── + + +def test_fees_are_positive_at_fixed_height(wasm: Client) -> None: + fees = [ + wasm.fungible_token_issuance_fee(HEIGHT, Network.MAINNET), + wasm.nft_issuance_fee(HEIGHT, Network.MAINNET), + wasm.data_deposit_fee(HEIGHT, Network.MAINNET), + wasm.token_supply_change_fee(HEIGHT, Network.MAINNET), + wasm.token_freeze_fee(HEIGHT, Network.MAINNET), + wasm.token_change_authority_fee(HEIGHT, Network.MAINNET), + ] + for fee in fees: + assert isinstance(fee, Amount) + assert fee.atoms not in ("", "0"), f"expected a non-zero fee, got {fee.atoms!r}" + assert int(fee.atoms) > 0 + + +def test_fees_are_deterministic(wasm: Client) -> None: + a = wasm.fungible_token_issuance_fee(HEIGHT, Network.MAINNET) + b = wasm.fungible_token_issuance_fee(HEIGHT, Network.MAINNET) + assert a == b + + +# ── staking ─────────────────────────────────────────────────────────────────── + + +def test_encode_stake_pool_data(wasm: Client) -> None: + wallet = Wallet(wasm) + data = wasm.encode_stake_pool_data( + Amount.from_atoms("40000000000000"), + wallet.addr, + VRF_MAINNET, + wallet.addr, + 100, + Amount.from_atoms("100000000"), + Network.MAINNET, + ) + assert isinstance(data, bytes) and len(data) > 0 + assert data == wasm.encode_stake_pool_data( + Amount.from_atoms("40000000000000"), + wallet.addr, + VRF_MAINNET, + wallet.addr, + 100, + Amount.from_atoms("100000000"), + Network.MAINNET, + ) + + +def test_encode_stake_pool_data_invalid_vrf_key_raises(wasm: Client) -> None: + wallet = Wallet(wasm) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_stake_pool_data( + Amount.from_atoms("40000000000000"), + wallet.addr, + "vrfpk1qqqsyqcyq5rqwzqfpg9scrgwpugpzysnzs23v9ccrydpk8qarc0sq3rz3k", # wrong HRP + wallet.addr, + 100, + Amount.from_atoms("100000000"), + Network.MAINNET, + ) + + +def test_effective_pool_balance(wasm: Client) -> None: + balance = wasm.effective_pool_balance( + Network.MAINNET, + Amount.from_atoms("50000000000"), + Amount.from_atoms("1000000000000"), + ) + assert isinstance(balance, Amount) + assert int(balance.atoms) > 0 + + +def test_effective_pool_balance_invalid_amount_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="Invalid atoms amount"): + wasm.effective_pool_balance( + Network.MAINNET, Amount.from_atoms("zz"), Amount.from_atoms("1") + ) + + +def test_staking_pool_spend_maturity_block_count(wasm: Client) -> None: + count = wasm.staking_pool_spend_maturity_block_count(HEIGHT, Network.MAINNET) + assert count > 0 + assert count == wasm.staking_pool_spend_maturity_block_count(HEIGHT, Network.MAINNET) diff --git a/tests/test_wasm_intents.py b/tests/test_wasm_intents.py new file mode 100644 index 0000000..a3816cf --- /dev/null +++ b/tests/test_wasm_intents.py @@ -0,0 +1,75 @@ +"""Tests for WASM transaction intents (mirrors go-sdk/wasm/intent.go). + +Flow: derive the canonical message to sign, sign it with the input key, +encode the signed intent, then verify — including destination-mismatch +rejection. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import Wallet, fake_input + +from mintlayer.wasm import Amount, Client, Network, WasmError + + +@pytest.fixture +def wallet(wasm: Client) -> Wallet: + return Wallet(wasm) + + +@pytest.fixture +def tx_id(wasm: Client, wallet: Wallet) -> str: + inp = fake_input(wasm) + out = wasm.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + tx = wasm.encode_transaction(inp, out, 0) + return wasm.get_transaction_id(tx, True) + + +def test_message_to_sign_is_deterministic(wasm: Client, tx_id: str) -> None: + message = wasm.make_transaction_intent_message_to_sign("test-intent", tx_id) + assert isinstance(message, bytes) and len(message) > 0 + assert message == wasm.make_transaction_intent_message_to_sign("test-intent", tx_id) + + +def test_message_to_sign_depends_on_inputs(wasm: Client, tx_id: str) -> None: + base = wasm.make_transaction_intent_message_to_sign("test-intent", tx_id) + other_intent = wasm.make_transaction_intent_message_to_sign("other-intent", tx_id) + other_txid = wasm.make_transaction_intent_message_to_sign("test-intent", "ff" * 32) + assert base != other_intent + assert base != other_txid + + +def test_intent_roundtrip(wasm: Client, wallet: Wallet, tx_id: str) -> None: + message = wasm.make_transaction_intent_message_to_sign("test-intent", tx_id) + signature = wasm.sign_challenge(wallet.recv, message) + encoded = wasm.encode_signed_transaction_intent(message, [signature]) + assert isinstance(encoded, bytes) and len(encoded) > 0 + wasm.verify_transaction_intent(message, encoded, [wallet.addr], Network.MAINNET) + + +def test_intent_rejects_mismatched_destinations(wasm: Client, wallet: Wallet, tx_id: str) -> None: + message = wasm.make_transaction_intent_message_to_sign("test-intent", tx_id) + signature = wasm.sign_challenge(wallet.recv, message) + encoded = wasm.encode_signed_transaction_intent(message, [signature]) + with pytest.raises(WasmError, match="^mintlayer: "): + # Two destinations for a one-signature intent: must not verify. + wasm.verify_transaction_intent( + message, encoded, [wallet.addr, wallet.addr], Network.MAINNET + ) + + +def test_intent_rejects_wrong_message(wasm: Client, wallet: Wallet, tx_id: str) -> None: + message = wasm.make_transaction_intent_message_to_sign("test-intent", tx_id) + signature = wasm.sign_challenge(wallet.recv, message) + encoded = wasm.encode_signed_transaction_intent(message, [signature]) + other = wasm.make_transaction_intent_message_to_sign("test-intent", "ff" * 32) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.verify_transaction_intent(other, encoded, [wallet.addr], Network.MAINNET) + + +def test_intent_message_bad_txid_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="Error parsing transaction id"): + wasm.make_transaction_intent_message_to_sign("test-intent", "nothex") diff --git a/tests/test_wasm_keys.py b/tests/test_wasm_keys.py new file mode 100644 index 0000000..f38f3d8 --- /dev/null +++ b/tests/test_wasm_keys.py @@ -0,0 +1,90 @@ +"""Tests for WASM key derivation (mirrors go-sdk/wasm keys tests). + +The derivation vectors use the standard "abandon ... about" mnemonic; the +private-path vs extended-public-path address equality is the key invariant +from Go's TestKeyDerivationChain. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import MNEMONIC, derive + +from mintlayer.wasm import Client, Network, WasmError + + +def test_make_private_key(wasm: Client) -> None: + key = wasm.make_private_key() + assert len(key) > 0 + assert any(b != 0 for b in key), "private key is all zeros" + + +def test_make_private_key_is_random(wasm: Client) -> None: + assert wasm.make_private_key() != wasm.make_private_key() + + +def test_make_default_account_privkey_is_deterministic(wasm: Client) -> None: + key = wasm.make_default_account_privkey(MNEMONIC, Network.MAINNET) + again = wasm.make_default_account_privkey(MNEMONIC, Network.MAINNET) + assert key == again + assert len(key) > 0 + + +def test_public_key_from_private_key(wasm: Client) -> None: + pub = wasm.public_key_from_private_key(wasm.make_private_key()) + assert len(pub) > 0 + assert any(b != 0 for b in pub) + + +def test_extended_key_pair_is_deterministic(wasm: Client) -> None: + account = wasm.make_default_account_privkey(MNEMONIC, Network.MAINNET) + ext1 = wasm.extended_public_key_from_extended_private_key(account) + ext2 = wasm.extended_public_key_from_extended_private_key(account) + assert ext1 == ext2 + assert len(ext1) > 0 + + +def test_receiving_and_change_addresses_differ(wasm: Client) -> None: + account = wasm.make_default_account_privkey(MNEMONIC, Network.MAINNET) + recv0 = wasm.make_receiving_address(account, 0) + recv1 = wasm.make_receiving_address(account, 1) + change0 = wasm.make_change_address(account, 0) + assert recv0 != recv1, "different key indices must derive different keys" + assert recv0 != change0, "receiving and change chains must diverge" + + +def test_receiving_and_change_public_keys(wasm: Client) -> None: + account = wasm.make_default_account_privkey(MNEMONIC, Network.MAINNET) + ext_pub = wasm.extended_public_key_from_extended_private_key(account) + recv_pub = wasm.make_receiving_address_public_key(ext_pub, 0) + change_pub = wasm.make_change_address_public_key(ext_pub, 0) + assert recv_pub == wasm.public_key_from_private_key(wasm.make_receiving_address(account, 0)) + assert change_pub == wasm.public_key_from_private_key(wasm.make_change_address(account, 0)) + + +def test_full_derivation_chain_equality(wasm: Client) -> None: + """Address derived via private keys equals the one via extended public keys.""" + account, _recv, pub, addr = derive(wasm) + ext_pub = wasm.extended_public_key_from_extended_private_key(account) + pub_from_ext = wasm.make_receiving_address_public_key(ext_pub, 0) + addr_from_ext = wasm.pubkey_to_pubkeyhash_address(pub_from_ext, Network.MAINNET) + assert pub == pub_from_ext + assert addr == addr_from_ext + assert addr + + +@pytest.mark.parametrize( + ("label", "call"), + [ + ("pub_from_garbage", lambda c: c.public_key_from_private_key(b"abc")), + ("ext_from_garbage", lambda c: c.extended_public_key_from_extended_private_key(b"abc")), + ("receiving_from_garbage", lambda c: c.make_receiving_address(b"abc", 0)), + ("change_from_garbage", lambda c: c.make_change_address(b"abc", 0)), + ("receiving_pub_from_garbage", lambda c: c.make_receiving_address_public_key(b"abc", 0)), + ("change_pub_from_garbage", lambda c: c.make_change_address_public_key(b"abc", 0)), + ("empty_mnemonic", lambda c: c.make_default_account_privkey("", Network.MAINNET)), + ], +) +def test_key_error_paths(wasm: Client, label: str, call) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + call(wasm) diff --git a/tests/test_wasm_lifecycle.py b/tests/test_wasm_lifecycle.py new file mode 100644 index 0000000..1caed8c --- /dev/null +++ b/tests/test_wasm_lifecycle.py @@ -0,0 +1,201 @@ +"""Tests for WASM client lifecycle and the low-level _core machinery. + +Covers instantiation, close()/context-manager semantics, closed-client +errors, the sha256 integrity pin, call-convention edge cases reachable from +Python (unknown exports, unexpected return counts, memory-read failures), +and the documented result-buffer zeroing behaviour. +""" + +from __future__ import annotations + +import hashlib +import threading + +import pytest +from wasm_helpers import MemorySpy + +from mintlayer.wasm import Client, Network, WasmError +from mintlayer.wasm import _core as wasm_core + +# ── integrity pin ───────────────────────────────────────────────────────────── + + +def test_integrity_pin_file_matches_binary() -> None: + """The vendored WASM binary matches its committed sha256 pin.""" + pin_path = wasm_core._WASM_PATH.with_suffix(".wasm.sha256") + assert pin_path.exists(), "sha256 pin file must be shipped next to the binary" + expected = pin_path.read_text().split()[0].strip() + actual = hashlib.sha256(wasm_core._WASM_BYTES).hexdigest() + assert actual == expected + # The import-time check must also succeed via the same code path. + wasm_core._verify_wasm_integrity() + + +def test_integrity_pin_rejects_tampered_binary(monkeypatch: pytest.MonkeyPatch) -> None: + """A mismatching binary fails closed with a descriptive error.""" + monkeypatch.setattr(wasm_core, "_WASM_BYTES", b"tampered") + with pytest.raises(WasmError, match="integrity check failed"): + wasm_core._verify_wasm_integrity() + + +# ── lifecycle ───────────────────────────────────────────────────────────────── + + +def test_instantiation_and_basic_call() -> None: + c = Client() + try: + assert c.make_private_key() + finally: + c.close() + + +def test_context_manager_closes() -> None: + with Client() as c: + c.make_private_key() + with pytest.raises(WasmError, match="closed"): + c.make_private_key() + + +def test_close_is_idempotent() -> None: + c = Client() + c.make_private_key() + c.close() + c.close() + + +def test_closed_client_rejects_calls() -> None: + c = Client() + c.close() + with pytest.raises(WasmError, match="closed"): + c.make_private_key() + + +def test_get_export_after_close_is_none() -> None: + c = Client() + c.close() + assert c.get_export("make_private_key") is None + + +# ── export lookup / low-level call conventions ──────────────────────────────── + + +def test_call_unknown_export(wasm: Client) -> None: + with pytest.raises(WasmError, match='function "no_such_export" not found'): + wasm._call("no_such_export") + + +def test_fn_lookup_unknown_export_open_client(wasm: Client) -> None: + with pytest.raises(WasmError, match="not found"): + wasm._fn("no_such_export") + + +def test_call_return_bytes_unexpected_count(wasm: Client) -> None: + wasm._exports["fake_no_ret"] = lambda store: None + try: + with pytest.raises(WasmError, match="unexpected return count"): + wasm._call_return_bytes("fake_no_ret") + with pytest.raises(WasmError, match="unexpected return count"): + wasm._call_return_string("fake_no_ret") + with pytest.raises(WasmError, match="unexpected return count"): + wasm._call_return_bytes_no_err("fake_no_ret") + finally: + del wasm._exports["fake_no_ret"] + + +def test_call_return_json_without_json_result( + wasm: Client, monkeypatch: pytest.MonkeyPatch +) -> None: + """A successful call that captured no JSON payload is an error.""" + monkeypatch.setattr(wasm, "_call", lambda name, *params: [0, 0]) + with pytest.raises(WasmError, match="no JSON result"): + wasm._call_return_json("fake_json_fn") + + +def test_read_bytes_out_of_bounds_is_empty(wasm: Client) -> None: + """Out-of-bounds reads are clamped to an empty buffer by wasmtime.""" + data = wasm._read_bytes(0xFFFF_FFFF, 16) + assert data is not None and len(data) == 0 + + +def test_memory_read_failure(wasm: Client, monkeypatch: pytest.MonkeyPatch) -> None: + """If the result buffer cannot be read back, callers get a clear error.""" + pub = wasm.public_key_from_private_key(wasm.make_private_key()) + monkeypatch.setattr(wasm, "_read_bytes", lambda ptr, length: None) + with pytest.raises(WasmError, match="memory read failed"): + wasm.pubkey_to_pubkeyhash_address(pub, Network.MAINNET) + + +def test_no_return_value_from_amount_call(wasm: Client, monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setattr(wasm, "_call", lambda name, *params: []) + with pytest.raises(WasmError, match="no return value"): + wasm._call_return_amount("fake_amount_fn") + with pytest.raises(WasmError, match="no return value"): + wasm._call_return_amount_fallible("fake_amount_fn") + + +def test_memory_helpers_edge_cases(wasm: Client) -> None: + """Empty/None writes are the (0, 0) null pair; freeing null is a no-op.""" + assert wasm._write_bytes(b"") == (0, 0) + assert wasm._write_string("") == (0, 0) + assert wasm._write_optional_string(None) == (0, 0) + assert wasm._write_optional_bytes(None) == (0, 0) + wasm._free_wasm(0, 128) # null pointer: must not touch the allocator + wasm._dealloc_indices([]) # empty: no table slots to release + + +def test_write_bytes_roundtrip(wasm: Client) -> None: + ptr, length = wasm._write_bytes(b"payload") + try: + assert length == len(b"payload") + data = wasm.memory.read(wasm.store, ptr, ptr + length) + assert data is not None and bytes(data) == b"payload" + finally: + wasm._free_wasm(ptr, length) + + +# ── memory hygiene ──────────────────────────────────────────────────────────── + + +def test_result_buffers_are_zeroed_before_release(wasm: Client) -> None: + """Key-bearing result buffers are zeroed in WASM memory before being freed.""" + spy = MemorySpy(wasm.memory) + original = wasm.memory + wasm.memory = spy # type: ignore[assignment] + try: + key = wasm.make_private_key() + finally: + wasm.memory = original + assert len(key) > 0 + assert len(key) in spy.zero_writes, "result buffer carrying the key must be zeroed" + + +# ── concurrency ─────────────────────────────────────────────────────────────── + + +def test_concurrent_calls_are_serialised(wasm: Client) -> None: + """Concurrent public calls all succeed on the shared single instance.""" + errors: list[Exception] = [] + keys: list[bytes] = [] + lock = threading.Lock() + + def worker() -> None: + try: + for _ in range(5): + key = wasm.make_private_key() + addr = wasm.pubkey_to_pubkeyhash_address( + wasm.public_key_from_private_key(key), Network.MAINNET + ) + assert addr + with lock: + keys.append(key) + except Exception as exc: # pragma: no cover - only on failure + errors.append(exc) + + threads = [threading.Thread(target=worker) for _ in range(4)] + for t in threads: + t.start() + for t in threads: + t.join() + assert not errors + assert len(keys) == 20 + assert len(set(keys)) == 20 diff --git a/tests/test_wasm_outputs.py b/tests/test_wasm_outputs.py new file mode 100644 index 0000000..ebef430 --- /dev/null +++ b/tests/test_wasm_outputs.py @@ -0,0 +1,278 @@ +"""Tests for WASM output encoding (mirrors go-sdk/wasm/outputs.go). + +Every ``encode_output_*`` method must return non-empty deterministic bytes; +error paths pin the ``mintlayer: `` prefix contract. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import HEIGHT, VRF_MAINNET, Wallet, fake_input + +from mintlayer.wasm import ( + Amount, + Client, + FreezableToken, + Network, + TotalSupply, + WasmError, +) + +ONE_ML = Amount.from_atoms("100000000000") + + +@pytest.fixture +def wallet(wasm: Client) -> Wallet: + return Wallet(wasm) + + +@pytest.fixture +def pool_id(wasm: Client) -> str: + return wasm.get_pool_id(fake_input(wasm), Network.MAINNET) + + +@pytest.fixture +def token_id(wasm: Client) -> str: + return wasm.get_token_id(fake_input(wasm), HEIGHT, Network.MAINNET) + + +@pytest.fixture +def delegation_id(wasm: Client) -> str: + return wasm.get_delegation_id(fake_input(wasm), Network.MAINNET) + + +@pytest.fixture +def lock(wasm: Client) -> bytes: + return wasm.encode_lock_for_block_count(100) + + +# ── transfers ───────────────────────────────────────────────────────────────── + + +def test_encode_output_transfer(wallet: Wallet, wasm: Client) -> None: + out = wasm.encode_output_transfer(ONE_ML, wallet.addr, Network.MAINNET) + assert isinstance(out, bytes) and len(out) > 0 + assert out == wasm.encode_output_transfer(ONE_ML, wallet.addr, Network.MAINNET) + + +def test_encode_output_token_transfer(wallet: Wallet, token_id: str, wasm: Client) -> None: + out = wasm.encode_output_token_transfer( + Amount.from_atoms("5"), wallet.addr, token_id, Network.MAINNET + ) + assert len(out) > 0 + assert out != wasm.encode_output_transfer(Amount.from_atoms("5"), wallet.addr, Network.MAINNET) + + +def test_encode_output_lock_then_transfer(wallet: Wallet, lock: bytes, wasm: Client) -> None: + out = wasm.encode_output_lock_then_transfer(ONE_ML, wallet.addr, lock, Network.MAINNET) + assert len(out) > 0 + assert out != wasm.encode_output_transfer(ONE_ML, wallet.addr, Network.MAINNET) + + +def test_encode_output_token_lock_then_transfer( + wallet: Wallet, token_id: str, lock: bytes, wasm: Client +) -> None: + out = wasm.encode_output_token_lock_then_transfer( + Amount.from_atoms("5"), wallet.addr, token_id, lock, Network.MAINNET + ) + assert len(out) > 0 + + +# ── burns and data ──────────────────────────────────────────────────────────── + + +def test_encode_output_coin_burn(wasm: Client) -> None: + out = wasm.encode_output_coin_burn(Amount.from_atoms("1")) + assert len(out) > 0 + + +def test_encode_output_token_burn(token_id: str, wasm: Client) -> None: + out = wasm.encode_output_token_burn(Amount.from_atoms("1"), token_id, Network.MAINNET) + assert len(out) > 0 + + +def test_encode_output_data_deposit(wasm: Client) -> None: + assert len(wasm.encode_output_data_deposit(b"hello on-chain")) > 0 + assert len(wasm.encode_output_data_deposit(b"")) > 0 # empty payload allowed + + +# ── staking outputs ─────────────────────────────────────────────────────────── + + +def test_encode_output_create_delegation(wallet: Wallet, pool_id: str, wasm: Client) -> None: + out = wasm.encode_output_create_delegation(pool_id, wallet.addr, Network.MAINNET) + assert len(out) > 0 + + +def test_encode_output_delegate_staking(delegation_id: str, wasm: Client) -> None: + out = wasm.encode_output_delegate_staking( + Amount.from_atoms("1000"), delegation_id, Network.MAINNET + ) + assert len(out) > 0 + + +def test_encode_output_create_stake_pool(wallet: Wallet, pool_id: str, wasm: Client) -> None: + pool_data = wasm.encode_stake_pool_data( + Amount.from_atoms("40000000000000"), + wallet.addr, + VRF_MAINNET, + wallet.addr, + 100, + Amount.from_atoms("100000000"), + Network.MAINNET, + ) + out = wasm.encode_output_create_stake_pool(pool_id, pool_data, Network.MAINNET) + assert len(out) > 0 + + +def test_encode_output_produce_block_from_stake(wallet: Wallet, pool_id: str, wasm: Client) -> None: + out = wasm.encode_output_produce_block_from_stake(pool_id, wallet.addr, Network.MAINNET) + assert len(out) > 0 + + +# ── HTLC ────────────────────────────────────────────────────────────────────── + + +def test_encode_output_htlc_coin(wallet: Wallet, lock: bytes, wasm: Client) -> None: + secret_hash = "03" * 20 # RIPEMD160(SHA256(secret)) as hex + out = wasm.encode_output_htlc( + ONE_ML, None, secret_hash, wallet.addr, wallet.addr, lock, Network.MAINNET + ) + assert len(out) > 0 + + +def test_encode_output_htlc_token(wallet: Wallet, token_id: str, lock: bytes, wasm: Client) -> None: + out = wasm.encode_output_htlc( + Amount.from_atoms("5"), + token_id, + "ab" * 20, + wallet.addr, + wallet.addr, + lock, + Network.MAINNET, + ) + assert len(out) > 0 + + +def test_encode_output_htlc_bad_secret_hash(wallet: Wallet, lock: bytes, wasm: Client) -> None: + with pytest.raises(WasmError, match="htlc secret hash"): + wasm.encode_output_htlc( + ONE_ML, None, "03" * 32, wallet.addr, wallet.addr, lock, Network.MAINNET + ) + + +# ── issuance ────────────────────────────────────────────────────────────────── + + +def test_encode_output_issue_fungible_token_lockable(wallet: Wallet, wasm: Client) -> None: + out = wasm.encode_output_issue_fungible_token( + wallet.addr, + "GLD", + "https://example.com/gld.json", + 8, + TotalSupply.LOCKABLE, + None, + FreezableToken.YES, + HEIGHT, + Network.MAINNET, + ) + assert len(out) > 0 + + +def test_encode_output_issue_fungible_token_fixed(wallet: Wallet, wasm: Client) -> None: + out = wasm.encode_output_issue_fungible_token( + wallet.addr, + "GLD", + "", + 8, + TotalSupply.FIXED, + Amount.from_atoms("1000000"), + FreezableToken.NO, + HEIGHT, + Network.MAINNET, + ) + assert len(out) > 0 + + +def test_issue_fixed_supply_without_amount_raises(wallet: Wallet, wasm: Client) -> None: + with pytest.raises(WasmError, match="fixed total supply"): + wasm.encode_output_issue_fungible_token( + wallet.addr, + "GLD", + "", + 8, + TotalSupply.FIXED, + None, + FreezableToken.NO, + HEIGHT, + Network.MAINNET, + ) + + +def test_encode_output_issue_nft_minimal(wallet: Wallet, token_id: str, wasm: Client) -> None: + out = wasm.encode_output_issue_nft( + token_id, + wallet.addr, + "TestNFT", + "TNFT", + "TestNFTDescription", + b"\x02" * 32, + None, + None, + None, + None, + HEIGHT, + Network.MAINNET, + ) + assert len(out) > 0 + + +def test_encode_output_issue_nft_full(wallet: Wallet, token_id: str, wasm: Client) -> None: + out = wasm.encode_output_issue_nft( + token_id, + wallet.addr, + "TestNFT", + "TNFT", + "TestNFTDescription", + b"\x02" * 32, + wallet.pub, + "https://example.com/media", + "https://example.com/icon", + "https://example.com/meta", + HEIGHT, + Network.MAINNET, + ) + assert len(out) > 0 + + +# ── DEX orders ──────────────────────────────────────────────────────────────── + + +def test_encode_create_order_output_coin_for_token( + wallet: Wallet, token_id: str, wasm: Client +) -> None: + out = wasm.encode_create_order_output( + ONE_ML, None, Amount.from_atoms("20"), token_id, wallet.addr, Network.MAINNET + ) + assert len(out) > 0 + + +def test_encode_create_order_output_coin_for_coin(wallet: Wallet, wasm: Client) -> None: + out = wasm.encode_create_order_output( + ONE_ML, None, Amount.from_atoms("2"), None, wallet.addr, Network.MAINNET + ) + assert len(out) > 0 + + +# ── error contract ──────────────────────────────────────────────────────────── + + +def test_output_error_messages_carry_mintlayer_prefix(wallet: Wallet, wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: Invalid atoms amount: xyz$"): + wasm.encode_output_transfer(Amount.from_atoms("xyz"), wallet.addr, Network.MAINNET) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_output_transfer(ONE_ML, "not-an-address", Network.MAINNET) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_output_token_transfer( + Amount.from_atoms("1"), wallet.addr, "bad-token", Network.MAINNET + ) diff --git a/tests/test_wasm_signing.py b/tests/test_wasm_signing.py new file mode 100644 index 0000000..3cd0b2f --- /dev/null +++ b/tests/test_wasm_signing.py @@ -0,0 +1,205 @@ +"""Tests for WASM signing: witnesses, message signatures and verification. + +Mirrors go-sdk TestSignChallengeRoundtrip, TestSignMessageForSpendingRoundtrip +and TestEncodeWitnessNoSignature; the transaction-witness flow uses a real +signed UTXO input so the sighash path is genuinely exercised. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import Wallet, fake_input, witness_for + +from mintlayer.wasm import ( + Amount, + Client, + Network, + SignatureHashType, + TxAdditionalInfo, + WasmError, +) + +ONE_ML = Amount.from_atoms("100000000000") + + +@pytest.fixture +def wallet(wasm: Client) -> Wallet: + return Wallet(wasm) + + +@pytest.fixture +def self_transfer(wasm: Client, wallet: Wallet) -> tuple[bytes, bytes, bytes]: + """(input, output, unsigned tx) sending 1 ML back to the wallet.""" + inp = fake_input(wasm) + out = wasm.encode_output_transfer(ONE_ML, wallet.addr, Network.MAINNET) + return inp, out, wasm.encode_transaction(inp, out, 0) + + +# ── challenge signatures ────────────────────────────────────────────────────── + + +def test_sign_challenge_roundtrip(wasm: Client) -> None: + priv = wasm.make_private_key() + pub = wasm.public_key_from_private_key(priv) + addr = wasm.pubkey_to_pubkeyhash_address(pub, Network.MAINNET) + message = b"hello mintlayer" + sig = wasm.sign_challenge(priv, message) + assert len(sig) > 0 + assert wasm.verify_challenge(addr, Network.MAINNET, sig, message) is True + + +def test_verify_challenge_rejects_wrong_message(wasm: Client) -> None: + priv = wasm.make_private_key() + addr = wasm.pubkey_to_pubkeyhash_address( + wasm.public_key_from_private_key(priv), Network.MAINNET + ) + sig = wasm.sign_challenge(priv, b"hello mintlayer") + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.verify_challenge(addr, Network.MAINNET, sig, b"other message") + + +def test_verify_challenge_rejects_tampered_signature(wasm: Client) -> None: + priv = wasm.make_private_key() + addr = wasm.pubkey_to_pubkeyhash_address( + wasm.public_key_from_private_key(priv), Network.MAINNET + ) + sig = bytearray(wasm.sign_challenge(priv, b"hello mintlayer")) + sig[-1] ^= 0x01 + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.verify_challenge(addr, Network.MAINNET, bytes(sig), b"hello mintlayer") + + +def test_verify_challenge_invalid_address_raises(wasm: Client) -> None: + priv = wasm.make_private_key() + sig = wasm.sign_challenge(priv, b"m") + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.verify_challenge("not an address", Network.MAINNET, sig, b"m") + + +# ── spending signatures ─────────────────────────────────────────────────────── + + +def test_sign_message_for_spending_roundtrip(wasm: Client) -> None: + priv = wasm.make_private_key() + pub = wasm.public_key_from_private_key(priv) + message = b"spending message test" + sig = wasm.sign_message_for_spending(priv, message) + assert len(sig) > 0 + assert wasm.verify_signature_for_spending(pub, sig, message) is True + + +def test_verify_signature_for_spending_wrong_message_is_false(wasm: Client) -> None: + priv = wasm.make_private_key() + pub = wasm.public_key_from_private_key(priv) + sig = wasm.sign_message_for_spending(priv, b"m") + assert wasm.verify_signature_for_spending(pub, sig, b"other") is False + + +# ── transaction witnesses ───────────────────────────────────────────────────── + + +def test_encode_witness(wasm: Client, wallet: Wallet, self_transfer) -> None: + inp, out, tx = self_transfer + witness = witness_for(wasm, wallet, inp, out, tx) + assert isinstance(witness, bytes) and len(witness) > 0 + + +def test_encode_witness_no_signature(wasm: Client) -> None: + witness = wasm.encode_witness_no_signature() + assert isinstance(witness, bytes) and len(witness) > 0 + + +def test_encode_witness_key_destination_mismatch_raises( + wasm: Client, wallet: Wallet, self_transfer +) -> None: + _inp, out, tx = self_transfer + other = wasm.make_private_key() # not the key behind wallet.addr + with pytest.raises(WasmError, match="hash mismatch"): + wasm.encode_witness( + SignatureHashType.SIGHASH_ALL, + other, + wallet.addr, + tx, + b"\x01" + out, + 0, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) + + +def test_encode_witness_invalid_key_raises(wasm: Client, wallet: Wallet, self_transfer) -> None: + _inp, out, tx = self_transfer + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_witness( + SignatureHashType.SIGHASH_ALL, + b"abc", + wallet.addr, + tx, + b"\x01" + out, + 0, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) + + +# ── HTLC witness variants ───────────────────────────────────────────────────── + + +def test_encode_witness_htlc_spend_invalid_key_raises( + wasm: Client, wallet: Wallet, self_transfer +) -> None: + _inp, out, tx = self_transfer + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_witness_htlc_spend( + SignatureHashType.SIGHASH_ALL, + b"abc", + wallet.addr, + tx, + b"\x01" + out, + 0, + b"\x01" * 32, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) + + +def test_encode_witness_htlc_refund_single_sig_invalid_key_raises( + wasm: Client, wallet: Wallet, self_transfer +) -> None: + _inp, out, tx = self_transfer + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_witness_htlc_refund_single_sig( + SignatureHashType.SIGHASH_ALL, + b"abc", + wallet.addr, + tx, + b"\x01" + out, + 0, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) + + +def test_encode_witness_htlc_refund_multisig_invalid_key_raises( + wasm: Client, wallet: Wallet, self_transfer +) -> None: + _inp, out, tx = self_transfer + challenge = wasm.encode_multisig_challenge(wallet.pub + wallet.pub, 2, Network.MAINNET) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_witness_htlc_refund_multisig( + SignatureHashType.SIGHASH_ALL, + b"abc", + 0, + b"", + challenge, + tx, + b"\x01" + out, + 0, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) diff --git a/tests/test_wasm_transactions.py b/tests/test_wasm_transactions.py new file mode 100644 index 0000000..5ebc212 --- /dev/null +++ b/tests/test_wasm_transactions.py @@ -0,0 +1,344 @@ +"""Tests for WASM transaction encoding, ids, sizes and decoding. + +Mirrors go-sdk TestEncodeTransaction plus the Python-specific flows +validated against the embedded module: estimate size stability (externref +table must not leak across repeated calls), signed/partially-signed +encoding and the decode-to-JSON paths. +""" + +from __future__ import annotations + +import pytest +from wasm_helpers import Wallet, fake_input, witness_for +from wasmtime import Val + +from mintlayer.wasm import ( + Amount, + Client, + Network, + SignatureHashType, + SourceId, + TxAdditionalInfo, + WasmError, +) + + +@pytest.fixture +def wallet(wasm: Client) -> Wallet: + return Wallet(wasm) + + +@pytest.fixture +def unsigned_tx(wasm: Client, wallet: Wallet) -> tuple[bytes, bytes, bytes]: + """(input, output, unsigned transaction) for a 1-ML self transfer.""" + inp = fake_input(wasm) + out = wasm.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + tx = wasm.encode_transaction(inp, out, 0) + return inp, out, tx + + +def test_encode_outpoint_source_id_transaction(wasm: Client) -> None: + src = wasm.encode_outpoint_source_id(b"\x01" * 32, SourceId.SOURCE_TRANSACTION) + assert isinstance(src, bytes) and len(src) > 0 + assert src == wasm.encode_outpoint_source_id(b"\x01" * 32, SourceId.SOURCE_TRANSACTION) + + +def test_encode_outpoint_source_id_block_reward(wasm: Client) -> None: + from_tx = wasm.encode_outpoint_source_id(b"\x01" * 32, SourceId.SOURCE_TRANSACTION) + from_block = wasm.encode_outpoint_source_id(b"\x01" * 32, SourceId.SOURCE_BLOCK_REWARD) + assert len(from_block) > 0 + assert from_tx != from_block, "source kind must change the encoding" + + +def test_encode_outpoint_source_id_wrong_length_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.encode_outpoint_source_id(b"\x00" * 31, SourceId.SOURCE_TRANSACTION) + + +def test_encode_transaction_and_get_id(wasm: Client, unsigned_tx) -> None: + _inp, _out, tx = unsigned_tx + assert len(tx) > 0 + tx_id = wasm.get_transaction_id(tx, True) + assert len(tx_id) == 64 + assert all(ch in "0123456789abcdef" for ch in tx_id) + assert tx_id == wasm.get_transaction_id(tx, True) # deterministic + + +def test_get_transaction_id_garbage_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_transaction_id(b"garbage!", True) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.get_transaction_id(b"\x00", False) + + +def test_encode_transaction_flags_change_the_id(wasm: Client, wallet: Wallet) -> None: + inp = fake_input(wasm) + out = wasm.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + assert wasm.encode_transaction(inp, out, 0) != wasm.encode_transaction(inp, out, 1) + + +def test_estimate_transaction_size_stable(wasm: Client, wallet: Wallet, unsigned_tx) -> None: + _inp, out, tx = unsigned_tx + size = wasm.estimate_transaction_size(tx, [wallet.addr], out, Network.MAINNET) + assert 0 < size < 10000 + # Repeated calls must be stable: externref table slots must not leak. + for _ in range(100): + repeat = wasm.estimate_transaction_size(tx, [wallet.addr], out, Network.MAINNET) + assert repeat == size + + +def test_estimate_transaction_size_multiple_destinations(wallet: Wallet) -> None: + """One destination per input; a 2-input tx estimates with 2 destinations. + + Uses a fresh client: the first multi-element string-array call on a + client always works (later ones can hit the slot-reuse bug documented + in test_estimate_transaction_size_multi_dest_after_repeats). + """ + c = Client() + try: + inp0 = fake_input(c, txid=b"\x01" * 32) + inp1 = fake_input(c, txid=b"\x02" * 32) + out = c.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + tx = c.encode_transaction(inp0 + inp1, out, 0) + size = c.estimate_transaction_size(tx, [wallet.addr, wallet.addr], out, Network.MAINNET) + assert size > 0 + finally: + c.close() + + +def test_estimate_transaction_size_multi_dest_after_repeats(wallet: Wallet) -> None: + """Regression: multi-destination estimates must survive interleaved use. + + Used to fail with 'array contains a value of the wrong type' after + repeated single-destination calls: the host deallocated the callee-owned + externref table slots after every call, double-freeing free-list entries. + """ + c = Client() + try: + inp = fake_input(c) + out = c.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + tx = c.encode_transaction(inp, out, 0) + assert c.estimate_transaction_size(tx, [wallet.addr], out, Network.MAINNET) > 0 + assert c.estimate_transaction_size(tx, [wallet.addr, wallet.addr], out, Network.MAINNET) > 0 + assert c.estimate_transaction_size(tx, [wallet.addr], out, Network.MAINNET) > 0 + assert c.estimate_transaction_size(tx, [wallet.addr, wallet.addr], out, Network.MAINNET) > 0 + finally: + c.close() + + +def test_estimate_size_mixed_load_externref_table_stable() -> None: + """Stress regression: mixed single/multi-destination load on one client. + + Alternates 1-3 destination ``estimate_transaction_size`` calls with + occasional intent encode/verify rounds (multi-element externref arrays + of both the string and Uint8Array kinds). Every call must succeed, sizes + must stay consistent per destination count, and the wasm externref table + must not grow across the run — table growth would mean table slots are + leaking (the pre-fix double-dealloc corrupted the free list instead of + recycling it). + """ + c = Client() + try: + wallet = Wallet(c) + dests = [wallet.addr] * 3 + inputs = b"".join(fake_input(c, txid=bytes([i]) * 32, index=i) for i in range(3)) + out = c.encode_output_transfer( + Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET + ) + tx = c.encode_transaction(inputs, out, 0) + tx_id = c.get_transaction_id(tx, True) + message = c.make_transaction_intent_message_to_sign("stress-intent", tx_id) + + def intent_round() -> None: + signatures = [c.sign_challenge(wallet.recv, message) for _ in range(2)] + encoded = c.encode_signed_transaction_intent(message, signatures) + assert len(encoded) > 0 + c.verify_transaction_intent(message, encoded, dests[:2], Network.MAINNET) + + # Warmup with every call shape once: initial table growth (the module + # grows its 128-slot table on first demand) must not count as a leak. + expected: dict[int, int] = {} + for n in (1, 2, 3): + expected[n] = c.estimate_transaction_size(tx, dests[:n], out, Network.MAINNET) + assert expected[n] > 0 + intent_round() + baseline_table = c.table.size(c.store) + + for i in range(120): + n = 1 + (i % 3) + size = c.estimate_transaction_size(tx, dests[:n], out, Network.MAINNET) + assert size == expected[n], f"iteration {i}: size for {n} destinations changed" + if i % 10 == 0: + intent_round() + + assert c.table.size(c.store) == baseline_table, ( + "externref table grew across the mixed-load run (table slot leak)" + ) + finally: + c.close() + + +def _is_null_anyref(value: object) -> bool: + """True when wasmtime reports a null (undefined) externref table slot. + + Depending on version and context wasmtime surfaces null anyrefs either + as ``None`` or as a ``Val`` wrapping ``None``; both mean "the slot was + released". + """ + if value is None: + return True + if isinstance(value, Val): + return value.__dict__.get("_val", object()) is None + return False + + +def _alloc_reusable_slot(c: Client) -> int: + """Allocate one externref-table slot from the reusable region. + + The module reserves its lowest table indices as a permanent slab whose + ``__externref_table_dealloc`` deliberately does not recycle (bounded, + one-time JS globals); the managed region begins where a freed slot is + handed out again via the LIFO free list. Bounded loop: the slab is finite. + """ + for _ in range(512): + probe = c._invoke1("__externref_table_alloc") + c._dealloc_indices([probe]) + if c._invoke1("__externref_table_alloc") == probe: + return probe + raise AssertionError("no reusable externref table slot found") + + +def test_dealloc_indices_rollback_releases_slots_for_reuse() -> None: + """Unit test for the pre-call rollback path: ``_dealloc_indices``. + + A rolled-back array write (failure before the WASM callee ever runs) + must fully release the allocated externref table slots: they read back + as null/undefined and the allocator hands them out again. This is the + inverse contract of the post-call ownership rule (callee owns slots); + getting either side wrong corrupts the table free list. + """ + c = Client() + try: + slot_a = _alloc_reusable_slot(c) + slot_b = _alloc_reusable_slot(c) + assert slot_a != slot_b + c.table.set(c.store, slot_a, "rollback-a") + c.table.set(c.store, slot_b, "rollback-b") + assert c.table.get(c.store, slot_a) == "rollback-a" + assert c.table.get(c.store, slot_b) == "rollback-b" + + c._dealloc_indices([slot_a, slot_b]) + + assert _is_null_anyref(c.table.get(c.store, slot_a)), "slot_a still holds a value" + assert _is_null_anyref(c.table.get(c.store, slot_b)), "slot_b still holds a value" + # The free list must hand exactly these slots back (LIFO order). + assert c._invoke1("__externref_table_alloc") == slot_b + assert c._invoke1("__externref_table_alloc") == slot_a + finally: + c.close() + + +def test_encode_signed_transaction(wasm: Client, wallet: Wallet, unsigned_tx) -> None: + inp, out, tx = unsigned_tx + witness = witness_for(wasm, wallet, inp, out, tx) + signed = wasm.encode_signed_transaction(tx, witness) + assert len(signed) > len(tx) + + +def test_encode_partially_signed_transaction(wasm: Client, wallet: Wallet, unsigned_tx) -> None: + inp, out, tx = unsigned_tx + witness = witness_for(wasm, wallet, inp, out, tx) + pst = wasm.encode_partially_signed_transaction( + tx, + b"\x01" + witness, # Option::Some + b"\x01" + out, # Option::Some + b"\x01" + wasm.encode_destination(wallet.addr, Network.MAINNET), + b"\x00", # Option::None (one per input) + TxAdditionalInfo(), + Network.MAINNET, + ) + assert len(pst) > 0 + + +def test_decode_signed_transaction_to_js(wasm: Client, wallet: Wallet, unsigned_tx) -> None: + inp, out, tx = unsigned_tx + signed = wasm.encode_signed_transaction(tx, witness_for(wasm, wallet, inp, out, tx)) + decoded = wasm.decode_signed_transaction_to_js(signed, Network.MAINNET) + assert b"transaction" in decoded + assert decoded[:1] == b"{" + + +def test_decode_partially_signed_transaction_to_js( + wasm: Client, wallet: Wallet, unsigned_tx +) -> None: + inp, out, tx = unsigned_tx + witness = witness_for(wasm, wallet, inp, out, tx) + pst = wasm.encode_partially_signed_transaction( + tx, + b"\x01" + witness, + b"\x01" + out, + b"\x01" + wasm.encode_destination(wallet.addr, Network.MAINNET), + b"\x00", + TxAdditionalInfo(), + Network.MAINNET, + ) + decoded = wasm.decode_partially_signed_transaction_to_js(pst, Network.MAINNET) + assert b'"type":"V1"' in decoded + assert b'"tx"' in decoded + + +def test_decode_garbage_raises(wasm: Client) -> None: + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.decode_signed_transaction_to_js(b"\x00" * 8, Network.MAINNET) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.decode_partially_signed_transaction_to_js(b"\x00" * 8, Network.MAINNET) + + +def test_extract_htlc_secret_no_htlc_raises(wasm: Client, wallet: Wallet, unsigned_tx) -> None: + inp, out, tx = unsigned_tx + signed = wasm.encode_signed_transaction(tx, witness_for(wasm, wallet, inp, out, tx)) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.extract_htlc_secret(signed, True, b"\x02" * 32, 0) + + +def test_internal_verify_witness_ok(wasm: Client, wallet: Wallet, unsigned_tx) -> None: + inp, out, tx = unsigned_tx + witness = witness_for(wasm, wallet, inp, out, tx) + wasm.internal_verify_witness( + int(SignatureHashType.SIGHASH_ALL), + wallet.addr, + witness, + tx, + b"\x01" + out, + 0, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) + + +def test_internal_verify_witness_wrong_input_index( + wasm: Client, wallet: Wallet, unsigned_tx +) -> None: + inp, out, tx = unsigned_tx + witness = witness_for(wasm, wallet, inp, out, tx) + with pytest.raises(WasmError, match="^mintlayer: "): + wasm.internal_verify_witness( + int(SignatureHashType.SIGHASH_ALL), + wallet.addr, + witness, + tx, + b"\x01" + out, + 1, # transaction has a single input (index 0) + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) diff --git a/tests/test_wasm_types.py b/tests/test_wasm_types.py new file mode 100644 index 0000000..df40697 --- /dev/null +++ b/tests/test_wasm_types.py @@ -0,0 +1,148 @@ +"""Tests for the pure-Python WASM types and the host JSON serialisation. + +The JSON shapes are the serde wire shapes consumed by the Rust module and +must match go-sdk/wasm/types.go exactly (tagged enums, redundant balance +objects, nested additional-info maps). +""" + +from __future__ import annotations + +import json + +from mintlayer.wasm import ( + Amount, + CurrencyAmountKind, + FreezableToken, + Network, + OrderBalance, + OrderInfo, + PoolInfo, + SignatureHashType, + SimpleCurrencyAmount, + SourceId, + TokenUnfreezable, + TotalSupply, + TxAdditionalInfo, + WasmError, +) +from mintlayer.wasm.host import _json_dumps +from mintlayer.wasm.types import OrderBalance as OrderBalanceReimported + + +def test_wasm_error_prefix_contract() -> None: + err = WasmError("mintlayer: boom") + assert isinstance(err, Exception) + assert str(err).startswith("mintlayer: ") + + +def test_enum_discriminants() -> None: + assert [int(n) for n in Network] == [0, 1, 2, 3] + assert [int(s) for s in SignatureHashType] == [0, 1, 2, 3] + assert int(SourceId.SOURCE_TRANSACTION) == 0 + assert int(SourceId.SOURCE_BLOCK_REWARD) == 1 + assert [int(t) for t in TotalSupply] == [0, 1, 2] + assert int(FreezableToken.NO) == 0 and int(FreezableToken.YES) == 1 + assert int(TokenUnfreezable.NO) == 0 and int(TokenUnfreezable.YES) == 1 + assert int(CurrencyAmountKind.COINS) == 0 + assert int(CurrencyAmountKind.TOKENS) == 1 + + +def test_amount() -> None: + one_ml = Amount.from_atoms("100000000000") + assert one_ml.atoms == "100000000000" + assert str(one_ml) == "100000000000" + assert Amount.zero().atoms == "0" + assert one_ml.to_json_value() == {"atoms": "100000000000"} + assert one_ml == Amount.from_atoms("100000000000") + + +def test_simple_currency_amount_coins_shape() -> None: + coins = SimpleCurrencyAmount.coins("5") + assert coins.kind == CurrencyAmountKind.COINS + assert coins.token_id is None + assert coins.to_json_value() == {"coins": {"atoms": "5"}} + + +def test_simple_currency_amount_tokens_shape() -> None: + tokens = SimpleCurrencyAmount.tokens("7", "mmltk1abc") + assert tokens.kind == CurrencyAmountKind.TOKENS + assert tokens.to_json_value() == {"tokens": {"amount": {"atoms": "7"}, "token_id": "mmltk1abc"}} + + +def test_order_balance_redundant_shape() -> None: + balance = OrderBalance("9", None) + assert balance.to_json_value() == { + "atoms": "9", + "amount": {"atoms": "9"}, + "token_id": None, + } + with_token = OrderBalance("9", "mmltk1abc") + assert with_token.to_json_value() == { + "atoms": "9", + "amount": {"atoms": "9"}, + "token_id": "mmltk1abc", + } + + +def test_pool_info_shape() -> None: + info = PoolInfo(staker_balance=Amount.from_atoms("42")) + assert info.to_json_value() == {"staker_balance": {"atoms": "42"}} + + +def test_order_info_shape() -> None: + info = OrderInfo( + initially_asked=SimpleCurrencyAmount.coins("1"), + initially_given=SimpleCurrencyAmount.tokens("2", "mmltk1abc"), + ask_balance=OrderBalance("3", None), + give_balance=OrderBalance("4", "mmltk1abc"), + ) + assert info.to_json_value() == { + "initially_asked": {"coins": {"atoms": "1"}}, + "initially_given": {"tokens": {"amount": {"atoms": "2"}, "token_id": "mmltk1abc"}}, + "ask_balance": {"atoms": "3", "amount": {"atoms": "3"}, "token_id": None}, + "give_balance": {"atoms": "4", "amount": {"atoms": "4"}, "token_id": "mmltk1abc"}, + } + + +def test_tx_additional_info_empty_defaults() -> None: + info = TxAdditionalInfo() + assert info.pool_info == {} + assert info.order_info == {} + assert info.to_json_value() == {"pool_info": {}, "order_info": {}} + + +def test_tx_additional_info_nested_shape() -> None: + info = TxAdditionalInfo( + pool_info={"mpool1x": PoolInfo(staker_balance=Amount.from_atoms("5"))}, + order_info={ + "mordr1y": OrderInfo( + initially_asked=SimpleCurrencyAmount.coins("1"), + initially_given=SimpleCurrencyAmount.coins("2"), + ask_balance=OrderBalance("3", None), + give_balance=OrderBalance("4", None), + ) + }, + ) + value = info.to_json_value() + assert set(value) == {"pool_info", "order_info"} + assert value["pool_info"]["mpool1x"] == {"staker_balance": {"atoms": "5"}} + assert value["order_info"]["mordr1y"]["ask_balance"]["atoms"] == "3" + + +def test_order_balance_reimport_is_same_class() -> None: + assert OrderBalanceReimported is OrderBalance + + +def test_host_json_dumps_honours_to_json_value() -> None: + assert _json_dumps(Amount.from_atoms("5")) == '{"atoms":"5"}' + assert _json_dumps(TxAdditionalInfo()) == '{"pool_info":{},"order_info":{}}' + # Nesting is handled inside to_json_value implementations, not by the helper. + info = TxAdditionalInfo(pool_info={"p": PoolInfo(staker_balance=Amount.from_atoms("5"))}) + expected = '{"pool_info":{"p":{"staker_balance":{"atoms":"5"}}},"order_info":{}}' + assert _json_dumps(info) == expected + + +def test_host_json_dumps_plain_values() -> None: + assert _json_dumps([1, 2, 3]) == "[1,2,3]" + assert _json_dumps("x") == '"x"' + assert json.loads(_json_dumps({"a": [True, None]})) == {"a": [True, None]} diff --git a/tests/wasm_helpers.py b/tests/wasm_helpers.py new file mode 100644 index 0000000..bde2a5d --- /dev/null +++ b/tests/wasm_helpers.py @@ -0,0 +1,96 @@ +"""Shared helpers for the WASM client tests. + +All WASM tests run fully offline: the embedded ``wasm_wrappers_bg.wasm`` +module is instantiated in-process via wasmtime, no node/daemon/network is +needed. Values pinned here are real test vectors taken from the Mintlayer +sources (mintlayer-core) so the WASM module accepts them. +""" + +from __future__ import annotations + +from mintlayer.wasm import ( + Amount, + Client, + Network, + SignatureHashType, + SourceId, + TxAdditionalInfo, +) + +# The canonical BIP-39 test mnemonic ("abandon ... about"). +MNEMONIC = "abandon " * 11 + "about" + +# A valid mainnet VRF public key: bech32m HRP "mvrfpk", payload +# 0x00 (Schnorrkel variant tag) + 32-byte key. Taken from the +# example_mainnet_vrf test in mintlayer-core common/src/address/hexified.rs. +VRF_MAINNET = "mvrfpk1qqyxcl4tc6y9amf2vmv6sgu8x5jwqlxawx73vhgemkduag9c8ku57m03mze" + +# Height used across fee/staking/ids calls (post all early forks). +HEIGHT = 500_000 +# Height at/after the orders V1 fork (encode_input_for_freeze_order). +ORDERS_HEIGHT = 1_000_000 + + +def derive(c: Client) -> tuple[bytes, bytes, bytes, str]: + """Derive the standard (account, receiving key, pubkey, address) chain.""" + account = c.make_default_account_privkey(MNEMONIC, Network.MAINNET) + recv = c.make_receiving_address(account, 0) + pub = c.public_key_from_private_key(recv) + addr = c.pubkey_to_pubkeyhash_address(pub, Network.MAINNET) + return account, recv, pub, addr + + +class Wallet: + """Derived identity bundle for one client (fixed by the test mnemonic).""" + + def __init__(self, c: Client) -> None: + self.account, self.recv, self.pub, self.addr = derive(c) + + +def fake_input(c: Client, txid: bytes = b"\x01" * 32, index: int = 0) -> bytes: + """A real encoded UTXO input spending ``txid`` output ``index``.""" + src = c.encode_outpoint_source_id(txid, SourceId.SOURCE_TRANSACTION) + return c.encode_input_for_utxo(src, index) + + +def simple_transfer_tx(c: Client, wallet: Wallet) -> tuple[bytes, bytes, bytes]: + """Build (input, output, unsigned tx) sending 1 ML back to ``wallet``.""" + inp = fake_input(c) + out = c.encode_output_transfer(Amount.from_atoms("100000000000"), wallet.addr, Network.MAINNET) + tx = c.encode_transaction(inp, out, 0) + return inp, out, tx + + +def witness_for(c: Client, wallet: Wallet, inp: bytes, out: bytes, tx: bytes) -> bytes: + """Sign input 0 of ``tx`` with the wallet's receiving key.""" + return c.encode_witness( + SignatureHashType.SIGHASH_ALL, + wallet.recv, + wallet.addr, + tx, + b"\x01" + out, + 0, + TxAdditionalInfo(), + 100, + Network.MAINNET, + ) + + +class MemorySpy: + """Proxy for ``client.memory`` recording zero-filled writes. + + ``_core._call_return_*`` zeroes result buffers that carried key material + before releasing them; the spy lets tests observe that contract. + """ + + def __init__(self, mem) -> None: + self._mem = mem + self.zero_writes: list[int] = [] + + def read(self, *args): # noqa: ANN002, ANN003 - passthrough + return self._mem.read(*args) + + def write(self, store, data, ptr): # noqa: ANN001 - passthrough + if len(data) > 0 and set(data) <= {0}: + self.zero_writes.append(len(data)) + return self._mem.write(store, data, ptr) From 8be7bc6232b2cb3e99912c1495c4e08590a0c108 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 17:14:41 +0400 Subject: [PATCH 14/31] Add CI: lint, typecheck, test matrix, build with coverage gate Mirrors go-sdk's ci.yml structure adapted to Python/uv: - lint job: ruff check + scoped format check + mypy - test matrix on Python 3.10-3.13 with pytest-cov and a hard --cov-fail-under=80 gate (current: 95.5%) - build job: sdist/wheel + smoke test that the vendored wasm binary and its sha256 pin ship in the wheel - least-privilege permissions (contents: read), SHA-pinned actions, persist-credentials: false, cache keyed on pyproject.toml (uv.lock is gitignored), concurrency cancellation, per-job timeouts --- .github/workflows/ci.yml | 121 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..0d5170e --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,121 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +# Least privilege: the workflow only reads the repo. +permissions: + contents: read + +# Cancel superseded runs on rapid pushes. +concurrency: + group: ci-${{ github.ref }} + cancel-in-progress: true + +jobs: + lint: + name: Lint & typecheck + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + persist-credentials: false + + - uses: astral-sh/setup-uv@c7f87aa956e4bb3fa984f422a52ffa2ccc4abd77 # v5.4.2 + with: + enable-cache: true + # uv.lock is intentionally gitignored for this library, so key the + # cache on the dependency manifest instead. + cache-dependency-glob: pyproject.toml + + - name: Install Python + run: uv python install 3.12 + + - name: Sync dependencies + run: uv sync --group dev --python 3.12 + + - name: Ruff lint + run: uv run ruff check . + + # Scoped to Python paths: repo-wide format would also reformat the + # illustrative snippets inside docs/*.md and README.md. + - name: Ruff format + run: uv run ruff format --check mintlayer/ tests/ examples/ + + - name: Mypy + run: uv run mypy mintlayer/ + + test: + name: Test (Python ${{ matrix.python }}) + runs-on: ubuntu-latest + timeout-minutes: 20 + strategy: + fail-fast: false + matrix: + python: ["3.10", "3.11", "3.12", "3.13"] + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + persist-credentials: false + + - uses: astral-sh/setup-uv@c7f87aa956e4bb3fa984f422a52ffa2ccc4abd77 # v5.4.2 + with: + enable-cache: true + cache-dependency-glob: pyproject.toml + + - name: Install Python ${{ matrix.python }} + run: uv python install ${{ matrix.python }} + + - name: Sync dependencies + run: uv sync --group dev --python ${{ matrix.python }} + + # WASM init costs ~400 ms per Client; the session-scoped fixture keeps + # the suite to ~2 min. Coverage gate: total must stay above 80%. + - name: Run tests with coverage + run: > + uv run pytest tests/ -q + --cov --cov-report=term-missing + --cov-fail-under=80 + + build: + name: Build wheel + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + persist-credentials: false + + - uses: astral-sh/setup-uv@c7f87aa956e4bb3fa984f422a52ffa2ccc4abd77 # v5.4.2 + with: + enable-cache: true + cache-dependency-glob: pyproject.toml + + - name: Install Python + run: uv python install 3.12 + + - name: Build sdist and wheel + run: uv build + + - name: Smoke-test wheel contents + run: | + python3 - <<'EOF' + import zipfile, glob + wheel = glob.glob("dist/*.whl")[0] + names = zipfile.ZipFile(wheel).namelist() + assert any(n.endswith("wasm_wrappers_bg.wasm") for n in names), "wasm binary missing" + assert any(n.endswith("wasm_wrappers_bg.wasm.sha256") for n in names), "sha256 pin missing" + assert any(n == "mintlayer/__init__.py" for n in names), "package missing" + print(f"{wheel}: {len(names)} entries OK") + EOF + + all-green: + name: All checks passed + runs-on: ubuntu-latest + needs: [lint, test, build] + steps: + - run: echo "All CI jobs green" From fa16e45b5209ddea47aa86e458e71ed951d64089 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 17:17:14 +0400 Subject: [PATCH 15/31] Fix setup-uv action pin: use real v5.4.2 commit SHA --- .github/workflows/ci.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0d5170e..e8979dc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -25,7 +25,7 @@ jobs: with: persist-credentials: false - - uses: astral-sh/setup-uv@c7f87aa956e4bb3fa984f422a52ffa2ccc4abd77 # v5.4.2 + - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 with: enable-cache: true # uv.lock is intentionally gitignored for this library, so key the @@ -62,7 +62,7 @@ jobs: with: persist-credentials: false - - uses: astral-sh/setup-uv@c7f87aa956e4bb3fa984f422a52ffa2ccc4abd77 # v5.4.2 + - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 with: enable-cache: true cache-dependency-glob: pyproject.toml @@ -90,7 +90,7 @@ jobs: with: persist-credentials: false - - uses: astral-sh/setup-uv@c7f87aa956e4bb3fa984f422a52ffa2ccc4abd77 # v5.4.2 + - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 with: enable-cache: true cache-dependency-glob: pyproject.toml From 9a343efaa59bf71a58a0c83ff7049df3ee77f75d Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 18:20:39 +0400 Subject: [PATCH 16/31] Add AI code review workflow (port of rust-sdk code-review.yml) alibaba/open-code-review v1.12.0 (SHA-pinned) on pull_request events, reviewing with glm-5.3-flash via the z.ai API using the OCR_LLM_TOKEN secret. Fork PRs are skipped cleanly (no secret exposure); concurrency grouped per PR; npm CLI additionally pinned via ocr_version. --- .github/workflows/code-review.yml | 39 +++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 .github/workflows/code-review.yml diff --git a/.github/workflows/code-review.yml b/.github/workflows/code-review.yml new file mode 100644 index 0000000..e327910 --- /dev/null +++ b/.github/workflows/code-review.yml @@ -0,0 +1,39 @@ +name: AI Code Review + +on: + pull_request: + types: [opened, synchronize, reopened] + +permissions: + contents: read + pull-requests: write + +concurrency: + group: ocr-${{ github.event.pull_request.number }} + cancel-in-progress: true + +jobs: + review: + # Fork PRs cannot read secrets; skip them cleanly. + if: github.event.pull_request.head.repo.fork == false + runs-on: ubuntu-latest + timeout-minutes: 40 + steps: + - uses: alibaba/open-code-review@494bf1c8d7a19196ab166960a06fef38d69a1d16 # v1.12.0 + with: + # Pin the npm CLI too: the SHA pin freezes the action harness, but + # it installs @alibaba-group/open-code-review@latest at runtime. + ocr_version: '1.12.0' + llm_url: https://api.z.ai/api/coding/paas/v4 + llm_auth_token: ${{ secrets.OCR_LLM_TOKEN }} + llm_model: glm-5.3-flash + llm_use_anthropic: false + # GLM-5.3 family rejects thinking.type=disabled, which is the + # action's default extra_body — this override is required. + llm_extra_body: '{"thinking": {"type": "enabled"}}' + llm_reasoning_effort: low + incremental: 'true' + route_severity_below: 'low' + max_tokens_budget: '500000' + review_task_timeout: '15' + stream_progress: 'true' From 87efd2bc141000e243c500ef0df41ac07f8614ab Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 18:23:06 +0400 Subject: [PATCH 17/31] Revert ocr_version pin: breaks the action's CLI install (ocr not found) The pinned-version install flow leaves the ocr binary unresolvable in the run step (exit 127). Restore byte parity with the known-working rust-sdk code-review.yml (@latest install). --- .github/workflows/code-review.yml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/code-review.yml b/.github/workflows/code-review.yml index e327910..b2802e3 100644 --- a/.github/workflows/code-review.yml +++ b/.github/workflows/code-review.yml @@ -21,9 +21,6 @@ jobs: steps: - uses: alibaba/open-code-review@494bf1c8d7a19196ab166960a06fef38d69a1d16 # v1.12.0 with: - # Pin the npm CLI too: the SHA pin freezes the action harness, but - # it installs @alibaba-group/open-code-review@latest at runtime. - ocr_version: '1.12.0' llm_url: https://api.z.ai/api/coding/paas/v4 llm_auth_token: ${{ secrets.OCR_LLM_TOKEN }} llm_model: glm-5.3-flash From e19c5fed576dc9d257a688a0d1704f53a0ce7c29 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 19:33:53 +0400 Subject: [PATCH 18/31] Address all OCR (open-code-review) findings on PR #1 Library fixes: - Config.password redacted from repr (same treatment as wallet params) - Client.close() now also closes node/indexer/wallet sessions - indexer: get_token_statistics URL-encodes token id (_seg); submit_transaction and get_pool_block_stats validate response shape into IndexerError; from_json wrapper also catches AttributeError; parse_per_thousand rejects invalid types with IndexerError - wallet: _call_model_list validates shape (null -> [] Go nil-slice parity, non-list -> JSONRPCError); staking_status simplification - wasm host: signal_exception records the host-side message in the per-call side channel (first-wins; cast_2 still overwrites with the richer Rust message); _subarray clamps the range like JS TypedArray.subarray (closes OOB view arithmetic) - wasm _core: WasmError preserves the cause chain (from exc instead of from None); zero-length return buffers now uniformly read/zero/free Examples: - send_coins: mnemonic via env/hidden prompt (no argv requirement), Coin-only UTXO selection with warnings, fatal re-encode failure instead of silent 0x00 downgrade, change output + iterative fee estimation from the indexer fee rate - issue_token: poll the indexer for issuance confirmation (404-tolerant, bounded by --wait-timeout) before minting Meta: hatchling>=1.26 floor (PEP 639 fields), wheel-glob guard in CI, gitignore dedupe + .env.example negation. 20 new regression tests (406 total, 95.7% coverage); ruff + mypy clean. Rejected findings (documented): cast_2 last-wins error capture (Go/wasm- bindgen error convention), lazy Amount validation (Rust validates at encode time), strict response-id matching (sync client + JSON-RPC null-id error envelopes), naive-datetime handling (already documented). --- .github/workflows/ci.yml | 4 +- .gitignore | 2 +- examples/issue_token.py | 35 +++++- examples/send_coins.py | 170 +++++++++++++++++++----------- mintlayer/client.py | 20 +++- mintlayer/indexer/number.py | 2 +- mintlayer/indexer/pool.py | 11 +- mintlayer/indexer/statistics.py | 4 +- mintlayer/indexer/transaction.py | 4 +- mintlayer/indexer/types.py | 2 +- mintlayer/wallet/_core.py | 6 +- mintlayer/wallet/staking.py | 2 +- mintlayer/wasm/_core.py | 14 ++- mintlayer/wasm/host.py | 15 ++- mintlayer/wasm/types.py | 6 ++ pyproject.toml | 4 +- tests/test_client.py | 56 ++++++++++ tests/test_indexer_number.py | 26 +++++ tests/test_indexer_pool.py | 21 +++- tests/test_indexer_statistics.py | 14 +++ tests/test_indexer_transaction.py | 24 ++++- tests/test_indexer_types.py | 33 ++++++ tests/test_wallet_staking.py | 19 ++++ tests/test_wasm_types.py | 23 ++++ 24 files changed, 429 insertions(+), 88 deletions(-) create mode 100644 tests/test_indexer_number.py create mode 100644 tests/test_indexer_types.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e8979dc..3bedd4c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -105,7 +105,9 @@ jobs: run: | python3 - <<'EOF' import zipfile, glob - wheel = glob.glob("dist/*.whl")[0] + wheels = glob.glob("dist/*.whl") + assert wheels, "no wheel produced by uv build" + wheel = wheels[0] names = zipfile.ZipFile(wheel).namelist() assert any(n.endswith("wasm_wrappers_bg.wasm") for n in names), "wasm binary missing" assert any(n.endswith("wasm_wrappers_bg.wasm.sha256") for n in names), "sha256 pin missing" diff --git a/.gitignore b/.gitignore index 1f413c4..dc0e5ed 100644 --- a/.gitignore +++ b/.gitignore @@ -8,13 +8,13 @@ build/ .mypy_cache/ .ruff_cache/ .pytest_cache/ -.coverage htmlcov/ .wrangler/ uv.lock # secrets .env* +!.env.example *.pem *.key *.seed diff --git a/examples/issue_token.py b/examples/issue_token.py index 134b5bb..1f3342b 100644 --- a/examples/issue_token.py +++ b/examples/issue_token.py @@ -36,6 +36,7 @@ import argparse import logging import sys +import time from mintlayer.wallet import ( Amount, @@ -60,7 +61,14 @@ def main() -> None: parser.add_argument("--supply", default="1000000", help="initial mint supply in smallest unit") parser.add_argument("--uri", default="", help="URL pointing to token metadata JSON") parser.add_argument("--wallet-rpc", default="http://127.0.0.1:3034", help="wallet RPC endpoint") + parser.add_argument("--indexer", default="http://127.0.0.1:3000", help="indexer base URL") parser.add_argument("--account", type=int, default=0, help="wallet account index") + parser.add_argument( + "--wait-timeout", + type=int, + default=300, + help="max seconds to wait for issuance confirmation", + ) args = parser.parse_args() logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") @@ -135,8 +143,31 @@ def main() -> None: # MintTokens creates new tokens and sends them to the given address. # The wallet must control the authority key. # - # Note: wait for the issuance transaction to confirm before minting. - # In production, poll indexer.get_transaction until confirmations != "". + # Minting requires the issuance transaction to be confirmed first, so poll + # the indexer until it is (bounded by --wait-timeout). + from mintlayer.indexer import Client as IndexerClient + from mintlayer.indexer import HTTPError + + indexer = IndexerClient(args.indexer) + deadline = time.monotonic() + args.wait_timeout + while True: + try: + info = indexer.get_transaction(issue_result.tx_id) + except HTTPError: + info = None # not indexed yet — keep polling + if info and info.confirmations: + log.info("issuance confirmed (%s confirmations)", info.confirmations) + break + if time.monotonic() >= deadline: + log.warning( + "issuance tx %s not confirmed within %ds; skipping mint (re-run once it confirms)", + issue_result.tx_id, + args.wait_timeout, + ) + return + log.info("waiting for issuance tx %s to confirm...", issue_result.tx_id) + time.sleep(5) + try: mint_result = wallet.mint_tokens( MintParams( diff --git a/examples/send_coins.py b/examples/send_coins.py index 6be2447..9971a76 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -9,30 +9,33 @@ 1. Derive an account key and receiving address from a BIP-39 mnemonic. 2. Fetch spendable UTXOs for that address from the indexer. -3. Build an unsigned transaction (encode inputs and outputs). +3. Build an unsigned transaction (encode inputs, recipient output, change). 4. Sign each input with encode_witness. 5. Submit the signed transaction to the indexer. Usage: - uv run python examples/send_coins.py \ - --mnemonic "word1 word2 ... word12" \ - --to mtc1qrecipient... \ - --amount 100000000000 \ + uv run python examples/send_coins.py \\ + --to mtc1qrecipient... \\ + --amount 100000000000 \\ --indexer http://127.0.0.1:3000 -NOTE: Secrets passed via command-line arguments are visible in -shell history and `ps` output; use stdin/env vars in production. +The mnemonic can be passed via ``--mnemonic``, the ``MNEMONIC`` environment +variable, or a hidden interactive prompt — avoiding shell history and ``ps`` +exposure. -NOTE: This example sends ALL spendable UTXOs to the recipient with no change -output. It is intentionally minimal. Production code should select UTXOs, -compute fees, add a change output, and handle errors more robustly. +NOTE: This is a teaching example: fees are estimated from the indexer fee +rate, the remainder is returned to the source address as change, and only +plain Transfer/Coin UTXOs are selected. Production code should use the wallet +daemon or a proper coin-selection and fee-bumping strategy. """ from __future__ import annotations import argparse +import getpass import logging +import os import sys from mintlayer.indexer import Client as IndexerClient @@ -49,45 +52,57 @@ log = logging.getLogger("send-coins") +FEE_RATE_PER_KB_FALLBACK = 100_000 # atoms/KB used when the indexer has no fee data -def total_atoms(utxos: list) -> int: - """Sum the coin atoms across all Transfer/Coin UTXOs.""" - total = 0 - for u in utxos: - try: - if u.output.get("type") == "Transfer": - value = u.output.get("value") or {} - if value.get("type") == "Coin": - total += int(value["amount"]["atoms"]) - except (AttributeError, KeyError, TypeError, ValueError): - continue - return total + +def is_coin_transfer(output: object) -> bool: + """Whether a decoded UTXO output is a plain Transfer of native coins.""" + if not isinstance(output, dict) or output.get("type") != "Transfer": + return False + value = output.get("value") + return isinstance(value, dict) and value.get("type") == "Coin" + + +def output_atoms(output: dict) -> int: + """Atom count of a Transfer/Coin output (pre-validated by is_coin_transfer).""" + return int(output["value"]["amount"]["atoms"]) def encode_utxo_entry(wasm: WasmClient, utxo_json: dict, network: Network) -> bytes: """Re-encode a JSON UTXO output into the binary form encode_witness expects. - Format: 0x01 + when the output can be re-encoded, - 0x00 otherwise (signing still succeeds for many output types). + Format: ``0x01 + ``. Signatures only verify on-chain + if the sighash covers the real output, so a re-encoding failure is fatal + rather than silently downgraded to a non-UTXO (``0x00``) entry. """ - try: - if utxo_json.get("type") == "Transfer": - value = utxo_json["value"] - if value.get("type") == "Coin": - encoded = wasm.encode_output_transfer( - Amount(atoms=value["amount"]["atoms"]), - value["destination"], - network, - ) - return b"\x01" + encoded - except (KeyError, TypeError, ValueError): - pass - return b"\x00" + if utxo_json.get("type") == "Transfer": + value = utxo_json["value"] + if value.get("type") == "Coin": + encoded = wasm.encode_output_transfer( + Amount(atoms=value["amount"]["atoms"]), + value["destination"], + network, + ) + return b"\x01" + encoded + raise ValueError(f"unsupported UTXO output type for minimal send: {utxo_json.get('type')!r}") + + +def resolve_mnemonic(cli_value: str) -> str: + """CLI argument, then the ``MNEMONIC`` env var, then a hidden prompt.""" + if cli_value: + return cli_value + env = os.environ.get("MNEMONIC", "") + if env: + log.info("using mnemonic from the MNEMONIC environment variable") + return env + return getpass.getpass("BIP-39 mnemonic (input hidden): ") def main() -> None: parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--mnemonic", required=True, help="BIP-39 mnemonic (12 or 24 words)") + parser.add_argument( + "--mnemonic", default="", help="BIP-39 mnemonic; omit to use $MNEMONIC or a hidden prompt" + ) parser.add_argument("--to", required=True, help="recipient bech32m address") parser.add_argument("--amount", required=True, help="amount to send in atoms (1 ML = 1e11)") parser.add_argument("--indexer", default="http://127.0.0.1:3000", help="indexer base URL") @@ -104,23 +119,33 @@ def main() -> None: wasm = WasmClient() # ── 2. Derive the spending key and address ─────────────────────────────── - account_key = wasm.make_default_account_privkey(args.mnemonic, network) + mnemonic = resolve_mnemonic(args.mnemonic) + account_key = wasm.make_default_account_privkey(mnemonic, network) spend_key = wasm.make_receiving_address(account_key, args.key_index) pub_key = wasm.public_key_from_private_key(spend_key) from_addr = wasm.pubkey_to_pubkeyhash_address(pub_key, network) log.info("spending from: %s", from_addr) - # ── 3. Fetch spendable UTXOs ───────────────────────────────────────────── + # ── 3. Fetch spendable UTXOs (this minimal send only handles Coin) ─────── indexer = IndexerClient(args.indexer) - utxos = indexer.get_spendable_utxos(from_addr) + all_utxos = indexer.get_spendable_utxos(from_addr) + + utxos = [u for u in all_utxos if is_coin_transfer(u.output)] + for u in all_utxos: + if not is_coin_transfer(u.output): + output_type = u.output.get("type") if isinstance(u.output, dict) else None + log.warning("skipping non-Coin UTXO (type=%s)", output_type) if not utxos: - log.fatal("no spendable UTXOs for %s", from_addr) + log.fatal("no spendable Coin UTXOs for %s", from_addr) sys.exit(1) log.info("found %d spendable UTXO(s)", len(utxos)) - total = total_atoms(utxos) + total = sum(output_atoms(u.output) for u in utxos) send_amt = int(args.amount.strip()) + if send_amt <= 0: + log.fatal("amount must be positive") + sys.exit(1) if total < send_amt: log.fatal("insufficient balance: have %d atoms, need %d atoms", total, send_amt) sys.exit(1) @@ -131,22 +156,54 @@ def main() -> None: for u in utxos: tx_id_bytes = bytes.fromhex(u.outpoint.source_id) src_id = wasm.encode_outpoint_source_id(tx_id_bytes, SOURCE_TRANSACTION) - inp = wasm.encode_input_for_utxo(src_id, u.outpoint.index) - encoded_inputs += inp + encoded_inputs += wasm.encode_input_for_utxo(src_id, u.outpoint.index) all_utxo_bytes += encode_utxo_entry(wasm, u.output, network) - # ── 5. Encode the transfer output ──────────────────────────────────────── - output = wasm.encode_output_transfer(Amount(atoms=args.amount), args.to, network) + # ── 5. Fee rate, then build the transaction with change ────────────────── + try: + fee_rate = int(indexer.get_fee_rate()) # atoms per kilobyte + except Exception as exc: + log.warning( + "fee rate lookup failed (%s); using fallback %d atoms/KB", + exc, + FEE_RATE_PER_KB_FALLBACK, + ) + fee_rate = FEE_RATE_PER_KB_FALLBACK + + def build(fee: int) -> tuple[bytes, int]: + """Recipient output + change output; return (tx, estimated size).""" + change = total - send_amt - fee + if change < 0: + raise ValueError(f"insufficient balance for fee: have {total}, need {send_amt} + {fee}") + outputs = wasm.encode_output_transfer(Amount(atoms=str(send_amt)), args.to, network) + if change > 0: + outputs += wasm.encode_output_transfer(Amount(atoms=str(change)), from_addr, network) + tx = wasm.encode_transaction(encoded_inputs, outputs, 0) + size = wasm.estimate_transaction_size(tx, [from_addr] * len(utxos), outputs, network) + return tx, size + + # The fee depends on the tx size, which depends on the change amount's + # digit count; the loop converges in a couple of passes. + fee = fee_rate # start from 1 KB worth of fees + tx, size = build(fee) + for _ in range(4): + new_fee = max(1, -(-size // 1000) * fee_rate) # ceil(size / 1000) * rate + if new_fee == fee: + break + fee = new_fee + tx, size = build(fee) + + if total - send_amt - fee <= 0: + log.fatal("balance %d cannot cover amount %d plus fee %d", total, send_amt, fee) + sys.exit(1) - # ── 6. Build the unsigned transaction ──────────────────────────────────── - tx = wasm.encode_transaction(encoded_inputs, output, 0) tx_id = wasm.get_transaction_id(tx, True) - log.info("unsigned tx id: %s", tx_id) + log.info("unsigned tx id: %s (fee: %d atoms)", tx_id, fee) - # ── 7. Sign each input and collect witnesses ───────────────────────────── + # ── 6. Sign each input and collect witnesses ───────────────────────────── witness_bytes = b"" for i in range(len(utxos)): - witness = wasm.encode_witness( + witness_bytes += wasm.encode_witness( SignatureHashType.SIGHASH_ALL, spend_key, from_addr, @@ -157,20 +214,15 @@ def main() -> None: 0, # block height (0 = no lock-time constraint) network, ) - witness_bytes += witness - # ── 8. Assemble the signed transaction ─────────────────────────────────── + # ── 7. Assemble the signed transaction ─────────────────────────────────── signed_tx = wasm.encode_signed_transaction(tx, witness_bytes) log.info("signed tx (%d bytes)", len(signed_tx)) - # ── 9. Submit ──────────────────────────────────────────────────────────── + # ── 8. Submit ──────────────────────────────────────────────────────────── submitted_tx_id = indexer.submit_transaction(signed_tx.hex()) print(f"submitted: {submitted_tx_id}") - # Informational: in production, call wasm.estimate_transaction_size and - # multiply by the fee rate from node.get_fee_rate or indexer.get_fee_rate - # to compute the exact fee before building outputs. - if __name__ == "__main__": main() diff --git a/mintlayer/client.py b/mintlayer/client.py index 94ae563..53ffc08 100644 --- a/mintlayer/client.py +++ b/mintlayer/client.py @@ -8,7 +8,7 @@ from __future__ import annotations import threading -from dataclasses import dataclass +from dataclasses import dataclass, field from .indexer import Client as IndexerClient from .node import Client as NodeClient @@ -79,15 +79,23 @@ class Config: """Top-level SDK configuration. Only sub-clients whose URL field is non-empty are constructed. + ``password`` is redacted from :func:`repr` to keep credentials out of logs. """ node_url: str = "" indexer_url: str = "" wallet_url: str = "" username: str = "" - password: str = "" + password: str = field(default="", repr=False) timeout: float = 30.0 + def __repr__(self) -> str: + return ( + f"Config(node_url={self.node_url!r}, indexer_url={self.indexer_url!r}, " + f"wallet_url={self.wallet_url!r}, username={self.username!r}, " + f"password='***', timeout={self.timeout!r})" + ) + class Client: """The top-level Mintlayer SDK client. @@ -140,8 +148,14 @@ def wasm(self) -> WASMClient: return self._wasm def close(self) -> None: - """Release WASM resources; HTTP sub-clients need no teardown.""" + """Release WASM resources and close sessions owned by sub-clients.""" with self._mu: + if self.node is not None: + self.node.close() + if self.indexer is not None: + self.indexer.close() + if self.wallet is not None: + self.wallet.close() if self._wasm is not None: self._wasm.close() self._wasm = None diff --git a/mintlayer/indexer/number.py b/mintlayer/indexer/number.py index d5f7a36..d597532 100644 --- a/mintlayer/indexer/number.py +++ b/mintlayer/indexer/number.py @@ -50,7 +50,7 @@ def parse_per_thousand(data: Any) -> float: except ValueError as exc: raise IndexerError(f"PerThousand: {exc}") from exc else: - value = float(data) + raise IndexerError(f"PerThousand: invalid value {data!r}") if not math.isfinite(value): raise IndexerError(f"PerThousand: non-finite value {data!r}") return value diff --git a/mintlayer/indexer/pool.py b/mintlayer/indexer/pool.py index d2ac96e..70b44e6 100644 --- a/mintlayer/indexer/pool.py +++ b/mintlayer/indexer/pool.py @@ -4,7 +4,7 @@ from datetime import datetime -from ._http import IndexerHTTP, _seg +from ._http import IndexerError, IndexerHTTP, _seg from .types import Pool, PoolDelegation, PoolListOpts @@ -24,7 +24,14 @@ def get_pool_block_stats(self, pool_id: str, from_time: datetime, to_time: datet f"/pool/{_seg(pool_id)}/block-stats", {"from": int(from_time.timestamp()), "to": int(to_time.timestamp())}, ) - return int(data["block_count"]) + if not isinstance(data, dict) or "block_count" not in data: + raise IndexerError(f"get_pool_block_stats: unexpected response {data!r}") + try: + return int(data["block_count"]) + except (TypeError, ValueError) as exc: + raise IndexerError( + f"get_pool_block_stats: invalid block_count {data['block_count']!r}" + ) from exc def get_pool_delegations(self, pool_id: str) -> list[PoolDelegation]: """Return the delegations to a pool.""" diff --git a/mintlayer/indexer/statistics.py b/mintlayer/indexer/statistics.py index 2274c98..2769b7c 100644 --- a/mintlayer/indexer/statistics.py +++ b/mintlayer/indexer/statistics.py @@ -2,7 +2,7 @@ from __future__ import annotations -from ._http import IndexerHTTP +from ._http import IndexerHTTP, _seg from .types import CoinStats @@ -13,7 +13,7 @@ def get_coin_statistics(self) -> CoinStats: def get_token_statistics(self, token_id: str) -> CoinStats: """Return the same statistics for a token.""" - return CoinStats.from_json(self.get(f"/statistics/token/{token_id}")) + return CoinStats.from_json(self.get(f"/statistics/token/{_seg(token_id)}")) def get_fee_rate(self, in_top_x_mb: int = 0) -> str: """Return the fee rate (atoms per KB) as a decimal string. diff --git a/mintlayer/indexer/transaction.py b/mintlayer/indexer/transaction.py index b796553..b1c0ded 100644 --- a/mintlayer/indexer/transaction.py +++ b/mintlayer/indexer/transaction.py @@ -4,7 +4,7 @@ from typing import Any -from ._http import IndexerHTTP, _seg +from ._http import IndexerError, IndexerHTTP, _seg from .types import MerklePath, PageOpts, Transaction @@ -29,4 +29,6 @@ def get_transaction_output(self, tx_id: str, output_index: int) -> Any: def submit_transaction(self, signed_tx_hex: str) -> str: """Submit a signed transaction (hex) — requires ``--enable-post-routes``.""" data = self.post_text("/transaction", signed_tx_hex) + if not isinstance(data, dict) or "tx_id" not in data: + raise IndexerError(f"submit_transaction: unexpected response {data!r}") return str(data["tx_id"]) diff --git a/mintlayer/indexer/types.py b/mintlayer/indexer/types.py index 8688f45..c086f94 100644 --- a/mintlayer/indexer/types.py +++ b/mintlayer/indexer/types.py @@ -504,7 +504,7 @@ def from_json(cls_: type[_T], data: Any) -> _T: return original(cls_, data) except IndexerError: raise - except (KeyError, TypeError, ValueError) as exc: + except (AttributeError, KeyError, TypeError, ValueError) as exc: raise IndexerError(f"{cls_.__name__}: malformed payload ({exc!r})") from exc return classmethod(from_json) diff --git a/mintlayer/wallet/_core.py b/mintlayer/wallet/_core.py index 24a4503..c3ffe78 100644 --- a/mintlayer/wallet/_core.py +++ b/mintlayer/wallet/_core.py @@ -20,4 +20,8 @@ def _call_model(self, method: str, params: Any, cls: type[_T]) -> _T: def _call_model_list(self, method: str, params: Any, cls: type[_T]) -> list[_T]: data = self._rpc.call(method, params) - return [cls.from_json(item) for item in data or []] # type: ignore[attr-defined] + if data is None: + return [] # JSON null == empty list (matches Go's nil-slice decode) + if not isinstance(data, list): + raise JSONRPCError(f"{method}: expected list result, got {data!r}") + return [cls.from_json(item) for item in data] # type: ignore[attr-defined] diff --git a/mintlayer/wallet/staking.py b/mintlayer/wallet/staking.py index 98d72ba..24453b6 100644 --- a/mintlayer/wallet/staking.py +++ b/mintlayer/wallet/staking.py @@ -51,7 +51,7 @@ def stop_staking(self, account: int) -> None: def get_staking_status(self, account: int) -> StakingStatus: """Return whether the account is currently staking.""" result = self._call("staking_status", {"account": account}) - return StakingStatus(str(result)) + return StakingStatus(result) def create_delegation(self, params: CreateDelegationParams) -> CreateDelegationResult: """Create a delegation ID for delegating to a pool.""" diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 16e869b..9b9b141 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -130,9 +130,11 @@ def _call(self, name: str, *params: Any) -> list: res = fn(self.store, *params) except Exception as exc: # WasmThrow (from the host's __wbindgen_throw) and traps land here. + # The cause chain is preserved: wasmtime trap traces are noisy but + # invaluable for diagnosing memory/ABI failures. if self.call_state.err_msg: - raise WasmError(f"mintlayer: {self.call_state.err_msg}") from None - raise WasmError(f"mintlayer: call {name}: {exc}") from None + raise WasmError(f"mintlayer: {self.call_state.err_msg}") from exc + raise WasmError(f"mintlayer: call {name}: {exc}") from exc self._last_err_msg = self.call_state.err_msg self._last_json = self.call_state.last_json # Func.__call__ returns None / scalar / list depending on result count. @@ -157,9 +159,7 @@ def _call_return_bytes(self, name: str, *params: Any) -> bytes: if len(ret) < 2: raise WasmError(f"mintlayer: unexpected return count from {name}") ptr, length = ret[0], ret[1] - if length == 0: - return b"" - data = self._read_bytes(ptr, length) + data = self._read_bytes(ptr, length) if length else bytearray() if data is None: raise WasmError("mintlayer: memory read failed") with contextlib.suppress(Exception): @@ -173,9 +173,7 @@ def _call_return_bytes_no_err(self, name: str, *params: Any) -> bytes: if len(ret) < 2: raise WasmError(f"mintlayer: unexpected return count from {name}") ptr, length = ret[0], ret[1] - if length == 0: - return b"" - data = self._read_bytes(ptr, length) + data = self._read_bytes(ptr, length) if length else bytearray() if data is None: raise WasmError("mintlayer: memory read failed") with contextlib.suppress(Exception): diff --git a/mintlayer/wasm/host.py b/mintlayer/wasm/host.py index db87750..17d3366 100644 --- a/mintlayer/wasm/host.py +++ b/mintlayer/wasm/host.py @@ -96,7 +96,15 @@ def alloc_table_slot(value: Any) -> int: return idx def signal_exception(msg: str) -> None: - """Mirror JS ``handleError``: stash the exception so WASM returns Err.""" + """Mirror JS ``handleError``: stash the exception so WASM returns Err. + + The message is recorded in the per-call side channel so host-side + failures surface even if the WASM error path never calls + ``__wbindgen_cast_...2`` (a later cast still overwrites it with the + richer Rust-side message). + """ + if not state.err_msg: + state.err_msg = msg if client.get_export("__externref_table_alloc") is None: return if client.get_export("__wbindgen_exn_store") is None: @@ -219,7 +227,12 @@ def _prototypesetcall(dst_ptr: int, dst_len: int, src: Any) -> None: client.memory.write(store, data, dst_ptr) def _subarray(value: Any, start: int, end: int) -> Any: + # JS spec: TypedArray.prototype.subarray clamps the range silently. + # (Divergence: JS also accepts negative indices as from-the-end; this + # host clamps them to 0 — wasm-bindgen only ever passes u32 offsets.) if isinstance(value, Uint8ArrayRef): + start = max(0, min(start, value.length)) + end = max(start, min(end, value.length)) return Uint8ArrayRef(value.ptr + start, end - start) return None diff --git a/mintlayer/wasm/types.py b/mintlayer/wasm/types.py index 6956035..6b927fb 100644 --- a/mintlayer/wasm/types.py +++ b/mintlayer/wasm/types.py @@ -108,6 +108,12 @@ class SimpleCurrencyAmount: kind: CurrencyAmountKind = CurrencyAmountKind.COINS token_id: str | None = None + def __post_init__(self) -> None: + if self.kind == CurrencyAmountKind.TOKENS and not self.token_id: + raise ValueError("token_id is required for TOKENS amounts") + if self.kind == CurrencyAmountKind.COINS and self.token_id is not None: + raise ValueError("token_id must be None for COINS amounts") + @classmethod def coins(cls, atoms: str) -> SimpleCurrencyAmount: return cls(atoms=atoms, kind=CurrencyAmountKind.COINS, token_id=None) diff --git a/pyproject.toml b/pyproject.toml index dcd1bcd..cd14b20 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,5 +1,5 @@ [build-system] -requires = ["hatchling"] +requires = ["hatchling>=1.26"] build-backend = "hatchling.build" [project] @@ -32,7 +32,7 @@ dev = [ "pytest>=8.0", "ruff>=0.6", "mypy>=1.11", - "pytest-cov>=7.1.0", + "pytest-cov>=7.1.0", # keep floor in sync with pytest>=8.0 ] [tool.hatch.build.targets.wheel] diff --git a/tests/test_client.py b/tests/test_client.py index edd727f..3702b14 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -100,6 +100,62 @@ def test_init_wasm_creates_client_and_close_releases_it(self) -> None: _ = client.wasm +class TestConfigRedaction: + def test_repr_redacts_password(self) -> None: + got = repr( + Config( + node_url="http://127.0.0.1:3030", + indexer_url="http://127.0.0.1:3000", + wallet_url="http://127.0.0.1:3034", + username="alice", + password="hunter2", + timeout=5.0, + ) + ) + assert "password='***'" in got + assert "hunter2" not in got + # The non-secret fields stay visible for debugging. + assert "node_url='http://127.0.0.1:3030'" in got + assert "indexer_url='http://127.0.0.1:3000'" in got + assert "wallet_url='http://127.0.0.1:3034'" in got + assert "username='alice'" in got + assert "timeout=5.0" in got + + def test_password_field_has_repr_disabled(self) -> None: + """The dataclass field itself is marked repr=False (belt to the braces).""" + assert Config.__dataclass_fields__["password"].repr is False + + +class TestCloseClosesSubClients: + def test_close_closes_each_sub_clients_session( + self, rpc_server, rest_server, monkeypatch + ) -> None: + """Top-level close() must reach the HTTP session each sub-client owns.""" + node_srv = rpc_server(result=_BLOCK_RESULT) + indexer_srv = rest_server(payload={}) + wallet_srv = rpc_server(result=None) + client = Client( + Config( + node_url=node_srv.url, + indexer_url=indexer_srv.url, + wallet_url=wallet_srv.url, + ) + ) + closed: list[str] = [] + monkeypatch.setattr(client.node._rpc._session, "close", lambda: closed.append("node")) + monkeypatch.setattr(client.indexer._session, "close", lambda: closed.append("indexer")) + monkeypatch.setattr(client.wallet._rpc._session, "close", lambda: closed.append("wallet")) + client.close() + # Node, indexer and wallet are all released, in construction order. + assert closed == ["node", "indexer", "wallet"] + + def test_close_is_idempotent_with_sub_clients(self, rpc_server) -> None: + """A second close() with real sub-clients must not raise.""" + client = Client(Config(node_url=rpc_server(result=_BLOCK_RESULT).url)) + client.close() + client.close() + + class TestContextManager: def test_with_block_and_idempotent_close(self) -> None: with mintlayer.Client(mintlayer.Config(node_url="http://127.0.0.1:3030")) as c: diff --git a/tests/test_indexer_number.py b/tests/test_indexer_number.py new file mode 100644 index 0000000..293e652 --- /dev/null +++ b/tests/test_indexer_number.py @@ -0,0 +1,26 @@ +"""Tests for the lenient numeric decoders (mintlayer.indexer.number). + +Mirrors go-sdk/indexer/number.go semantics: out-of-contract payload shapes +must raise IndexerError (the library's codec failure), never a bare +TypeError from float()/str conversion. +""" + +from __future__ import annotations + +import pytest + +from mintlayer.indexer import IndexerError +from mintlayer.indexer.number import parse_per_thousand + + +@pytest.mark.parametrize( + "data", + [ + pytest.param(None, id="null"), + pytest.param([1], id="list"), + ], +) +def test_parse_per_thousand_non_scalar_raises_indexer_error(data: object) -> None: + """None/list payloads raise IndexerError instead of a bare TypeError.""" + with pytest.raises(IndexerError, match="PerThousand: invalid value"): + parse_per_thousand(data) diff --git a/tests/test_indexer_pool.py b/tests/test_indexer_pool.py index b459fef..9fb79fc 100644 --- a/tests/test_indexer_pool.py +++ b/tests/test_indexer_pool.py @@ -12,7 +12,7 @@ import pytest -from mintlayer.indexer import Client, Pool, PoolDelegation, PoolListOpts +from mintlayer.indexer import Client, IndexerError, Pool, PoolDelegation, PoolListOpts def _pool_payload(**margin_overrides: object) -> dict: @@ -118,6 +118,25 @@ def test_get_pool_block_stats_query_params(rest_server) -> None: client.close() +@pytest.mark.parametrize( + "payload", + [ + pytest.param({"nope": 1}, id="missing-block-count"), + pytest.param(["nope"], id="list"), + pytest.param("astring", id="bare-string"), + ], +) +def test_get_pool_block_stats_malformed_payload_raises_indexer_error( + rest_server, payload: object +) -> None: + """Non-dict payloads and dicts without block_count raise IndexerError.""" + srv = rest_server(payload=payload) + client = Client(srv.url) + with pytest.raises(IndexerError, match="get_pool_block_stats: unexpected response"): + client.get_pool_block_stats("mpool1abc", _FROM, _TO) + client.close() + + def test_get_pool_delegations(rest_server) -> None: srv = rest_server( payload=[ diff --git a/tests/test_indexer_statistics.py b/tests/test_indexer_statistics.py index e206e98..08770e7 100644 --- a/tests/test_indexer_statistics.py +++ b/tests/test_indexer_statistics.py @@ -39,6 +39,20 @@ def test_get_token_statistics(rest_server) -> None: client.close() +def test_get_token_statistics_percent_encodes_reserved_characters(rest_server) -> None: + """A token id containing '/' or '?' must be percent-encoded in the path.""" + srv = rest_server(payload=_COIN_STATS) + client = Client(srv.url) + try: + stats = client.get_token_statistics("tok/en?x") + assert isinstance(stats, CoinStats) + assert srv.capture.path == "/api/v2/statistics/token/tok%2Fen%3Fx" + # Nothing may leak out of the path into the query string. + assert srv.capture.query == "" + finally: + client.close() + + def test_get_fee_rate_in_top_x_mb(rest_server) -> None: """in_top_x_mb=5 is sent and the bare JSON string result is returned.""" srv = rest_server(payload="1000") diff --git a/tests/test_indexer_transaction.py b/tests/test_indexer_transaction.py index 4980e62..9aa7526 100644 --- a/tests/test_indexer_transaction.py +++ b/tests/test_indexer_transaction.py @@ -6,7 +6,9 @@ from __future__ import annotations -from mintlayer.indexer import Client, MerklePath, PageOpts, Transaction +import pytest + +from mintlayer.indexer import Client, IndexerError, MerklePath, PageOpts, Transaction def test_list_transactions_pagination(rest_server) -> None: @@ -126,3 +128,23 @@ def test_submit_transaction(rest_server) -> None: assert srv.capture.raw_body == b"cafebabe" assert srv.capture.headers.get("content-type", "").startswith("text/plain") client.close() + + +@pytest.mark.parametrize( + "payload", + [ + pytest.param({"nope": 1}, id="missing-tx-id"), + pytest.param("astring", id="bare-string"), + ], +) +def test_submit_transaction_malformed_payload_raises_indexer_error( + rest_server, payload: object +) -> None: + """A response without a tx_id is a codec failure, not KeyError/TypeError.""" + srv = rest_server(payload=payload) + client = Client(srv.url) + try: + with pytest.raises(IndexerError): + client.submit_transaction("cafebabe") + finally: + client.close() diff --git a/tests/test_indexer_types.py b/tests/test_indexer_types.py new file mode 100644 index 0000000..7398749 --- /dev/null +++ b/tests/test_indexer_types.py @@ -0,0 +1,33 @@ +"""Tests for indexer payload decoding (mintlayer.indexer.types). + +Every ``from_json`` classmethod is wrapped so a malformed server payload +raises IndexerError — including payloads of the wrong JSON *shape* (a list +or scalar where an object is expected), which surface as AttributeError +inside the original decoders and must not leak out uncaught. +""" + +from __future__ import annotations + +import pytest + +from mintlayer.indexer import Amount, IndexerError, Transaction +from mintlayer.indexer.types import BlockBody + + +@pytest.mark.parametrize( + ("cls", "payload"), + [ + pytest.param(Amount, ["list"], id="amount-list"), + pytest.param(BlockBody, None, id="block-body-null"), + ], +) +def test_from_json_non_object_payload_raises_indexer_error(cls: type, payload: object) -> None: + """AttributeError from ``data.get`` on a non-dict is wrapped as IndexerError.""" + with pytest.raises(IndexerError, match=f"{cls.__name__}: malformed payload"): + cls.from_json(payload) # type: ignore[attr-defined] + + +def test_indexer_error_from_json_still_lists_transaction_fields() -> None: + """Sanity: well-formed payloads keep decoding through the same wrapper.""" + tx = Transaction.from_json({"id": "tx01"}) + assert tx.id == "tx01" diff --git a/tests/test_wallet_staking.py b/tests/test_wallet_staking.py index 3a94870..b751e64 100644 --- a/tests/test_wallet_staking.py +++ b/tests/test_wallet_staking.py @@ -7,6 +7,8 @@ from __future__ import annotations +import pytest + from mintlayer.wallet import ( Amount, Client, @@ -16,6 +18,7 @@ DecommissionParams, DelegateParams, DelegationInfo, + JSONRPCError, OwnedPool, StakingStatus, WithdrawParams, @@ -113,6 +116,22 @@ def test_list_owned_pools_null_result_returns_empty(rpc_server) -> None: client.close() +@pytest.mark.parametrize( + "result", + [ + pytest.param({"pool_id": "pool1abc"}, id="dict"), + pytest.param("astring", id="bare-string"), + ], +) +def test_list_owned_pools_non_list_result_raises_jsonrpc_error(rpc_server, result: object) -> None: + """A non-list, non-null result is a protocol error, not a decode crash.""" + srv = rpc_server(result=result) + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="staking_list_pools: expected list result"): + client.list_owned_pools(0) + client.close() + + def test_get_pool_balance_account_not_sent(rpc_server) -> None: srv = rpc_server(result={"balance": {"atoms": "50000000000000", "decimal": "500000.0"}}) client = Client(srv.url) diff --git a/tests/test_wasm_types.py b/tests/test_wasm_types.py index df40697..e9de8c7 100644 --- a/tests/test_wasm_types.py +++ b/tests/test_wasm_types.py @@ -9,6 +9,8 @@ import json +import pytest + from mintlayer.wasm import ( Amount, CurrencyAmountKind, @@ -69,6 +71,27 @@ def test_simple_currency_amount_tokens_shape() -> None: assert tokens.to_json_value() == {"tokens": {"amount": {"atoms": "7"}, "token_id": "mmltk1abc"}} +def test_simple_currency_amount_tokens_without_token_id_rejected() -> None: + """A TOKENS amount without a token_id cannot be constructed.""" + with pytest.raises(ValueError, match="token_id is required for TOKENS amounts"): + SimpleCurrencyAmount(atoms="1", kind=CurrencyAmountKind.TOKENS) + + +def test_simple_currency_amount_coins_with_token_id_rejected() -> None: + """A COINS amount must not carry a token_id.""" + with pytest.raises(ValueError, match="token_id must be None for COINS amounts"): + SimpleCurrencyAmount(atoms="1", token_id="mmltk1abc") + + +def test_simple_currency_amount_valid_constructions_still_work() -> None: + """The invariant only rejects the two contradictory combinations.""" + coins = SimpleCurrencyAmount(atoms="1") + assert coins.kind == CurrencyAmountKind.COINS + assert coins.token_id is None + tokens = SimpleCurrencyAmount(atoms="1", kind=CurrencyAmountKind.TOKENS, token_id="mmltk1abc") + assert tokens.to_json_value() == {"tokens": {"amount": {"atoms": "1"}, "token_id": "mmltk1abc"}} + + def test_order_balance_redundant_shape() -> None: balance = OrderBalance("9", None) assert balance.to_json_value() == { From 3d86367a5c9d317a202f744a11df1f62abb21d36 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 19:52:58 +0400 Subject: [PATCH 19/31] Address round-2 OCR findings - CI reproducibility: commit uv.lock, sync --locked in all jobs, cache keyed on uv.lock - _jsonrpc: non-dict JSON-RPC error object -> JSONRPCError (was raw AttributeError) - node: strict _call_opt_int (no bool/float/str coercion) and _call_str_list (list-of-strings validation, None -> []) - p2p: _duration_to_wire integer math (no float precision loss; old code could emit nanos == 1e9) - wasm: return-count guards in the bool/u32/u64 helpers (consistent with the string/bytes helpers) - examples: issue_token password via $WALLET_PASSWORD / hidden prompt; send_coins --mnemonic help text warns about ps/shell-history exposure Rejected (documented): code-review.yml pull-requests:write is required to post reviews; send_coins fee-loop 'oversized fee' claim is incorrect (the remainder always goes to the change output); naive-datetime behavior is documented Go parity; __wbindgen_free align=1 matches the JS glue and Go free convention (dlmalloc ignores the align hint). --- .github/workflows/ci.yml | 16 +- .gitignore | 1 - README.md | 102 ++--- docs/indexer.md | 36 +- docs/node.md | 37 +- docs/staking.md | 80 ++-- docs/tokens.md | 158 ++++---- docs/transactions.md | 14 +- docs/wallet.md | 54 +-- docs/wasm.md | 35 +- examples/issue_token.py | 12 +- examples/send_coins.py | 4 +- mintlayer/_jsonrpc.py | 2 + mintlayer/node/_core.py | 12 +- mintlayer/node/p2p.py | 5 +- mintlayer/wasm/_core.py | 6 + uv.lock | 851 +++++++++++++++++++++++++++++++++++++++ 17 files changed, 1177 insertions(+), 248 deletions(-) create mode 100644 uv.lock diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3bedd4c..5083f0e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -28,15 +28,13 @@ jobs: - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 with: enable-cache: true - # uv.lock is intentionally gitignored for this library, so key the - # cache on the dependency manifest instead. - cache-dependency-glob: pyproject.toml + cache-dependency-glob: uv.lock - name: Install Python run: uv python install 3.12 - - name: Sync dependencies - run: uv sync --group dev --python 3.12 + - name: Sync dependencies (locked) + run: uv sync --locked --group dev --python 3.12 - name: Ruff lint run: uv run ruff check . @@ -65,13 +63,13 @@ jobs: - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 with: enable-cache: true - cache-dependency-glob: pyproject.toml + cache-dependency-glob: uv.lock - name: Install Python ${{ matrix.python }} run: uv python install ${{ matrix.python }} - - name: Sync dependencies - run: uv sync --group dev --python ${{ matrix.python }} + - name: Sync dependencies (locked) + run: uv sync --locked --group dev --python ${{ matrix.python }} # WASM init costs ~400 ms per Client; the session-scoped fixture keeps # the suite to ~2 min. Coverage gate: total must stay above 80%. @@ -93,7 +91,7 @@ jobs: - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 with: enable-cache: true - cache-dependency-glob: pyproject.toml + cache-dependency-glob: uv.lock - name: Install Python run: uv python install 3.12 diff --git a/.gitignore b/.gitignore index dc0e5ed..a71a9a1 100644 --- a/.gitignore +++ b/.gitignore @@ -10,7 +10,6 @@ build/ .pytest_cache/ htmlcov/ .wrangler/ -uv.lock # secrets .env* diff --git a/README.md b/README.md index 2c04df9..3e49b00 100644 --- a/README.md +++ b/README.md @@ -48,11 +48,13 @@ sub-modules directly when you only need one. ```python import mintlayer -client = mintlayer.Client(mintlayer.Config( - node_url="http://127.0.0.1:3030", - indexer_url="http://127.0.0.1:3000", - wallet_url="http://127.0.0.1:3034", -)) +client = mintlayer.Client( + mintlayer.Config( + node_url="http://127.0.0.1:3030", + indexer_url="http://127.0.0.1:3000", + wallet_url="http://127.0.0.1:3034", + ) +) # Query the chain tip from the indexer. tip = client.indexer.get_tip() @@ -68,7 +70,7 @@ pub_key = client.wasm.public_key_from_private_key(priv_key) addr = client.wasm.pubkey_to_pubkeyhash_address(pub_key, mintlayer.MAINNET) print("address:", addr) -client.close() # or use `with mintlayer.Client(cfg) as client:` +client.close() # or use `with mintlayer.Client(cfg) as client:` ``` `Config` only constructs the sub-clients whose URL field is non-empty @@ -87,9 +89,9 @@ from mintlayer.node import Client c = Client( "http://127.0.0.1:3030", - username="user", # optional - password="pass", # optional - timeout=10.0, # optional, seconds + username="user", # optional + password="pass", # optional + timeout=10.0, # optional, seconds ) # Chain state @@ -138,7 +140,7 @@ tx_ids = c.get_block_transaction_ids("00000000...") # Transaction tx = c.get_transaction("aabbcc...") -tx_id = c.submit_transaction(signed_tx_hex) # requires --enable-post-routes +tx_id = c.submit_transaction(signed_tx_hex) # requires --enable-post-routes # Address utxos = c.get_spendable_utxos("mtc1q...") @@ -189,35 +191,41 @@ c.sync_wallet() # Accounts and addresses info = c.get_wallet_info() -addr = c.new_address(0) # account 0 +addr = c.new_address(0) # account 0 balance = c.get_balance(0) # Send coins (account 0, auto fee) -result = c.address_send(SendParams( - account=0, - address="mtc1q...", - amount=Amount(atoms="100000000000"), # 1 ML -)) +result = c.address_send( + SendParams( + account=0, + address="mtc1q...", + amount=Amount(atoms="100000000000"), # 1 ML + ) +) print("tx id:", result.tx_id) # Token operations -issue_result = c.issue_token(IssueTokenParams( - account=0, - destination_address=addr, - metadata=TokenMetadata( - token_ticker="MYTOKEN", - number_of_decimals=2, - metadata_uri="https://example.com/token", - token_supply=TokenSupply(type="Lockable"), - is_freezable=False, - ), -)) -mint_result = c.mint_tokens(MintParams( - account=0, - token_id=issue_result.token_id, - address=addr, - amount=Amount(atoms="1000"), -)) +issue_result = c.issue_token( + IssueTokenParams( + account=0, + destination_address=addr, + metadata=TokenMetadata( + token_ticker="MYTOKEN", + number_of_decimals=2, + metadata_uri="https://example.com/token", + token_supply=TokenSupply(type="Lockable"), + is_freezable=False, + ), + ) +) +mint_result = c.mint_tokens( + MintParams( + account=0, + token_id=issue_result.token_id, + address=addr, + amount=Amount(atoms="1000"), + ) +) # Staking c.start_staking(0) @@ -252,7 +260,9 @@ from mintlayer.wasm import Client as WasmClient c = WasmClient() # Key derivation (BIP-44 path 44'/mintlayer_coin_type'/0') -mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" +mnemonic = ( + "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" +) account_key = c.make_default_account_privkey(mnemonic, Network.MAINNET) recv_key = c.make_receiving_address(account_key, 0) pub_key = c.public_key_from_private_key(recv_key) @@ -263,12 +273,12 @@ src_id = c.encode_outpoint_source_id(tx_id_bytes, SOURCE_TRANSACTION) input_ = c.encode_input_for_utxo(src_id, output_index) output = c.encode_output_transfer( - Amount(atoms="100000000000"), # 1 ML + Amount(atoms="100000000000"), # 1 ML dest_addr, Network.MAINNET, ) -tx = c.encode_transaction(input_, output, 0) # flags = 0 +tx = c.encode_transaction(input_, output, 0) # flags = 0 tx_id = c.get_transaction_id(tx, True) # Signing @@ -277,8 +287,8 @@ witness = c.encode_witness( recv_key, addr, tx, - utxo_bytes, # see docs/transactions.md for the encoding details - 0, # input index + utxo_bytes, # see docs/transactions.md for the encoding details + 0, # input index TxAdditionalInfo(), block_height, Network.MAINNET, @@ -300,11 +310,13 @@ walkthrough. ```python # Node + WASM only — no wallet or indexer client is created. -client = mintlayer.Client(mintlayer.Config( - node_url="http://127.0.0.1:3030", - username="user", - password="pass", -)) +client = mintlayer.Client( + mintlayer.Config( + node_url="http://127.0.0.1:3030", + username="user", + password="pass", + ) +) # Call init_wasm() before using client.wasm (raises WasmError otherwise). client.init_wasm() @@ -334,9 +346,9 @@ decimal string of _atoms_ — the smallest indivisible unit. **1 ML = ```python from mintlayer.wasm import Amount -one = Amount.from_atoms("100000000000") # 1 ML +one = Amount.from_atoms("100000000000") # 1 ML zero = Amount.zero() -print(one.atoms) # "100000000000" +print(one.atoms) # "100000000000" ``` The indexer and wallet clients use their own `Amount` dataclass with both diff --git a/docs/indexer.md b/docs/indexer.md index 9782fb8..c060f13 100644 --- a/docs/indexer.md +++ b/docs/indexer.md @@ -9,8 +9,8 @@ from mintlayer.indexer import Client c = Client( "http://127.0.0.1:3000", - timeout=15.0, # optional, seconds (default 30.0) - session=None, # optional requests.Session (client owns it otherwise) + timeout=15.0, # optional, seconds (default 30.0) + session=None, # optional requests.Session (client owns it otherwise) ) ``` @@ -25,7 +25,7 @@ from mintlayer.indexer import HTTPError, IndexerError try: info = c.get_address_info("mtc1q...") except HTTPError as e: - print(e.status_code, e.body) # e.g. 404 "address not found" + print(e.status_code, e.body) # e.g. 404 "address not found" except IndexerError as e: ... # connection failure or malformed JSON body ``` @@ -42,8 +42,8 @@ List endpoints accept a `PageOpts` dataclass: ```python @dataclass(frozen=True) class PageOpts: - offset: int = 0 # default: 0 - items: int = 0 # default: 10 (server-side default) + offset: int = 0 # default: 0 + items: int = 0 # default: 10 (server-side default) ``` **Zero-omission rule:** zero values are omitted from the query string entirely, @@ -53,7 +53,7 @@ so the server defaults apply. Only positive values are sent: from mintlayer.indexer import PageOpts c.list_transactions(PageOpts(offset=20, items=50)) -c.list_orders() # server defaults +c.list_orders() # server defaults ``` --- @@ -159,8 +159,8 @@ fields are empty strings for unconfirmed transactions. @dataclass(frozen=True) class Transaction: id: str - inputs: Any # raw decoded JSON - outputs: Any # raw decoded JSON + inputs: Any # raw decoded JSON + outputs: Any # raw decoded JSON block_id: str timestamp: str confirmations: str @@ -219,7 +219,7 @@ class AddressInfo: coin_balance: Amount locked_coin_balance: Amount transaction_history: list[str] - tokens: list[TokenBalance] # TokenBalance(token_id, amount) + tokens: list[TokenBalance] # TokenBalance(token_id, amount) ``` ### `get_spendable_utxos` @@ -241,8 +241,8 @@ Returns all UTXOs including those that are locked or otherwise unspendable. ```python @dataclass(frozen=True) class UTXO: - outpoint: UTXOOutpoint # UTXOOutpoint(source_id: str, index: int) - output: Any # raw JSON; note the payload key on the wire is "utxo" + outpoint: UTXOOutpoint # UTXOOutpoint(source_id: str, index: int) + output: Any # raw JSON; note the payload key on the wire is "utxo" ``` ### `get_delegations` @@ -292,7 +292,7 @@ Returns staking pools with optional pagination. The `sort` field accepts: class PoolListOpts: offset: int = 0 items: int = 0 - sort: str = "" # omitted from the query when empty (zero-omission rule) + sort: str = "" # omitted from the query when empty (zero-omission rule) ``` ```python @@ -397,10 +397,10 @@ class TokenInfo: token_ticker: str metadata_uri: str number_of_decimals: int - total_supply: Any # raw JSON + total_supply: Any # raw JSON frozen: bool - is_token_unfreezable: bool | None # non-None only when frozen - is_token_freezable: bool | None # non-None only when not frozen + is_token_unfreezable: bool | None # non-None only when frozen + is_token_freezable: bool | None # non-None only when not frozen next_nonce: int ``` @@ -458,10 +458,10 @@ Returns a single order by its bech32m order ID. class Order: order_id: str conclude_destination: str - give_currency: Any # raw JSON, "type" of "Coin" or "Token" + give_currency: Any # raw JSON, "type" of "Coin" or "Token" initially_given: Amount give_balance: Amount - ask_currency: Any # raw JSON, "type" of "Coin" or "Token" + ask_currency: Any # raw JSON, "type" of "Coin" or "Token" initially_asked: Amount ask_balance: Amount nonce: int @@ -522,7 +522,7 @@ queue. parameter is omitted entirely and the server default (5 MB) applies. ```python -rate = int(c.get_fee_rate(1)) # atoms per KB, top 1 MB of the mempool +rate = int(c.get_fee_rate(1)) # atoms per KB, top 1 MB of the mempool ``` --- diff --git a/docs/node.md b/docs/node.md index 2198cea..194e331 100644 --- a/docs/node.md +++ b/docs/node.md @@ -8,10 +8,10 @@ from mintlayer.node import Client c = Client( "http://127.0.0.1:3030", - username="user", # optional; Basic Auth applied only when set - password="pass", # optional - timeout=10.0, # optional, seconds (default 30.0) - session=None, # optional requests.Session (client owns it otherwise) + username="user", # optional; Basic Auth applied only when set + password="pass", # optional + timeout=10.0, # optional, seconds (default 30.0) + session=None, # optional requests.Session (client owns it otherwise) ) ``` @@ -58,7 +58,7 @@ Returns a summary of the current chain state. class ChainstateInfo: best_block_height: int best_block_id: str - best_block_timestamp: Timestamp # Timestamp(timestamp: int), Unix seconds + best_block_timestamp: Timestamp # Timestamp(timestamp: int), Unix seconds median_time: Timestamp is_initial_block_download: bool ``` @@ -138,10 +138,11 @@ class Outpoint: source_id: OutpointSourceID index: int + @dataclass class OutpointSourceID: - type: str # "Transaction" or "BlockReward" - content: Any # {"tx_id": ""} or {"block_id": ""} + type: str # "Transaction" or "BlockReward" + content: Any # {"tx_id": ""} or {"block_id": ""} ``` Build the `content` payloads with the helpers: @@ -221,8 +222,8 @@ Returns on-chain token metadata (`None` if unknown). ```python @dataclass class TokenInfo: - type: str # "FungibleToken" or "NonFungibleToken" - content: Any # raw decoded JSON + type: str # "FungibleToken" or "NonFungibleToken" + content: Any # raw decoded JSON ``` ### `tokens_info` @@ -250,7 +251,7 @@ class OrderInfo: initially_given: Any ask_balance: Amount give_balance: Amount - nonce: int | None # None for active orders (daemon sends null) + nonce: int | None # None for active orders (daemon sends null) is_frozen: bool ``` @@ -273,8 +274,8 @@ sent; `None` serialises as JSON `null`). ```python @dataclass(frozen=True) class Currency: - type: str # "Coin" or "Token" - content: str | None # bech32 token ID when type is "Token" + type: str # "Coin" or "Token" + content: str | None # bech32 token ID when type is "Token" ``` Construct with the helpers: @@ -325,9 +326,7 @@ class MempoolTx: ### `mempool_submit_transaction` ```python -def mempool_submit_transaction( - self, tx_hex: str, trust_policy: TrustPolicy | str -) -> None: ... +def mempool_submit_transaction(self, tx_hex: str, trust_policy: TrustPolicy | str) -> None: ... ``` Submits a transaction to the local mempool only, without broadcasting to peers. @@ -358,7 +357,7 @@ mempool. ```python @dataclass(frozen=True) class FeeRate: - amount_per_kb: Amount # atoms per kilobyte + amount_per_kb: Amount # atoms per kilobyte ``` ### `get_fee_rate_points` @@ -477,7 +476,7 @@ Wire quirk: each entry is a two-element array @dataclass(frozen=True) class BannedPeer: address: str - ban_time: tuple[int, int] # (seconds, nanoseconds) + ban_time: tuple[int, int] # (seconds, nanoseconds) ``` ### `ban` @@ -506,9 +505,7 @@ Removes a peer from the ban list. ### `p2p_submit_transaction` ```python -def p2p_submit_transaction( - self, tx_hex: str, trust_policy: TrustPolicy | str -) -> None: ... +def p2p_submit_transaction(self, tx_hex: str, trust_policy: TrustPolicy | str) -> None: ... ``` Submits a transaction to the mempool and broadcasts it to peers. This is the diff --git a/docs/staking.md b/docs/staking.md index 5b66562..a95e374 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -20,15 +20,17 @@ from mintlayer.wallet import Amount, Client, CreatePoolParams wc = Client("http://127.0.0.1:3034") -result = wc.create_stake_pool(CreatePoolParams( - account=0, - amount=Amount(atoms="40000000000000"), # minimum pledge - cost_per_block=Amount(atoms="100000000"), # flat fee per block - margin_ratio_per_thousand="100", # 10% staker cut - decommission_address=decommission_addr, - # staker_address and vrf_public_key default to wallet-managed keys - # when None (sent as JSON null) -)) +result = wc.create_stake_pool( + CreatePoolParams( + account=0, + amount=Amount(atoms="40000000000000"), # minimum pledge + cost_per_block=Amount(atoms="100000000"), # flat fee per block + margin_ratio_per_thousand="100", # 10% staker cut + decommission_address=decommission_addr, + # staker_address and vrf_public_key default to wallet-managed keys + # when None (sent as JSON null) + ) +) print(f"tx id: {result.tx_id}") ``` @@ -44,10 +46,10 @@ predicted before broadcasting with `get_pool_id` (see below). ### Starting and stopping block production ```python -wc.start_staking(0) # account 0 +wc.start_staking(0) # account 0 status = wc.get_staking_status(0) -print(status) # StakingStatus.ACTIVE ("Staking") or StakingStatus.INACTIVE ("NotStaking") +print(status) # StakingStatus.ACTIVE ("Staking") or StakingStatus.INACTIVE ("NotStaking") wc.stop_staking(0) ``` @@ -66,7 +68,7 @@ for p in pools: ### Pool balance ```python -balance = wc.get_pool_balance(0, "mpool1...") # Amount +balance = wc.get_pool_balance(0, "mpool1...") # Amount ``` Quirk: matching the daemon route, the `account` argument is accepted for API @@ -77,11 +79,13 @@ consistency but **not sent on the wire** — the route only uses `pool_id`. ```python from mintlayer.wallet import DecommissionParams -result = wc.decommission_stake_pool(DecommissionParams( - account=0, - pool_id="mpool1...", - output_address=return_addr, -)) +result = wc.decommission_stake_pool( + DecommissionParams( + account=0, + pool_id="mpool1...", + output_address=return_addr, + ) +) ``` After decommissioning, the pledge is returned to `output_address` after the @@ -128,19 +132,23 @@ delegation record first, then fund it separately. from mintlayer.wallet import Amount, CreateDelegationParams, DelegateParams # Step 1: create the delegation -create_result = wc.create_delegation(CreateDelegationParams( - account=0, - address=owner_addr, # address that can withdraw funds - pool_id="mpool1...", -)) +create_result = wc.create_delegation( + CreateDelegationParams( + account=0, + address=owner_addr, # address that can withdraw funds + pool_id="mpool1...", + ) +) print(f"delegation id: {create_result.delegation_id}") # Step 2: fund the delegation (wait for the creation tx to confirm first) -delegate_result = wc.delegate_staking(DelegateParams( - account=0, - amount=Amount(atoms="10000000000000"), # 100 ML - delegation_id=create_result.delegation_id, -)) +delegate_result = wc.delegate_staking( + DelegateParams( + account=0, + amount=Amount(atoms="10000000000000"), # 100 ML + delegation_id=create_result.delegation_id, + ) +) ``` You can send multiple `delegate_staking` transactions to the same delegation to @@ -151,12 +159,14 @@ increase your stake. ```python from mintlayer.wallet import WithdrawParams -result = wc.withdraw_from_delegation(WithdrawParams( - account=0, - address=recipient_addr, - amount=Amount(atoms="5000000000000"), # 50 ML - delegation_id="mdelg1...", -)) +result = wc.withdraw_from_delegation( + WithdrawParams( + account=0, + address=recipient_addr, + amount=Amount(atoms="5000000000000"), # 50 ML + delegation_id="mdelg1...", + ) +) ``` Withdrawn funds arrive at `address` after the lock period (determined by @@ -237,7 +247,7 @@ withdraw_input = c.encode_input_for_withdraw_from_delegation( withdraw_output = c.encode_output_lock_then_transfer( Amount.from_atoms("5000000000000"), recipient_address, - lock, # from encode_lock_for_block_count or similar + lock, # from encode_lock_for_block_count or similar Network.MAINNET, ) ``` @@ -264,7 +274,7 @@ pool_data = c.encode_stake_pool_data( staker=staker_addr, vrf_public_key=vrf_key, decommission_key=decommission_addr, - margin_ratio_per_thousand=100, # int here (wallet daemon takes a string) + margin_ratio_per_thousand=100, # int here (wallet daemon takes a string) cost_per_block=Amount.from_atoms("100000000"), network=Network.MAINNET, ) diff --git a/docs/tokens.md b/docs/tokens.md index af8048b..919e4ea 100644 --- a/docs/tokens.md +++ b/docs/tokens.md @@ -22,7 +22,7 @@ When issuing a token you choose one of three supply policies For a `Fixed` cap, set the `content` field to an `Amount`: ```python -TokenSupply(type="Fixed", content=Amount(atoms="1000000")) # hard cap +TokenSupply(type="Fixed", content=Amount(atoms="1000000")) # hard cap ``` `content` is omitted from the wire for the other two policies. @@ -42,17 +42,19 @@ wc = Client("http://127.0.0.1:3034") authority_addr = wc.new_address(0) -result = wc.issue_token(IssueTokenParams( - account=0, - destination_address=authority_addr, - metadata=TokenMetadata( - token_ticker="MYTOKEN", - number_of_decimals=2, - metadata_uri="https://example.com/token-metadata.json", - token_supply=TokenSupply(type="Lockable"), - is_freezable=True, - ), -)) +result = wc.issue_token( + IssueTokenParams( + account=0, + destination_address=authority_addr, + metadata=TokenMetadata( + token_ticker="MYTOKEN", + number_of_decimals=2, + metadata_uri="https://example.com/token-metadata.json", + token_supply=TokenSupply(type="Lockable"), + is_freezable=True, + ), + ) +) print(f"token id: {result.token_id}\ntx id: {result.tx_id}") ``` @@ -67,12 +69,14 @@ Wait for the issuance transaction to confirm before minting. ```python from mintlayer.wallet import MintParams -mint_result = wc.mint_tokens(MintParams( - account=0, - token_id=result.token_id, - address=recipient_addr, - amount=Amount(atoms="100000"), # in smallest token units -)) +mint_result = wc.mint_tokens( + MintParams( + account=0, + token_id=result.token_id, + address=recipient_addr, + amount=Amount(atoms="100000"), # in smallest token units + ) +) print(f"minted tx id: {mint_result.tx_id}") ``` @@ -84,11 +88,13 @@ burning). ```python from mintlayer.wallet import UnmintParams -unmint_result = wc.unmint_tokens(UnmintParams( - account=0, - token_id="ttml1...", - amount=Amount(atoms="50000"), -)) +unmint_result = wc.unmint_tokens( + UnmintParams( + account=0, + token_id="ttml1...", + amount=Amount(atoms="50000"), + ) +) ``` ### Locking supply @@ -99,10 +105,12 @@ supply. This operation is irreversible. ```python from mintlayer.wallet import LockSupplyParams -lock_result = wc.lock_token_supply(LockSupplyParams( - account_index=0, - token_id="ttml1...", -)) +lock_result = wc.lock_token_supply( + LockSupplyParams( + account_index=0, + token_id="ttml1...", + ) +) ``` Quirk: the field is `account_index`, not `account` — the daemon route expects @@ -116,16 +124,20 @@ can unfreeze later. ```python from mintlayer.wallet import FreezeParams, UnfreezeParams -freeze_result = wc.freeze_token(FreezeParams( - account=0, - token_id="ttml1...", - is_unfreezable=True, -)) +freeze_result = wc.freeze_token( + FreezeParams( + account=0, + token_id="ttml1...", + is_unfreezable=True, + ) +) -unfreeze_result = wc.unfreeze_token(UnfreezeParams( - account=0, - token_id="ttml1...", -)) +unfreeze_result = wc.unfreeze_token( + UnfreezeParams( + account=0, + token_id="ttml1...", + ) +) ``` ### Transferring authority @@ -133,11 +145,13 @@ unfreeze_result = wc.unfreeze_token(UnfreezeParams( ```python from mintlayer.wallet import ChangeAuthorityParams -change_result = wc.change_token_authority(ChangeAuthorityParams( - account=0, - token_id="ttml1...", - address=new_authority_addr, -)) +change_result = wc.change_token_authority( + ChangeAuthorityParams( + account=0, + token_id="ttml1...", + address=new_authority_addr, + ) +) ``` ### Sending tokens @@ -145,12 +159,14 @@ change_result = wc.change_token_authority(ChangeAuthorityParams( ```python from mintlayer.wallet import TokenSendParams -send_result = wc.send_token(TokenSendParams( - account=0, - token_id="ttml1...", - address=recipient_addr, - amount=Amount(atoms="10000"), -)) +send_result = wc.send_token( + TokenSendParams( + account=0, + token_id="ttml1...", + address=recipient_addr, + amount=Amount(atoms="10000"), + ) +) ``` `send_token` is an alias of `token_send` on the transactions mixin — both call @@ -169,19 +185,21 @@ from mintlayer.wallet import IssueNFTParams, NFTMetadata owner_addr = wc.new_address(0) -result = wc.issue_nft(IssueNFTParams( - account=0, - destination_address=owner_addr, - metadata=NFTMetadata( - name="My NFT", - description="A unique digital collectible", - ticker="MYNFT", - media_hash="sha256hexhash...", - media_uri="https://example.com/media.png", - icon_uri="https://example.com/icon.png", - # creator and additional_metadata_uri default to None - ), -)) +result = wc.issue_nft( + IssueNFTParams( + account=0, + destination_address=owner_addr, + metadata=NFTMetadata( + name="My NFT", + description="A unique digital collectible", + ticker="MYNFT", + media_hash="sha256hexhash...", + media_uri="https://example.com/media.png", + icon_uri="https://example.com/icon.png", + # creator and additional_metadata_uri default to None + ), + ) +) print(f"nft id: {result.token_id}") ``` @@ -243,9 +261,9 @@ try: authority_addr, "MYTOKEN", "https://example.com/metadata.json", - 2, # decimals + 2, # decimals TotalSupply.LOCKABLE, - None, # supply_amount: only required for TotalSupply.FIXED + None, # supply_amount: only required for TotalSupply.FIXED FreezableToken.YES, tip.block_height, Network.MAINNET, @@ -263,7 +281,7 @@ issue_output = c.encode_output_issue_fungible_token( "https://example.com/metadata.json", 2, TotalSupply.FIXED, - Amount.from_atoms("1000000"), # required exactly for TotalSupply.FIXED + Amount.from_atoms("1000000"), # required exactly for TotalSupply.FIXED FreezableToken.NO, tip.block_height, Network.MAINNET, @@ -277,13 +295,13 @@ UTXO. ```python issue_nft_output = c.encode_output_issue_nft( - token_id=token_id_str, # derived with get_token_id (same scheme as FTs) + token_id=token_id_str, # derived with get_token_id (same scheme as FTs) authority=owner_addr, name="My NFT", ticker="MYNFT", description="A unique digital collectible", - media_hash=bytes.fromhex("..."), # 32-byte sha256 of the media - creator=bytes.fromhex("..."), # or None + media_hash=bytes.fromhex("..."), # 32-byte sha256 of the media + creator=bytes.fromhex("..."), # or None media_uri="https://example.com/media.png", icon_uri=None, additional_metadata_uri=None, @@ -320,7 +338,7 @@ from mintlayer.wasm import TokenUnfreezable freeze_input = c.encode_input_for_freeze_token( token_id_str, - TokenUnfreezable.YES, # can be unfrozen later + TokenUnfreezable.YES, # can be unfrozen later token_info.next_nonce, Network.MAINNET, ) @@ -340,9 +358,9 @@ before building transactions: tip = idx.get_tip() issuance_fee = c.fungible_token_issuance_fee(tip.block_height, Network.MAINNET) -nft_fee = c.nft_issuance_fee(tip.block_height, Network.MAINNET) -mint_fee = c.token_supply_change_fee(tip.block_height, Network.MAINNET) -freeze_fee = c.token_freeze_fee(tip.block_height, Network.MAINNET) +nft_fee = c.nft_issuance_fee(tip.block_height, Network.MAINNET) +mint_fee = c.token_supply_change_fee(tip.block_height, Network.MAINNET) +freeze_fee = c.token_freeze_fee(tip.block_height, Network.MAINNET) authority_fee = c.token_change_authority_fee(tip.block_height, Network.MAINNET) ``` diff --git a/docs/transactions.md b/docs/transactions.md index 147102a..7fe23b2 100644 --- a/docs/transactions.md +++ b/docs/transactions.md @@ -98,7 +98,7 @@ for u in utxos: from mintlayer.wasm import Amount output = c.encode_output_transfer( - Amount(atoms="100000000000"), # 1 ML in atoms + Amount(atoms="100000000000"), # 1 ML in atoms "mtc1qrecipient...", Network.MAINNET, ) @@ -109,7 +109,7 @@ For multiple outputs, concatenate them: ```python change_output = c.encode_output_transfer( Amount(atoms=str(change_atoms)), - from_addr, # send change back to sender + from_addr, # send change back to sender Network.MAINNET, ) @@ -121,7 +121,7 @@ all_outputs = output + change_output ## Step 5: Build the unsigned transaction ```python -tx = c.encode_transaction(encoded_inputs, output, 0) # flags = 0 +tx = c.encode_transaction(encoded_inputs, output, 0) # flags = 0 tx_id = c.get_transaction_id(tx, True) print(f"unsigned tx id: {tx_id}") @@ -180,9 +180,9 @@ for i in range(len(utxos)): from_addr, tx, all_utxo_bytes, - i, # input index - TxAdditionalInfo(), # empty for standard transfers - 0, # block height (0 when no timelock constraint) + i, # input index + TxAdditionalInfo(), # empty for standard transfers + 0, # block height (0 when no timelock constraint) Network.MAINNET, ) witness_bytes += w @@ -256,7 +256,7 @@ Sending fungible tokens uses the same flow, with a different output encoder: ```python token_output = c.encode_output_token_transfer( - Amount(atoms="1000"), # token amount in smallest units + Amount(atoms="1000"), # token amount in smallest units "mtc1qrecipient...", "ttml1tokenid...", Network.MAINNET, diff --git a/docs/wallet.md b/docs/wallet.md index d4f9dbc..6a1fe06 100644 --- a/docs/wallet.md +++ b/docs/wallet.md @@ -9,10 +9,10 @@ from mintlayer.wallet import Client c = Client( "http://127.0.0.1:3034", - username="user", # optional; Basic Auth applied only when set - password="pass", # optional - timeout=30.0, # optional, seconds (default 30.0) - session=None, # optional requests.Session (client owns it otherwise) + username="user", # optional; Basic Auth applied only when set + password="pass", # optional + timeout=30.0, # optional, seconds (default 30.0) + session=None, # optional requests.Session (client owns it otherwise) ) ``` @@ -56,10 +56,12 @@ c = Client("http://127.0.0.1:3034") # 1. Create a wallet file (a fresh 24-word BIP-39 phrase is generated # when params.mnemonic is None). -result = c.create_wallet(CreateWalletParams( - path="/path/to/wallet.dat", - store_seed_phrase=False, # don't persist the phrase to disk -)) +result = c.create_wallet( + CreateWalletParams( + path="/path/to/wallet.dat", + store_seed_phrase=False, # don't persist the phrase to disk + ) +) if result.mnemonic: print(result.mnemonic.content.mnemonic) # store it securely NOW @@ -92,6 +94,7 @@ class CreateWalletParams: passphrase: str | None = None hardware_wallet: str | None = None + @dataclass(frozen=True) class CreateWalletResult: mnemonic: MnemonicResult | None = None @@ -203,7 +206,7 @@ Returns the confirmed coin and token balances for an account (the request pins @dataclass(frozen=True) class Balance: coins: Amount - tokens: dict[str, Amount] # keyed by token ID + tokens: dict[str, Amount] # keyed by token ID ``` ### `new_address` @@ -283,6 +286,7 @@ class SendParams: selected_utxos: list[Outpoint] | None = None options: TxOptions = field(default_factory=TxOptions) + @dataclass(frozen=True) class SendResult: tx_id: str @@ -303,12 +307,14 @@ class SendResult: ```python from mintlayer.wallet import Amount, SendParams, TxOptions -result = c.address_send(SendParams( - account=0, - address="mtc1q...", - amount=Amount(atoms="100000000000"), # 1 ML - options=TxOptions(in_top_x_mb=1), # high fee priority -)) +result = c.address_send( + SendParams( + account=0, + address="mtc1q...", + amount=Amount(atoms="100000000000"), # 1 ML + options=TxOptions(in_top_x_mb=1), # high fee priority + ) +) print(result.tx_id, result.fees.coins.atoms, result.broadcasted) ``` @@ -358,7 +364,7 @@ for advanced flows where you construct outputs manually. @dataclass(frozen=True) class ComposeParams: inputs: list[Outpoint] = field(default_factory=list) - outputs: list[Any] = field(default_factory=list) # raw output objects + outputs: list[Any] = field(default_factory=list) # raw output objects htlc_secrets: Any = None only_transaction: bool = False ``` @@ -538,8 +544,8 @@ from mintlayer.wallet import CreateOrderParams, OutputValue, coin_filter, token_ params = CreateOrderParams( account=0, - ask=OutputValue.coins(atoms="500000000000"), # asking 5 ML - give=OutputValue.tokens("ttml1...", atoms="1000"), # giving 1000 tokens + ask=OutputValue.coins(atoms="500000000000"), # asking 5 ML + give=OutputValue.tokens("ttml1...", atoms="1000"), # giving 1000 tokens conclude_address="mtc1q...", ) created = c.create_order(params) @@ -597,11 +603,13 @@ ask_balance, give_balance, is_own)`). from mintlayer.wallet import ListOrdersParams, coin_filter, token_filter # module-level helpers (same as CurrencyFilter.coin_filter() / .token_filter(id)) -orders = c.list_all_active_orders(ListOrdersParams( - account=0, - ask_currency=coin_filter(), - give_currency=token_filter("ttml1..."), -)) +orders = c.list_all_active_orders( + ListOrdersParams( + account=0, + ask_currency=coin_filter(), + give_currency=token_filter("ttml1..."), + ) +) ``` `CurrencyFilter` (wire: `{"type":"Coin"}` with no content key, or diff --git a/docs/wasm.md b/docs/wasm.md index 846d7d5..238939d 100644 --- a/docs/wasm.md +++ b/docs/wasm.md @@ -7,9 +7,9 @@ wasmtime, sha256-pinned at import). ```python from mintlayer.wasm import Client -c = Client() # instantiation compiles the WASM binary: ~400 ms +c = Client() # instantiation compiles the WASM binary: ~400 ms ... -c.close() # or use `with Client() as c:` +c.close() # or use `with Client() as c:` ``` Call it once per process and reuse it. The `Client` is **safe for concurrent @@ -24,7 +24,7 @@ from mintlayer.wasm import WasmError try: addr = c.pubkey_to_pubkeyhash_address(pubkey, Network.MAINNET) except WasmError as e: - print(e) # e.g. "mintlayer: invalid public key" + print(e) # e.g. "mintlayer: invalid public key" ``` > **Key material in memory:** result buffers carrying private keys, derived @@ -41,10 +41,10 @@ except WasmError as e: ```python from mintlayer.wasm import Amount -one = Amount.from_atoms("100000000000") # 1 ML +one = Amount.from_atoms("100000000000") # 1 ML zero = Amount.zero() -print(one.atoms) # "100000000000" -print(str(one)) # "100000000000" +print(one.atoms) # "100000000000" +print(str(one)) # "100000000000" ``` All amounts are decimal strings of atoms. **1 ML = 100,000,000,000 atoms** @@ -59,12 +59,12 @@ discriminant: ```python from mintlayer.wasm import ( - Network, # MAINNET=0, TESTNET=1, REGTEST=2, SIGNET=3 + Network, # MAINNET=0, TESTNET=1, REGTEST=2, SIGNET=3 SignatureHashType, # SIGHASH_ALL=0, SIGHASH_NONE=1, SIGHASH_SINGLE=2, SIGHASH_ANYONECANPAY=3 - SourceId, # SOURCE_TRANSACTION=0, SOURCE_BLOCK_REWARD=1 - TotalSupply, # LOCKABLE=0, UNLIMITED=1, FIXED=2 - FreezableToken, # NO=0, YES=1 - TokenUnfreezable, # NO=0, YES=1 + SourceId, # SOURCE_TRANSACTION=0, SOURCE_BLOCK_REWARD=1 + TotalSupply, # LOCKABLE=0, UNLIMITED=1, FIXED=2 + FreezableToken, # NO=0, YES=1 + TokenUnfreezable, # NO=0, YES=1 ) ``` @@ -286,7 +286,9 @@ def encode_input_for_unmint_tokens(self, token_id: str, nonce: int, network: Net ### `encode_input_for_lock_token_supply` ```python -def encode_input_for_lock_token_supply(self, token_id: str, nonce: int, network: Network) -> bytes: ... +def encode_input_for_lock_token_supply( + self, token_id: str, nonce: int, network: Network +) -> bytes: ... ``` ### `encode_input_for_freeze_token` @@ -835,7 +837,14 @@ Some transaction types (pool operations, orders) require extra data not present in the UTXO itself: ```python -from mintlayer.wasm import Amount, OrderBalance, OrderInfo, PoolInfo, SimpleCurrencyAmount, TxAdditionalInfo +from mintlayer.wasm import ( + Amount, + OrderBalance, + OrderInfo, + PoolInfo, + SimpleCurrencyAmount, + TxAdditionalInfo, +) info = TxAdditionalInfo( pool_info={"mpool1...": PoolInfo(staker_balance=Amount.from_atoms("40000000000000"))}, diff --git a/examples/issue_token.py b/examples/issue_token.py index 1f3342b..2118e94 100644 --- a/examples/issue_token.py +++ b/examples/issue_token.py @@ -34,7 +34,9 @@ from __future__ import annotations import argparse +import getpass import logging +import os import sys import time @@ -55,7 +57,11 @@ def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--wallet", default="", help="path to wallet file (skip if already open)") - parser.add_argument("--password", default="", help="wallet password (empty for unencrypted)") + parser.add_argument( + "--password", + default="", + help="wallet password; omit to use $WALLET_PASSWORD or a hidden prompt", + ) parser.add_argument("--ticker", required=True, help="token ticker symbol, e.g. MYTOKEN") parser.add_argument("--decimals", type=int, default=2, help="number of decimal places (0-18)") parser.add_argument("--supply", default="1000000", help="initial mint supply in smallest unit") @@ -72,6 +78,10 @@ def main() -> None: args = parser.parse_args() logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s") + if not args.password: + args.password = os.environ.get("WALLET_PASSWORD", "") + if not args.password and sys.stdin.isatty(): + args.password = getpass.getpass("wallet password (input hidden, empty if none): ") # ── 1. Connect to the wallet daemon ────────────────────────────────────── wallet = WalletClient(args.wallet_rpc) diff --git a/examples/send_coins.py b/examples/send_coins.py index 9971a76..f9a325a 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -101,7 +101,9 @@ def resolve_mnemonic(cli_value: str) -> str: def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( - "--mnemonic", default="", help="BIP-39 mnemonic; omit to use $MNEMONIC or a hidden prompt" + "--mnemonic", + default="", + help="BIP-39 mnemonic (insecure: visible in ps/shell history); prefer $MNEMONIC or prompt", ) parser.add_argument("--to", required=True, help="recipient bech32m address") parser.add_argument("--amount", required=True, help="amount to send in atoms (1 ML = 1e11)") diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index f8c18d2..78e2360 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -101,6 +101,8 @@ def call(self, method: str, params: Any) -> Any: raise JSONRPCError("decode response: unexpected JSON-RPC response shape") error = body.get("error") if error is not None: + if not isinstance(error, dict): + raise JSONRPCError("decode response: JSON-RPC error object has unexpected shape") raise RPCError(error.get("code", 0), error.get("message", "")) return body.get("result") diff --git a/mintlayer/node/_core.py b/mintlayer/node/_core.py index 73fa8d3..ee68f77 100644 --- a/mintlayer/node/_core.py +++ b/mintlayer/node/_core.py @@ -30,7 +30,11 @@ def _call_int(self, method: str, params: Any) -> int: def _call_opt_int(self, method: str, params: Any) -> int | None: result = self._rpc.call(method, params) - return None if result is None else int(result) + if result is None: + return None + if isinstance(result, bool) or not isinstance(result, int): + raise JSONRPCError(f"{method}: expected integer result, got {result!r}") + return result def _call_bool(self, method: str, params: Any) -> bool: result = self._rpc.call(method, params) @@ -40,7 +44,11 @@ def _call_bool(self, method: str, params: Any) -> bool: def _call_str_list(self, method: str, params: Any) -> list[str]: result = self._rpc.call(method, params) - return [str(item) for item in result or []] + if result is None: + return [] + if not isinstance(result, list) or not all(isinstance(item, str) for item in result): + raise JSONRPCError(f"{method}: expected list of strings, got {result!r}") + return result def _call_opt_amount(self, method: str, params: Any) -> Amount | None: result = self._rpc.call(method, params) diff --git a/mintlayer/node/p2p.py b/mintlayer/node/p2p.py index 2906c17..cc3d5ba 100644 --- a/mintlayer/node/p2p.py +++ b/mintlayer/node/p2p.py @@ -11,9 +11,8 @@ def _duration_to_wire(duration: timedelta) -> list[int]: """Split a duration into the daemon's [seconds, nanoseconds] wire form.""" - total_seconds = duration.total_seconds() - secs = int(total_seconds) - nanos = int(round((total_seconds - secs) * 1_000_000_000)) + secs = duration.days * 86_400 + duration.seconds + nanos = duration.microseconds * 1_000 return [secs, nanos] diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 9b9b141..b6230d1 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -202,6 +202,8 @@ def _call_return_bool(self, name: str, *params: Any) -> bool: ret = self._call(name, *params) if len(ret) >= 3 and ret[2] != 0: raise self._extract_error(ret[1]) + if len(ret) < 1: + raise WasmError(f"mintlayer: unexpected return count from {name}") return ret[0] != 0 def _call_return_u32(self, name: str, *params: Any) -> int: @@ -209,6 +211,8 @@ def _call_return_u32(self, name: str, *params: Any) -> int: ret = self._call(name, *params) if len(ret) >= 3 and ret[2] != 0: raise self._extract_error(ret[1]) + if len(ret) < 1: + raise WasmError(f"mintlayer: unexpected return count from {name}") return ret[0] & 0xFFFFFFFF def _call_return_u64(self, name: str, *params: Any) -> int: @@ -216,6 +220,8 @@ def _call_return_u64(self, name: str, *params: Any) -> int: ret = self._call(name, *params) if len(ret) >= 3 and ret[2] != 0: raise self._extract_error(ret[1]) + if len(ret) < 1: + raise WasmError(f"mintlayer: unexpected return count from {name}") return ret[0] & 0xFFFFFFFFFFFFFFFF def _call_return_amount(self, name: str, *params: Any) -> Amount: diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..f86bb11 --- /dev/null +++ b/uv.lock @@ -0,0 +1,851 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] + +[[package]] +name = "ast-serialize" +version = "0.11.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/1e/4f6082cdd6e5a29093513e9a3eabc5ed1c5331a9a84386b2fece80a00a48/ast_serialize-0.11.2.tar.gz", hash = "sha256:976a5bd75845d22f4b52905ddf53ab669ef1b14dba7735f5512841a2ef2b5450", size = 954387, upload-time = "2026-09-13T18:48:55.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/2e/beec3364eef4b01793a676d8cd16e9014c42044a5505000ceae3955e33fa/ast_serialize-0.11.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f6a8dfc5ab204a706f6e5d39c6f77c18c27ef084fa2081803a64a9160ce89277", size = 897089, upload-time = "2026-09-13T18:47:22.69Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d7/ef56443df2891c6ba2c4019c2cb3dcaf97c9948da6d963068e04e8dac6ea/ast_serialize-0.11.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:cb073bfa15742699d408ac50f60878383b5665ae1791d1b6799ea6f08633cd77", size = 1235218, upload-time = "2026-09-13T18:47:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/42/8d/cff58d17ba1d0272ff0b7ab5d3bdfcf8f47317eb0f47c001d394bffebf95/ast_serialize-0.11.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1d6ad94edbe93bf1dabc06c9f37d55b898fdabc456aa6d7ced5e23c14f795f32", size = 1216399, upload-time = "2026-09-13T18:47:26.202Z" }, + { url = "https://files.pythonhosted.org/packages/de/d2/a1da7675af5f42335c36e4da6d86ef4fd7168cead18de81df0a2d6faeb1a/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40b2801cf2221bd922d9f69d2f0ebc373c3db47207315d525b2d87fa161a2af4", size = 1282064, upload-time = "2026-09-13T18:47:27.787Z" }, + { url = "https://files.pythonhosted.org/packages/97/89/5a400a13b2c9c0152ebb5ad45408a3fe5e4e60e325d3ac4e5cf6e915a0cc/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd666cebd6ab3b3c0fd348a6202c26e18a401ee34293c3804d3472266bc146f6", size = 1285864, upload-time = "2026-09-13T18:47:29.667Z" }, + { url = "https://files.pythonhosted.org/packages/02/b8/80a381c70fd49f0316fb0383c4f9e4c13e81b010b64889bd45898ce8f5f4/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0d01f61352c96370febf6c0dbd488dee9183a731fb2702170da9163ae317cded", size = 1554755, upload-time = "2026-09-13T18:47:31.257Z" }, + { url = "https://files.pythonhosted.org/packages/90/97/dcaa34a32d2db789221c125b3eb10feb5089715fe53d9874d627afc26231/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a0fd40c668b0fa19b8fdb61d9e63d547e2e19cfbfe053a51ef0b6c37070298a8", size = 1301807, upload-time = "2026-09-13T18:47:32.714Z" }, + { url = "https://files.pythonhosted.org/packages/5c/9a/84a22420cb312642d7d31547c644d09a3d101418c6d6b9ef2ec30735cf11/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efa819d7c14c8e4153dcd84671826331538be7cbe460383fc6386f5eea5bd234", size = 1301941, upload-time = "2026-09-13T18:47:34.418Z" }, + { url = "https://files.pythonhosted.org/packages/20/8a/aa5f3dcf1aed9678c25982f40d366004e3c0cac47bc0c240f6b837dcbb1f/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:a9ffa8a197a721f07a352d0be6185f5b3e6f9aaebfdb66169ed652108531ae3b", size = 1307910, upload-time = "2026-09-13T18:47:36.253Z" }, + { url = "https://files.pythonhosted.org/packages/78/79/91a5102797fe3dc992171382d8579bcb33cbd1424b864ad3117ac43fb3fe/ast_serialize-0.11.2-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:00119a8fb8c1dc0f1fab023f4d8071fa49e3b0208ee54d589fd463c16ab0124e", size = 1356258, upload-time = "2026-09-13T18:47:37.984Z" }, + { url = "https://files.pythonhosted.org/packages/51/52/54eeef9918e187ced417c4363eecea66975314cd5b9c91759eef7f7b714b/ast_serialize-0.11.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0de02520c11391a026e62987a9aa2c3c2ff01545155059ddf0c4bdf2c5ecbe9f", size = 1459057, upload-time = "2026-09-13T18:47:39.891Z" }, + { url = "https://files.pythonhosted.org/packages/e4/cb/fd84b52b15d42f2423319cffd1fb7f1e9df5d5198e69ab0b449c450254cf/ast_serialize-0.11.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b4e4558956b6a0fb35e18fba58f7d1810b1f2c0e6b52352572cd5dfb6b4ef33a", size = 1562447, upload-time = "2026-09-13T18:47:41.727Z" }, + { url = "https://files.pythonhosted.org/packages/be/92/9fb34f2e64b84a63cca92fb86bd0847b995a63b67477f44c20502fb60352/ast_serialize-0.11.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:6061a54f39e82a9f2cbcb9c268fc441890e4818a6636473caa4f4063254e0750", size = 1556423, upload-time = "2026-09-13T18:47:43.357Z" }, + { url = "https://files.pythonhosted.org/packages/75/0f/c43c44449e7ebc4e83ebd48750088fb06234622faa2d62d2a6dc8970d2a3/ast_serialize-0.11.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:85fbb01e83967a126d71f679f2b9528ef0912cb0854aa1a4657314c34e255b57", size = 1687156, upload-time = "2026-09-13T18:47:44.995Z" }, + { url = "https://files.pythonhosted.org/packages/2b/a7/9e520f4a79b639da9ee20c1e747c3d739329e902fc55ac38065f25419f56/ast_serialize-0.11.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:7aaaffc32905159774a107d3cf33dad59bd41b7a0d1bc9885532186753ee7439", size = 1481008, upload-time = "2026-09-13T18:47:46.602Z" }, + { url = "https://files.pythonhosted.org/packages/48/a8/bdd3989f19de09cffcd8179c131f6741a5a8619705fc75b09541ff61530b/ast_serialize-0.11.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:08eda88a0f290a36c38cab33df8bf7e35eb95bc802ca5beb2c8fcda471a7d10c", size = 1501597, upload-time = "2026-09-13T18:47:48.265Z" }, + { url = "https://files.pythonhosted.org/packages/a5/8a/ca2dce2950875a4ef1d7c298196f803b0adcdb7c15ed0cecc71d84bccd70/ast_serialize-0.11.2-cp314-cp314t-win32.whl", hash = "sha256:76cc294246e60a914326b4ca88c6a5ea89c064906614aaf1537ce82f09e9449f", size = 1119503, upload-time = "2026-09-13T18:47:49.896Z" }, + { url = "https://files.pythonhosted.org/packages/5a/12/3f38e3613d07c46f9f81c5b1352748c6552397cc52825502e2c6ae44c6ea/ast_serialize-0.11.2-cp314-cp314t-win_amd64.whl", hash = "sha256:43b51e6ebe6549bf21416c3c78ee886147b80875a87cc6f69e303dde0d75be0b", size = 1156828, upload-time = "2026-09-13T18:47:51.454Z" }, + { url = "https://files.pythonhosted.org/packages/22/90/f89a4f67428a261daafdb69a0d0132c27933268702d1ba47e0b61c51aff1/ast_serialize-0.11.2-cp314-cp314t-win_arm64.whl", hash = "sha256:8df32ad4ff7843734a6c2f067ee974f6d3109ee5a2c3e1a9d2f79347bd282a9a", size = 1128298, upload-time = "2026-09-13T18:47:53.008Z" }, + { url = "https://files.pythonhosted.org/packages/0b/55/a1962188abf0e62d84d55892bb044347e434711763b9a1d4ad867a70c1be/ast_serialize-0.11.2-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:ab924ba260efd7509492f272d4e236d24564033f20c005d7c63a107c6a76fc85", size = 1235457, upload-time = "2026-09-13T18:47:54.554Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ad/439c2959150718446af76fbe2f4000f35eba9869ef8564f3d9a3d0b1c370/ast_serialize-0.11.2-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:a586be418eb70a9f1396cea29ddac8f4b9bf277fb73ea2340db31e218bc00f32", size = 1215705, upload-time = "2026-09-13T18:47:56.178Z" }, + { url = "https://files.pythonhosted.org/packages/6d/d8/2c6542fc3e7c56a0a25d8d12d034d5a2d2e1900e292567b1c1dca8e83124/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8532f20916fa3189d4d785ef2a62d93c4d651ec9c5bffda66d2fc36898351f34", size = 1282530, upload-time = "2026-09-13T18:47:57.619Z" }, + { url = "https://files.pythonhosted.org/packages/fa/ad/6f6755cd0842db46c3b10b1e4735f14aad78d71dea4753eb46933101711b/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ee732ae167e686d1d3c00f98d7d82b23138304694f0441b14d7ddf9c0f8a921c", size = 1287792, upload-time = "2026-09-13T18:47:59.227Z" }, + { url = "https://files.pythonhosted.org/packages/03/40/5da672f5dd23fb7dc0c884c97711e56a3540f2fe3c4355a81f8beb385911/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:75a1c7f46b9c19fc0ae01ca6fd076301628faa2ed7a8edbd55c6353c483946a3", size = 1557971, upload-time = "2026-09-13T18:48:00.96Z" }, + { url = "https://files.pythonhosted.org/packages/df/c7/2bb25684f697801eb72866fdb94ed5edbff3867ce878b0e542a4a5b9dab9/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2fdf31a0bb85ea2575cc91669f005e6647d2efed491231c4dc1497bc9a5b3aa6", size = 1303230, upload-time = "2026-09-13T18:48:02.337Z" }, + { url = "https://files.pythonhosted.org/packages/d8/85/754681846f26e0ff1da729b1ffe3171e93c22f0aa6ec3cea5b14e3703846/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b78e6fdef3b06c86ed263e1962fee5a7b9d2d158e738b212d13b2c605ee12f5", size = 1302271, upload-time = "2026-09-13T18:48:03.915Z" }, + { url = "https://files.pythonhosted.org/packages/fb/dc/f5521d8cb44b69095c3982ae3658a12c403e0efa19e51aeb9c8a79dff60c/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:8d62a47714c8bc432b9fabcc29989c815c5da17327d35151f2fd0d85c2a7a5ff", size = 1309529, upload-time = "2026-09-13T18:48:05.562Z" }, + { url = "https://files.pythonhosted.org/packages/73/0d/649182c7fd7c4f782279bed514de2dd67e48a5afecb605a098d64fdc01fd/ast_serialize-0.11.2-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8a5ffa70e76191dcf240d3c43e20c93b3bfd26f54d89148c762d57837f5bcd2c", size = 1356869, upload-time = "2026-09-13T18:48:07.534Z" }, + { url = "https://files.pythonhosted.org/packages/bf/cc/aff4d84c16afa742d13a75384127c7d24594dc8c304f0558a15924fd51af/ast_serialize-0.11.2-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:bfbe47a3a7c368f28836e78b2440a3643ac0ec4c67d9fe53588e1448f0a3d35d", size = 1460006, upload-time = "2026-09-13T18:48:09.162Z" }, + { url = "https://files.pythonhosted.org/packages/94/a7/891cbec2e5e0d7159196159d3ff0646622f3120ff4576c839ac2dd56c719/ast_serialize-0.11.2-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:7f1823275b246f9c7d373be6879e4eec09686948895d4ad083f4b27fd7e4da70", size = 1562935, upload-time = "2026-09-13T18:48:10.978Z" }, + { url = "https://files.pythonhosted.org/packages/45/c4/2c8c4498340ea9aff87a9fd408309aa25d56dd51d7bbddfdb46a3c31424a/ast_serialize-0.11.2-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:57c0f5cb0021a5beb1e5e4d6e840ae2f23a28909703ef4d256a144cc1ad3d437", size = 1557109, upload-time = "2026-09-13T18:48:12.616Z" }, + { url = "https://files.pythonhosted.org/packages/0d/8b/c5d4e5226fa18885fe17f949aee3ab1aeb8389c384d946ec1b7c9489cc94/ast_serialize-0.11.2-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:cd320a5c4f1f2742af97eea22954f776379175c5ef2504801e9a155f2ff9a4d7", size = 1691603, upload-time = "2026-09-13T18:48:14.293Z" }, + { url = "https://files.pythonhosted.org/packages/73/d6/1d2ca472586f9e3416a289a22f36eeb6dd6f47d77b1a4aba358405babbc7/ast_serialize-0.11.2-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:13b13afe32e845c86a573497729e1b7ddeb26c572c78bf50ece51da23b8fad5e", size = 1483053, upload-time = "2026-09-13T18:48:15.789Z" }, + { url = "https://files.pythonhosted.org/packages/0e/16/d3703a7c1e3c76b144ac9349a54d3926d0749918a8dc13a66cede208b8ec/ast_serialize-0.11.2-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:9d80a81ec84660422579bdb8e789f656a794b48c7a1ae1261f6bd8bc1897d17d", size = 1502499, upload-time = "2026-09-13T18:48:17.405Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e4/d974e55c2e247ef26ed1df01c74940583db9a5b3a8bcaad5732c6e2047fb/ast_serialize-0.11.2-cp315-abi3.abi3t-win32.whl", hash = "sha256:af8c003ce721b0099dd55cef4ba733500fc3054ea0cc8565d8957aaf7cccdeb4", size = 1119739, upload-time = "2026-09-13T18:48:19.005Z" }, + { url = "https://files.pythonhosted.org/packages/0d/00/d229443488e095054d5e0c0cc20689a2633b899d735849ff1b2c8e4f0cbf/ast_serialize-0.11.2-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:554d117cb916d8032d85007c654d179efbbfd446174c048062778136a922944f", size = 1158602, upload-time = "2026-09-13T18:48:20.524Z" }, + { url = "https://files.pythonhosted.org/packages/11/75/389fc1a6cfa0c4b2ce522f47d8401329d8bb11732e516d46465960fef1d9/ast_serialize-0.11.2-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:d60515335750d431e462af6e722bb55720a5e7827192777bddfd9c4376065a4d", size = 1128842, upload-time = "2026-09-13T18:48:22.052Z" }, + { url = "https://files.pythonhosted.org/packages/45/7d/c4f36898f19c728d091cdfdf960c9488e8d82bbe2e49ba13c05f43907a5d/ast_serialize-0.11.2-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:89499a439955931281986e97ca4dd3c064bf0d2e0027c0017344eb86667733a1", size = 897204, upload-time = "2026-09-13T18:48:23.695Z" }, + { url = "https://files.pythonhosted.org/packages/b1/54/f67120006fc73a55b6d057d4662d061fbb4eceafce3047c76ca8b382eb11/ast_serialize-0.11.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:daadf1c3e0224621607ffe16f1379e4bd372271ed2e1db8a67878f0bab3ef7e4", size = 1240734, upload-time = "2026-09-13T18:48:25.287Z" }, + { url = "https://files.pythonhosted.org/packages/9a/7e/8f2ab68bddbe58a66fbbaad87beeae3e7d7edddb17263d1fc423936cf34d/ast_serialize-0.11.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1844ed9a487fb3de7325c52ddb33f2918b66b65cd54d3f8d83d23785ffe99fa4", size = 1228053, upload-time = "2026-09-13T18:48:26.788Z" }, + { url = "https://files.pythonhosted.org/packages/d2/1b/8a69ab68f4c1603819f0481d756abdd8caf27cec7f1d77caa71007ebe997/ast_serialize-0.11.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b17869f4ba261a5fa468a753328a548f4dbaf74b4eadae9e28aff66df7f1425b", size = 1292542, upload-time = "2026-09-13T18:48:28.295Z" }, + { url = "https://files.pythonhosted.org/packages/d1/ce/872f2e00f0467c289e483f0a34543463347243a2d0632748d89fcee5e0dc/ast_serialize-0.11.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:feb16d9c2a720e0120c58dd5d6e7b3c7c86b43249b60a3bc212bcb8fa031e2dd", size = 1294791, upload-time = "2026-09-13T18:48:29.969Z" }, + { url = "https://files.pythonhosted.org/packages/3a/82/36277c12af861c64b375c316135d8feffe3f400568463a8d2b2de4c2c4fb/ast_serialize-0.11.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f3109fe4805384effc8d0f8e41fbf875aa8f389af91b4348c1cfb60ea6e4cb82", size = 1567583, upload-time = "2026-09-13T18:48:31.85Z" }, + { url = "https://files.pythonhosted.org/packages/b0/d7/ec643df91cea8bcbcb4e8011d6a8b08e5119b84f9554879f3e3c786d29d1/ast_serialize-0.11.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:abdb3e49ba053c3486ac1263bee9f16cc9a4a8abd9f8c90bfc21e3669f3ad9d1", size = 1312878, upload-time = "2026-09-13T18:48:33.495Z" }, + { url = "https://files.pythonhosted.org/packages/04/6f/4c992cd7841ba589fefb14ddc9aff2f6db7f2a615d4074f9ad04115b5ce0/ast_serialize-0.11.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7004ba572f09be34342ccb98dcd4bad5707d3d81adc8cb4c3f685d2a2c51bbc", size = 1312642, upload-time = "2026-09-13T18:48:35.294Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e3/22aaa209c231a83cfea004fd67dee7a7a54da3f169c6c460b14b96887385/ast_serialize-0.11.2-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:59c25f47524efa052971b860e128b1add0c94ede7dd16b2962952c85c3582365", size = 1319776, upload-time = "2026-09-13T18:48:36.866Z" }, + { url = "https://files.pythonhosted.org/packages/c1/f7/d4685fb54d10108ce44d3bc893ef670854d61645d47ed96d73524db90c23/ast_serialize-0.11.2-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f3a367e0e05ed2d1b747ceb07aa728a8c204cc008b589127e9bd4f40053d7575", size = 1365324, upload-time = "2026-09-13T18:48:38.412Z" }, + { url = "https://files.pythonhosted.org/packages/42/3a/250643ffad02bda520c50a9a5f02a5d43259a06f34ce393c91761d134d7e/ast_serialize-0.11.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:00bbf1f6669f813b48925b759f7ae4591067d456d443924055cab386e7e0a719", size = 1467653, upload-time = "2026-09-13T18:48:40.348Z" }, + { url = "https://files.pythonhosted.org/packages/c7/da/af66a646b9b7f8fdec95ce83fc7b1fe538b06864bc79bd554ac4fae2e6ea/ast_serialize-0.11.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:ec1c20f89c3e0d83576e3c06f79375ce936266591fe0d5fd969914af3185cbaa", size = 1571914, upload-time = "2026-09-13T18:48:41.968Z" }, + { url = "https://files.pythonhosted.org/packages/34/82/77a9714564b9e8800087a8afec41527c65c39e49282baae2ac847b9c1c6a/ast_serialize-0.11.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:c58bb119b73657fdc5569692f316e1e25ca114bd62f7782eb527c6be438ba3a9", size = 1569862, upload-time = "2026-09-13T18:48:43.701Z" }, + { url = "https://files.pythonhosted.org/packages/65/06/fa77b52f46b9bd6dcd8ff2b880e3781f8c1a316bb1342bc3de92907c6f96/ast_serialize-0.11.2-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:f739e0b601be7300c5697a2573d9200bd1db74b34ab111ef9537b9d5dcd7f106", size = 1699020, upload-time = "2026-09-13T18:48:45.261Z" }, + { url = "https://files.pythonhosted.org/packages/e1/09/239c83153c7e0798e5867d6909cb06f53dccfef02f6999c8e2e21ecb98c3/ast_serialize-0.11.2-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:cae5addfbb54cc1d47fe947ef9138e9d83849ed1cbc72b819cf36d96a2315b07", size = 1492869, upload-time = "2026-09-13T18:48:46.922Z" }, + { url = "https://files.pythonhosted.org/packages/2f/eb/6108fb9a43fc7ab5529856e38e33c6e3e064fbfe375fdcbb208c7cd5438d/ast_serialize-0.11.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2fa3be25f7f5351b1b39c9f8a52779b2dbf21199efbae564b4746422e8edca4e", size = 1511621, upload-time = "2026-09-13T18:48:48.667Z" }, + { url = "https://files.pythonhosted.org/packages/8a/82/60367e58ef346a41ebc90d3f28593c1b8f5c2cb5314c7b2bbd98910ee131/ast_serialize-0.11.2-cp39-abi3-win32.whl", hash = "sha256:d70556a2f9230a44c99a655774cde823f056efc34466eabfb4085f0cb1ea9f99", size = 1125873, upload-time = "2026-09-13T18:48:50.661Z" }, + { url = "https://files.pythonhosted.org/packages/23/bf/b419c3205ce1143ba7c69baef4f0ba43c14d8712113bf34f9e0d27d609be/ast_serialize-0.11.2-cp39-abi3-win_amd64.whl", hash = "sha256:b9065dd23131a23b41f5bab3bf4e9b3c350a3fe8e36e8200eded9b729fcea484", size = 1165434, upload-time = "2026-09-13T18:48:52.169Z" }, + { url = "https://files.pythonhosted.org/packages/91/a7/c8bbb2173f7a7131b3b2412035b2d814ab5ef2ce9799bd06f07c451640e4/ast_serialize-0.11.2-cp39-abi3-win_arm64.whl", hash = "sha256:dab599cbdcb7b45b18c41fad746645580b3a24357082b7f0e8921cd373804f27", size = 1136031, upload-time = "2026-09-13T18:48:54.04Z" }, +] + +[[package]] +name = "certifi" +version = "2026.7.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e5/3f/143b048436775b0f76ac3eec145c019e8173ccc2885c8f20319b996d5e83/charset_normalizer-3.5.1.tar.gz", hash = "sha256:6117b84ea48435e5356dc737f5121485c30920ba43375fa7b434fd753df0eac3", size = 171764, upload-time = "2026-08-15T08:20:44.807Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/aa/554e2614f38fc34c58ff1d0911ae8535ad2516440d5482d76fe59f1088b0/charset_normalizer-3.5.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d1ee1e296209fdce05b81b663250eefa02213a2da7b41bf26f7829b8ba3545aa", size = 369072, upload-time = "2026-08-15T08:16:22.964Z" }, + { url = "https://files.pythonhosted.org/packages/03/6d/439231dfc3ccfa6f8c06477b7da2219cbd41a2de3d49084df8ec7b5100f2/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9fbdce1e47394b09bc9f26ab117dfc8d6491977a11d86f592bb42c779db2fda", size = 251142, upload-time = "2026-08-15T08:16:24.81Z" }, + { url = "https://files.pythonhosted.org/packages/55/53/7d819bd23a00ef45039146fa2cce1daa2f0771e758c5653ee1f6edac91ed/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00668ebb0609751758682eb0b5857e7c35b9f00e84dfdef062e103244ec94d45", size = 240714, upload-time = "2026-08-15T08:16:26.392Z" }, + { url = "https://files.pythonhosted.org/packages/b2/2c/45847198c16f4b38090cc7423b2b6a9008e438704d8ab413211832498d31/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba2f37ee79e6338845261a3c5b1784e5d1acdff2c0785b284f1b633033d136ab", size = 279637, upload-time = "2026-08-15T08:16:27.961Z" }, + { url = "https://files.pythonhosted.org/packages/69/2b/d8be3523ddf9f0b0f3e56d1359034aa10653a4d11564c697f802b4775766/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ce854f5f478050ade5a238731c4ca985a7d3b3cb53ff600a9b5c3b689b5f0a7a", size = 276543, upload-time = "2026-08-15T08:16:29.399Z" }, + { url = "https://files.pythonhosted.org/packages/32/cd/4f564b8f132de25db594efc706897069f016790cea63a5669c9df2675f64/charset_normalizer-3.5.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96eefc178f8636b9c760c5829345307fd81cfae9ab1e80997dbddeb0f54ee9a3", size = 261644, upload-time = "2026-08-15T08:16:30.722Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e3/38b975422534a608f98c360e79c2f07c763d66dd4272300d45fb1fee54b0/charset_normalizer-3.5.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:366ec70f5547c640d3ce1985722490f23faf4eb5216a7eeba78277490e78dacb", size = 259609, upload-time = "2026-08-15T08:16:32.248Z" }, + { url = "https://files.pythonhosted.org/packages/87/bd/fbc24d825c66f1c74f6ccdea3742c3d8354a4888e86d1315a197fee69061/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:950f23cb393f85543777b0433f082cddd25b51ab398eac7971146495679efe5f", size = 252457, upload-time = "2026-08-15T08:16:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2d/918d0e98a0e679469ed05bb2d90c2088b4d315bb612969d8499f76fb5210/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:c1dcc36dcb96abc02236e182d17e0f71430152a6c2c7447421da2d2dc144edea", size = 242240, upload-time = "2026-08-15T08:16:35.396Z" }, + { url = "https://files.pythonhosted.org/packages/20/c8/c36f6e0b2dfec351bd38cbc05362697e58bcd073d7dbd95154290c9714ce/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:07ffd07412fc5d5e84cd8952acf9ff7e4ed7a708e69d1bada19d8ba91711353f", size = 280308, upload-time = "2026-08-15T08:16:36.825Z" }, + { url = "https://files.pythonhosted.org/packages/ca/7b/311b3e02e8c4092400c449c850a760d8c45d900983c83a70cc07208c551d/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:f5542f9b941279d82d41eb0aa9f98eba36fe4df5c7086c651df7944935b37182", size = 258679, upload-time = "2026-08-15T08:16:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b9/90/082cc45599c392f28c036a497f49e0634041a785fc3849c80ccf396d096f/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:a545775cfe815855ea32d7c27731d79da358ef2055b4a25830231b1622dd18aa", size = 277221, upload-time = "2026-08-15T08:16:39.62Z" }, + { url = "https://files.pythonhosted.org/packages/58/ad/b9aecf38d805cbcf84fa94f14c5d972a16561e20296a11dc799a5dcf3763/charset_normalizer-3.5.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:494b70049a4d69aec6e8137c13af4cf8db8c9f9820a1392ac293b0dd2987a818", size = 263799, upload-time = "2026-08-15T08:16:40.885Z" }, + { url = "https://files.pythonhosted.org/packages/b7/23/b38a20598d5a825f85d9d7636860e56ff0db1479f86497a6e485aa9326f7/charset_normalizer-3.5.1-cp310-cp310-win32.whl", hash = "sha256:94fbf1c0c6cc0d3d5e50f9a9313a8cdca90dd696d34b381cd1704f8c9e939f20", size = 182037, upload-time = "2026-08-15T08:16:42.198Z" }, + { url = "https://files.pythonhosted.org/packages/d2/21/83fffb77864408b8bf0fe1ca603926401d6f8775a8e150b39aacc9958f8a/charset_normalizer-3.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:be47f99644b208bff7766314013f9acf57b056b04191d570d68ad14022cf5b1d", size = 206030, upload-time = "2026-08-15T08:16:43.787Z" }, + { url = "https://files.pythonhosted.org/packages/86/2e/b93135b5034b1157fb29554b0d06d4844ce62282f0e0a14036f93d7ee2e7/charset_normalizer-3.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:a6d095662e73e74f0a49988e0593373e243e3a52e27bfeea0a859e88acf4a0f5", size = 185092, upload-time = "2026-08-15T08:16:45.177Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b6/034f6802e9c3f6418966cfabb7db8c9252cc2429c5098f41cc43af804149/charset_normalizer-3.5.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eda059b6bc8bc0812d626fd91a7ce01bf583df0a61296eff390fd94141a34e30", size = 363585, upload-time = "2026-08-15T08:16:46.646Z" }, + { url = "https://files.pythonhosted.org/packages/d5/fa/6a7e2a7c4b5451912b8c417732df79574354443592a88d616de03da66ae5/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa2bb0b37202dca27175591f761108b5d34096ade1191ffe4808bdf6b1571488", size = 251189, upload-time = "2026-08-15T08:16:48.287Z" }, + { url = "https://files.pythonhosted.org/packages/a4/c8/ab42b07cfd82e919f427fcfaa7c41abae8242833ad1aad66d42bae40b669/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b2b1b3fa5670c127b246df1d0c059defd41f689a868a3b9d79df9b1cac42d22", size = 239724, upload-time = "2026-08-15T08:16:49.67Z" }, + { url = "https://files.pythonhosted.org/packages/e7/80/b9348b5d3041209f98b4cdad7655766369233f1d533f4f4f7558e9717bec/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6e5e4d73d588ca5ed09df1b7dcd1b203d1df3c542e3f50d126c947d432b10731", size = 280078, upload-time = "2026-08-15T08:16:51.228Z" }, + { url = "https://files.pythonhosted.org/packages/82/38/083a24028304bc85bb9e376fed801178423dcbb67495f73b6ea0624e1894/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b54e7e13267d49ffbfe68e25b3cbd774dab38fa37238f71265e91b36146eb21c", size = 276650, upload-time = "2026-08-15T08:16:52.625Z" }, + { url = "https://files.pythonhosted.org/packages/0d/35/731ac04aa0a097fc1c97f0994c375bdb230c6c96619db794208fe664e9ce/charset_normalizer-3.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7b742bf31c88566b4bb6335a7f393bb322e580b6bb98df7bd0c25e6e3519ce8", size = 262325, upload-time = "2026-08-15T08:16:54.085Z" }, + { url = "https://files.pythonhosted.org/packages/f5/28/c2028e7021fb89c6e56868ed0e387b8e9aa811abdd2ab3208d6578d2c930/charset_normalizer-3.5.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6ba32c4d2abf1d2fe7cf27d280f4cca5664233b0f885549c7761719eb977f486", size = 261140, upload-time = "2026-08-15T08:16:55.604Z" }, + { url = "https://files.pythonhosted.org/packages/28/f0/0c0ceec6d98b7daa62e361e418135d59685811d79ba11529aad5cdf15e84/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0722590aabf9dc6a6c0343d523c05458fa2b5047dbe6302fd526bb570600753f", size = 252791, upload-time = "2026-08-15T08:16:57.103Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3e/48f4cd187b1c33189d86039e9cbe4f92c05454175504b44ff81806d4d1bf/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:aa1099b956fb795e686d073568f6dc002a0bb89765ea6d5b055dd7d9bf1b116c", size = 240730, upload-time = "2026-08-15T08:16:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/42/85/f9e22af69af67c54cce42be9455d9c81294f918b4ccc454db01f66efcac2/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:bd6c173f04743d483881bffa1478d5a4624475b8cd1d2194956a75548e191c18", size = 280791, upload-time = "2026-08-15T08:16:59.918Z" }, + { url = "https://files.pythonhosted.org/packages/fd/4c/9044135f42127630b6fa742feb51256353f6ab87a78f2fdd1de3de955a7f/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f298e218441525d3794428b4c8b8fb8662c6d3ea79925d4807ee6b9a96a3bca5", size = 259598, upload-time = "2026-08-15T08:17:01.421Z" }, + { url = "https://files.pythonhosted.org/packages/ba/ed/1dd7cfebb4e75812934c49ca3b79757d11948053f7937ab7070c151f3c55/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:6e2912d4babbc65196ac13c2f53468dc57fb8b9c25ef913e8c59ddf7c6dc0e1b", size = 278217, upload-time = "2026-08-15T08:17:02.782Z" }, + { url = "https://files.pythonhosted.org/packages/bf/eb/239c84503cc9e3ba6eb34686a24bc66e84f3924efdd7e38e751a19f6bc10/charset_normalizer-3.5.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3d27167433c0d5f18dc850f07d0b3816221984fecdc405d6c157a6f0b8f8e9e6", size = 263417, upload-time = "2026-08-15T08:17:04.216Z" }, + { url = "https://files.pythonhosted.org/packages/37/ab/4e4510e1e288478e2c8333131d1c1382382ba8cd2165053c79e39d1da961/charset_normalizer-3.5.1-cp311-cp311-win32.whl", hash = "sha256:ac00177c4831ffa650f8609e4bdddd5fe09c03b1c0c47acece7e6ea20421598b", size = 181774, upload-time = "2026-08-15T08:17:05.58Z" }, + { url = "https://files.pythonhosted.org/packages/e3/57/32f0ccea59e8612057c61d6fd22ef2cb63cca93c9fe594094919696ac170/charset_normalizer-3.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:f9b1e28d0e8dbfa858abdba91d6b547beaf2df1a59bec6da6faae7b96a4991a9", size = 206653, upload-time = "2026-08-15T08:17:07.075Z" }, + { url = "https://files.pythonhosted.org/packages/17/d4/b65c433fc521e58b5f54293982a5e51c05cb5f2dd3f1c7a6acb65b75324e/charset_normalizer-3.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:ae31a1a1db2ee6cc2942fccaf695c934bc7f3db9f2133a3fef1f367cf1a4ab10", size = 185630, upload-time = "2026-08-15T08:17:08.502Z" }, + { url = "https://files.pythonhosted.org/packages/30/27/78873dc8b6a56357517b74b6bb9568b80450e7bb4f6ef7e3fa9d22aa0bd7/charset_normalizer-3.5.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5b6d1386bf0096d26d3a863dc0a487a5b4eb9aa93cf5ba69683d29dde6b9d60f", size = 344456, upload-time = "2026-08-15T08:17:10.072Z" }, + { url = "https://files.pythonhosted.org/packages/9a/4c/be49ada26b1f0232d57aa89bbebf997a5cc2332a5616b6eca26ff680044d/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4582c27e8c889d64811987b5967fbd3ae0c823fe1fd933b543d55ac20bb475fa", size = 238530, upload-time = "2026-08-15T08:17:11.563Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/6f1290fa07ae6978d3960caa3eb1b8019bf9284ab7c2297b00c099ef4250/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1d1c7a53a6c2103925cdd6d7229f8c567379f211c869793df679f2e9f738c369", size = 230200, upload-time = "2026-08-15T08:17:12.919Z" }, + { url = "https://files.pythonhosted.org/packages/e7/a0/47b18adeed31c8f16ba9700f32c1b18594cfa09f47eb672a488c273c22bf/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e6621fb2a4988d6e53eedc455e5903e2679f3967b8acb3d639f1b63c14a2e893", size = 262222, upload-time = "2026-08-15T08:17:14.571Z" }, + { url = "https://files.pythonhosted.org/packages/38/fe/341861ac118dae06f3ec0eb487488af52128f2ef2faf0b11003944d22259/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7c0c10730342b0c9b35dd1d619beb8214e520bd96a1f870f452680b238aab3e0", size = 258951, upload-time = "2026-08-15T08:17:16.158Z" }, + { url = "https://files.pythonhosted.org/packages/6f/89/bb5108dc6c3651dca963f2b0a3ba19bbcb370c94e1b6d3e0e844a58e6dca/charset_normalizer-3.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9af956078716df40d985fb0dfeb2c2120c5ca92ba4ff4b388acfd01cdc14d08", size = 248801, upload-time = "2026-08-15T08:17:17.683Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ba/ef83ae3aca816393decfa3530976f38a79812d707b80b580ac33b83f9877/charset_normalizer-3.5.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9f8405c2c758532c74fed975dbee57be1f31a6e865c031870c79a6ed3212ada", size = 244070, upload-time = "2026-08-15T08:17:19.191Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0b/c5292a2462d69b7378ea89793bbb5b2b6fcf6f7dd6d1667f9619094ad553/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:96fef3e886d6a9874b14f27fc193fbdc69d5d8035783d86aa4e1cea594e695f9", size = 240110, upload-time = "2026-08-15T08:17:20.547Z" }, + { url = "https://files.pythonhosted.org/packages/46/22/111e5be3b740d5c2a5bfcedb3d237b6591e5c2e82ae9d6ffcb121fe0909c/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5d8531a6569d025f68e2321e7638fb7978f23db58e5f69f56913837aae03816e", size = 232836, upload-time = "2026-08-15T08:17:21.895Z" }, + { url = "https://files.pythonhosted.org/packages/f9/d2/d2aad6fe0dbb44b194bf3becb60f5a0ac48446ade999a47fe7bb41eb09a7/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aae2ee51122d3ae968a3837d97dc24a0aeebb0dea23694422cd172bd30017cd6", size = 262712, upload-time = "2026-08-15T08:17:23.727Z" }, + { url = "https://files.pythonhosted.org/packages/35/5a/337e4663a5eae6de99db940ee8066d4145caafb61327db62deda15313cce/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:7235dc28fc6dd9d832ac7c7bce95367dedb85929f17368a0c2bee1e080b9acbf", size = 242977, upload-time = "2026-08-15T08:17:25.157Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/f82f8a92e31c7519410e2e1afdc630f28ec47490ce2c09a11c1a43cbb459/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4abdc5f9ad448c1ecbfae2974b820535d6bc6e7eef63babbab3d81cf46968c71", size = 260207, upload-time = "2026-08-15T08:17:26.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/52/643d11ffd60e9ac2fd1fb87e167a19285b9eefeff4a40e63c87cbfbeab36/charset_normalizer-3.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ba501e667c17d8411f98e67a022d9604ef179aff0e459b7e292c796837c13573", size = 250562, upload-time = "2026-08-15T08:17:27.971Z" }, + { url = "https://files.pythonhosted.org/packages/62/16/46556278c2168d12df9da7fede5dc6fc70e60301b26a82bbeec238c9cfe3/charset_normalizer-3.5.1-cp312-cp312-win32.whl", hash = "sha256:cfa1c0cc3a8f9f53f1243a5a99ac36fd003880199383b37672e86ddda9cb07e2", size = 178507, upload-time = "2026-08-15T08:17:29.277Z" }, + { url = "https://files.pythonhosted.org/packages/9d/7a/4c6c298171e6b3e745633180ff59350fc0ca0db1ffd28df1e369e0579f71/charset_normalizer-3.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:3617ac3cfd8b9888f145ad89dd6e692285834b0201c6074a5eeaad3fd4d668c2", size = 200551, upload-time = "2026-08-15T08:17:30.668Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d7/eb95a042f0dd22e304b0b6472b154f3546a1a039a9ee89ccb2a7f61591fc/charset_normalizer-3.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:88e85ab89cb822c1e635f51d6d32e488f94e002e70e2f492bdb8b945543f345a", size = 180700, upload-time = "2026-08-15T08:17:32.028Z" }, + { url = "https://files.pythonhosted.org/packages/bc/61/2cb6ad133dbbb449fa2d37ccae973232f4827e799af258d15e589a3d1e9e/charset_normalizer-3.5.1-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:4f298bdadb8f0b9e5672877f647d1be9373ef5320c9e2f049795e26cad28b6a9", size = 211584, upload-time = "2026-08-15T08:17:33.597Z" }, + { url = "https://files.pythonhosted.org/packages/18/57/a305c968be1ca13f3dd1b32f445877e97addf55d80b65c7cb35fac82b777/charset_normalizer-3.5.1-cp313-cp313-android_24_x86_64.whl", hash = "sha256:88ca277405c2d3b71c4e1c2ee0e7966e807bcba86a69d11e19ba199d18ae4491", size = 223359, upload-time = "2026-08-15T08:17:35.022Z" }, + { url = "https://files.pythonhosted.org/packages/09/0a/d3646670292ce8d8f8cc11ac067d44885e697a5591f57a9221128da5e7b3/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:9362dd90aa7dab48c0054a21187791ccf05473f7dba5d92b8033ae62164675e7", size = 194464, upload-time = "2026-08-15T08:17:36.452Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/d51ec556e01042fed6f993ea859311bc7917b466684182fbbceb6ca24762/charset_normalizer-3.5.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:977cdbd483a9cff38179bea4fd754289a6f2195c7abd414aba85410b3e66cc5e", size = 197676, upload-time = "2026-08-15T08:17:37.819Z" }, + { url = "https://files.pythonhosted.org/packages/a4/a0/562247944386f7d4ef94467e84876600cc1e0f1b93239aaa9213d2bc3cbd/charset_normalizer-3.5.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e90251c0c7bdd54a100a0dce3c07b7e637278c93af29dbf78ebb89a58c4bac7d", size = 340473, upload-time = "2026-08-15T08:17:39.303Z" }, + { url = "https://files.pythonhosted.org/packages/31/e7/1d994be1b93d41e9502b8b0460eaa88a1dd8df335df415db87d6c3e91ab2/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94d78ecec2605a8d0398b0f365d5f12a63248438516f5dac536a5eff7337df4a", size = 240156, upload-time = "2026-08-15T08:17:40.66Z" }, + { url = "https://files.pythonhosted.org/packages/09/53/27923ce5cc6cbccb832037b27dca98882d9c53e9b69e866bbbef4aae7fc8/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d59b75732e9b6f27388e10c14b0259cc5f2e48c78627d185e6a177b58ad3cffe", size = 228246, upload-time = "2026-08-15T08:17:42.003Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/5a97e84d63af1d55c07439cb80e56d99a8efb4295700eb4e18c0d1615d2c/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0d929fc574b4d6fd9e7c0f5c2ede8716a41911923aa7fa5fce38e0818aa4a1ac", size = 263660, upload-time = "2026-08-15T08:17:43.627Z" }, + { url = "https://files.pythonhosted.org/packages/7a/c2/071575791dcc88316c0a9a65ce38897a82e4cfe4a325f0f7fe1b1ac47bcf/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:394fea06235c8543390050ed5f529187074b029fb027213f6c46ac11ab5d950e", size = 260354, upload-time = "2026-08-15T08:17:45.094Z" }, + { url = "https://files.pythonhosted.org/packages/fb/af/63240b0c0248c075c2535a1f1bd992821d8251b9f173abc13329661d09e4/charset_normalizer-3.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62b55f6722735a6c472f88361cde6640608773d9443cebdbb51abf436a1fcdd3", size = 250638, upload-time = "2026-08-15T08:17:46.496Z" }, + { url = "https://files.pythonhosted.org/packages/4d/66/70dfad64f15be09c15ccfee81330a7e515895dbe296dd23114e9a231268a/charset_normalizer-3.5.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa48b1b63d639f9483e0633e092f5851e2348c352f1f9bb6c8182f87884ef876", size = 244583, upload-time = "2026-08-15T08:17:47.963Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/ef36367d38b9ddd4bccbf72888c342e8de1f5ae506fa0b2dcf970e2732a1/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c71fb0d56c920c269cd3e2e3fe7c610e3f1fdb21a6ce60efa6430ff63676cea6", size = 242038, upload-time = "2026-08-15T08:17:49.481Z" }, + { url = "https://files.pythonhosted.org/packages/db/ab/55e683ba0fff2e43adafc10daa3001eac90fdaa419a97227d5a7067eedde/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:485a0d363cafefcd2538a73c7c838daa2035f09b2c9f9b5e3133f80c6aeb84c2", size = 233677, upload-time = "2026-08-15T08:17:50.845Z" }, + { url = "https://files.pythonhosted.org/packages/bd/67/0f40eaf8d1b6e7cf15e82382a2965efaca787fc1c2794b7021d37aaf5036/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c0ea61a470e070686aa30892fed79e297d2c8d0ab46b8bcdf027d38c51da591", size = 264491, upload-time = "2026-08-15T08:17:52.61Z" }, + { url = "https://files.pythonhosted.org/packages/5c/64/12b4c2a11ee8df4fcc518c78b0d93e3a92bd3d5253d1617ce74ff0e8c7ef/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:90b7481fb62fbe172c558bc6fd1c4c98d82004a54a7551f20e11ac9bf0b8708c", size = 245196, upload-time = "2026-08-15T08:17:54.023Z" }, + { url = "https://files.pythonhosted.org/packages/37/2e/651d910af6d0fba325eee1cda37ec5443462ed25360e666c144166eb6091/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:35fe081843b35aad20ffeccec3eeffbe637b15d14f3fb22cc1b59cd8ec17e93c", size = 261660, upload-time = "2026-08-15T08:17:55.491Z" }, + { url = "https://files.pythonhosted.org/packages/90/c6/b09e05e6db7f64338e0dc067c79577b1138da86c1e38369096851d96be88/charset_normalizer-3.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fd0350afdc3aabd5576f60ea109228bd5538139713c7b094c5cd27c73a98bc6f", size = 252618, upload-time = "2026-08-15T08:17:57.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/4e/362d4f9fdcdf5556fb2aa3ce7d4a58ebce03ed1ff03aa1d9aca8d02f13f3/charset_normalizer-3.5.1-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:9d9a0dc7cbe9bec24c3f767c9122c41fe5a1bc43f47cd099d00d393e09769de4", size = 140362, upload-time = "2026-08-15T08:17:58.425Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/703be739b26acce318bd29eb3b25b7209e1b1f527f9eae3d1f1f01fdde2b/charset_normalizer-3.5.1-cp313-cp313-win32.whl", hash = "sha256:d63600d620ad0064c3a748b950ac5ea38a80190e5498532efefa4b7b3f1da1f3", size = 177755, upload-time = "2026-08-15T08:18:00.037Z" }, + { url = "https://files.pythonhosted.org/packages/8a/33/56d97ade41c8db611e727168c52ae46c9224c362ec28d4b65d7e9869e8da/charset_normalizer-3.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:aea996a6aba25260827c9ea511d1addfde2da9eb686ac961838509086188b7e6", size = 199295, upload-time = "2026-08-15T08:18:01.506Z" }, + { url = "https://files.pythonhosted.org/packages/5b/75/5b20dd1e6573a01a08158fe104104fa2c8abf941745596954185726cd46c/charset_normalizer-3.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:fd0a274c0e5f9a21565cd9d3dd749b61f96b7aa1e20a93aa1ba4029518f2e5c0", size = 179856, upload-time = "2026-08-15T08:18:02.929Z" }, + { url = "https://files.pythonhosted.org/packages/29/cd/2b812ce5e888f1ce69a5350281e58aab07ae64a958ecae8912f30865718e/charset_normalizer-3.5.1-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:774d157f112367ff4abd29019f38f023c24e00e56edc7829c20e358a5a913ad8", size = 212318, upload-time = "2026-08-15T08:18:04.403Z" }, + { url = "https://files.pythonhosted.org/packages/9e/4a/a6ee107430768a5334e6d63f31f148a04a1a491ef161a1ac9415a73f2fa8/charset_normalizer-3.5.1-cp314-cp314-android_24_x86_64.whl", hash = "sha256:26422d45fd13551cf564c58932f7d72b4f58b93b0fcf18c35ba6be12b46bb102", size = 224897, upload-time = "2026-08-15T08:18:05.997Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d9/35ae3f64f29d0179c35c3baefe575904df2913dde519129c7f75995a2b1d/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:09a7bba9f739468c8e78c36a75c33768e53cb1959fc638f510454c14683f00d5", size = 194848, upload-time = "2026-08-15T08:18:07.397Z" }, + { url = "https://files.pythonhosted.org/packages/74/76/f2fc7380f056cc273a53af37f50d08ad54b2c59f61078f31432edcf1c2bd/charset_normalizer-3.5.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c9548dc78002099910abaebc0a72ac58b7d30931869e0351c09b507dff4ece3", size = 198163, upload-time = "2026-08-15T08:18:08.989Z" }, + { url = "https://files.pythonhosted.org/packages/e9/40/095ce62fa078483cccc1fa2b36e6bc9580b85422a20ee9f925341c50e44f/charset_normalizer-3.5.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c428c6c31eb5f4277d7f8eccaf767fbd548ddd5ce3c8b4f4cbbfab3d96b5904c", size = 341823, upload-time = "2026-08-15T08:18:10.458Z" }, + { url = "https://files.pythonhosted.org/packages/f1/5a/0e58b1c04a1596e0256f407274a92d5fb2ee21324409d1fab1da48a65b5b/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2f06b7eae9dbe77fe1d644ca244dad508de8d302870a43f3c559b521270938a0", size = 242458, upload-time = "2026-08-15T08:18:11.989Z" }, + { url = "https://files.pythonhosted.org/packages/22/95/b4618ce912e6db0b1aae89ba788e38e8a7eba0f3025cc66e8c0699f977b2/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b7430cf5728e68f6c462254009a6ef4086e1bea43cf2f57aa9c55fb4f50ff96", size = 226717, upload-time = "2026-08-15T08:18:13.401Z" }, + { url = "https://files.pythonhosted.org/packages/8a/76/c681192bbda3d55356db5dadd64381d5202b37c6b598fcda5282e88b5d3d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab743e9bc90c1f73552ec33e10e3331315acd2c397b36065b591b0181de533cc", size = 266111, upload-time = "2026-08-15T08:18:14.961Z" }, + { url = "https://files.pythonhosted.org/packages/88/be/55127bfca72c0cff6c022488d140d7c5b04c771e3b72e9bdb4836d54979d/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6f7deae3feb4edfa2efaf7c574fe88cbf055038a6abdb40188e4fff66d5699f", size = 263128, upload-time = "2026-08-15T08:18:16.515Z" }, + { url = "https://files.pythonhosted.org/packages/e0/91/39c3af510b0aa32bbda03374259200f28430febfd1bf5e511fe765282ce5/charset_normalizer-3.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15f024313246a4ed976c60f440bb8d257815513a681d212ff74fd46f7d715a90", size = 251240, upload-time = "2026-08-15T08:18:18.127Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a5/cbe418bbc6ecdfc3e05a0116002897c4b403a5e838d697e64c78e9f0190d/charset_normalizer-3.5.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:823f82903d189af463d7df250ef1f7f696f3cee08cc8d91deb565e8d425f6506", size = 245282, upload-time = "2026-08-15T08:18:19.625Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a4/689bb42e8e7cd492f3cb64907c6bc00ad247ec9a3628cd3f8eed126e8ae1/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:01e93745f7f219b703b60ba7afead36cfc4242782be5af484673fc500df12da5", size = 244597, upload-time = "2026-08-15T08:18:21.121Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ce/9962938e179cf9f699d3f1e7b3114b5d7642dee6a893745229f9dd04f274/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:329fc3ccb63ad22d867d84c2adea759a64079a37ba4a343433b02c7a2816871e", size = 231376, upload-time = "2026-08-15T08:18:22.57Z" }, + { url = "https://files.pythonhosted.org/packages/85/54/46000450ada53bd9eac5429a2c8c54cd2d9b39c0c255f229aea9af0948a5/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bb57753e36e4855b8ca375069482250a6246372331a3e4f3407eaebb007443f5", size = 266715, upload-time = "2026-08-15T08:18:24.235Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bb/618749d70f792b44252a777bf89bfb86823b9bbc1ea13fe8ce759b07f38a/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:fce8cbd4997efeb450bd298b54f755dcdff18d496f7a5ddbb4867c6d7c88fdc3", size = 245848, upload-time = "2026-08-15T08:18:25.726Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3f/ffb64458527c7668031d5eb095d978de561958dc9f5b53f8e488a533e603/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6c9cdde8becb25a7fde49924511aa2644d6f8081cc8df8e9452724303348d8e3", size = 264521, upload-time = "2026-08-15T08:18:27.193Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ab/74a55fd803916a35ac461daf002708191aac19b546b80dc8cabfedc63d98/charset_normalizer-3.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9ac4444d8d4fd4c4bd08bf451ed3167aa9e7ec6cdb41b648794f1d1103652e36", size = 253054, upload-time = "2026-08-15T08:18:28.568Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2a/6a9034b7d3c60b17499afb482df5878bf9fa20b50cc3887d5ef017a833db/charset_normalizer-3.5.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:f03ac127268b43ef4fe9e6ab6794a6794b49485a0cc0c1db79876d2f33f75bc7", size = 140580, upload-time = "2026-08-15T08:18:30.214Z" }, + { url = "https://files.pythonhosted.org/packages/f3/46/1d362e1a00d035d66b9869e1281eee115907f7e390a16a07824ab5737360/charset_normalizer-3.5.1-cp314-cp314-win32.whl", hash = "sha256:1f5883d77fd409a261abb5dc8ccbe335720d798b1de4abb3b1d47ccbbc76b53b", size = 180325, upload-time = "2026-08-15T08:18:31.877Z" }, + { url = "https://files.pythonhosted.org/packages/7a/7c/4938c329b6a9d446f6a59aa2092ff7118f274209b5ed0e26893d1d30a63c/charset_normalizer-3.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:c658c50ac0c98cd755a2dd50b7977d3bca7df401dcc47fbdfa87db53ef7d4e8b", size = 204175, upload-time = "2026-08-15T08:18:33.466Z" }, + { url = "https://files.pythonhosted.org/packages/ac/33/eeb384dbd8dec570661354592f4f2e1b2fcc92585624d146a000caf53841/charset_normalizer-3.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:4bea7f8ebe90bbd7f0e4a2de42ca6924ba23e3e76418c408ff82f1d46fabd687", size = 184123, upload-time = "2026-08-15T08:18:34.913Z" }, + { url = "https://files.pythonhosted.org/packages/1c/6c/c73fa9d5a85f6ab05395de61c5f6984e0a9ff40bb5ff888d46dff02526c6/charset_normalizer-3.5.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:fbc597639158fd7c14d55e808718848319540f51b0e6746e3eefa59723a4a348", size = 381682, upload-time = "2026-08-15T08:18:36.349Z" }, + { url = "https://files.pythonhosted.org/packages/30/c7/63565f860921457feba93bae6c86fb7746deb4cffeed2f375cb845318146/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e71c909f353863b2b89c83de2ebed71ea6d0df8a6ef65a128193c5e650766bef", size = 240826, upload-time = "2026-08-15T08:18:37.887Z" }, + { url = "https://files.pythonhosted.org/packages/06/ae/7ae8807410dfa33f8e6f1715740adeaafa8a816cc4cb33508f54b1f7c896/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7ac76cf9afd34929d76eb7fcb63be476a4853d8a96f0dcf2d0db68a0cbdf9885", size = 227861, upload-time = "2026-08-15T08:18:39.315Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/887c1642f0da26000b0e0652d91071113c0e72cea33952e225cf589f49a9/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a3a370082ce34d0612f421e15fe011c53bb1feff21a26d06ad4fb244dab5a375", size = 260758, upload-time = "2026-08-15T08:18:40.88Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/e6f5b9a3d0e55b0ef7505cd3765cdd48f22db89994c947b316f52f801fd8/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:256dd4d85d9e4dc595e2bc983c980e73f62ddeb3165c58b4c3dfe78c5c8548c1", size = 259950, upload-time = "2026-08-15T08:18:42.351Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ee/e4e10a94d51cd1ee638aa7e00b65399e6b2a4e8376ab6d2eac9f95586671/charset_normalizer-3.5.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:58d4aa13a59c969dbfdf9e6a9560e242cbfd9e8a8f50c2747714df1a423adf65", size = 249329, upload-time = "2026-08-15T08:18:43.914Z" }, + { url = "https://files.pythonhosted.org/packages/c4/25/d5f4198819e6059735a84e8d0bfb72dc33976da67b97adcd3fb5a5e07ec6/charset_normalizer-3.5.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0c6dfb5ca6723eeed15aa8e564a014d69fcb8812f94eef11fe3631e0508199f5", size = 243137, upload-time = "2026-08-15T08:18:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/a5/e9/e925ca7569cf9fb9701fd82503fee73eea5268fdb856bdd64947092d3daa/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c010f5581d9c612804cc59fcf7b524b707fbcb72828551237ab545bb5c7034af", size = 242820, upload-time = "2026-08-15T08:18:46.842Z" }, + { url = "https://files.pythonhosted.org/packages/34/17/672c251a888ed2aebcdd2fe830ad0104e25ff83c43f5c4f9c15e9fc6853c/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:52ec005752a56ae79547a05c0139ca2501a0c866390b6115008456b9f0e7cde1", size = 230504, upload-time = "2026-08-15T08:18:48.353Z" }, + { url = "https://files.pythonhosted.org/packages/3f/fc/f6a85abebd42ce4da2f1db0aa56cc6a0df1995e318b3875d14401b8381d1/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:2bced4061f000f7187254a02ad3433ae17eaf991747ceea2f478422590a5bba9", size = 263087, upload-time = "2026-08-15T08:18:49.859Z" }, + { url = "https://files.pythonhosted.org/packages/98/66/7c42677e739ba66746b297e2046918d793078094dc239e1e72768cffccc6/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:9eea3ab2597a5e65fe65296e2d6a84570845a6b55532d90333d740d48bbc850a", size = 243269, upload-time = "2026-08-15T08:18:51.601Z" }, + { url = "https://files.pythonhosted.org/packages/de/d8/a50b79237f417af10f8c2a501ce8d1ca87829a22e69117891ca4ba20a69e/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:496846868fea80e479324862fa877f02411f2fd0f83b79ccee2607aa68b2a032", size = 258766, upload-time = "2026-08-15T08:18:53.23Z" }, + { url = "https://files.pythonhosted.org/packages/2e/1d/0fc91aeaeb3c83b748f532399ce67cf84604b48297405d740000f7a9e786/charset_normalizer-3.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:85d5855daafc240cc045c026d7a15fd198a09b0fc8ff6f5ecbb5297b509cb11e", size = 250814, upload-time = "2026-08-15T08:18:54.768Z" }, + { url = "https://files.pythonhosted.org/packages/ae/10/3d8c777cf9024615295aa1b808324ad5b4a77855869c00824bad74ffaf8a/charset_normalizer-3.5.1-cp314-cp314t-win32.whl", hash = "sha256:58d3e12c88e0950bca850ae1f7c256055c097639c2edb9eb123af9807d8b15e4", size = 191074, upload-time = "2026-08-15T08:18:56.305Z" }, + { url = "https://files.pythonhosted.org/packages/4d/81/ae557d3c44d1a1d688696d60563413a0866a91b7ebc50f20df838be3d8c8/charset_normalizer-3.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:acaf604462bf330b0d07e7a07c1d6e4adac79e5fb13e9c5140590542cafacc00", size = 216476, upload-time = "2026-08-15T08:18:57.889Z" }, + { url = "https://files.pythonhosted.org/packages/27/e9/61c01fb8b804692569c036b3fc50495814502dcf13a60649c6055390b02c/charset_normalizer-3.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:fdb8a068947befafba9952162645dc2fecaeb400e64584829ed5e9b2fbe21a7f", size = 194115, upload-time = "2026-08-15T08:18:59.418Z" }, + { url = "https://files.pythonhosted.org/packages/4a/4e/8544831ef59d8f27ce92c80871380fdacc8076a8a56ed62f82e54f991333/charset_normalizer-3.5.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:9085f87b0e38a2b92b8923059b4e8789fe40d9279712d15dcc670048d77079af", size = 342048, upload-time = "2026-08-15T08:19:01.054Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a6/e3b46852424246065355644f4fb6dbccc0239a42a2eee27ecfc8957f0bcd/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2679de311c7946dde5d3b6f44941844133ff5c7cb86099c0061ab1e8901c20a8", size = 242997, upload-time = "2026-08-15T08:19:02.492Z" }, + { url = "https://files.pythonhosted.org/packages/03/3b/0cc9a26777334ab2f2e3089b948bbf4e4fe72ea70b897715ef6415043ec8/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:baf3775a2635e5a11fbd5e4e64ee69c7e86875d224a5c72aca4c141064589a90", size = 237014, upload-time = "2026-08-15T08:19:03.943Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c2/027335f0aa337a2a2e121bac1ad88c4f02ba6053ea0926802784f3db11af/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ac8c94b6539074e0f40899301273ac8402b9b3e01c7b7ba269ff30340aaaf20", size = 266174, upload-time = "2026-08-15T08:19:05.598Z" }, + { url = "https://files.pythonhosted.org/packages/86/d3/e367787febe4e74769dec0f406f2c3c8d1b955fce5aee1fd0f94e8367a45/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fe532b3c966d1fb794e0698e4589d0444017ae77fc0b31edea13c0e35bcc449", size = 263361, upload-time = "2026-08-15T08:19:07.251Z" }, + { url = "https://files.pythonhosted.org/packages/af/3d/391b193eb9f3e84b02f9314088c386debdc0debee843535aaea2e2c6715d/charset_normalizer-3.5.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5c84bec0ab5ae0c64bfe73a7d2adcb5ce73b467523fc27fd6a28ab2aa6cbe35a", size = 252143, upload-time = "2026-08-15T08:19:08.816Z" }, + { url = "https://files.pythonhosted.org/packages/2e/57/de221f1745a90d418199761967e2776bfe2c275a1194220985e8c1d37833/charset_normalizer-3.5.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:854066be00447fa8de2ccbbe893e2ffc4b123ef16d897af794c1e18bd4a714b0", size = 252086, upload-time = "2026-08-15T08:19:10.255Z" }, + { url = "https://files.pythonhosted.org/packages/c8/e3/d119f86a01f9331e8186175f24873b1d74a7ee9e2e4b4d68f9947dae5afd/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:21b82d8082f6f5e7f456ef0bd16323d08de1266efbfeb476e64b2a91d1471a4e", size = 245231, upload-time = "2026-08-15T08:19:11.807Z" }, + { url = "https://files.pythonhosted.org/packages/26/de/d8e48c135ae480879539cdb179c8d3b50c7879497d75dd899b5763b69cee/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:838648accb3a7fd9803fd45c87bce8509648eb0c11bc34e216141300977244f2", size = 241546, upload-time = "2026-08-15T08:19:13.416Z" }, + { url = "https://files.pythonhosted.org/packages/67/c4/217755fd1abc50d326c252922cd642002758095a81ff45010337b8b3ef65/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:195ce897c6153c0700078142cf8efe3e6454ca4cf4357499e4078dfd83396626", size = 267033, upload-time = "2026-08-15T08:19:14.981Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d7/34d8e404e358d2adcc5a228c2134643af00104c8fb0bf525f3688d756f05/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:978eab16f55b4ab2c2a745be9a0a840bf8f09a7f227d9c76eb30214d078865a5", size = 252045, upload-time = "2026-08-15T08:19:16.618Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fa/40414471acf0aa0692ca77305aa00e434fcd8288f0941c93c30e9a5f8f2f/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:cc0329df4caaceb950d2f580b5ac716a377f7059624a0bafaeaf8a218c6ed774", size = 264866, upload-time = "2026-08-15T08:19:18.101Z" }, + { url = "https://files.pythonhosted.org/packages/32/90/fcc850bae791abd2e0c041847f13e270aa08692a79f3e00de6d2dce1cb50/charset_normalizer-3.5.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:687c9ca3035544b113bea2055e180af96fb63c0c476e22a9180f51925186e7b7", size = 253932, upload-time = "2026-08-15T08:19:19.734Z" }, + { url = "https://files.pythonhosted.org/packages/af/af/53afe99068b3c10b4cbae592a52ef72a7c92c0188440e83ee3a078fd8f75/charset_normalizer-3.5.1-cp315-cp315-win32.whl", hash = "sha256:706bfd38730a5ac7a365793269a00f4e988178cec121391f4248d84ad8c972e9", size = 180320, upload-time = "2026-08-15T08:19:21.37Z" }, + { url = "https://files.pythonhosted.org/packages/c9/bc/f46a132041b29e4a8779ed712d3df1bf112e94ca8de58b66d7ec2c0cf8b9/charset_normalizer-3.5.1-cp315-cp315-win_amd64.whl", hash = "sha256:92caef967d287a407085d61176fce4012b1dd62daed4eb6d5ceb26d3d2538712", size = 204174, upload-time = "2026-08-15T08:19:23.088Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5d/9ed554480eda8e447b673648628fdc29574d23dbad01fe11837adedd1cae/charset_normalizer-3.5.1-cp315-cp315-win_arm64.whl", hash = "sha256:5fc45d653ea8c9a20479167e11d4a0f8cb2fa3470737ab6f9c827532313187b7", size = 184126, upload-time = "2026-08-15T08:19:24.471Z" }, + { url = "https://files.pythonhosted.org/packages/3b/32/9b8929bf384061ee1fe5d9c27c6f9776d3d824039ad4e14c88ec00c7808e/charset_normalizer-3.5.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59171c6e45bf07d0d5cab3b0bf81d945035530f6873398b3b531c31184d46663", size = 381441, upload-time = "2026-08-15T08:19:26.038Z" }, + { url = "https://files.pythonhosted.org/packages/96/10/e9aa7923d3ddac652c99a1c5f7be494e737e151566a44abe018daf757f2c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9dbdd9205662134957cf0c324f639bdc5031c0ca056e2369e238db75187c0f11", size = 241742, upload-time = "2026-08-15T08:19:27.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/53/a2d249ebddf47b889a100c0bdcb61a2f9dbb8bc24ef325cc062e4f476877/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e4b018dc5a0eee4676e38fe84a47a427816c590b93b55d9025274ec4d6ffc2dc", size = 235298, upload-time = "2026-08-15T08:19:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/7d/07/469f78af590f7d5cd48e20d8dbfa3d66deeff9ba37768c04d886b5afd45c/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced3fdd71aaa83ce593746c2edb42b7a59cb4c19c8b5c407781c72e493aae55a", size = 262500, upload-time = "2026-08-15T08:19:30.955Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/3bb56a47f7dcba014055b1a1d33c6f08bbe9c1e74dba154cfa25f90ae885/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:19a3dd5aa73cef1c99687c4fc57db016a9c17104ae1185da88ba566a5d3bebe4", size = 258888, upload-time = "2026-08-15T08:19:32.458Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c1/2adc2800903fb013210349313b710a5376856578d9e33e6b9a1d8b36714a/charset_normalizer-3.5.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc5d36d96478aa9c60654bd932525bf32964c62a7281eafdf16d85003a8d6004", size = 250243, upload-time = "2026-08-15T08:19:33.94Z" }, + { url = "https://files.pythonhosted.org/packages/95/b5/a18d0dd1157ab655cc2cb14a545f4a4784bbad70ab3502412e36097502d9/charset_normalizer-3.5.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04368edf83514385ffc3e1cfd4546e595f4f1272dd23ba437a93a9cc3741d47b", size = 249871, upload-time = "2026-08-15T08:19:35.413Z" }, + { url = "https://files.pythonhosted.org/packages/ad/c3/525f508cd1e58d0450ac55ed40ac75bc3a97482c59def5278456a5fbf03c/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:9b5db6052055d34d41230fb78d7c439c23dc536a9896f6cb039e8dd92cfc1263", size = 243580, upload-time = "2026-08-15T08:19:36.886Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/49a91fe7e97c8140094ca5c64161ab623a70d9f636bf834eace14048acb5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:252d099029bcbea642f2a06c4ed5046bdf8b5a8150b64afa5e027e88b106e5ee", size = 239807, upload-time = "2026-08-15T08:19:38.392Z" }, + { url = "https://files.pythonhosted.org/packages/d3/58/56a48c296601274c4689b864a8e2dfb209b81dfcb39472753ce95eea662b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:6199d5606e2bbf2b096cf64d03f8b6790c91081d5ac866b8e7bb6422738cc60c", size = 264083, upload-time = "2026-08-15T08:19:39.856Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/dc48409274a1817ff349711d26c62aa0c597df865d4d69ef79160c859193/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:77efcff2b23071c349402ac1066667a3d011f62398d81408c9b88ad991747c9e", size = 250317, upload-time = "2026-08-15T08:19:41.53Z" }, + { url = "https://files.pythonhosted.org/packages/81/58/d325912115caec62d6bdd77bbab5e0b7da5d234a9f20affdffcbcb530d0b/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:a5cbd90ecf0fc62e64726917ad083b73001f0563657a87ec3c0b504e277dc90d", size = 258173, upload-time = "2026-08-15T08:19:43.07Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/b13b1ccae2c8ec63980d13be1890eb73f8aeabbfce02a24aabc0908788f5/charset_normalizer-3.5.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4d26f14f041e83dd8edfd61f4cd4fa7285d31798b5bf1f28e70c367ba6c41d61", size = 251960, upload-time = "2026-08-15T08:19:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/1e/25/ed3f9919c5aef8cc818be1f972f565f7610d7b2076b8ebb98839516ffc3c/charset_normalizer-3.5.1-cp315-cp315t-win32.whl", hash = "sha256:ac13b004224fb341e1e25a1ed5e19d32f57cdb2a403e01f003b46f051a550f6f", size = 191186, upload-time = "2026-08-15T08:19:46.293Z" }, + { url = "https://files.pythonhosted.org/packages/69/d5/43c2b3e9d8267092b913eb8b0603f0f71993c395632886bd37a7223f96cf/charset_normalizer-3.5.1-cp315-cp315t-win_amd64.whl", hash = "sha256:35aea775dc2bd5f54cd84a1cd2696cc3207c479cb9cf0bd346f0d343e4300ddb", size = 215947, upload-time = "2026-08-15T08:19:47.853Z" }, + { url = "https://files.pythonhosted.org/packages/a8/76/9aad3e9c8865e5e0efa9a7f6f81c37a67635a985145ecd44528a81e088ee/charset_normalizer-3.5.1-cp315-cp315t-win_arm64.whl", hash = "sha256:fb78f6e7fcd8ad785d28cd577168bc1aaee827b25bb8755638f694794ea98f0a", size = 193909, upload-time = "2026-08-15T08:19:49.383Z" }, + { url = "https://files.pythonhosted.org/packages/5b/97/fb4e82231aba271ffd775a1b4993b0defc4e3059f286ae41d9433409fe85/charset_normalizer-3.5.1-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:41876ee62a3dddf48ff1121ad8f0798032aa03f2fd35f21f34a4cab14f18d8d2", size = 331467, upload-time = "2026-08-15T08:19:50.959Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2f/fe3f187327aac18e2d54e9d2b08e15d27bf9b642d9e51c219f130fc34d1a/charset_normalizer-3.5.1-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a6dac12ff6b846103483683f60c5f8fee205121adc58ffd87e90a90a3af69e99", size = 253057, upload-time = "2026-08-15T08:19:52.654Z" }, + { url = "https://files.pythonhosted.org/packages/d7/c7/9e48cee5c161fe24da823b61bf381921d77cb994a0a4de148e95018c1984/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cee5dd7c6fb5dd52a0fe2a740f9bc6e3593f5f8b1788bde49de02086f30182b2", size = 240930, upload-time = "2026-08-15T08:19:54.163Z" }, + { url = "https://files.pythonhosted.org/packages/49/e0/716601f3cc69be7b198951150c75ead1ece33c3c8036ff6ffa46029659a0/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:343fb4f2821043bd87095f7b08a1a181febc8e36ac64212143bbfd0a0e1bc235", size = 230822, upload-time = "2026-08-15T08:19:55.807Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/71bfc5caa0abcc45aea1f6a4d50ac68e59605ddc7666fe8494f4cd229665/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ae4a097991662cd4fff0ddc74e0fe7874f82e00042fa0ea00855645ed0c79598", size = 260037, upload-time = "2026-08-15T08:19:57.312Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/de7e32ed05341e7a9c4c877c318418197b7f2d66a3b68d561bf2ac57ca3e/charset_normalizer-3.5.1-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b599739b93b2cbeded49645ae3c8d1405c29ddfbceac1545c87a3f9580a9e96", size = 255097, upload-time = "2026-08-15T08:19:59.056Z" }, + { url = "https://files.pythonhosted.org/packages/f5/7b/ade0a122600319dfa0b1000ab0f9731c94a817904cf3c5de408c73a4ede7/charset_normalizer-3.5.1-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b39b69b347e5e47a3b5b8cfc005c68c1ba347474e3960236c4944a8ecd174962", size = 250166, upload-time = "2026-08-15T08:20:00.612Z" }, + { url = "https://files.pythonhosted.org/packages/75/9c/019fbb9f4834491a160951349b1a3714439376f66e5f7cf18b4f18f0c7aa/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:a2028475ba855475b8b4d3cfeb4994269c967aea8b9892dfba907f4263a863a3", size = 241821, upload-time = "2026-08-15T08:20:02.321Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b8/11d4840bfc99330cc7fbcc2681ee5a044553a6e77655508d8f9b2bff7b34/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:36047af20e17097c3bb9476c2b7655f2f7aa51322c0ba58c07695bedf755a950", size = 232529, upload-time = "2026-08-15T08:20:04.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/96/2b3a21492d9f65171ac75d872f5018260013d00bfa0ff70ec9f179148cbd/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:4c4fb141a727957c93edfe5c32a26ceb6b5f6461d67146e2d39f51e16170bea8", size = 260348, upload-time = "2026-08-15T08:20:05.877Z" }, + { url = "https://files.pythonhosted.org/packages/d6/aa/a69a2028e8bd052476c245460ab19d7de595de084dd968f2d75cd50c3e25/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:2f293479cce755c75f1697e87c409b7ae4c555c7dfecb6e988ad13abba943031", size = 247234, upload-time = "2026-08-15T08:20:07.487Z" }, + { url = "https://files.pythonhosted.org/packages/35/8a/3d130aeabcaf3d2466af76b7b141c08d9e89c9016ab4b7cdd0f7dc2d1c62/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:3588e376b3ea2eea84976f67273d679f229e24c66dce7b82ae45aef04ff6e072", size = 256917, upload-time = "2026-08-15T08:20:09.142Z" }, + { url = "https://files.pythonhosted.org/packages/80/c2/a7379b840292d0c1ab9fbd17d1f3967aa81794dc95bc74be8999d7fedcf7/charset_normalizer-3.5.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e199fb99720074809a7720f1c0b4d919eea8b87e88713e0f8f602f7bef543d9d", size = 254846, upload-time = "2026-08-15T08:20:10.727Z" }, + { url = "https://files.pythonhosted.org/packages/01/65/d43b714731bb2f40d4053dfa00ecfc1c5a301f8e3316c5db3a09af59fe94/charset_normalizer-3.5.1-cp37-abi3-win32.whl", hash = "sha256:dd732602a7009217f658d5863d12d79d373a4de0eebc111094bcdd3bb8e0a6cc", size = 174216, upload-time = "2026-08-15T08:20:12.334Z" }, + { url = "https://files.pythonhosted.org/packages/35/4f/b911ed898b26a09789eba9c9200c999aff6c61b4bafaf4838e56d1a1e1a3/charset_normalizer-3.5.1-cp37-abi3-win_amd64.whl", hash = "sha256:70055ff39b97c99e7ae40ea3e393fb62aa2e44dbd9b29f8d14f42fb0025c3959", size = 199764, upload-time = "2026-08-15T08:20:13.908Z" }, + { url = "https://files.pythonhosted.org/packages/f0/a7/920baf467bfd9bf689f3b318340f37aee4572a71f162bd8db51da55ba4fa/charset_normalizer-3.5.1-cp37-abi3-win_arm64.whl", hash = "sha256:87e4f41d375c0b9be2fb5251aee4b8a689169e134535aed81bf085c3b647451e", size = 287318, upload-time = "2026-08-15T08:20:15.551Z" }, + { url = "https://files.pythonhosted.org/packages/cc/61/d01fc49b8dea277640b55a9e15960dbca9fdc8c9fde18e572d39c59f4019/charset_normalizer-3.5.1-py3-none-any.whl", hash = "sha256:6df0ec430f9a831772c23ca5a224cba36517a58a84bb32c32bb59a9fa67c47f6", size = 68658, upload-time = "2026-08-15T08:20:43.306Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "coverage" +version = "7.16.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/65/2d/c738872f477f5687152acae68635790387425d407ae37dd3d3a8a6692307/coverage-7.16.1.tar.gz", hash = "sha256:f83981779bcf9dfa06fa0a8d4cb43e0faec1706328ce07aa3e7b665b4ac0f210", size = 969651, upload-time = "2026-09-13T19:12:21.422Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f6/62/a8b4dd53308a4b1571e6bdd77ee562c9b1c1742db9886c0aef2f69463067/coverage-7.16.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:4f12a9e27ca7b65e40a8475d27899b2d45064d9020e6a89148939e01987b5853", size = 223178, upload-time = "2026-09-13T19:08:21.805Z" }, + { url = "https://files.pythonhosted.org/packages/5e/7a/b9325b8d486a5c05fd4a9eb1cd9c9f697c361ddeda0e73567d5c2d8959f6/coverage-7.16.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f590d46c30d9e4c1fda3efefe5443f4c2f6a4192c5ca2ba403653e9ebadf097", size = 223701, upload-time = "2026-09-13T19:08:23.391Z" }, + { url = "https://files.pythonhosted.org/packages/ef/ee/3ab3ac6e9e7165a623695b73a83d1bfbdf5069681a68a012cb5abb096060/coverage-7.16.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3df82f0a3cef4e1bcfc799436056f0b978dda319d0bfd4460c6e479b2802d98a", size = 250434, upload-time = "2026-09-13T19:08:24.948Z" }, + { url = "https://files.pythonhosted.org/packages/b6/a9/31ffc231e9879876f611cf1ac7622cf092d76762c07ca64dce47b29a200b/coverage-7.16.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bb462d59146656e278d1e8ed913ce374d0ba68a4e081acde1867f6d3377fc881", size = 252264, upload-time = "2026-09-13T19:08:26.734Z" }, + { url = "https://files.pythonhosted.org/packages/c9/f4/4fb4f6b16de07dbae3d3a111ae28d32ad657ce6ff4d364c49c10962daad5/coverage-7.16.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7db888dd0a1df1a653cae7f99d4047430d2187a3626eda51bc847b0fd6b9b43", size = 254127, upload-time = "2026-09-13T19:08:28.254Z" }, + { url = "https://files.pythonhosted.org/packages/9b/3d/048e88eb610f44b7542dac10fa45bb2ffad5fbfcdab0f03289a843da934b/coverage-7.16.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:38a7e16f061504ac2b45370bf5bf97e8250d8d3f25e37385bae884978166554b", size = 256043, upload-time = "2026-09-13T19:08:30.019Z" }, + { url = "https://files.pythonhosted.org/packages/97/59/d27b113c80b04c7fc64c69457132648e1d287b83a1de41189a504b50b52b/coverage-7.16.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2b26b55b18e1a53e1a159dd743728c4ddbbef28ba19000a91aaff5ce023197ec", size = 251092, upload-time = "2026-09-13T19:08:31.57Z" }, + { url = "https://files.pythonhosted.org/packages/45/42/b7eafaceff08dc1dcbfc924fa9233031fd00c8b8287cc4a1a0dcdedcb0f9/coverage-7.16.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fdb2f528b50953e29d22033b3256c396a700193c6e45b2490222ef9c333cbbf9", size = 252170, upload-time = "2026-09-13T19:08:33.191Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8f/57dcc5360aa6d8d24370c12fe855f6ebf5fbf2718c154fb9fdec7161de07/coverage-7.16.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3284754371dc78592aa3ae4d661d30ee20e02b2b6b0de3590a181a936d0d3b38", size = 250173, upload-time = "2026-09-13T19:08:34.75Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/379a8c7ac0f3063769dc43fd2475e9fc9b2722cb88eabe71f4d862660c93/coverage-7.16.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:802d1246c540e07486d4ee1adfa19a797e4b33529ffc371dc140644e8f27da0a", size = 253986, upload-time = "2026-09-13T19:08:36.737Z" }, + { url = "https://files.pythonhosted.org/packages/45/25/70218d2a6077730843b75ee2525fa64a750283d71cc4c063dc0b75ba6979/coverage-7.16.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:6fc735d6fe6d57f803e7ba021be4dde48e43e6aff94e6954350555d5332b0594", size = 250444, upload-time = "2026-09-13T19:08:38.434Z" }, + { url = "https://files.pythonhosted.org/packages/58/ac/6c41c441baa6c8a1fed5615e4e1e7d0ca649b33b472ee28591a92d70a1ff/coverage-7.16.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ed5ade1bb18f62edace1bd198c66f9d4c75a8385d5fd24e87d917ea1a5958773", size = 251046, upload-time = "2026-09-13T19:08:40.133Z" }, + { url = "https://files.pythonhosted.org/packages/fa/f9/01166d6f8aa42acd148b4c2c88173d60eefdd0270ea2bcbba79be35bc193/coverage-7.16.1-cp310-cp310-win32.whl", hash = "sha256:0c309096926b119543dc16438a11ef4c80783d2f4e59ff94f7f462651a944cdc", size = 225242, upload-time = "2026-09-13T19:08:41.672Z" }, + { url = "https://files.pythonhosted.org/packages/d2/28/a76060478919becf0fbea2df2053a6e1a7195f11edf8dfd51c58c1636b43/coverage-7.16.1-cp310-cp310-win_amd64.whl", hash = "sha256:7562f8067ed9360e8b9739e5703403a7686dd1b36bf0f89fc538047c54cdea90", size = 225868, upload-time = "2026-09-13T19:08:43.22Z" }, + { url = "https://files.pythonhosted.org/packages/af/3a/d09495dfd5191b5593852bbe2f037afae768157443378d066d9ecea69a49/coverage-7.16.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:72e013665e25cf9d44779f01f340af26319756f9a76822b7c94ce6b1d93813da", size = 223307, upload-time = "2026-09-13T19:08:44.914Z" }, + { url = "https://files.pythonhosted.org/packages/a3/34/310196a80258e28ebf6e5aa814a5a6ffbb18c03cf3c0c0c04191ed893e88/coverage-7.16.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:cb05c0ff98b56ba6969adf35556bc43bcb8d094df8bc9cb403acff53460c4e07", size = 223817, upload-time = "2026-09-13T19:08:46.738Z" }, + { url = "https://files.pythonhosted.org/packages/73/29/ed0fda1fcd440cdfc07e72a07f3c9c3b43f65a6b3d53bff2cba9b9de50e8/coverage-7.16.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0d0ececb32090e3fbb03e0d352b973a0485879b4de6c58daf47227b9988b99e5", size = 254222, upload-time = "2026-09-13T19:08:48.358Z" }, + { url = "https://files.pythonhosted.org/packages/ac/4e/5e2507fbd71ec1047620978f39568b0d2ed6c4468d08495a0c24f5677f65/coverage-7.16.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f0ba3892d81aacf36996c52f16bca04e39af31a6c5de930b7688ab617f4a6475", size = 256134, upload-time = "2026-09-13T19:08:49.926Z" }, + { url = "https://files.pythonhosted.org/packages/7e/b1/a9f97846554bc240473656f9c3874591105f29c08eccf4282daadc6bc281/coverage-7.16.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6410b75fe07d5271eaa95fc24bd0a9177ed588d9d1c10c0cf67829adb8f0567", size = 258240, upload-time = "2026-09-13T19:08:51.584Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c3/2b1ab208d06719394851cdd7dc322157870a93b178410b1bda6cac7755f9/coverage-7.16.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d1039cb2de093225d597109342ce1675626bd127565e80b3044f4eca07c15b2e", size = 260202, upload-time = "2026-09-13T19:08:53.204Z" }, + { url = "https://files.pythonhosted.org/packages/af/14/ff4db31d6e3126d5b72aab1e868d35ec94e1b71dee46f5c3b54cb1b2438e/coverage-7.16.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cf047bc39fde5425be2628666d0f435ed8817859111c3aacc84b32d858069f5d", size = 254305, upload-time = "2026-09-13T19:08:54.833Z" }, + { url = "https://files.pythonhosted.org/packages/ce/27/c28faa4818f61c49ca3bfb4a77e1c191e79a40447504b89af0bd859cd6fc/coverage-7.16.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c05913d0d5badf7ac83200f35dcf9514cce5df16a7cc89e7d1d7fff0461813b", size = 255935, upload-time = "2026-09-13T19:08:56.453Z" }, + { url = "https://files.pythonhosted.org/packages/46/5a/42e64e5b716048cae33e2e15f8c6fe04a927467056c533b8e88900da895e/coverage-7.16.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4027bf6d7bc0a16df058ce913b69f10c5687f8e1ca668f08caa659ce101744bf", size = 253995, upload-time = "2026-09-13T19:08:58.159Z" }, + { url = "https://files.pythonhosted.org/packages/84/e5/860287acd5a1e29acd337f302b476b54148203590091b1a1555b2e914b50/coverage-7.16.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:4f48b345f831eaf4402ab6333c2dc3e2e2b5bc7b9c1b8fe12680dee3f0538f01", size = 257767, upload-time = "2026-09-13T19:08:59.958Z" }, + { url = "https://files.pythonhosted.org/packages/a5/c5/4b68006da567b4b413352f891776c35776b3557a0479a28187ab57c21659/coverage-7.16.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:8643baeb590726c558b2faed6cd59b0917480f9367fcc692026f1a86d824fd08", size = 253715, upload-time = "2026-09-13T19:09:01.778Z" }, + { url = "https://files.pythonhosted.org/packages/a1/0e/b2d0c47cfbf11770e197f1d0f11a92864eb29fd7eaca45bc9915573d9725/coverage-7.16.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d06dcc420b570bf683cdb647cc8fe62b672d9e429ef711c3cbbb7a6880ca1572", size = 254624, upload-time = "2026-09-13T19:09:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/2e/14/3bab8821b2b942155578fc34e88e21b0670d922f039ab23651f6035ba7f7/coverage-7.16.1-cp311-cp311-win32.whl", hash = "sha256:946f58aa59b08bcd6afcc6a7bd0ff54ed5eee844f32ad69fe6814836d15856a2", size = 225404, upload-time = "2026-09-13T19:09:05.174Z" }, + { url = "https://files.pythonhosted.org/packages/9b/ce/4f4ce667a97d1c538b46a79b89161395ad2beffc248b6c782afc9f521927/coverage-7.16.1-cp311-cp311-win_amd64.whl", hash = "sha256:684c7ee9b4c04358fe6ac8b517ab51ec35fcd79d08ff0f105dd8bcd96885bbb7", size = 225879, upload-time = "2026-09-13T19:09:06.81Z" }, + { url = "https://files.pythonhosted.org/packages/26/17/f3dce5e47351ab34522dd037fd64b111742958e24861bdd2820971bc1a26/coverage-7.16.1-cp311-cp311-win_arm64.whl", hash = "sha256:1b24f79e25bcf6c73931aeca7a3dfc7595c0cb5e9364aba3fdf387a3de4b1c22", size = 225428, upload-time = "2026-09-13T19:09:08.502Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f7/7cd4c9f2a3b7574414222ec425d5eee21cc690d867a013315e3be8ba185c/coverage-7.16.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b7f2c26ce6ce0b1e0ca0d5fae96ea510e3a2e78b7207f06e76b7f2c87fa3d0af", size = 223475, upload-time = "2026-09-13T19:09:10.145Z" }, + { url = "https://files.pythonhosted.org/packages/3e/f2/9ac65f9cedd43f91e2d3657c11f13aef82aebae89b2243dc9e44fe58a740/coverage-7.16.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:070acb9da788dff743a4d36fc015feee12d68f0349959017542017c79f59c21c", size = 223845, upload-time = "2026-09-13T19:09:11.988Z" }, + { url = "https://files.pythonhosted.org/packages/62/4d/f13db452d4367fe1122abfd98ae330596f65a3b40498f8e1a5811f68f123/coverage-7.16.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e366587b370bc9b8b51b7b7272c610c56db5d5b4795b9e4a29d28ff2f440f809", size = 255341, upload-time = "2026-09-13T19:09:13.708Z" }, + { url = "https://files.pythonhosted.org/packages/5d/6b/85ed86e82835a96ddfbe7705c387c28ce1cbbecd1b6d606f5ddfeeb712df/coverage-7.16.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e82e10b9d290f60b63459cfb245a841aec347603997206296b93881463a93dcf", size = 258078, upload-time = "2026-09-13T19:09:15.368Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d2/f66945853d850b9c05f4e012e37396f1f31d0cd40d062394b229c22e7b56/coverage-7.16.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d73bb1f85c4150ac208fb0755beb04b2e44897bad81414de9380f98dd74729f", size = 259191, upload-time = "2026-09-13T19:09:17.046Z" }, + { url = "https://files.pythonhosted.org/packages/77/a1/7b907abe62461f289035c7ac60ab3e6334efb8c425151aac4abfa0c97820/coverage-7.16.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3397b9032553d281ad6a9253b12675b65e0cc8cd7a3b0633cf48872c9eb13360", size = 261452, upload-time = "2026-09-13T19:09:18.756Z" }, + { url = "https://files.pythonhosted.org/packages/51/e6/e26f4d6b1069a2a2fee3238a132f85c5b4c1dc25aebd88e015451ff0bd68/coverage-7.16.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:77890395cf37026a5907d3ad32376aa51f41c0f163b7477fdbd4f94966cc1d08", size = 255698, upload-time = "2026-09-13T19:09:20.786Z" }, + { url = "https://files.pythonhosted.org/packages/7f/ec/99db7450e813050ebce300e31bbd4f997c76a8c6e3a6d168c5dffc104109/coverage-7.16.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b0944dc3bee3091039bf970d73caaf930c906013128a421bdc132e797494d941", size = 257111, upload-time = "2026-09-13T19:09:22.693Z" }, + { url = "https://files.pythonhosted.org/packages/2e/9d/500df9d3cd8c541ac84b5e0bcab00646be75654e05aa34e8410ec851282d/coverage-7.16.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b89d22a89d5bc05dd95b64e08295b8394aa96dc88e08f8ba210c9ebfebbe0489", size = 255258, upload-time = "2026-09-13T19:09:24.429Z" }, + { url = "https://files.pythonhosted.org/packages/c0/24/53318d96da332bb4946f8ac646fa19fd37fecbd0c49144735c716ac69bf0/coverage-7.16.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:550a2a1faf7559f13d5344f12d1eb886ad87955155d7dfab2a3fe5c8ec8fe776", size = 259326, upload-time = "2026-09-13T19:09:26.32Z" }, + { url = "https://files.pythonhosted.org/packages/c5/ce/abc0462b2e6ae96ae22197d2bc30fe33b6b4e52937e782745436ceb2a761/coverage-7.16.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:55eb268e5b81aefac759766c9162625b06c1bedb7b77d936225bafc4f038a6f6", size = 254827, upload-time = "2026-09-13T19:09:28.191Z" }, + { url = "https://files.pythonhosted.org/packages/8b/e1/0a04eedaaf19196b51f0180968134228c7646e469ed29914e48690a7cf3e/coverage-7.16.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:65a8fc80898c9ce59f04349fe8b4849b1f9787f14e52ead990e5f849ff4727a0", size = 256698, upload-time = "2026-09-13T19:09:29.922Z" }, + { url = "https://files.pythonhosted.org/packages/de/1d/d441a55cf22ce9d8e9e34814806c47441ab844bd534e0f4b64e1c6ae8bd1/coverage-7.16.1-cp312-cp312-win32.whl", hash = "sha256:528a61be40977c340cf201d23b69bd6a6bab507da60e9dbda85f8b30e935d70d", size = 225541, upload-time = "2026-09-13T19:09:31.752Z" }, + { url = "https://files.pythonhosted.org/packages/73/27/ec3d032375735dd331477caa051419678079ff90fcb53d0284a6c2bfb757/coverage-7.16.1-cp312-cp312-win_amd64.whl", hash = "sha256:d0f02c633630e2b74522108ee95a84ad6e1204a8016a6cca5297f335ea27147e", size = 226075, upload-time = "2026-09-13T19:09:33.556Z" }, + { url = "https://files.pythonhosted.org/packages/94/00/90e9f5c4434878494306b9c0ee8068ebbd829483737d8cefccc58884d728/coverage-7.16.1-cp312-cp312-win_arm64.whl", hash = "sha256:2959978f9d1d20a2c0c15d0a68baaeccf615ac1aa214cf4a05a10d6f568926c8", size = 225461, upload-time = "2026-09-13T19:09:35.48Z" }, + { url = "https://files.pythonhosted.org/packages/aa/74/c08c0c4dc9fa6bcd1d90728a63660aa1b17b488a806948598456c48f75d1/coverage-7.16.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ee5465db6e9152a7d09f3215309326878c6aa3ac509195a369f9d264ff4bfbd9", size = 223501, upload-time = "2026-09-13T19:09:37.276Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c8/784986d326663285258a8e39835c46fb730cc85284f0dbcd82078586dd22/coverage-7.16.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2b8256f8b525ba233d2e4cdcdce0d6673c66fc9bf70df1fd5e67c54a74e2d245", size = 223876, upload-time = "2026-09-13T19:09:39.385Z" }, + { url = "https://files.pythonhosted.org/packages/15/76/73fb792928872bbb07e553f920ff55c65ee962c469265feb5d1d4ae5f97a/coverage-7.16.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d57cc400275b9a2892e905fc893f732b21ddb95271bf96406c88e2f6367848b5", size = 254863, upload-time = "2026-09-13T19:09:41.326Z" }, + { url = "https://files.pythonhosted.org/packages/ca/8d/1fd78899513244b065ccecdd1cfc6aa8b8f1bdee796d8c4f2aa8e8e5397d/coverage-7.16.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6b3fd0f3435ebb7a7183b32a6062a8b755f08242ced1f3f22761d30b56b3c2a5", size = 257460, upload-time = "2026-09-13T19:09:43.086Z" }, + { url = "https://files.pythonhosted.org/packages/47/1c/b23ddfcb7ef9bd7b3fdb7be9a5dccf9925ae88e556df7aa5b655283c78f2/coverage-7.16.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e5eb1762e7eb5fad34ef913e8107c7788a66f19d328e598ce95bf7217f9e5c8f", size = 258697, upload-time = "2026-09-13T19:09:45.161Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c9/19d0c6ca35778a7e9415c30c46a0c64c9d4374219d004a35563132296896/coverage-7.16.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:46cd3a73e9140410de62cceb66214bce0e08fb3922b9176fbfc1522fec151b41", size = 260827, upload-time = "2026-09-13T19:09:47.061Z" }, + { url = "https://files.pythonhosted.org/packages/97/fc/5862f7344382c62b85df43d483e579168cc062e007f54d895dfa51fe3e7d/coverage-7.16.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d1ba5142d68dd2cb775cbd0ac8601819298152047803c8efe4eec6d7d7aa7878", size = 255038, upload-time = "2026-09-13T19:09:48.945Z" }, + { url = "https://files.pythonhosted.org/packages/2e/9f/5c26583199a68df8d15124b4590520903f8eb7cef17db293fea712bb0783/coverage-7.16.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c389c6f9d1d518e1249ddcb8a7f158135644ce2c508fa6cc17b680777dad5bf2", size = 256827, upload-time = "2026-09-13T19:09:50.738Z" }, + { url = "https://files.pythonhosted.org/packages/95/13/605198bff079b107336710f28a797312ab132587168600d70a290e7ecd2e/coverage-7.16.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cdc57746c7ac0ea063351b4d651c3bb4dd4fd35e64dbb8e90c10e14eb03c4080", size = 254794, upload-time = "2026-09-13T19:09:52.577Z" }, + { url = "https://files.pythonhosted.org/packages/43/b7/0bbb32dc5ccdac766a13763fdfbffd7d73fc80349a69230c46c6b71e7508/coverage-7.16.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5597180ed7670cc94c04c65347418a467d3a43d5f0cf52fcac647f5425f42037", size = 258947, upload-time = "2026-09-13T19:09:54.372Z" }, + { url = "https://files.pythonhosted.org/packages/13/bd/65c31ddd43ff4e61b63721b3dad17cca412dba6e2ce89f92abdf75734339/coverage-7.16.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:a9647a0ac46255b8fef59a433a2161f03e5483f3a35e1cbd9dfe4600baff0c6b", size = 254613, upload-time = "2026-09-13T19:09:56.198Z" }, + { url = "https://files.pythonhosted.org/packages/25/20/d278115f2ba522b3e3128c6852be265f4e0df7202b2effca4db96cf0217d/coverage-7.16.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e306e98186b9cd109121f3583aeb7978797ad21d948f22944c5c08845cd554d0", size = 256388, upload-time = "2026-09-13T19:09:58.095Z" }, + { url = "https://files.pythonhosted.org/packages/e1/ca/d43aa396fb3a2f71c9411b99d926475f5acaf5c124f605c592865c80c8d5/coverage-7.16.1-cp313-cp313-win32.whl", hash = "sha256:48a78a66fcce49d7f6156524bf979c0ac633d584199717c68c6ffa949fc14e6a", size = 225550, upload-time = "2026-09-13T19:09:59.998Z" }, + { url = "https://files.pythonhosted.org/packages/0e/30/df2f6114f6a17cffe94721bd1d298f77f86aad493717fa5bc03cb291a1a6/coverage-7.16.1-cp313-cp313-win_amd64.whl", hash = "sha256:7af03247d598a353bbbbe1b925deb735276e4d845e7197c4073dc89352b236fa", size = 226091, upload-time = "2026-09-13T19:10:02.331Z" }, + { url = "https://files.pythonhosted.org/packages/ee/31/6f90d8aab72a112492bd50e3b5485b53b772b1f5fa70da0a620e723caae6/coverage-7.16.1-cp313-cp313-win_arm64.whl", hash = "sha256:166adae25b05b04c9a84135912066d9c97482115af38df1a419a38aacc6b6f5d", size = 225481, upload-time = "2026-09-13T19:10:04.151Z" }, + { url = "https://files.pythonhosted.org/packages/8e/b4/2a7c793965bae9f067aabab793a44d7a2f3ee7fb16b01ce1976bbd4a0218/coverage-7.16.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:cc0b37fe6f5ce5f1ccc62ad4fa9b1ad201d8e9b6027fd5e0170877beee4b2d15", size = 223546, upload-time = "2026-09-13T19:10:06.019Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e2/633469076a2dbbea036cc15a268a3a5d6b2c7dd5d9a9567b2553dfc5ad61/coverage-7.16.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6618f481053b63fc6121faf8fc676bd9b7163c2a19d9e984a2e850002c28ab57", size = 223881, upload-time = "2026-09-13T19:10:08.246Z" }, + { url = "https://files.pythonhosted.org/packages/de/c3/f06150c13284569d53273b909f31222874276a595637b7852571dfeb2c18/coverage-7.16.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fa02d561eb1d8d2f8ba43ba6e3cef4c6c402a3b632a9460fa329fcadcd5df6a3", size = 254919, upload-time = "2026-09-13T19:10:10.254Z" }, + { url = "https://files.pythonhosted.org/packages/d5/40/47e25b215ae18a29010c8e29be8782a6e04d18ba6224be2bf6cebfce6427/coverage-7.16.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:bc5354a124799f1f87b7637bbe6f18cd4bc66a1f37f6aa2b5db40f9adad531dc", size = 257428, upload-time = "2026-09-13T19:10:12.124Z" }, + { url = "https://files.pythonhosted.org/packages/27/4b/1e2a4267d14cbd12a8489364a9d40020233e6be836d929b363f0e77209e2/coverage-7.16.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:34bafe9f4094315248573e6223e11af0ec1b25f9cbca43bf0e9a26a189ba2751", size = 258771, upload-time = "2026-09-13T19:10:14.031Z" }, + { url = "https://files.pythonhosted.org/packages/be/2e/9aa6146cea929fab9185bb2642ffef7f47520a6e5efe407f75f9b12f4cf0/coverage-7.16.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:29c4d3e32a3b5efa420a3dc627c7e570deb80ef997def52c7686a474f5edc7ab", size = 261086, upload-time = "2026-09-13T19:10:16.213Z" }, + { url = "https://files.pythonhosted.org/packages/13/3c/f9ad8bcd4fb3d21c9d20a16d6d6c6f999eee8f4498ed7659a3dbd2f4b74a/coverage-7.16.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2066c447fdd0bca39a9633a082d8ce67bf9a539a203b85059a364a405dc9fe9", size = 254895, upload-time = "2026-09-13T19:10:18.602Z" }, + { url = "https://files.pythonhosted.org/packages/b7/d1/47eda9fd1eaeea39fa7b5b13a63b2bed92ab901841fb120b3f9f5e1dc30c/coverage-7.16.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fd8ac10cd2458b3c6343aac082fb9bd0e3fa806cb2c4975f2280153474b88412", size = 256783, upload-time = "2026-09-13T19:10:20.778Z" }, + { url = "https://files.pythonhosted.org/packages/38/c3/565edf044877cb8cd3373c56885347ffc38f0edfd1f1679a487b208c19a8/coverage-7.16.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9d8c54ec32e5c102b9241f75d88ae26538b53662868ca491736611db448d9c7a", size = 254742, upload-time = "2026-09-13T19:10:22.733Z" }, + { url = "https://files.pythonhosted.org/packages/fd/88/87d2b2aeaba719192b2089ff1c2cf89a06cf73a6d2e9f1f145626617700c/coverage-7.16.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:6dd8dda3402a01a1a8fe8b753a282466f615128574a5590a9108acd07b1f8540", size = 259016, upload-time = "2026-09-13T19:10:24.769Z" }, + { url = "https://files.pythonhosted.org/packages/fc/1b/70813185b125768abdcf7899fec4d37edc2e5fc9b60c7045c8f4271ec757/coverage-7.16.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:79afa9726438912e5cddd1fe541815cea9763c92935f594835e4c432565b68a9", size = 254559, upload-time = "2026-09-13T19:10:26.781Z" }, + { url = "https://files.pythonhosted.org/packages/d8/fa/e7aa5af279aafda633a1ede8bfd7d6916b0c8b2082be86759e0b52e73a61/coverage-7.16.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3db3978211c3cead5437a80136ca0556bab8bc7828de15a762884b0598c41361", size = 256215, upload-time = "2026-09-13T19:10:28.714Z" }, + { url = "https://files.pythonhosted.org/packages/38/87/7a894fa4f8c6662d2b6a87a3436950e15b1fa56e01765c9d6634fb2cbeb8/coverage-7.16.1-cp314-cp314-win32.whl", hash = "sha256:49c39c7068a494f8eb427155f5682f44feee43f9b3107fd54b1e52465379c54b", size = 225719, upload-time = "2026-09-13T19:10:30.743Z" }, + { url = "https://files.pythonhosted.org/packages/8b/01/fa7193c8005fb85488f02b0e1cc3c05a233cf2640206dd978af447aeecbf/coverage-7.16.1-cp314-cp314-win_amd64.whl", hash = "sha256:c510dad19552d912058e4c3e3cbec3fb155dbe8d0ce0ceb7e7dbf5c5822bae0b", size = 226208, upload-time = "2026-09-13T19:10:32.698Z" }, + { url = "https://files.pythonhosted.org/packages/da/5c/a08634c714924c3eaef811bb3576c044128aa5e7dfa86c75e52f0761849e/coverage-7.16.1-cp314-cp314-win_arm64.whl", hash = "sha256:b7d4d7e6dcaf33e85f1919f03346403bdcc27437c420a78835f3805bca0ab71f", size = 225633, upload-time = "2026-09-13T19:10:34.79Z" }, + { url = "https://files.pythonhosted.org/packages/43/df/ddb8a4c664046b1a0ee29c9c2d25b993e5dbc8fbde715df3694a64532781/coverage-7.16.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:3d0a3681c12d3e0bcdea3d9414b04087828d6c1a482802d6f7f42c37ed530152", size = 224281, upload-time = "2026-09-13T19:10:36.853Z" }, + { url = "https://files.pythonhosted.org/packages/e2/d0/9076e0c762d8afd91182e60a520fa5c92c4a334785eeb9fd6b8ef8fe7e3c/coverage-7.16.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3f3b4469d3da3ecced775d1a8c9c5d9fc80f259e30b7b89f9fed0700d6035ecb", size = 224547, upload-time = "2026-09-13T19:10:39.359Z" }, + { url = "https://files.pythonhosted.org/packages/03/e5/9c59e64b6161704f35fe91549bb19b2bb355e95caf596c26a2065564807c/coverage-7.16.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:c08ae35c1be2fe1ce4b4c628df5c6fc0dc9a87f8e5fe8e20238d249678984741", size = 265906, upload-time = "2026-09-13T19:10:41.434Z" }, + { url = "https://files.pythonhosted.org/packages/57/5a/13ccaffb77f766101bf6f38be9dba9e468b02cc92da4552a57877dbf1c1f/coverage-7.16.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8ee71a38c54bb2676bbe762b8b0943a79ccb1c2fd6a52054f66e63eda392f8c1", size = 268023, upload-time = "2026-09-13T19:10:43.533Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a1/05cfcf01d3c7c922832698ad46e51d3441d820ce87a943014bb5cf5710dd/coverage-7.16.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76491917771f179f9772efe218c5ccc65950dbdb35f4439298d8a8dfc6ec1f72", size = 270442, upload-time = "2026-09-13T19:10:45.895Z" }, + { url = "https://files.pythonhosted.org/packages/72/15/a2f1544b8e3835d7b769f7dabcc9ac0283e0b646ef3344703ff8f18d83e6/coverage-7.16.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f4aa0b0a6f81fa3deb211e643f6954e78b4376b62b9c218271236cfa757664e8", size = 271565, upload-time = "2026-09-13T19:10:48.123Z" }, + { url = "https://files.pythonhosted.org/packages/df/5b/963c2993a82bd313f298d663afe03e164b96ace4d9d4c7561740a559e13d/coverage-7.16.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:756ba2d96d073c5a2a55d67fa22784763710fadbe22c41adde2d9cfa4dd78a8c", size = 264959, upload-time = "2026-09-13T19:10:50.195Z" }, + { url = "https://files.pythonhosted.org/packages/12/59/5eba06d1943735d7cd61d46d8c8a20ffe8ddd2da06b3c94366078dadeb9b/coverage-7.16.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:99bf9ea435cefcefd220f8687c3ddbbf78dc2de0bd11b57c3ae9fbbdf8d5561a", size = 267897, upload-time = "2026-09-13T19:10:52.252Z" }, + { url = "https://files.pythonhosted.org/packages/bd/48/af6c30f6ea431bb9b83f9070d268a9cc4fc97490abd32080164177ea999f/coverage-7.16.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:35cbc81f937fc402971df45c897d2df2bfb2014efcd990360032aa0a651635da", size = 265504, upload-time = "2026-09-13T19:10:54.432Z" }, + { url = "https://files.pythonhosted.org/packages/80/f2/6e13852a8656d05fa83284567dd5a5b1e6d89bef79fe3effca2787159eab/coverage-7.16.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:8fae08e85b334ac6ac886002b5041396a31bcf805225bbe19847627203da99e2", size = 269235, upload-time = "2026-09-13T19:10:56.563Z" }, + { url = "https://files.pythonhosted.org/packages/c2/32/b4fe465daa64ece674f83a750dfa4ba0fa3c5c74d6ef5dbb8dfce892cf0d/coverage-7.16.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:83362b64e215ef00b0ba33fcf13655ace6c9fdd144d5ad2ab59ac86c2daf166e", size = 264347, upload-time = "2026-09-13T19:10:58.634Z" }, + { url = "https://files.pythonhosted.org/packages/54/f3/88b5c0e4ca3994c6d5feb7b1bf4c9a62cee205553159184968426930a7b1/coverage-7.16.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:33300f2e140ccf26af3d8152e62bff71993f9310cfc63ba7a20940b0d246a0ae", size = 266660, upload-time = "2026-09-13T19:11:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/97/72/6eff5456d7ba7f1c4678af531c33f9d957cae3201bd229b056fd13a204a3/coverage-7.16.1-cp314-cp314t-win32.whl", hash = "sha256:5539304fdbb2cc144df684d35a33b81145334d23e1c2367b5a923d25107f70b2", size = 226026, upload-time = "2026-09-13T19:11:02.846Z" }, + { url = "https://files.pythonhosted.org/packages/8e/c8/6e5ae3d8d4d0f2c0078985bf4db55fafd90e8107b1bf91ee3547a13f5694/coverage-7.16.1-cp314-cp314t-win_amd64.whl", hash = "sha256:715dcb72c3280c428c3a20134b87e42c29acec9669136e899ab2de69ca86218d", size = 226862, upload-time = "2026-09-13T19:11:04.921Z" }, + { url = "https://files.pythonhosted.org/packages/be/c7/68f9f0734afc904a92b974b489545b6a15700f3b1c4bd36eae764561e661/coverage-7.16.1-cp314-cp314t-win_arm64.whl", hash = "sha256:dac8b84c03e6029d272b8249c77018db83de59ca009a9adef7c144b4a62ee5e6", size = 226171, upload-time = "2026-09-13T19:11:06.969Z" }, + { url = "https://files.pythonhosted.org/packages/ae/16/e11addf5322d98e86307da9e00c94644b97cb72c534c74cda89705bebeef/coverage-7.16.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a337dc2d54c74430cd2febb8ee04f7c508ba8b3b412bf0463f077a66cfc73743", size = 223544, upload-time = "2026-09-13T19:11:09.108Z" }, + { url = "https://files.pythonhosted.org/packages/92/d9/7ccd6484f615961d94b09c75904f87d86375109596069ae3a495a205dbbe/coverage-7.16.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:3acd1d78397dead78dd1b011b5fc19cc823c190349acd549e63856dff649c80e", size = 223882, upload-time = "2026-09-13T19:11:11.132Z" }, + { url = "https://files.pythonhosted.org/packages/59/37/2fd78152a557df4a7e4ad78d6851ede90c211838d526e4916c6016f45144/coverage-7.16.1-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:73a32694603a34ad01d7e51a481a4023410d8099e1d0757e067945695c10f0ae", size = 254987, upload-time = "2026-09-13T19:11:13.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4a/58e2f9b8b13cc422aa7f474a498945ec7f446ef473b5b6bae18d2981f2a9/coverage-7.16.1-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fbbe8265736659a6be2e6042b6a35be13545d14b243cc1d7ecf65f90d788a370", size = 257902, upload-time = "2026-09-13T19:11:16.025Z" }, + { url = "https://files.pythonhosted.org/packages/3c/74/63f8f6a67c03b86455c726be273b2aa5b57fd1122f22350d141bbb142e91/coverage-7.16.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4b0359eb4c62f9993e176bc8f50450fc736a6b90dbcc05bb8584e948812699ae", size = 259522, upload-time = "2026-09-13T19:11:18.206Z" }, + { url = "https://files.pythonhosted.org/packages/e2/3b/1f2261da7483e345fe55de11e41ffc16a543511e37c0912134c0dccc4f6c/coverage-7.16.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:da506e669a8a851b59e122b4b219ea70996a6296f44f3a9348a852526ff961de", size = 261723, upload-time = "2026-09-13T19:11:20.628Z" }, + { url = "https://files.pythonhosted.org/packages/a7/8a/7eb1a361e044b7293f49c921a974b532627ed37f3bef5e7e9f58bcd0d5a2/coverage-7.16.1-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:64a2a5985d81810ed605ff0dc4ccd6555efcb5700353825532a9a0aea65826e1", size = 255462, upload-time = "2026-09-13T19:11:22.733Z" }, + { url = "https://files.pythonhosted.org/packages/67/66/6d94f7ea87e99c519def5cfa5d4a1ab20247d6b403eb6e6b5b63d6aa5985/coverage-7.16.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:66d70132b69b861805dc1ca46cdd733e54c416890e8f1371d2fd103f70b59c9c", size = 257617, upload-time = "2026-09-13T19:11:24.933Z" }, + { url = "https://files.pythonhosted.org/packages/3d/52/c3de0a3868589a1463a4f1cb0222eca0e5fa9f91da865ccf20d2e19ec19c/coverage-7.16.1-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:db651a9cf325a542bc2b7b8cc8f1b2bdc6492739bae3103731b2f1c85b96cff6", size = 255495, upload-time = "2026-09-13T19:11:27.158Z" }, + { url = "https://files.pythonhosted.org/packages/9e/a3/ea10e75f20fc1e7be10b166a494826a965d19b1dc9c8a81c511a01153311/coverage-7.16.1-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:4184e78a4465dcda359fb403172b8951dd220929cb0984c02fabca1742fff06f", size = 259728, upload-time = "2026-09-13T19:11:29.33Z" }, + { url = "https://files.pythonhosted.org/packages/0e/96/9d8020d97de46f0390739beda196322586cdd87e1fc357223e6a28bc4135/coverage-7.16.1-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:bc53c3f3adaa939b7a063533ffe0ae1259e7073393c618043a99a6970a87e3df", size = 254904, upload-time = "2026-09-13T19:11:31.86Z" }, + { url = "https://files.pythonhosted.org/packages/5b/21/2ff8867d4560f4f639a82d8fcf13c27eea88a96193daba096027c48bb929/coverage-7.16.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:b44308854ef210b9b78df9cdfd4e159513382a859f5ef8464306d14a54c2a040", size = 256828, upload-time = "2026-09-13T19:11:34.078Z" }, + { url = "https://files.pythonhosted.org/packages/6a/4b/feacad51cb5163e3baa13281f8a3098f15d7934cc1f28cfe656557eb4e46/coverage-7.16.1-cp315-cp315-win32.whl", hash = "sha256:dccc142614d3419ed71857deb43f1d757829a4c7fce9994464b71e7e38309827", size = 225722, upload-time = "2026-09-13T19:11:36.314Z" }, + { url = "https://files.pythonhosted.org/packages/39/34/66bbc6ffd3c51fa67604c566920e772c5e3baa57f88dcf7b109c7f18b2cb/coverage-7.16.1-cp315-cp315-win_amd64.whl", hash = "sha256:961fc424e9d5229a99f8f1189942d8e7f4e1519147c3af64842f944aca03914d", size = 226195, upload-time = "2026-09-13T19:11:38.493Z" }, + { url = "https://files.pythonhosted.org/packages/f7/96/4bad920d4caed127c37c136a64b0730fa495517d2eb58809e0d81e6e7dff/coverage-7.16.1-cp315-cp315-win_arm64.whl", hash = "sha256:681a9488c5a234397c4f013da065aa9e53eb7af4c78f1f80c6f15e7208acb855", size = 225625, upload-time = "2026-09-13T19:11:40.664Z" }, + { url = "https://files.pythonhosted.org/packages/f5/2b/a88c7906eeb7da4394e932060d7008e153b3a2cd8d11782d82faa03bb7a3/coverage-7.16.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:8bb09a2d19b04db1fa0e087a7ca4f12458f7e0e7364cfcd838441d86fb1c61f6", size = 224271, upload-time = "2026-09-13T19:11:42.876Z" }, + { url = "https://files.pythonhosted.org/packages/1f/1f/98db59c595680d16f553890deac6d72610e04f192c1964ec9b69cbe790ab/coverage-7.16.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:2270a794600b635ca9452ce4c32e2fe81a35f9caa17ffac0eba99f14f275bd4d", size = 224564, upload-time = "2026-09-13T19:11:45.071Z" }, + { url = "https://files.pythonhosted.org/packages/b5/e8/699e236d4cb97ec282b0655afc85acf12349e71a02fff0f1a7d0fb643079/coverage-7.16.1-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a4eff405b545dfcf79cf0d9d3ff750e5c5a887aa066114175193a81d249c5ee6", size = 265423, upload-time = "2026-09-13T19:11:47.666Z" }, + { url = "https://files.pythonhosted.org/packages/96/1b/6eaa21912863b3e3bf23cfe605fb62929bb1a41dc33d2bfa8e92000232bd/coverage-7.16.1-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ee1d5fc9e3bd6a217906929cc97880239a91d20dae7746f538eb0eefee705ab1", size = 268503, upload-time = "2026-09-13T19:11:50.12Z" }, + { url = "https://files.pythonhosted.org/packages/9f/ac/4eb46bffa98c28a80559a58c12f17e19308d52b31174af1bd49decf76606/coverage-7.16.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4ec944947de098ad5a1738413f9364689a57067ecbc328e9de37218aa1e5cc1", size = 271059, upload-time = "2026-09-13T19:11:52.363Z" }, + { url = "https://files.pythonhosted.org/packages/ed/d4/17a51ef1f6a084c9abbead522cfbee0fe9d29a593128781e724b7a0795b3/coverage-7.16.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3f73ee3956fde2d461c9e2955dd48166e4821fc8587d135e8780fb84da2a098b", size = 272039, upload-time = "2026-09-13T19:11:54.935Z" }, + { url = "https://files.pythonhosted.org/packages/4a/ff/9fdeba8b8aa0848030f45f869ddedc306795a8c6e53e901b8553afbf5415/coverage-7.16.1-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1ec9a4ee989c0d06ad95add0dbfdbb72b00ef53f43431ca0b612384e7878e5de", size = 265869, upload-time = "2026-09-13T19:11:57.423Z" }, + { url = "https://files.pythonhosted.org/packages/95/eb/ab3eb506b2e4dd278440fbbbc7ed18424a86d8a981db0b90fdba66f5d34d/coverage-7.16.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:7e5727b2508f817f3126d6c33327dda32fe69d15514badfcd61db8bc4209ecef", size = 268883, upload-time = "2026-09-13T19:11:59.71Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0c/f4edefdce33f01954a74237df5ee83ccef5dcd1165e04abf0adf47543fca/coverage-7.16.1-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:19a3ea2f364012ef06678118fffdc92442a16bef4a5c8ad4f4019dd8f9ac8876", size = 265359, upload-time = "2026-09-13T19:12:01.953Z" }, + { url = "https://files.pythonhosted.org/packages/df/86/ce5ed885fc7ce2adc9a5971134ace257d0f84f19c3d117da89c179b9662e/coverage-7.16.1-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:996c2b891b441ec2b39725ee3e8386e2f11b4894b92be225fdfd54a3eeada2c8", size = 270056, upload-time = "2026-09-13T19:12:04.46Z" }, + { url = "https://files.pythonhosted.org/packages/48/a1/5dbd5f95070cece25c6df9e6ea4ded2a87dc695ce82a49bcb2116452b342/coverage-7.16.1-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:a125fac1f6b1e88488d208a86b578e1790e3c4937f2e1568d23356141d236220", size = 265498, upload-time = "2026-09-13T19:12:06.811Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ff/254b26f3300f87c7c53ac97da41ae75f0e2ac066aa964bc073c0f3750b38/coverage-7.16.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b10095528b866d322d33d6bf1709b7f8cbf959f12e8cb2ba22fc59c8717866b0", size = 267459, upload-time = "2026-09-13T19:12:09.479Z" }, + { url = "https://files.pythonhosted.org/packages/61/20/bf9958f8ddbbf6a2d39da3d4009f33e0fcf19c2d2fd99715c6494cdc8e8c/coverage-7.16.1-cp315-cp315t-win32.whl", hash = "sha256:531d9be377fdcc05593b974656872eb82e808ebeb42a72515e3aaeb8bb7166f5", size = 226021, upload-time = "2026-09-13T19:12:11.933Z" }, + { url = "https://files.pythonhosted.org/packages/35/8f/12d46948704d9e437c8dca2718e5d54ecc2f85396b64b500c29d8dbe10db/coverage-7.16.1-cp315-cp315t-win_amd64.whl", hash = "sha256:46a88f51770df7c9bc376bd57d3f86cdc7624b8e16ac4b585a655c22b7a1b4db", size = 226853, upload-time = "2026-09-13T19:12:14.254Z" }, + { url = "https://files.pythonhosted.org/packages/a5/7f/1ca5fd0601054fce5a3539375b997e67683646e2bf62f60c41e70b529fcc/coverage-7.16.1-cp315-cp315t-win_arm64.whl", hash = "sha256:7580432cbe1e8b762660ae5806f04f869e1c02e519836a43f8094437e561e9f0", size = 226163, upload-time = "2026-09-13T19:12:16.589Z" }, + { url = "https://files.pythonhosted.org/packages/96/1a/d6d16babd0a5fe4c3fae40702158c570351694e74516d8d81b86c5637448/coverage-7.16.1-py3-none-any.whl", hash = "sha256:3d8bd4e58b6a5c2018d808f297905393c6c61da466a48c3f0596a76a4900ebe4", size = 215264, upload-time = "2026-09-13T19:12:18.895Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "idna" +version = "3.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/f7/abb373e5757eaec4b922b92f97ec8d6d7e057cf06778247604fbc4e7c3f3/idna-3.19.tar.gz", hash = "sha256:5e0811a4383b21dc5838069f801c4fb62113b7447663d2530d2bd6e77b49bf15", size = 215237, upload-time = "2026-08-18T05:14:24.27Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/57/b0/0e52c878c53f245edd3a11020f20979b3f490f245af532c7cae3027754b5/idna-3.19-py3-none-any.whl", hash = "sha256:815e7be7a7806d54abb586dc943addc79e8b2ee16915059658cbeff4b1b43bf4", size = 68550, upload-time = "2026-08-18T05:14:22.343Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "librt" +version = "0.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/36/9b/356320fbae2ac8467e21c5e73e1389c80468e4998c62cc7d3536cc51b614/librt-0.15.0.tar.gz", hash = "sha256:4e66cbe84437497d951b799d3e1551291b6fb3d643820a7014b3655d57a59162", size = 214338, upload-time = "2026-08-07T10:49:42.663Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/48/12/e2e9ca532cf5a0e08c9489826c4a35c6958c92ba0313fda70e8c6c3912be/librt-0.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e1a49adf16a7c9d9646816c2946135527197b6fcf4347c7b8b761cf1bfbf4489", size = 148673, upload-time = "2026-08-07T10:46:22.569Z" }, + { url = "https://files.pythonhosted.org/packages/6d/7c/02005e23478bd5950618d9712e0fd2b4c511657857f3efd8ba6a5feabcdd/librt-0.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:81a398f45b45a59200e13cd5ad1ae1d3f44334de98b148331afe2cdfee701c52", size = 153547, upload-time = "2026-08-07T10:46:23.931Z" }, + { url = "https://files.pythonhosted.org/packages/a0/90/d8848a735f5642077fc4b3b4bebcdb08edf10178e3add45597f5201a368f/librt-0.15.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4eafbaff06b9563f8b1c850621ce51605de05208e09d4d71ce490bc972b7b9e8", size = 494355, upload-time = "2026-08-07T10:46:25.122Z" }, + { url = "https://files.pythonhosted.org/packages/e1/0b/8604f41ea02feace490e9e405a338a15f9905369f55b239a9ce31c946f24/librt-0.15.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b0411b4066db926b80258c60dcb0e6db4c9cee312eab45b7e8866b17ddf9ada1", size = 485459, upload-time = "2026-08-07T10:46:26.447Z" }, + { url = "https://files.pythonhosted.org/packages/a0/ac/84153bda1ce0da609182527ab92b40d961809e544eefdc5a1c2422971416/librt-0.15.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:febb1ce6cac545a54e6b769982824e955a700fdd9fbf3a08a3d82c990968b57d", size = 498398, upload-time = "2026-08-07T10:46:27.701Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3a/5ca6cd282b2c244bec8ec84102e09773264e9c02891d56ab3a8f0e4d7083/librt-0.15.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b230acc1c3bfe2d6f2627ba2b95dc92e58aa494600e9722d0e6ccbc931e59702", size = 515474, upload-time = "2026-08-07T10:46:28.9Z" }, + { url = "https://files.pythonhosted.org/packages/73/d3/bd34110234779eb843c6ed66aba7c9b2091d3dd85989f1fb9922f564cb7a/librt-0.15.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6da110e5f314c19ab8478464d02ae18808ae73d522c15260fa4918acdcd64da9", size = 509484, upload-time = "2026-08-07T10:46:30.124Z" }, + { url = "https://files.pythonhosted.org/packages/1b/6c/43c3f7f071d71631a7daa3b835ef2168ea39f20692d81464d4e47fbaa6d6/librt-0.15.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:eab9208b00ca55bf75983ec99f7bf13acc746a36102e98953addaad7f7ea1e1b", size = 532534, upload-time = "2026-08-07T10:46:31.511Z" }, + { url = "https://files.pythonhosted.org/packages/c5/1c/b854adf036ea817c40408873a5b794d65a91d9f0f39826f2ad2a2d5d7f48/librt-0.15.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6c013cd3a1721e69e14380ada97eaa4b7b0cdf1c6b96fa765d4ea47c875088db", size = 537087, upload-time = "2026-08-07T10:46:32.734Z" }, + { url = "https://files.pythonhosted.org/packages/25/5c/c9a890e244e7dd725d3bd8b560e41f0aec787eaf343b46956a290ab7b841/librt-0.15.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:567b1c430f8bd560e689421468278ac5941bab4a05303b5d95b6ae10db03f451", size = 536575, upload-time = "2026-08-07T10:46:33.965Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c5/c8e70b60b704299555f55db468eb46b1c81bfc60201ffbfe20407d89870c/librt-0.15.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:29c4cab9df457b19672c39be7f384ebb2bc925c4e2684b8780c222b43eb36389", size = 517142, upload-time = "2026-08-07T10:46:35.577Z" }, + { url = "https://files.pythonhosted.org/packages/56/d1/767a90c41f5d381b3195bc88ac0ec4afda35777c9c781e1f9848fedd965e/librt-0.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bccbd8e5b0bffb7106cf18eb1baa3d7194b1cebb3b4b1cdbd4bdb19382a6ee6c", size = 558714, upload-time = "2026-08-07T10:46:36.829Z" }, + { url = "https://files.pythonhosted.org/packages/f9/b4/3c0624b8dc8301ab808f2b3a910995bcabe28df070fb9a0e5505ae997dae/librt-0.15.0-cp310-cp310-win32.whl", hash = "sha256:8ae493ed5f659a7761c43d42f183db514536073ded9bcf671d2d1df47e29a07e", size = 104426, upload-time = "2026-08-07T10:46:38.594Z" }, + { url = "https://files.pythonhosted.org/packages/31/98/e91c0382304bedb2db9c6801897319a9dcb68daac5e975819b562362f20d/librt-0.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:bc25fb356d0c7810bb49ff3df908ad1fda6995d660ab099ded69244ed7ab6053", size = 125057, upload-time = "2026-08-07T10:46:40.052Z" }, + { url = "https://files.pythonhosted.org/packages/59/52/06790ced2ac7117f890c21bda43c39c958ec82aa665c0718e821d33ff939/librt-0.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:823b92cf3c18ecd08afc70c42473888b41b6e8ef5046f3b82c05c154a2fa3d22", size = 148039, upload-time = "2026-08-07T10:46:41.165Z" }, + { url = "https://files.pythonhosted.org/packages/e7/1d/8e150b7fc449a1f33c8a760965cc1f43b14fc1577d9d0b50ab2701420e74/librt-0.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c70bc1b602cf59917e8f0c7a2cbc8bcc6fbc14d5486136b00707a79619121d63", size = 153067, upload-time = "2026-08-07T10:46:42.418Z" }, + { url = "https://files.pythonhosted.org/packages/51/87/a162bc5a66a35599dc619ecb215145f4de7d68e886b479b6d12593139f7c/librt-0.15.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:814ff83a25b5fce8b9c80c4dd803153fb5c5599fc74db9e022466938368957ef", size = 493087, upload-time = "2026-08-07T10:46:43.657Z" }, + { url = "https://files.pythonhosted.org/packages/e5/3a/aeea1fc620cf48060d3065b37614edbf97043c099d0f50782bc8ca61d897/librt-0.15.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:57f5eeb6ad4c180de583b1038e61fe5fbd9796bb69a8a1c1a0c7ddbec4c8c60f", size = 485608, upload-time = "2026-08-07T10:46:45.038Z" }, + { url = "https://files.pythonhosted.org/packages/52/ff/fe571ad416f0856fd0d5578ffc2e6dc531891e586e36b647bcf50569cab8/librt-0.15.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82909c8f7eb9952656b65d3147afde4cf8e6d5a991eebc86418b5e65843b0ab8", size = 498723, upload-time = "2026-08-07T10:46:46.35Z" }, + { url = "https://files.pythonhosted.org/packages/0f/e1/7a65eb5dedb1f00aebd948cdd8e17add48bf066cab3514e9daf84ab45a6c/librt-0.15.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f779070399f991400fc451719e0ea388eb7de313388bada2c127a35de05f798a", size = 516002, upload-time = "2026-08-07T10:46:47.599Z" }, + { url = "https://files.pythonhosted.org/packages/5f/45/59832b0ebfbd08c2742e6ece372ceb53f18bf1faef5d33c8daf3abebf749/librt-0.15.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bac89069bc496ebdf4f79ebb57bbd10d0b214c8454225deb672d91002bd17e18", size = 508607, upload-time = "2026-08-07T10:46:48.873Z" }, + { url = "https://files.pythonhosted.org/packages/ea/0d/37fa73f3b43ebd8259f91ae9102a15e5a54e65d581e48dea72df3e81d7a4/librt-0.15.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e0d00c708fb2f5822b152429b1ac80a58dbbbc3f6c232c4d13a3f7fcf2ea5b4c", size = 530422, upload-time = "2026-08-07T10:46:50.45Z" }, + { url = "https://files.pythonhosted.org/packages/26/02/e046c6fe7a5881ac34623242192f484426ba8a75595fd18f22c53a3f530f/librt-0.15.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6c6624fe268625869485553dd7cc1daf30d22558215bb2a4ff16f67a9801a31a", size = 534303, upload-time = "2026-08-07T10:46:51.693Z" }, + { url = "https://files.pythonhosted.org/packages/95/32/d5e6d861ab0366f3edf74f887ab0c9eb9f535aaf01d32b80b4f734daa179/librt-0.15.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f56b397858a23dacf35ede366ed2212fdc03a6a57a1ad36468ad6e9dc5fac091", size = 536084, upload-time = "2026-08-07T10:46:52.951Z" }, + { url = "https://files.pythonhosted.org/packages/2a/de/d69d725513fe53fc90c6d7a1f86e4428939bad2fb905b17fe4c18d413dde/librt-0.15.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4388184646efe2054911c5b00a1077d6d1ee86a95b7e8ba96dc7850a809f3f40", size = 514307, upload-time = "2026-08-07T10:46:54.194Z" }, + { url = "https://files.pythonhosted.org/packages/36/93/f8aded0d6682b4f25820fa86e0690f87f01df9fd7bd09ddb04d9167ad021/librt-0.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:97335f59082f9fe2ce6c2a9cc6433a0114bbb6cd4d5c09dd76c95c68b9f9a8b0", size = 557686, upload-time = "2026-08-07T10:46:55.443Z" }, + { url = "https://files.pythonhosted.org/packages/74/09/ffeb6bdeb6cd862b4272fddc8ad05f938dd25d020ed517e631813917d80a/librt-0.15.0-cp311-cp311-win32.whl", hash = "sha256:83380ffde38062a2e9bb55d83e74474f6614665528b98a6928720fc006dfffbb", size = 104917, upload-time = "2026-08-07T10:46:56.605Z" }, + { url = "https://files.pythonhosted.org/packages/96/28/7e2313a3ffbf0b4de7ba3da58a09e488507b4bd1ea2b5e69378354a23415/librt-0.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:f75720477ee05d509a310e856cacc8d909adc182f7b91193c207bcc26d7ee6db", size = 125886, upload-time = "2026-08-07T10:46:57.729Z" }, + { url = "https://files.pythonhosted.org/packages/39/9e/04b8c3cde014ef255ee785730425268354543acc38902093a40afa0dc164/librt-0.15.0-cp311-cp311-win_arm64.whl", hash = "sha256:256237037a3ab001ae8d9803b2d43562a4c3aa38739843694349e4d5ebb0fd56", size = 111885, upload-time = "2026-08-07T10:46:58.787Z" }, + { url = "https://files.pythonhosted.org/packages/ba/39/99c25030e782bdfb7a21be8c05254806a2e4bbb05c8d50c2a2130acbfa05/librt-0.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e87bc679f86a99aa3b26e3c78eeb821a247c9a28eae48eaafcc32c3bf4c3bb9e", size = 151021, upload-time = "2026-08-07T10:47:00.057Z" }, + { url = "https://files.pythonhosted.org/packages/14/43/f4b1bd1b2888798a1409808889a25ea1ba49eaabce7d681ed27734c2df9d/librt-0.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:71599e011ac880e8e45d46047d714871894c7d4ab6f25626f8d4f89da21f368d", size = 155267, upload-time = "2026-08-07T10:47:01.311Z" }, + { url = "https://files.pythonhosted.org/packages/0c/db/3ad9c965c72f1e1d6beeec44ec10a54e17be8ae042fbb4baade16cbadced/librt-0.15.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c802434092b769b1d613ed2e13fac15fbfce1934a74bd10283b03c0fae231cd1", size = 503136, upload-time = "2026-08-07T10:47:02.45Z" }, + { url = "https://files.pythonhosted.org/packages/4b/07/5888a6d76acd62ebce66c61b74d94e9370b9c32929f111e487bb6546f8ed/librt-0.15.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5500eeae393a184d14e1f35645962c27129d20c81afa4069e6ef826ebc2b3aaa", size = 496670, upload-time = "2026-08-07T10:47:03.675Z" }, + { url = "https://files.pythonhosted.org/packages/29/39/ab57cc2f5b276156da02bb7f5a8921bada1cb1993ffec99acf811c602c23/librt-0.15.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6ecfc32dfb46fb7b565bcd6abf9412acf978775a998273d22888a6d7953730dd", size = 513688, upload-time = "2026-08-07T10:47:04.981Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b9/bdbb0b648b5c2befb031f4c6f3b1dd857415e8fb492a25a3c764a6681e6c/librt-0.15.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cc46cfd15022e35084355478c9ac809d90b1152222706ac9a7655ec21df6fa", size = 531904, upload-time = "2026-08-07T10:47:06.211Z" }, + { url = "https://files.pythonhosted.org/packages/93/26/473c2e4b6c104e9e58e27ce95fc8005c8bd4fc36cae4f254371125a92db8/librt-0.15.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5f51401d102c885b9ca509e62c79b1dbff286e1b9b047fde6f763780789356d", size = 524427, upload-time = "2026-08-07T10:47:07.592Z" }, + { url = "https://files.pythonhosted.org/packages/26/60/03b3abb82b41714671b907bf6989b228e31e6a8af52dec82b5b0728dc250/librt-0.15.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cc30523e3f1a23fb7511cc659834a0d01a1042bb9de359bc1c131cc4ec6c9656", size = 543155, upload-time = "2026-08-07T10:47:08.866Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0e/9bb1f0a4affbd0a1888f4f79dc03ed2a299d9a2c26c59ab2a97dcbf11903/librt-0.15.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:59fe030d8ae4a57e3fb7756bf35a858de74e04066fc8555c53d0af979132af81", size = 546890, upload-time = "2026-08-07T10:47:10.327Z" }, + { url = "https://files.pythonhosted.org/packages/dc/84/6937a280d461f7de6e031ffb02edc2b7c3c90d49d630565ce8ff27cbc5f2/librt-0.15.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5a6526a2a956bbb1e4ae3568c82e650fc99119c66bb011ea60715744955a2b4d", size = 555163, upload-time = "2026-08-07T10:47:11.798Z" }, + { url = "https://files.pythonhosted.org/packages/bc/95/2a2853c1ee014bf102116e7f897a04beeaeb2461b45b79af98bdfb95f1ef/librt-0.15.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:85ea21ec6730194d67156b0e0b5430ccb1d61f8b8b907e39b37f9812b74a13f0", size = 535812, upload-time = "2026-08-07T10:47:13.279Z" }, + { url = "https://files.pythonhosted.org/packages/c9/4c/cf9601c1b4c5f09280acd5d83abdb2e68527a2be8257136eb42304218622/librt-0.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1e47b8ba865d7ede071a91a7163073bbaeb72541f1ef8a07d512c45c7b5007f2", size = 573688, upload-time = "2026-08-07T10:47:14.727Z" }, + { url = "https://files.pythonhosted.org/packages/47/6d/9ac7cbec46189a7625af4b5acbd25f10d827f4141b2002181848c8418923/librt-0.15.0-cp312-cp312-win32.whl", hash = "sha256:a5207ec414d1c4a2a7231b2086970dc036f94293cdf338190984958a013a42f1", size = 106138, upload-time = "2026-08-07T10:47:15.973Z" }, + { url = "https://files.pythonhosted.org/packages/38/d0/2ae99c83be86ce23f925ac1aeeedc777e97f427c4a8d190c70d0a16e9a87/librt-0.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:73b30cfa976659b3917c8f6153bdb0591c6a9ec6583599fd24a689b690622022", size = 126974, upload-time = "2026-08-07T10:47:17.049Z" }, + { url = "https://files.pythonhosted.org/packages/5d/ef/dd24f9635c730b86b87587967dda7516b1845e8b17684603d31607fed598/librt-0.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:a54cf9e0ef47b96af580849db5471142200568ce1e02cbf416addab551369570", size = 112292, upload-time = "2026-08-07T10:47:18.222Z" }, + { url = "https://files.pythonhosted.org/packages/e7/42/467b53a601b406ccd7b97c1fd54b59cb34f9185ad5ce7e9d5c3c4e8961c8/librt-0.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:db13ca398005abcbe538deda87b686d9bd08b7001cf40c4c06b444960ae10a26", size = 151029, upload-time = "2026-08-07T10:47:19.312Z" }, + { url = "https://files.pythonhosted.org/packages/3e/e6/36c2299b7a94b84fdd01220d8a777a71be5be0925bb0dbdf71c0a06a34d9/librt-0.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa1f1995789dca3698bc550aaceb09a51bd5df0a057ff84ff15296cd1975b801", size = 155194, upload-time = "2026-08-07T10:47:20.398Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b6/ed5071f9325845e670bd36012757419767fbf56af77ed483077b9e4db541/librt-0.15.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55456ea87d8df21808446d03817be2f65e20391c1c615d9187440dff28cd08dc", size = 502568, upload-time = "2026-08-07T10:47:21.652Z" }, + { url = "https://files.pythonhosted.org/packages/7f/81/6450c67c3615d87704bcbc21323fafc69c799b06a044c447529f725d4b01/librt-0.15.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5a86a5a08c2235316bdb359d5dbb6ce0abfca7fac06363103e2c5af571d92f95", size = 496153, upload-time = "2026-08-07T10:47:22.925Z" }, + { url = "https://files.pythonhosted.org/packages/e1/d6/5f52b722bc75076954b3bfd49be15ea362df4d580c6fb315d0f617100d30/librt-0.15.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e56b6a368529bed262da40ce13f8fef590db0479819cca84f16a1f01ac356d0b", size = 513336, upload-time = "2026-08-07T10:47:24.213Z" }, + { url = "https://files.pythonhosted.org/packages/8d/e2/c08fd1d36ce63ea5a12b85c5d37f4550b5f86a692167e41e5a74222607ae/librt-0.15.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:234d8d394721fa0d786af15ebf1f3fb7f3ed82fd1cd0cde45c2f247b5d4281d2", size = 531661, upload-time = "2026-08-07T10:47:25.507Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d8/d9482fcbeb177b9eb87bb3899eeb3b42be690313c652f9e146b1d0681fb2/librt-0.15.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d8363d7accb0286ac3a0e633f396e93800dafb8150494505daf9515bbda591f3", size = 524487, upload-time = "2026-08-07T10:47:26.79Z" }, + { url = "https://files.pythonhosted.org/packages/10/cc/075171517b41f861753034fbb151b42cfc83bcc853849f24f5e66fd60ccf/librt-0.15.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0f0ee3644d951f31055ad07d77d92520e84505dd7a432cc4cd501dd70ee06785", size = 543201, upload-time = "2026-08-07T10:47:27.999Z" }, + { url = "https://files.pythonhosted.org/packages/b0/03/42c2330f37eeb475b6affeedd06518f60035f323af3a839335e3fc9fef2d/librt-0.15.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2cfd1a81a648806e6a7717be4cc4d1bb392fa229752bf8444ba365e381e984d6", size = 546467, upload-time = "2026-08-07T10:47:29.396Z" }, + { url = "https://files.pythonhosted.org/packages/57/1e/1ad4c5638f7e64d8560328bd25c54b409a661bdb6ff254b38ff90744288d/librt-0.15.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a6cd22c9da0d866558e46a041f1cc0c2bbb26b61b137b2347fa834c332e1d101", size = 555139, upload-time = "2026-08-07T10:47:30.815Z" }, + { url = "https://files.pythonhosted.org/packages/49/41/39fa7d15db1204cd1cbe6514680fbdc243adf754a0885061308f43afc013/librt-0.15.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6d5225ef8801e4ea5e482fa9b5dfb891dd9ef6f6d870f1f25d449ca2c70ac218", size = 536050, upload-time = "2026-08-07T10:47:32.222Z" }, + { url = "https://files.pythonhosted.org/packages/1e/88/c6dcf0dd8e26dc0c9a499a2abab8646c86dcaf9ecea9524cb46d3686331a/librt-0.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d28a05796b99f749bf8794f17ba9ba1612d0076b802e9cfc62c554634e9ce3b", size = 573700, upload-time = "2026-08-07T10:47:33.527Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9b/ab54c71a7918a7c34fa5327fb61390a77446a07a146fbfb1165250a61035/librt-0.15.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:2067ff438048cead9d223ca5675bae2a25e520a7c3e6c1498bf9c6892d22caab", size = 82194, upload-time = "2026-08-07T10:47:34.835Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b2/4f9a243bb892395f3becb80789ade13771701091f9f07ab8230247953ba8/librt-0.15.0-cp313-cp313-win32.whl", hash = "sha256:1cd3b721f24c206398b9e26da3c3a9c011e6e89d06f318ba8ebefc30f1003890", size = 106231, upload-time = "2026-08-07T10:47:36.251Z" }, + { url = "https://files.pythonhosted.org/packages/bf/af/64aff4885a40b93132382f2c314647d722574605416504379184ef3045ea/librt-0.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:f395a4a9a03ac062dbe9a9f82e0c720502e590a38feee6a757bc82e9c63afbd8", size = 126996, upload-time = "2026-08-07T10:47:37.453Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/335bccf6c7cb9028cb0b54aead27d9ece3f01f83bc6baa2abace5da655c1/librt-0.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:0a15cb554761247d84a3ec0cbdf4078d70725384f0e4662c0fa3b26266eb60ad", size = 112188, upload-time = "2026-08-07T10:47:38.729Z" }, + { url = "https://files.pythonhosted.org/packages/a8/93/949053fb462eecc4a9a5ee770a81f4b40be7b79538b245545d4aebc6b58b/librt-0.15.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f5de7feedc56337a088eb15cd9fafa9938367362221d8cc62c642b7f94821993", size = 149833, upload-time = "2026-08-07T10:47:39.86Z" }, + { url = "https://files.pythonhosted.org/packages/61/ca/8281aa6cd560a3420e4497729f6b704b53be3eeaaef82d5aeadddaf7441f/librt-0.15.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c0eb900c0e91f4aebe680845242e614f1864edfd44106380d0752ac29522bf8", size = 154088, upload-time = "2026-08-07T10:47:41.065Z" }, + { url = "https://files.pythonhosted.org/packages/dd/02/1a1662dceaba6a086360891448d5ce9a7d3555976cae59a31a39d744b9c7/librt-0.15.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e8c9a650a188e38bac005048cbe6342e81407782944d01934540ab75e417df21", size = 494215, upload-time = "2026-08-07T10:47:42.388Z" }, + { url = "https://files.pythonhosted.org/packages/69/84/99211619dc656370a3740c33d2b0b6d5a3fb1e73689314f6ed477a397dc4/librt-0.15.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:92bfed8deec93df30286b9fe9e3b1dd17329cc076a192b4ee5ec223841d54953", size = 491173, upload-time = "2026-08-07T10:47:43.683Z" }, + { url = "https://files.pythonhosted.org/packages/d4/aa/5448d0b05f4579b635d3899176817ebf561af0e57bacd425b5b1887264c1/librt-0.15.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec4b19788f835711a2072f9dbe6b03b3bf32ed1f0fb30cf399bdd59d9f0c33fa", size = 505512, upload-time = "2026-08-07T10:47:45.314Z" }, + { url = "https://files.pythonhosted.org/packages/95/82/01940e40b83c43a546c4a3c896cf34ca272a9690899d55914e4827b3dcce/librt-0.15.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4c7bacb70930f3d0a56f4ecf1be474a1f0d941b01dd73b756f3c256d42cb879", size = 523073, upload-time = "2026-08-07T10:47:46.66Z" }, + { url = "https://files.pythonhosted.org/packages/88/fa/759c0030f3ee371439eb26de34fc745807caf0abb878af7af4b8b7c3dd3d/librt-0.15.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3e79f05e4a08b4d880342673312bbc895b56df7765605796f15902eb5367d3ae", size = 515080, upload-time = "2026-08-07T10:47:48.319Z" }, + { url = "https://files.pythonhosted.org/packages/0b/27/894e072228fcb159703c655da69f8cd10dbed489c36e3df7dd032a2483be/librt-0.15.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a417149c0cba4d50b61e992e5a15e69eaf96746609b461cc4ed168aeef6b79dd", size = 534164, upload-time = "2026-08-07T10:47:49.875Z" }, + { url = "https://files.pythonhosted.org/packages/98/a3/0078e91c1f36f8815db17827de15650b9a3fe56c55fbf998c854b34e40d3/librt-0.15.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:da7a94d6a3411f579d72aa3e3bc5fbca7ed4549f3dbd7e5de3aa567333374285", size = 540616, upload-time = "2026-08-07T10:47:51.408Z" }, + { url = "https://files.pythonhosted.org/packages/86/33/81a29b796dd52a45e9ef7974c7732926e8f10f15b8d2be505665979f896d/librt-0.15.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:856f743ae607f2c1380eccb566c0038a9fb3eabf0fc2be2704d76d9f73557239", size = 545890, upload-time = "2026-08-07T10:47:52.818Z" }, + { url = "https://files.pythonhosted.org/packages/05/82/8be1baa1350e5d30cfd70ae79d0a6f4dc5862ef47f7bb2808aabc9bb86e5/librt-0.15.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:779a6e7c894737e5983e7790a9c78c4000c30e23c9aada08081bdbea53b0fa60", size = 523287, upload-time = "2026-08-07T10:47:54.165Z" }, + { url = "https://files.pythonhosted.org/packages/c6/4f/d1be6a01a35c20ef734e0e44113f87d4af756a9354a89dcfbe3b4f8af5e1/librt-0.15.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:96bb17dbe8bab3c0954fbebfc69ed395599de75b6bbc35e3270a878e15d4dd65", size = 565868, upload-time = "2026-08-07T10:47:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/67/88/649cfa33f5825927b160610f670bdab012a64d627eddb94fa795ea4292fd/librt-0.15.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:7220697efaa6e5348fc3d18ee7f8563d4bfecd9872b37ffb915bfc1d08840622", size = 81619, upload-time = "2026-08-07T10:47:56.886Z" }, + { url = "https://files.pythonhosted.org/packages/22/31/8e88a8d5e48fc8d1a817787fb6811dfff6499acd6c8683dd83934aa6ede0/librt-0.15.0-cp314-cp314-win32.whl", hash = "sha256:f54598964d357b1c5ab77cf5d92f21e598fe0e23cdbe9618480807f81b4eba15", size = 100138, upload-time = "2026-08-07T10:47:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/80/92/20fd6c4b6a1b1a564b076d55cd3d427d8428217d7638dc25a654cc4791d4/librt-0.15.0-cp314-cp314-win_amd64.whl", hash = "sha256:3ff5893a2c23d886aa9ce786de5ac6ddc74aeeaf90743682b74d920e117d2e28", size = 121258, upload-time = "2026-08-07T10:47:59.564Z" }, + { url = "https://files.pythonhosted.org/packages/fc/28/6af430b44d9ebb897b865a3c363b6dcace51357be2347cc0f8f869656a86/librt-0.15.0-cp314-cp314-win_arm64.whl", hash = "sha256:3722a099730704c9a3d70c879fc0f51daec25fe5f1555672d97bc595abeafb95", size = 106467, upload-time = "2026-08-07T10:48:01.097Z" }, + { url = "https://files.pythonhosted.org/packages/7e/aa/b42bb798942ced219f6d63b27e07f91237887a8d0bd0921666db79a13790/librt-0.15.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:38c0c7d4b6fc06c3324b3f9162c8391bfc4fd9dde53afe1033ce7edb48d5a714", size = 159523, upload-time = "2026-08-07T10:48:02.442Z" }, + { url = "https://files.pythonhosted.org/packages/75/03/1b53cd4ef904e73b1d828a5f90143bf94a2967d7cfff0b9ccf93e12aa9b4/librt-0.15.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8b2fdd7ead3c995c37940a790690660d0ca006c302db26cc51933f6766866fc3", size = 161638, upload-time = "2026-08-07T10:48:03.725Z" }, + { url = "https://files.pythonhosted.org/packages/ac/c4/9f9c9fba097d49e9e694c2b4dc331df31884645ecbc58a93b4b5fc69d2c5/librt-0.15.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2fde98cf1fc4bac144ce23c2c4c017b924ba714509ea9334977b0b27050c837d", size = 701795, upload-time = "2026-08-07T10:48:05.135Z" }, + { url = "https://files.pythonhosted.org/packages/4c/05/0966840bda0380c8ae167b9043c6230202941cc90ea29c48e096964c765e/librt-0.15.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:e3b461183c5fa7681b48560f91515f53a953122fb30c71e07abc67d7ddf58c38", size = 682147, upload-time = "2026-08-07T10:48:06.555Z" }, + { url = "https://files.pythonhosted.org/packages/18/af/1c47ca573c30ea47d195aec26133af522fea1104afaace028d7b32247ea8/librt-0.15.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4bbcc257e3babea20a91715c361b24554ec4e8f51aa578568afc230799fe1a19", size = 696397, upload-time = "2026-08-07T10:48:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/2e/0f/1aed6223d4f9f9d1171a8596ff100ea4c3f7699fea7a4ba657c3e60daa6c/librt-0.15.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b845b8d48088fad0cadc84be4b8fda63203be7e9237b71015b3925443c1f35ab", size = 722542, upload-time = "2026-08-07T10:48:09.569Z" }, + { url = "https://files.pythonhosted.org/packages/c6/22/9e3a929aea456c97d69e6ef3884efea56d4807f97399471cc946baebd8af/librt-0.15.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b30e600e8f337b9bd7f39b86d9fdfedc73cc46e3d0f745931a23a234220bb7e2", size = 729709, upload-time = "2026-08-07T10:48:11.129Z" }, + { url = "https://files.pythonhosted.org/packages/e9/1b/c327ef6018e3a9ca0b8e7c5eddeeb331ba8f9b76c24e126d37d0f6d62faf/librt-0.15.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:64b0c8c35aa4c4ed79896359f3e0b285cbe4e610042106500da4811c322cc108", size = 752891, upload-time = "2026-08-07T10:48:12.558Z" }, + { url = "https://files.pythonhosted.org/packages/d7/d1/d5f1ea02c56930087009e39db9b70660a663e76c730b27b925d786718457/librt-0.15.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0da0d94cb802f32a0524653e7201f2cef72d5f700a5407678f5290483d4fcd08", size = 745301, upload-time = "2026-08-07T10:48:14.55Z" }, + { url = "https://files.pythonhosted.org/packages/d9/3c/5f7c585d15ebb2250c73e7c0ee4e9e47be72c65d520c07ddbcdc62037674/librt-0.15.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:4a6369168d371207339b1e50d4532b06a7121586141f82599505a3f315751d47", size = 747921, upload-time = "2026-08-07T10:48:16.453Z" }, + { url = "https://files.pythonhosted.org/packages/7f/52/1443a446486eba966bcbca1696b472e4f210320ec42f490a47f48fbf0fdc/librt-0.15.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c434e072557ade9cbc642d052c89d031efe47d5c9614523619d0d74a02378e81", size = 727561, upload-time = "2026-08-07T10:48:18.089Z" }, + { url = "https://files.pythonhosted.org/packages/79/91/2270a9380f11725cf83ce1925a5e32dd1dde2be9bba597f25c10a38644e7/librt-0.15.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7eec6a42018bc1d45763b1c162d3d2bf7c3b9a1b0ed30d3e91dcba390efefcc", size = 774417, upload-time = "2026-08-07T10:48:19.611Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/f4b1548d4f5b99186737fe27aec238e9823e8d5d23bf4df007c030689dc5/librt-0.15.0-cp314-cp314t-win32.whl", hash = "sha256:6912fa5e635d74529ac7cdb1bdf6ca3af4453da8d1edbe0110ee1cb4ad407ebf", size = 104381, upload-time = "2026-08-07T10:48:21.048Z" }, + { url = "https://files.pythonhosted.org/packages/80/b6/134afad262def1de04c0843c376d02135f1168af43f22e09a52bd8394727/librt-0.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8e11699ed745931c395acd3621b07062e0f840efa6935aad87a64ed0995f0915", size = 127034, upload-time = "2026-08-07T10:48:22.561Z" }, + { url = "https://files.pythonhosted.org/packages/99/5f/1b6846b20572bd699c9e9ec321a5f781845bee477df2aa2a43b28bc40119/librt-0.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5d2a91724463bfed4f573cd7a9fdc856d2e230d0c0e5a61416a93481dccd8605", size = 110827, upload-time = "2026-08-07T10:48:23.804Z" }, + { url = "https://files.pythonhosted.org/packages/c6/44/4de9f4ddadb009a55c7758eb5736d62534a7daaf27bd71bc50e64b606b06/librt-0.15.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:8443e38dcfcfdbcf5add5118c623efd788d65ac2e25756d6251a54a06a4d0aca", size = 149843, upload-time = "2026-08-07T10:48:25.148Z" }, + { url = "https://files.pythonhosted.org/packages/1f/eb/5d9ab71e30119c44094e0275f38b47dd327aea0f843a080396677029d508/librt-0.15.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6d15a29033c57490cfe2069097c6fc4049e4e65ffbb749be7dc453b7c4c68965", size = 154510, upload-time = "2026-08-07T10:48:26.485Z" }, + { url = "https://files.pythonhosted.org/packages/d0/9c/8505d1b8f5e8c19587bd03f7429993b3e9ce5c06819d856bfb11d919374c/librt-0.15.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d2c05c729b589e734c09578bf5964be48a911765484840d017bbc84f49d4c4ad", size = 497543, upload-time = "2026-08-07T10:48:28.045Z" }, + { url = "https://files.pythonhosted.org/packages/1d/9a/3a8390775cb095765aded027ac9c63e7c8ea74e731498607544c6505de0e/librt-0.15.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:fa60887537e1d0cd2d9982269d33a709bf54b195cd2b9364fc0a758022af5bd9", size = 480452, upload-time = "2026-08-07T10:48:29.531Z" }, + { url = "https://files.pythonhosted.org/packages/e7/40/258a4a7117ee915d66de5cd9b8ade65a440993161107ce3a686f1859955c/librt-0.15.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d8bc24219b24c0af375718942ab75e3544b2763085f40f965be4326734ae8328", size = 507768, upload-time = "2026-08-07T10:48:31.007Z" }, + { url = "https://files.pythonhosted.org/packages/6b/c6/2f4dd296c97a0b85b98894519b279408ec9dd602d4f692b1ea0e25dee670/librt-0.15.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:86a21a7bd3fe3a419512ef424cc1c020f6771d0b29cfddff36d1635a855e63f0", size = 525122, upload-time = "2026-08-07T10:48:32.7Z" }, + { url = "https://files.pythonhosted.org/packages/49/dd/29eab42be13b2bf0ea8cb227135a45d44693e30a7e8b92871981ff56b82b/librt-0.15.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dbab647e88d90b3167b91efe7091e248653688ed4337e4f90907a722c7361bb9", size = 520371, upload-time = "2026-08-07T10:48:34.294Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/4bad71adeca8fe208b775c2a35417fa5a2584c8f4791daaf89a89450fea1/librt-0.15.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:d8edcf6f550e918dca779c069b9e156385c60b406f99fc7641f32c52f7193659", size = 537258, upload-time = "2026-08-07T10:48:35.88Z" }, + { url = "https://files.pythonhosted.org/packages/4c/63/59dba6143fdcc7240c54458b629f3250000a61b8945890fc9efd451b19c5/librt-0.15.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:8b62076030baa2d8b1501a46bf0e19c27a489aa90671c55665bff7887f7660b0", size = 527432, upload-time = "2026-08-07T10:48:37.466Z" }, + { url = "https://files.pythonhosted.org/packages/ec/21/21a24c6a2327d8362580efebe77286bf47b0f4062ec5ea41766e609d3c7d/librt-0.15.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:d00d20d1818e82a07a0ee0aa89a98b17ed7916b92441090b683719cb20a59b6d", size = 548108, upload-time = "2026-08-07T10:48:39.384Z" }, + { url = "https://files.pythonhosted.org/packages/5a/6d/fc68c89a7971418b41f9a873623ff935cb864097544c6a2f8ce491c8ef5d/librt-0.15.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:4e6ee93fc3cf848dcbf0cce2eca73d8e7dcd0cc2b6df3a529d57750b30a4c55c", size = 529681, upload-time = "2026-08-07T10:48:41.392Z" }, + { url = "https://files.pythonhosted.org/packages/65/7e/c2d98766124400d722063a630b0fde38a9fc768705d37eecca15c47dc192/librt-0.15.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:32896a0af72508ea979e0acb4e4c04cbeeae04938167950d535c83c45597167d", size = 567736, upload-time = "2026-08-07T10:48:43.124Z" }, + { url = "https://files.pythonhosted.org/packages/55/6c/f8c34a95e3a515c6e1c192b89511e7253c89a7760c6b500d57ffdb8d2dc8/librt-0.15.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:ec3ba415afaf951f6951b1dd16d3c8e4f540065fc382d7e70b823a79567ca374", size = 81673, upload-time = "2026-08-07T10:48:44.645Z" }, + { url = "https://files.pythonhosted.org/packages/c9/9e/e23fa8e78679ec45728188650b39e8ff476c83b691c96f749217df3b1b7c/librt-0.15.0-cp315-cp315-win32.whl", hash = "sha256:d2813ba2503764f0450680c533d13df7cff9b49df1411062eded5f67db4195b9", size = 100081, upload-time = "2026-08-07T10:48:46.171Z" }, + { url = "https://files.pythonhosted.org/packages/e1/dc/3eb4c5e297343f0620a55532cd7c8d764d3001fa2159212dadf480464827/librt-0.15.0-cp315-cp315-win_amd64.whl", hash = "sha256:b87d67e33afaf265262f2a66db578284b88ee2e6fcd224579cb5c15518677ad8", size = 121228, upload-time = "2026-08-07T10:48:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/97/70/43abce19f04e49762f8ec834c8fafee13cc40fd6b94a72a24e534febfcd0/librt-0.15.0-cp315-cp315-win_arm64.whl", hash = "sha256:713bd7df21170b982e729e46870f31d6b437bd1a9b4648cffb529bd3c2ec5c4b", size = 106487, upload-time = "2026-08-07T10:48:49.095Z" }, + { url = "https://files.pythonhosted.org/packages/de/15/83f2deddb9368b8951ec8c9477269b5b9b8bd9bbf15e57402d0f38817dca/librt-0.15.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3de789c82752730f94782a5ee518baf9c05edf85733aeaf73bb6e518755cdf54", size = 159448, upload-time = "2026-08-07T10:48:50.649Z" }, + { url = "https://files.pythonhosted.org/packages/06/bf/043097353f9b3c73b583d07f6b8e552795463f4bfc8caf85e42eee50c26a/librt-0.15.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:e0b5deec9a8664eb722c797241970fd4aa1894d25fda36a1ddac0f7407606bd6", size = 161686, upload-time = "2026-08-07T10:48:52.174Z" }, + { url = "https://files.pythonhosted.org/packages/f4/2a/8ae77f9719d42ce71cd708560a3557b38ac3c17a0383e57f87084de45bbe/librt-0.15.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5563302a8359bc2295bb7084d1a8ed1519df96afb30eb2aa4e0bff7b54228988", size = 710668, upload-time = "2026-08-07T10:48:53.782Z" }, + { url = "https://files.pythonhosted.org/packages/61/34/c0436ea134deb9a0d6da80a396a2739a81cb31e0418f7227239e23140898/librt-0.15.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:22d6263b9d39d7bbb286fa791945646e3218f1be2d693e36fb630f1d0e59cd13", size = 679396, upload-time = "2026-08-07T10:48:55.645Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/001e0d99aa9250d5cd5715a9081291a20656083459f9019cda15255329e1/librt-0.15.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:39ffd14646190c454f0d86e0d256b33f00a87a26ab410e619773b841d0e41416", size = 704313, upload-time = "2026-08-07T10:48:57.46Z" }, + { url = "https://files.pythonhosted.org/packages/2d/53/b34fa9d0ff00f136f4d58ebb4c411ff634baed1eb412bb602a2bc8dcafcb/librt-0.15.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47318cd3a61401452de11282242937e3e057c4fd3dbaf601e269d0928a06c0a", size = 729847, upload-time = "2026-08-07T10:48:59.231Z" }, + { url = "https://files.pythonhosted.org/packages/86/ac/fa4d7a424665040e95baf480a6d523446057684b6758624c85338e8a23b2/librt-0.15.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a56a1d4f859a82ca5b99fc4b82c9b027b15e3c455c5cd99e7d0719f27bb20b6c", size = 742736, upload-time = "2026-08-07T10:49:01.151Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f1/e17a9bb5de6fb8c3186ed1a7d68d21618b027ac2d3633e03d3b6109c67ae/librt-0.15.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:077471b3182db4e17c36ae91555f36a4d2c00080b267f749bcad34a478a9a302", size = 763454, upload-time = "2026-08-07T10:49:03.039Z" }, + { url = "https://files.pythonhosted.org/packages/1d/ec/ecd02cd30935b931b9cdbfed6ab5a099c51b280b4e7baa274da80978ed27/librt-0.15.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:411ca4d1b905b860ceba7570dd6717a71dedaddcc4b0f77ece710aa41ee11f8d", size = 743296, upload-time = "2026-08-07T10:49:04.941Z" }, + { url = "https://files.pythonhosted.org/packages/e6/b5/b3c2b8353ce820a4854f78d19321344242f89fa71c975b71132ba9bf242a/librt-0.15.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1256589e0b0adb31751d685a68bce29d73407ddf4ef05d4188f49d5dcf9566d9", size = 756217, upload-time = "2026-08-07T10:49:06.825Z" }, + { url = "https://files.pythonhosted.org/packages/3c/52/6cc22542ba59146b05cca2a656f9ff8bb67e38e63d12c3b0cc183d837bf1/librt-0.15.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:f42b74a53e5f26a0ba0007411a7455b66c67ce4022a39cc1f56fc4efd65bcbab", size = 741934, upload-time = "2026-08-07T10:49:08.839Z" }, + { url = "https://files.pythonhosted.org/packages/40/32/a04b72b1aa86e3be23b2ecff8c1aad2dcc955bd3956d6d26e7e34267e57a/librt-0.15.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:291bf73caf78b9e88d6fae9bfd693207ff7d832e2fdbe2cf8e746bc13f5f892b", size = 783763, upload-time = "2026-08-07T10:49:10.661Z" }, + { url = "https://files.pythonhosted.org/packages/6c/f0/89eb11dffbe9279ff37144dec786927314502ae0b114f1449dc78c458aab/librt-0.15.0-cp315-cp315t-win32.whl", hash = "sha256:c16d15ee371643ab48dc8248a3e680ebbeca573a13af2c3dd0c985b142d77162", size = 104313, upload-time = "2026-08-07T10:49:12.305Z" }, + { url = "https://files.pythonhosted.org/packages/6d/4a/1f1978c200f563beda63c36adff2d65bbecb81e365e8e69e572f5f70fbc6/librt-0.15.0-cp315-cp315t-win_amd64.whl", hash = "sha256:dbd605739f228912dc49027cb764456b9757750bdc2b6b7773164db7096c6fd1", size = 126889, upload-time = "2026-08-07T10:49:13.881Z" }, + { url = "https://files.pythonhosted.org/packages/38/a6/800800bfed7b1fb10fc3f3d557785c3854e80d3f7a9800d784b176a1fc2d/librt-0.15.0-cp315-cp315t-win_arm64.whl", hash = "sha256:84d244b00604d17df3fc7736c327892d6bba66181254aa4087be807b6c342bdc", size = 110700, upload-time = "2026-08-07T10:49:15.499Z" }, +] + +[[package]] +name = "mintlayer" +version = "0.1.0" +source = { editable = "." } +dependencies = [ + { name = "requests" }, + { name = "wasmtime" }, +] + +[package.dev-dependencies] +dev = [ + { name = "mypy" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "requests", specifier = ">=2.32.4" }, + { name = "wasmtime", specifier = ">=25.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "mypy", specifier = ">=1.11" }, + { name = "pytest", specifier = ">=8.0" }, + { name = "pytest-cov", specifier = ">=7.1.0" }, + { name = "ruff", specifier = ">=0.6" }, +] + +[[package]] +name = "mypy" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ast-serialize" }, + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/82/6a/878cc1097d4035f82bd516658d0c528d2a9955bc7b363afcbd0b07fea11b/mypy-2.3.1.tar.gz", hash = "sha256:47c1b1207258513a9d93495f69c8be9de73916186f0e52703e8c461b7a623419", size = 3992554, upload-time = "2026-08-15T03:03:38.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/b9/de8f67e12d721cdcc8ba6cfc440b989a4ba4dfabe4402ae94dfdd8bb30a4/mypy-2.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:57a936373fc690c43a8cd7e7e12a35148e4ec5aa7698ad7fc0a9f918bdc5be41", size = 14015541, upload-time = "2026-08-15T03:01:53.104Z" }, + { url = "https://files.pythonhosted.org/packages/f1/8a/9e746ab012c67ed8ea3232a613716c306ee8c0b5682c80d8103b4f04568e/mypy-2.3.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d00d769056bde2f4e69c175071eba45cfb44fa1ed92bdfbfe64a93e0543b0cf0", size = 14248142, upload-time = "2026-08-15T03:02:43.201Z" }, + { url = "https://files.pythonhosted.org/packages/f7/5c/c99ff2d8d0e2c53393e32dfe22d9aa43a5d959d30db46c786dafd24527d3/mypy-2.3.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2166b29228835e1f88ff411e96639e6ca3c7fdde84b62ec211f70f86b4051167", size = 15193309, upload-time = "2026-08-15T03:01:28.714Z" }, + { url = "https://files.pythonhosted.org/packages/64/39/124638f745243faae1ff4b37d5426fe41c0f0454535edc82fe8102b56a3c/mypy-2.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:83d36c2924df7426333abe7faf4724a7e1aab0d9fd41625e81b4683034b80c13", size = 15498246, upload-time = "2026-08-15T03:02:46.29Z" }, + { url = "https://files.pythonhosted.org/packages/b2/83/31c0781e243836505c0fb5f4e865487d6df1023e4ad959f4ebd4b84a0226/mypy-2.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:f12fdb70459d0060dea40b29e52163a961b156106d68d57882a6a9f648983a53", size = 11155028, upload-time = "2026-08-15T03:01:39.08Z" }, + { url = "https://files.pythonhosted.org/packages/a0/ab/bc2eb0129e72d7d7d93d5e981a78084a9abefda7efa732a7e02f97d6e27d/mypy-2.3.1-cp310-cp310-win_arm64.whl", hash = "sha256:e099200a1b1b1223a4951f0a90cbff1b8c91b250ba599dab1f7217a628144d90", size = 10151438, upload-time = "2026-08-15T03:02:19.04Z" }, + { url = "https://files.pythonhosted.org/packages/a4/be/c624d4241484f37dc62839e177ab607a9b8b3e96f0866544ca99e8e41d51/mypy-2.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:94f04929f1c44c35fb0061e912087edaf504acede963a4a7d00680bd089d8531", size = 13936739, upload-time = "2026-08-15T03:03:26.475Z" }, + { url = "https://files.pythonhosted.org/packages/53/84/e3cf72f90dce5960871c82551c8fba6da05fc1018f79be41c047bd126bdd/mypy-2.3.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f5d716048611e85ca9eefb2e1baa5d73ede389b5820ded260ea27c757d667af8", size = 14166460, upload-time = "2026-08-15T03:01:50.565Z" }, + { url = "https://files.pythonhosted.org/packages/4a/ff/6b97d58aa0f79a5ab9b472db1f6d6df1b11a51d74d0c08ab3760d3a613ba/mypy-2.3.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b091a455111214cb5c9d54a57b9618e9a49f9fe2a42e4e1ac86e9d104ed96ce8", size = 15100476, upload-time = "2026-08-15T03:03:12.079Z" }, + { url = "https://files.pythonhosted.org/packages/da/f0/cbb4b7d2ae3ac635f6b4f2d9b04070b8a92edf50da599d3b39e5ed109001/mypy-2.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:df12e20c9efd614738c71b390007ecd0181125afc4ccafca04d78a1d2eed2c01", size = 15347826, upload-time = "2026-08-15T03:03:02.856Z" }, + { url = "https://files.pythonhosted.org/packages/5f/10/91dcdc6f8d43fc08e6a06ab1f9732f3abaaf835ac1b2e67b9dff56910855/mypy-2.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:52eaf3a155f35cf80b40220288c861eb45f14a2340c1f6cbfbdb0feff32879d1", size = 11142615, upload-time = "2026-08-15T03:03:36.316Z" }, + { url = "https://files.pythonhosted.org/packages/3d/8a/28d54535bf4b9aa43b2d8918c2ef660378b9f66b23d78dcee052744ae622/mypy-2.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:9b4eacbee8a69836c06eff6d0dd4e134a07c2b047755b30c08625fe214f322c6", size = 10141145, upload-time = "2026-08-15T03:03:07.406Z" }, + { url = "https://files.pythonhosted.org/packages/85/da/d6effc4f808a842d91edc22535dc9e799d2ff6e91449168b7f47a0771f54/mypy-2.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a32bbbb940af990d3be0b8af321c7b6815bb1b3b48142fe7459b9cc5f58959ff", size = 14047547, upload-time = "2026-08-15T03:02:57.707Z" }, + { url = "https://files.pythonhosted.org/packages/e4/e6/478229701dab76f26485fc8ff5d6f241f393da22447400bbc56f6946aebe/mypy-2.3.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff715e45b2231a8e85de1d163d1b42791e4d7aab8f5145f85fee1b710b735aff", size = 14216515, upload-time = "2026-08-15T03:01:26.496Z" }, + { url = "https://files.pythonhosted.org/packages/8d/fe/7c42327a3b21e84681f691982cbfe43f334a3685f3b683b72c376476c4fa/mypy-2.3.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:858fc57d3d91fa728e33e7ad71def60fc6272694607b306cd3292db53ae39080", size = 15307789, upload-time = "2026-08-15T03:03:31.62Z" }, + { url = "https://files.pythonhosted.org/packages/59/f4/7e597edbe01b5a56fa958ce541302dcaabfed979966f1dffedbea0ea0fc2/mypy-2.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:851833db876e7b650f93719c74b7879a08e338979c96054fdfc3bfd90a486355", size = 15548831, upload-time = "2026-08-15T03:03:15.55Z" }, + { url = "https://files.pythonhosted.org/packages/a3/52/cb31e084bc0314a1e384bdd677a4b80e55af04ccac077545e2238b9d320a/mypy-2.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:4c5095a327483591c94e0c8d3ef9e50d4ab1369b541eae007c1f23bc2a41f6bb", size = 11226359, upload-time = "2026-08-15T03:03:29.002Z" }, + { url = "https://files.pythonhosted.org/packages/7a/47/88fcf6217b43fa2da81a8c2611370af18141536a4f0294bbf98b457d456d/mypy-2.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bbfe022634a2a195406bd469e888d2eaf193b02ba7e607391cd7640374aaae3b", size = 10214707, upload-time = "2026-08-15T03:02:48.807Z" }, + { url = "https://files.pythonhosted.org/packages/de/cf/862010ee800ca9c2bd0c4c0dacf0f092e5411824a09b8f97ad4be8fe250e/mypy-2.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:114dff494000f18bd10d5d95d84b8567b26da60279ecbe838131841df20e635d", size = 13964542, upload-time = "2026-08-15T03:02:21.43Z" }, + { url = "https://files.pythonhosted.org/packages/75/5a/3f3a2107b41e3e92e617e25daaee121413b91e9784bea733131ed4fecc5d/mypy-2.3.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8637731bb5eee3671eb2c3200827aa3564ed8a9309ecee4d1afe77e6d031bdb", size = 14168922, upload-time = "2026-08-15T03:03:00.351Z" }, + { url = "https://files.pythonhosted.org/packages/8b/41/04dc4fe7e63d7820fa4eff272e95157d30cbea921388f3ab3fe77794cd0b/mypy-2.3.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c80fbc405ed8020f5ff3802dc18cf060197bcdd3fbdd6a26ef2fd34dfdd5226", size = 15244791, upload-time = "2026-08-15T03:02:31.089Z" }, + { url = "https://files.pythonhosted.org/packages/96/fc/c3053b26b9054949285aa868cb6af8c10e7591541cacd79c5dcc06a1fcf9/mypy-2.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:84081f538ce27375045c02e3d7f81bd11d853400621ae245d87ce7b6c420ec74", size = 15501627, upload-time = "2026-08-15T03:03:34.128Z" }, + { url = "https://files.pythonhosted.org/packages/70/4e/d77daab008bbc4e5001374d7928f4a260d28f0e6747af444fc4763f7a310/mypy-2.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:e9144ac16fde007096f9563eb2041b4433c2d705c4218edeb79e7e9d01035ee6", size = 11243961, upload-time = "2026-08-15T03:02:11.952Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f8/7eb68c136e4abd30569fe31ef2bfcb7eceae9952cab80017c04cd09f5d0c/mypy-2.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:77ad9529e67dca28e511f5cd5671436584ce91f6d3bac159a353158187b986ac", size = 10213219, upload-time = "2026-08-15T03:02:26.361Z" }, + { url = "https://files.pythonhosted.org/packages/be/c4/42a49d44aeff804edf1b19acce0b49e8bd1a9c57dee9605dd8d980aa43d7/mypy-2.3.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:192abaedf75da1bc0b1cef104927e70ec49c1ef0031cc4825c7ee10a438ed24d", size = 13986778, upload-time = "2026-08-15T03:01:33.69Z" }, + { url = "https://files.pythonhosted.org/packages/45/13/9331fd2dfed7194d66c5304072894a8be3e51e9deda6863c1eceaa35a43d/mypy-2.3.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf678dffd16efcda2c15cbd30e9ecc0081388e29ea23687a88e686ed92638dc3", size = 14188467, upload-time = "2026-08-15T03:02:40.554Z" }, + { url = "https://files.pythonhosted.org/packages/78/f7/f4a34edab45667c5465855dc585a20e87978ffa8aee711445b7239d120c6/mypy-2.3.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e036f06b41630f4c8a1d48f9ac6aa26acc65f8be089973f5519da643318f03f", size = 15225538, upload-time = "2026-08-15T03:03:09.761Z" }, + { url = "https://files.pythonhosted.org/packages/40/05/534b3590757bd05794f73e07f6666c2a77b8597ffed795c94ce570096aa0/mypy-2.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71af9c8a894e862b58e92abb08e53b05a384a1e5e5d6dc7cda59126211a53d82", size = 15480805, upload-time = "2026-08-15T03:01:41.134Z" }, + { url = "https://files.pythonhosted.org/packages/55/da/bdfba852e2562f599624af5bb7d29e36b0b4f526f2b8bac85efe0dd1803d/mypy-2.3.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3c80cd23d85368bdd9f37d5231dfd97d35bcbf5bf41af96ef3a9b078ad1957f9", size = 7761712, upload-time = "2026-08-15T03:02:36.008Z" }, + { url = "https://files.pythonhosted.org/packages/98/31/60fc64a74cdba4f2a5d642d32317993e479163e1ac7d91b695e5d15e2264/mypy-2.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:4956f34d145e145562a0a0bf367f642bbc85c04ec2baf47ae015947c3169a85d", size = 11423968, upload-time = "2026-08-15T03:02:06.931Z" }, + { url = "https://files.pythonhosted.org/packages/a9/23/eb5950b24cd26ba3b78f87707a275568d633c77dae8e61c9661be6055ca6/mypy-2.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:cfb12e360242d23d91f5e978d94f58ea66acf5804c4fb6f2f794a20d4cb1b595", size = 10399323, upload-time = "2026-08-15T03:02:33.671Z" }, + { url = "https://files.pythonhosted.org/packages/82/c7/f80f4e46c0b9a00eb5f78a79d49dda8bdf56a5230f7257fb33e76be04da7/mypy-2.3.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e5f1c50bb05b64e2026b52867e8d21106f01313c744a2c4ecc34c90d12e8d6e2", size = 15121308, upload-time = "2026-08-15T03:01:46.053Z" }, + { url = "https://files.pythonhosted.org/packages/5d/74/9b04f17c7074cc5188f02fb63a2ca1d43fedf479e84fe3091c39061a1d7f/mypy-2.3.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:667196b352f4cf304ded4c10f90cfc179263a1acfb3cdcfa984bdfd340d498bc", size = 15536590, upload-time = "2026-08-15T03:01:35.941Z" }, + { url = "https://files.pythonhosted.org/packages/26/04/c837ef6208e567774e2ed1f863f8ba6ec4817b1b6dd426315e5d559b6ec9/mypy-2.3.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b9c53e395c12cad2c6d4b67d5da7c6057638a132d85c08b73646b18f802a0045", size = 16791074, upload-time = "2026-08-15T03:01:31.073Z" }, + { url = "https://files.pythonhosted.org/packages/37/68/48730230afa45192d5bd429a6a2ff24a6f8dedda90fdf2b221792b54518f/mypy-2.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:18162b128c3f9c703cd35f5537446900b0d21a2549aa7a95d21380d2ef643fb0", size = 17069183, upload-time = "2026-08-15T03:02:28.566Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ea/ca23fc9c20eeda09a15c9cbcf50015d0e73f409f6ead059e42aa69a608ff/mypy-2.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:30c0477d4aab7b7f39c8397dc877f2c96b9fe5588ec379f372c56eb63d599f63", size = 12154679, upload-time = "2026-08-15T03:02:04.809Z" }, + { url = "https://files.pythonhosted.org/packages/3b/67/8d982126034990869466f73b8db80dcb2234a7ac39b4dad093e047a79835/mypy-2.3.1-cp314-cp314t-win_arm64.whl", hash = "sha256:6941ab3619377bc3f32ca02876b07d27f216f5201604b664d3937ea0fdd23bb4", size = 10969159, upload-time = "2026-08-15T03:02:38.152Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f7/41e7f2d8117fbc7a7587286162ffe2f688984b69c46ed63cf5f2e4fc3bae/mypy-2.3.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6f041a6de52c9217ca125e78ba0a335cb7fd98a1c0580978e49ab2b126f70b57", size = 13990694, upload-time = "2026-08-15T03:03:21.919Z" }, + { url = "https://files.pythonhosted.org/packages/06/85/8f665811a0c8f3bf6fa1d9acd665ec2d97a2bcc453ae68dcd92340941cd6/mypy-2.3.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5159ae60f5dbc3a498af5ba8365505808ac8031bc63f9e00304ad545d40bdd9b", size = 14203518, upload-time = "2026-08-15T03:01:48.455Z" }, + { url = "https://files.pythonhosted.org/packages/2d/82/91b866c8546b120bff83b73a439d90d2d63ef3aff113599e6b8e4d566848/mypy-2.3.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47a8a7a0a7f6f6e63995c0ac36fa0c07b127413fdc81f0439b7f3dccafd33561", size = 15220224, upload-time = "2026-08-15T03:01:23.577Z" }, + { url = "https://files.pythonhosted.org/packages/c8/78/c226c99208ee40de7c768369fa533f933afa003dfdc606ff021450724e91/mypy-2.3.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2329c0501293d4e1f33bc15d04d6304d65a1cdda967ee93a05c1e681a3923133", size = 15501512, upload-time = "2026-08-15T03:02:09.453Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e7/7cfb3f106c393979f4cc37ad6c0586044d50401e3c35b0c003e4f3ba6bc9/mypy-2.3.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:bb26deed807bdb0457cf3e3f1cd7c4a1cf9d66864eaf1b4a61e06805d4c6b1f9", size = 7761913, upload-time = "2026-08-15T03:01:55.65Z" }, + { url = "https://files.pythonhosted.org/packages/99/3c/52affefa273b97939a1f474ae4a349c8718635c15b941112dfab4291b0c1/mypy-2.3.1-cp315-cp315-win_amd64.whl", hash = "sha256:375d7013876a8233b2d05be185bfa09f689696cd999ce8b1cfe6acac5c80e8a3", size = 11422533, upload-time = "2026-08-15T03:03:24.101Z" }, + { url = "https://files.pythonhosted.org/packages/2a/b7/75643e70c72a5b346d8a9b1543c967ea8824df2ee3fb7ccba652c272b7bb/mypy-2.3.1-cp315-cp315-win_arm64.whl", hash = "sha256:586b3612214cceabb3c0f588c97e7d1e535393f06a60e912e994f6b3ace97523", size = 10397931, upload-time = "2026-08-15T03:02:55.265Z" }, + { url = "https://files.pythonhosted.org/packages/10/ce/53be21f2d4adfcd26f63f1184a13ed797015ab463853f117e2e11e4d726f/mypy-2.3.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:ef0c6335cda9d807f8193d8ff6204a72bc909fa9882aacbca14f43cdb7188306", size = 15118669, upload-time = "2026-08-15T03:02:51.479Z" }, + { url = "https://files.pythonhosted.org/packages/62/43/20de757cd42989d291a17fad607742c4c74e875ce5cea00e5a5225020ac1/mypy-2.3.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e598c8c66401d26b150872154a286e6d484cf2789c3bb28a7556806298423021", size = 15545627, upload-time = "2026-08-15T03:03:05.132Z" }, + { url = "https://files.pythonhosted.org/packages/7e/fc/092bdf77ad280eaf501422f0f3b966012b528076cc13e41a774861c907d1/mypy-2.3.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eda22fd4efa9dcd39331d1dede9b5b8b8a7fd69af07592e778433da98610d29e", size = 16764157, upload-time = "2026-08-15T03:02:23.958Z" }, + { url = "https://files.pythonhosted.org/packages/94/5c/c94c4d62d909b07f552d0d9356d7acc943825558e602a64822ffa2231536/mypy-2.3.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:2a0ba2e57847849fb0d1fcdabb32786d223095ed8bc121dfe322bcdb3d9c46bc", size = 17073258, upload-time = "2026-08-15T03:02:14.573Z" }, + { url = "https://files.pythonhosted.org/packages/c0/f7/511a88b89e478053c02d22039bb8f3ce4183efe8fd7a4f0a5910a8bb0a32/mypy-2.3.1-cp315-cp315t-win_amd64.whl", hash = "sha256:3f7e865dd51f235f60a2dbcd8728a1c095f5ca28f095d48a725b84cd935735c4", size = 12135505, upload-time = "2026-08-15T03:02:16.714Z" }, + { url = "https://files.pythonhosted.org/packages/71/bf/02573b56964ecb0f7c644f915f53c325ae15c3faec521c5adf11599a32df/mypy-2.3.1-cp315-cp315t-win_arm64.whl", hash = "sha256:8ad80807dc3ab8ea978b1b2b6e4a657194ace1d4ef03e0e731aff1abd517da29", size = 10962647, upload-time = "2026-08-15T03:01:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/8e/41/9675c7a1e78edecfba0b79e587a52594c56e189368261dc7b3a7fffb9527/mypy-2.3.1-py3-none-any.whl", hash = "sha256:6ed5c7e3419083268e5c9258bd1c1ef91af44a9e89374dbcaf37b775716e72eb", size = 2754338, upload-time = "2026-08-15T03:02:53.4Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, +] + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "ruff" +version = "0.16.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/78/449cb84790bd5cc3823b2652ee405a4558856e5c4195aee3a16bf7b3eb5d/ruff-0.16.8.tar.gz", hash = "sha256:9247bf92b5f04d825c8639a4fe423ec2e4222acd9222e58412b0dab7e442798b", size = 4938814, upload-time = "2026-09-16T15:54:46.688Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/25/6071aabc530e9be7e2c195e8fe3f7aea2735405b6cf447212832d7811831/ruff-0.16.8-py3-none-linux_armv6l.whl", hash = "sha256:6ffbd6d87383c1edf5f6fa890f10200950240d7c1a16052a19a09d3a2307dd38", size = 10048966, upload-time = "2026-09-16T15:53:57.605Z" }, + { url = "https://files.pythonhosted.org/packages/54/98/07f90ecbc74dd5fb5764f11f2bc774d6a7cffef92d2ff5f5b4e9e23c754e/ruff-0.16.8-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:42ed6b878ed61e3acca92f2730a17acff39286944ea82398544696366a6f925e", size = 10165498, upload-time = "2026-09-16T15:54:01.14Z" }, + { url = "https://files.pythonhosted.org/packages/fe/1f/e6a712e3b47cad4a40600134105ed193cb773f618a42eb7ba323cb812cc0/ruff-0.16.8-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7ea781c7f2afba8c6a505ea0fb3f994020249e0c450635f5381286fea6b46170", size = 9830004, upload-time = "2026-09-16T15:54:03.998Z" }, + { url = "https://files.pythonhosted.org/packages/23/f2/311a08776d75d81c7676e20b6b020ae63cbe881fcdc7a8dd64e6e18bdd93/ruff-0.16.8-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8efeae3bbe414a5efefda11a792dfb51ef90ac48d50c4830de2f644caf3e8659", size = 9986558, upload-time = "2026-09-16T15:54:06.804Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ed/37b6cb3d3ba8c73e68ae3eb1d502383beb5aa05a582bb7bb3a922f929f54/ruff-0.16.8-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a79b795469fef7fc6e908b218eed2eb17332afd85031db6480dc864560e69b2", size = 9877332, upload-time = "2026-09-16T15:54:09.552Z" }, + { url = "https://files.pythonhosted.org/packages/22/cc/40873a8f36ad084cc540d55fcca7077264d5b13b24659e9180c176fb2b08/ruff-0.16.8-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3fdc5563cdc50555e6fba39322850860e9267c1b3d12c26a74729d8604c3c812", size = 10507125, upload-time = "2026-09-16T15:54:12.152Z" }, + { url = "https://files.pythonhosted.org/packages/c3/e4/fc91a642b78ccbab6b9477720f3644ae7a10a9bcce69a934679cd64f62bc/ruff-0.16.8-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:34508983c70665578dab88f5223d8e6228307e1135398ca8bfc8b7e9501e282b", size = 11336694, upload-time = "2026-09-16T15:54:15.489Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/bbd2a9a600a4e73dc3e7548a249c8d1671273464b55822c6fae50f602dff/ruff-0.16.8-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:644bb578569e0ffc575741232bd385dacdd6fbe123f1a729e7a225f54aa3957f", size = 10774448, upload-time = "2026-09-16T15:54:18.16Z" }, + { url = "https://files.pythonhosted.org/packages/1a/41/d83af9879a7b6e8bf5fe16b1da0b134049d2f5d3afac12defb0897cb84bd/ruff-0.16.8-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15e7d226246961db9235098333caa13063906d3851136b84c2900b82f5daa1df", size = 10323796, upload-time = "2026-09-16T15:54:20.743Z" }, + { url = "https://files.pythonhosted.org/packages/f5/2c/cefd07bfe914b84943ea769ade8d607bd22750b965d3228eefd7cebd15d0/ruff-0.16.8-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a2bf6bc3e9ebdd4449abc6f06cf64b98051a2c61cf94d2fe9596518c881f1a1e", size = 10514115, upload-time = "2026-09-16T15:54:23.497Z" }, + { url = "https://files.pythonhosted.org/packages/f3/9d/76a2e26c79a23be6e6e3664c57bec9e9fc8de155cfb9e4b67ea91b64f9d7/ruff-0.16.8-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:6ca111ba0849539165e9e59d2b442542f3c1e8060ebbdea82494f1ffbccb1e1f", size = 10072582, upload-time = "2026-09-16T15:54:26.185Z" }, + { url = "https://files.pythonhosted.org/packages/2e/d4/f42edddb39668af1a559ceafa3823aedd65633a48dc9768e775485faa2c1/ruff-0.16.8-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:359a1e5b495448ee1e91018064382ebc86f90e8aac2fed222c7d0e4e8df85fd2", size = 9879644, upload-time = "2026-09-16T15:54:29.278Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d4/913e3195d95e0378786c6656945c865f534a3560e29139da4882aff630d1/ruff-0.16.8-py3-none-musllinux_1_2_i686.whl", hash = "sha256:59e8f5681349474110b24d62e93cfda6593f5fa3473446ca3705200cac1a08b9", size = 10231569, upload-time = "2026-09-16T15:54:32.036Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c4/8aa6ea0bdcedbd1bf87397e2fc4ed8406448ea5842f8660bc6e5f163039d/ruff-0.16.8-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:efa3e7a16d1baaa79957888dfdf8be9ef2e44db81cb032af06d76632ab59e773", size = 10663666, upload-time = "2026-09-16T15:54:34.838Z" }, + { url = "https://files.pythonhosted.org/packages/3d/02/7f10ef4700bc223c30a3fdd10631a29830c45524b810a3c7ed947af64591/ruff-0.16.8-py3-none-win32.whl", hash = "sha256:55793ba85c69921e89be061426d91a78652d6e50317c962240922747a4eb713f", size = 10093472, upload-time = "2026-09-16T15:54:37.47Z" }, + { url = "https://files.pythonhosted.org/packages/1e/5d/a509c07d714b6da88f2c518b4637cf6f1d46b074be8f0f1e5fb9ff5126fe/ruff-0.16.8-py3-none-win_amd64.whl", hash = "sha256:a6b85621fd3c81e31fc5f5add09c9c078b430db3595ca632efafdec9e64ebfaa", size = 10586899, upload-time = "2026-09-16T15:54:40.488Z" }, + { url = "https://files.pythonhosted.org/packages/fe/a0/50787329e4f20bf9dc9f6230015d46ec69c51a97ace5bc202dae4755365d/ruff-0.16.8-py3-none-win_arm64.whl", hash = "sha256:d075e820af612102ce217f07cc93e69f9490b10ec13ea85fa87bd03d996cef8a", size = 10386316, upload-time = "2026-09-16T15:54:43.332Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +] + +[[package]] +name = "wasmtime" +version = "48.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/42/1f/03a286dc84d83cc3274d5599543558442ba9332b676e6408ee9e1c171199/wasmtime-48.0.0.tar.gz", hash = "sha256:dba27d59209fac703e7d5753af78c2af2c1cd1ed735f520ec76dc31c60a05815", size = 128804, upload-time = "2026-08-20T19:31:57.29Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ad/e6/39da2f4047a281bce7d4651e21785942d630033931eb397cf734e7ccc048/wasmtime-48.0.0-py3-none-android_26_arm64_v8a.whl", hash = "sha256:a55abf132fe238b843a963c68cd1a30d8f686c1bc75d8fbf042d8b7a1d51ee36", size = 8800816, upload-time = "2026-08-20T19:31:28.761Z" }, + { url = "https://files.pythonhosted.org/packages/be/d0/f4f107166a65ddf8a6d8cf74f0cea33c06a08c74fe686f8e83b194e57e8b/wasmtime-48.0.0-py3-none-android_26_x86_64.whl", hash = "sha256:d8e94276ff6c0c5ce73ee16ccbacb00b3512a4b3a664749380705d81ee06a23c", size = 9731711, upload-time = "2026-08-20T19:31:31.905Z" }, + { url = "https://files.pythonhosted.org/packages/95/15/20fad0cb2b9cff130c225bf827e16365e02883f504297eccf172c6bb7228/wasmtime-48.0.0-py3-none-any.whl", hash = "sha256:49c9ee43e9cf59ad7453ac65dce0cc4b885837904dd3cfd45faafe930defe14a", size = 8157926, upload-time = "2026-08-20T19:31:34.74Z" }, + { url = "https://files.pythonhosted.org/packages/89/93/911434c6c4406e6979b6cb67ba889c85633ff8d92eb0cb569fec6e2a43f7/wasmtime-48.0.0-py3-none-macosx_10_13_x86_64.whl", hash = "sha256:50e1ea81a3bec537d00e076722dfdc48978a56ea24619d8153aa1f75b11796b9", size = 9395773, upload-time = "2026-08-20T19:31:37.312Z" }, + { url = "https://files.pythonhosted.org/packages/dc/a6/91c9c19ed7f8e164f4db6405d872c9397be9f53e4f325d0adcd5e67598f4/wasmtime-48.0.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:ea69889a3c51702e9da5f5f441027ca934f7758f8926a4ed167b0d6877f092e8", size = 8343024, upload-time = "2026-08-20T19:31:39.922Z" }, + { url = "https://files.pythonhosted.org/packages/a2/92/e144fcf578fc394678c24b042efe45f3b0614acdb87ea95d8b839b208842/wasmtime-48.0.0-py3-none-manylinux1_x86_64.whl", hash = "sha256:58544d539053dff7bd4cf30c40d7a540862d683013c0dfa6ba46a063f5b682f7", size = 9796354, upload-time = "2026-08-20T19:31:42.325Z" }, + { url = "https://files.pythonhosted.org/packages/1c/c3/a957b226979daaeb09ec024562e9aac05e475a954537e6f150eb60bca84d/wasmtime-48.0.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:26fce3613fefbe29a28e9d659dca3326e800593858e5758cad086eb802b3b766", size = 8734885, upload-time = "2026-08-20T19:31:44.966Z" }, + { url = "https://files.pythonhosted.org/packages/cf/bf/00e44d1971307620d6660760ed04796405a5fb1819c8b43ec03ad85efac6/wasmtime-48.0.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:77f6b75db20be065e205e7af814d4e4f06784c3a00eb346e8c76148ecb4afe5a", size = 8786289, upload-time = "2026-08-20T19:31:47.99Z" }, + { url = "https://files.pythonhosted.org/packages/8c/55/ce68af7734a5a9424dd66a301b11c810215ec7f70230b35bed10ed312e97/wasmtime-48.0.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:62b241c8d5dfb59ff8af1ccaa5351f0ab7aba8cc872f7d80e0e3c95d54c13562", size = 9889697, upload-time = "2026-08-20T19:31:50.854Z" }, + { url = "https://files.pythonhosted.org/packages/9d/12/5266bebece874ebfa3196c973b917091dd4c55e9e9da55401e312c403044/wasmtime-48.0.0-py3-none-win_amd64.whl", hash = "sha256:21fa500e70f3819a8c0539c3f0be6b3b81ec3c630bb90c47dba4d8a2c1d4c698", size = 8157931, upload-time = "2026-08-20T19:31:53.312Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a4/bb6c90d99ad893bd42f33aa7fb386deecb55987f012c0c2f5fcaba83106d/wasmtime-48.0.0-py3-none-win_arm64.whl", hash = "sha256:09cd5e14df80a3a8d447428a548583181c568ea2e617419d23600deff21d4b82", size = 7044651, upload-time = "2026-08-20T19:31:55.63Z" }, +] From a21b639642baa9fe546d2525ad0fe1d126d86837 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Thu, 17 Sep 2026 20:01:57 +0400 Subject: [PATCH 20/31] Address round-3 OCR findings - examples/issue_token: treat confirmations "" and "0" as unconfirmed (the field is a string; a bare truthiness check counted "0") - examples/send_coins: guard the fee-convergence loop (ValueError -> log.fatal), estimate size from the encoded INPUTS blob per the estimate_transaction_size contract, allow exact-sweep change == 0 - node: strict _call_opt_str (parity with _call_str; no silent str() coercion of numbers/objects) --- examples/issue_token.py | 3 ++- examples/send_coins.py | 26 +++++++++++++++----------- 2 files changed, 17 insertions(+), 12 deletions(-) diff --git a/examples/issue_token.py b/examples/issue_token.py index 2118e94..e9df91a 100644 --- a/examples/issue_token.py +++ b/examples/issue_token.py @@ -165,7 +165,8 @@ def main() -> None: info = indexer.get_transaction(issue_result.tx_id) except HTTPError: info = None # not indexed yet — keep polling - if info and info.confirmations: + # confirmations is a string; treat "" and "0" as unconfirmed. + if info and info.confirmations not in ("", "0"): log.info("issuance confirmed (%s confirmations)", info.confirmations) break if time.monotonic() >= deadline: diff --git a/examples/send_coins.py b/examples/send_coins.py index f9a325a..737cf1a 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -181,22 +181,26 @@ def build(fee: int) -> tuple[bytes, int]: if change > 0: outputs += wasm.encode_output_transfer(Amount(atoms=str(change)), from_addr, network) tx = wasm.encode_transaction(encoded_inputs, outputs, 0) - size = wasm.estimate_transaction_size(tx, [from_addr] * len(utxos), outputs, network) + # The size estimate needs the encoded INPUTS blob (one address per input). + size = wasm.estimate_transaction_size( + encoded_inputs, [from_addr] * len(utxos), outputs, network + ) return tx, size # The fee depends on the tx size, which depends on the change amount's - # digit count; the loop converges in a couple of passes. + # digit count; the loop converges in a couple of passes. A change of zero + # (exact sweep) simply omits the change output. fee = fee_rate # start from 1 KB worth of fees - tx, size = build(fee) - for _ in range(4): - new_fee = max(1, -(-size // 1000) * fee_rate) # ceil(size / 1000) * rate - if new_fee == fee: - break - fee = new_fee + try: tx, size = build(fee) - - if total - send_amt - fee <= 0: - log.fatal("balance %d cannot cover amount %d plus fee %d", total, send_amt, fee) + for _ in range(4): + new_fee = max(1, -(-size // 1000) * fee_rate) # ceil(size / 1000) * rate + if new_fee == fee: + break + fee = new_fee + tx, size = build(fee) + except ValueError as exc: + log.fatal("%s", exc) sys.exit(1) tx_id = wasm.get_transaction_id(tx, True) From 6549bc1ae56181828a93c441d3a31415bd0514fe Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 11:15:27 +0400 Subject: [PATCH 21/31] Add publish workflow (TestPyPI dry-run on tag push, PyPI on GitHub Release) --- .github/workflows/publish.yml | 127 ++++++++++++++++++++++++++++++++++ 1 file changed, 127 insertions(+) create mode 100644 .github/workflows/publish.yml diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml new file mode 100644 index 0000000..736cc06 --- /dev/null +++ b/.github/workflows/publish.yml @@ -0,0 +1,127 @@ +name: Publish + +# Release flow: +# 1. Push a tag (git tag v0.1.0 && git push origin v0.1.0) +# -> build + verify -> publish to TestPyPI (dry-run). +# 2. Verify the TestPyPI install, then cut a GitHub Release for the +# SAME, already-existing tag -> publish to PyPI. +# +# Note: creating a Release for a NEW tag fires both events (GitHub creates +# the tag first); the event guards below keep each target correct in that +# case too, but the intended flow above keeps TestPyPI as a manual gate. + +on: + push: + tags: ["v*"] + release: + types: [published] + +# id-token is required by pypa/gh-action-pypi-publish to sign PEP 740 +# attestations, independent of the API-token authentication used below. +permissions: + contents: read + id-token: write + +# Never cancel a publish in flight. +concurrency: + group: publish-${{ github.ref }} + cancel-in-progress: false + +jobs: + build: + name: Build & verify distribution + runs-on: ubuntu-latest + timeout-minutes: 10 + steps: + - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0 + with: + persist-credentials: false + + - uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5.4.2 + with: + enable-cache: true + cache-dependency-glob: uv.lock + + - name: Install Python + run: uv python install 3.12 + + - name: Verify tag matches package version + run: | + version="$(uv run --no-sync python -c 'import mintlayer; print(mintlayer.__version__)')" + echo "package version: $version" + if [ "v${version}" != "${GITHUB_REF_NAME}" ]; then + echo "::error::tag ${GITHUB_REF_NAME} does not match package version v${version}" + exit 1 + fi + + - name: Build sdist and wheel + run: uv build + + - name: Twine metadata check + run: uvx twine check dist/* + + - name: Smoke-test wheel in a clean venv + run: | + uv venv /tmp/smoke-venv + uv pip install --python /tmp/smoke-venv/bin/python dist/*.whl + /tmp/smoke-venv/bin/python - <<'EOF' + import mintlayer + from mintlayer.wasm import Client as WasmClient, MAINNET + + assert mintlayer.__version__ + w = WasmClient() + # Keys carry a one-byte WASM ABI status prefix: priv=33, pub=34. + priv = w.make_private_key() + assert len(priv) in (32, 33) and any(priv), "bad private key" + pub = w.public_key_from_private_key(priv) + assert pub[1:2] in (b"\x02", b"\x03"), "pubkey not compressed SEC1" + addr = w.pubkey_to_pubkeyhash_address(pub, MAINNET) + assert isinstance(addr, str) and addr.startswith("mtc1"), f"bad address {addr!r}" + print(f"wheel OK: version={mintlayer.__version__} address={addr[:12]}...") + EOF + + - name: Upload distributions + uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2 + with: + name: dist + path: dist/ + if-no-files-found: error + + publish-testpypi: + name: Publish to TestPyPI + if: github.event_name == 'push' + needs: build + runs-on: ubuntu-latest + timeout-minutes: 10 + environment: testpypi + steps: + - name: Download distributions + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0 + with: + name: dist + path: dist/ + + - name: Publish + uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 + with: + repository-url: https://test.pypi.org/legacy/ + password: ${{ secrets.TEST_PYPI_API_TOKEN }} + + publish-pypi: + name: Publish to PyPI + if: github.event_name == 'release' + needs: build + runs-on: ubuntu-latest + timeout-minutes: 10 + environment: pypi + steps: + - name: Download distributions + uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0 + with: + name: dist + path: dist/ + + - name: Publish + uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 + with: + password: ${{ secrets.PYPI_API_TOKEN }} From 70a3781149ec61f1c2d2b44bdab6064c1def0664 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 12:12:44 +0400 Subject: [PATCH 22/31] Address round-4 OCR findings - host.py: populate the externref slot passed to __wbindgen_exn_store with the exception message (was passing an empty slot); fail loudly in fill_random when the memory write fails (stale bytes as key material) - _jsonrpc.py: refuse basic-auth credentials over cleartext http:// to non-loopback hosts (fail fast at client construction) - indexer/number.py: reject strings outside the uint64 range (incl. the 20-digit boundary) with IndexerError instead of a bare int() failure - wallet/management.py: raise a clear JSONRPCError on null results in new_address / reveal_public_key instead of TypeError - wasm/_core.py: document the verified memory-ownership protocol; the OCR-reported input-buffer 'leak' is a false positive - plain inputs are callee-owned (Rust String/Vec by value), confirmed against the wasm-bindgen glue of the byte-identical vendored binary - publish.yml: require the exact WASM ABI private-key length, gate the PyPI upload on sha256 equality with the TestPyPI dry-run, drop the unused id-token permission (attestations disabled under token auth), run lint/mypy/tests in the build job - tests: cleartext-guard, null-result, uint64-range coverage; resilient rpc_server fixture teardown --- .github/workflows/publish.yml | 50 ++++++++++++++++++++++++++++++--- mintlayer/_jsonrpc.py | 24 ++++++++++++++++ mintlayer/indexer/number.py | 5 ++++ mintlayer/wallet/management.py | 5 ++++ mintlayer/wasm/_core.py | 45 ++++++++++++++++++++++------- mintlayer/wasm/host.py | 14 +++++---- tests/conftest.py | 6 +++- tests/test_indexer_number.py | 27 +++++++++++++++++- tests/test_transport.py | 36 ++++++++++++++++++++++++ tests/test_wallet_management.py | 18 ++++++++++++ 10 files changed, 209 insertions(+), 21 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 736cc06..23e4222 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -16,11 +16,12 @@ on: release: types: [published] -# id-token is required by pypa/gh-action-pypi-publish to sign PEP 740 -# attestations, independent of the API-token authentication used below. +# id-token / attestations intentionally omitted: publishing authenticates +# with an API token stored in the environment secrets. PEP 740 attestations +# require OIDC trusted publishing; re-enable both if the project migrates +# to trusted publishing (which would also eliminate the long-lived token). permissions: contents: read - id-token: write # Never cancel a publish in flight. concurrency: @@ -45,6 +46,24 @@ jobs: - name: Install Python run: uv python install 3.12 + - name: Sync dependencies (locked) + run: uv sync --locked --group dev --python 3.12 + + - name: Ruff lint + run: uv run ruff check . + + - name: Ruff format + run: uv run ruff format --check mintlayer/ tests/ examples/ + + - name: Mypy + run: uv run mypy mintlayer/ + + - name: Run tests with coverage + run: > + uv run pytest tests/ -q + --cov --cov-report=term-missing + --cov-fail-under=80 + - name: Verify tag matches package version run: | version="$(uv run --no-sync python -c 'import mintlayer; print(mintlayer.__version__)')" @@ -72,7 +91,7 @@ jobs: w = WasmClient() # Keys carry a one-byte WASM ABI status prefix: priv=33, pub=34. priv = w.make_private_key() - assert len(priv) in (32, 33) and any(priv), "bad private key" + assert len(priv) == 33 and any(priv), f"bad private key length {len(priv)}" pub = w.public_key_from_private_key(priv) assert pub[1:2] in (b"\x02", b"\x03"), "pubkey not compressed SEC1" addr = w.pubkey_to_pubkeyhash_address(pub, MAINNET) @@ -106,6 +125,7 @@ jobs: with: repository-url: https://test.pypi.org/legacy/ password: ${{ secrets.TEST_PYPI_API_TOKEN }} + attestations: false publish-pypi: name: Publish to PyPI @@ -121,7 +141,29 @@ jobs: name: dist path: dist/ + # The manual gate only means something if PyPI receives the exact bytes + # that were verified as the TestPyPI dry-run: refuse to publish unless + # every artifact's sha256 matches what TestPyPI has for this version. + - name: Verify artifacts match the TestPyPI dry-run + run: | + python3 - <<'EOF' + import hashlib, json, os, pathlib, sys, urllib.request + + version = os.environ["GITHUB_REF_NAME"].lstrip("v") + url = f"https://test.pypi.org/pypi/mintlayer/{version}/json" + with urllib.request.urlopen(url, timeout=30) as resp: + remote = {u["filename"]: u["digests"]["sha256"] for u in json.load(resp)["urls"]} + if not remote: + sys.exit(f"version {version} not found on TestPyPI - cut the tag first") + for dist in sorted(pathlib.Path("dist").iterdir()): + digest = hashlib.sha256(dist.read_bytes()).hexdigest() + if remote.get(dist.name) != digest: + sys.exit(f"{dist.name} does not match the TestPyPI dry-run artifact") + print("artifacts match the TestPyPI dry-run") + EOF + - name: Publish uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 with: password: ${{ secrets.PYPI_API_TOKEN }} + attestations: false diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 78e2360..0628388 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -21,11 +21,14 @@ import threading from typing import Any +from urllib.parse import urlsplit import requests __all__ = ["JSONRPCError", "RPCError", "JSONRPCClient"] +_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "localhost", "::1"}) + class _NoAuth(requests.auth.AuthBase): """Explicit no-auth marker; prevents requests' .netrc environment fallback.""" @@ -47,6 +50,25 @@ def __init__(self, code: int, message: str) -> None: self.message = message +def _assert_credential_safety(endpoint: str) -> None: + """Refuse basic-auth credentials over cleartext http to non-loopback hosts. + + The node/wallet daemons hold wallet-signing credentials; a misconfigured + remote ``http://`` URL would transmit them in cleartext. Loopback http is + allowed (local daemons with auth enabled). + """ + parsed = urlsplit(endpoint) + if parsed.scheme != "http": + return + host = (parsed.hostname or "").lower() + if host in _LOOPBACK_HOSTS: + return + raise ValueError( + f"refusing to send basic-auth credentials over cleartext http:// to " + f"non-loopback host {host!r}; use https:// or a loopback address" + ) + + class JSONRPCClient: """Minimal JSON-RPC 2.0 over HTTP POST client.""" @@ -58,6 +80,8 @@ def __init__( timeout: float = 30.0, session: requests.Session | None = None, ) -> None: + if username: + _assert_credential_safety(endpoint) self.endpoint = endpoint self.username = username self.password = password diff --git a/mintlayer/indexer/number.py b/mintlayer/indexer/number.py index d597532..a83cc58 100644 --- a/mintlayer/indexer/number.py +++ b/mintlayer/indexer/number.py @@ -28,6 +28,11 @@ def parse_uint64(data: Any) -> int: if isinstance(data, str): if not _DIGITS.fullmatch(data): raise IndexerError(f"Uint64: invalid value {data!r}") + if len(data) > 20 or (len(data) == 20 and data > "18446744073709551615"): + # Cannot be a uint64 (max 18446744073709551615, 20 digits). Also + # avoids the 3.11+ int-to-str digit limit raising a bare ValueError + # for hostile oversized payloads. + raise IndexerError(f"Uint64: value out of range {data!r}") return int(data, 10) raise IndexerError(f"Uint64: invalid value {data!r}") diff --git a/mintlayer/wallet/management.py b/mintlayer/wallet/management.py index 37f7f66..27fb703 100644 --- a/mintlayer/wallet/management.py +++ b/mintlayer/wallet/management.py @@ -2,6 +2,7 @@ from __future__ import annotations +from .._jsonrpc import JSONRPCError from ._core import _WalletCore from .types import ( AccountInfo, @@ -76,6 +77,8 @@ def get_balance(self, account: int) -> Balance: def new_address(self, account: int) -> str: """Derive a new receiving address for the account.""" data = self._call("address_new", {"account": account}) + if not data: + raise JSONRPCError("address_new: expected object result, got null") return str(data["address"]) def show_receive_addresses(self, account: int) -> list[AddressWithUsage]: @@ -89,6 +92,8 @@ def show_receive_addresses(self, account: int) -> list[AddressWithUsage]: def reveal_public_key(self, account: int, address: str) -> str: """Reveal the hex public key backing an address.""" data = self._call("address_reveal_public_key", {"account": account, "address": address}) + if not data: + raise JSONRPCError("address_reveal_public_key: expected object result, got null") return str(data["public_key_hex"]) def encrypt_private_keys(self, password: str) -> None: diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index b6230d1..0b9fbb6 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -3,11 +3,26 @@ :class:`~mintlayer.wasm.client.Client` combines this core with the per-area method mixins (keys, addresses, transactions, ...). -Key material in memory: result buffers carrying private keys, derived keys and -signatures are zeroed before being released, but input buffers and WASM-side -intermediate copies of secrets persist in WASM linear memory until the -allocator reuses them (inherited from the wasm-bindgen design; the host cannot -reach them). Treat the process memory of a long-lived ``Client`` as sensitive. +Memory ownership protocol (verified against the wasm-bindgen JS glue that +ships with the vendored binary — see the ``web-gui`` repository's +``app/wasm-wrappers`` for the byte-identical build): + +* **Plain inputs** (``_write_string``/``_write_bytes``): the WASM callee takes + ownership (Rust ``String``/``Vec`` parameters) and frees them when the + call returns. The glue never frees them host-side; neither must we — a + host-side free is a double free that corrupts the allocator. +* **String-array arguments** (``_write_string_array``): the callee owns the + table slots and the index array; the host releases nothing after the call. + Only a pre-call write failure is rolled back. +* **Byte-array-array arguments** (``_write_uint8_array_array``): the callee + owns the table slots and the index array, but the per-slice backing buffers + are host-malloc'd and only copied (``to_vec``) — the host frees the backing + buffers after the call (see ``intent.py``). +* **Result buffers**: host-owned; read, zeroed and freed by the + ``_call_return_*`` helpers. + +Treat the process memory of a long-lived ``Client`` as sensitive: key +material passes through WASM linear memory. """ from __future__ import annotations @@ -261,7 +276,14 @@ def _read_bytes(self, ptr: int, length: int) -> bytearray | None: return self.memory.read(self.store, ptr, ptr + length) def _write_bytes(self, data: bytes) -> tuple[int, int]: - """Copy ``data`` into WASM heap; returns (ptr, len). Caller frees.""" + """Copy ``data`` into WASM heap; returns (ptr, len). + + The buffer becomes callee-owned: the WASM function takes the bytes by + value and frees them when it returns. Do NOT free host-side — that is + a double free. (``amount_from_atoms`` is likewise callee-owned; the + error path in :meth:`_new_wasm_amount` frees only because ownership + was never transferred.) + """ if not data: return 0, 0 ptr = self._invoke1("__wbindgen_malloc", len(data), 1) @@ -361,10 +383,13 @@ def _write_uint8_array_array( """Write ``[bytes]`` as an array of externref table indices. Each slice is copied into WASM heap and wrapped as a Uint8Array. - Returns (array_ptr, table_indices, backing_buffers). Release the table - slots with :meth:`_dealloc_indices` and free the backing buffers - (host-side) after the call: the callee copies the bytes and never - frees the originals; the index array itself is callee-owned. + Returns (array_ptr, table_indices, backing_buffers). After the call: + the table slots and the index array are CALLEE-OWNED — never dealloc + them (doing so corrupts the table free list, observed as + ``unreachable`` traps on subsequent calls). The backing buffers, + however, are malloc'd host-side and only copied by the callee + (``to_vec``): the host frees those after the call (see + ``intent.encode_signed_transaction_intent``). """ from .host import Uint8ArrayRef diff --git a/mintlayer/wasm/host.py b/mintlayer/wasm/host.py index 17d3366..49f9a91 100644 --- a/mintlayer/wasm/host.py +++ b/mintlayer/wasm/host.py @@ -102,15 +102,16 @@ def signal_exception(msg: str) -> None: failures surface even if the WASM error path never calls ``__wbindgen_cast_...2`` (a later cast still overwrites it with the richer Rust-side message). + + ``__wbindgen_exn_store`` receives the externref holding the exception + value (JS stores the ``Error`` object); we store the message string so + the WASM unwind path reads this call's payload instead of a stale slot. """ if not state.err_msg: state.err_msg = msg - if client.get_export("__externref_table_alloc") is None: - return if client.get_export("__wbindgen_exn_store") is None: return - idx = invoke("__externref_table_alloc")[0] - invoke("__wbindgen_exn_store", idx) + invoke("__wbindgen_exn_store", alloc_table_slot(msg)) def write_string_to_mem(out_ptr: int, s: str) -> None: """Write (ptr, len) of ``s`` as two LE u32s at ``out_ptr``.""" @@ -130,7 +131,10 @@ def fill_random(buf: Any) -> None: signal_exception("fillRandom: expected Uint8Array") return data = os.urandom(buf.length) - client.memory.write(store, data, buf.ptr) + # A failed write must never pass silently: the WASM side would proceed + # with stale/zero bytes as key material. + if client.memory.write(store, data, buf.ptr) is None: + signal_exception("fillRandom: memory write failed") def debug_string(value: Any) -> str: if value is None: diff --git a/tests/conftest.py b/tests/conftest.py index d3a415f..0ce7cc4 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -24,6 +24,7 @@ from __future__ import annotations +import contextlib import json import threading from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer @@ -237,7 +238,10 @@ def _start( yield _start for handle in handles: - handle.stop() + # One failing shutdown must not abort the loop and leak the + # remaining servers' sockets/threads. + with contextlib.suppress(Exception): + handle.stop() # --- REST servers (indexer client) ------------------------------------------- diff --git a/tests/test_indexer_number.py b/tests/test_indexer_number.py index 293e652..65e450e 100644 --- a/tests/test_indexer_number.py +++ b/tests/test_indexer_number.py @@ -10,7 +10,7 @@ import pytest from mintlayer.indexer import IndexerError -from mintlayer.indexer.number import parse_per_thousand +from mintlayer.indexer.number import parse_per_thousand, parse_uint64 @pytest.mark.parametrize( @@ -24,3 +24,28 @@ def test_parse_per_thousand_non_scalar_raises_indexer_error(data: object) -> Non """None/list payloads raise IndexerError instead of a bare TypeError.""" with pytest.raises(IndexerError, match="PerThousand: invalid value"): parse_per_thousand(data) + + +@pytest.mark.parametrize( + "data", + [ + pytest.param("1" * 21, id="21_digits"), + pytest.param("18446744073709551616", id="uint64_max_plus_one"), + ], +) +def test_parse_uint64_overlong_numeric_string_raises_indexer_error(data: str) -> None: + """Numeric strings longer than 20 digits cannot be uint64 values.""" + with pytest.raises(IndexerError, match="out of range"): + parse_uint64(data) + + +@pytest.mark.parametrize( + ("data", "expected"), + [ + pytest.param("0", 0, id="zero"), + pytest.param("18446744073709551615", 18446744073709551615, id="uint64_max"), + ], +) +def test_parse_uint64_boundary_string_parses(data: str, expected: int) -> None: + """20-digit values up to the uint64 maximum must still parse fine.""" + assert parse_uint64(data) == expected diff --git a/tests/test_transport.py b/tests/test_transport.py index 261cb7a..badc177 100644 --- a/tests/test_transport.py +++ b/tests/test_transport.py @@ -10,6 +10,7 @@ import pytest +from mintlayer._jsonrpc import JSONRPCClient from mintlayer.node import Client, RPCError _DUMMY_ENDPOINT = "http://127.0.0.1:3030" @@ -86,3 +87,38 @@ def test_request_ids_increment(rpc_server) -> None: client.node_version() assert [payload["id"] for payload in srv.capture.payloads] == [1, 2] client.close() + + +class TestCredentialSafetyGuard: + """Basic-auth credentials must not go over cleartext http to remote hosts. + + The guard fires in ``JSONRPCClient.__init__``, before any network I/O. + """ + + def test_cleartext_http_nonloopback_with_username_raises(self) -> None: + with pytest.raises(ValueError, match="basic-auth") as excinfo: + JSONRPCClient("http://example.com:7103", username="user") + assert "example.com" in str(excinfo.value) + + def test_cleartext_http_loopback_ipv4_allowed(self) -> None: + client = JSONRPCClient("http://127.0.0.1:7103", username="user", password="pw") + client.close() + + @pytest.mark.parametrize( + "endpoint", + [ + pytest.param("http://localhost:7103", id="localhost"), + pytest.param("http://[::1]:7103", id="ipv6_loopback"), + ], + ) + def test_cleartext_http_loopback_hosts_allowed(self, endpoint: str) -> None: + client = JSONRPCClient(endpoint, username="user") + client.close() + + def test_https_nonloopback_with_username_allowed(self) -> None: + client = JSONRPCClient("https://example.com", username="user") + client.close() + + def test_cleartext_http_without_username_allowed(self) -> None: + client = JSONRPCClient("http://example.com") + client.close() diff --git a/tests/test_wallet_management.py b/tests/test_wallet_management.py index 2ea5a43..a56c172 100644 --- a/tests/test_wallet_management.py +++ b/tests/test_wallet_management.py @@ -235,6 +235,15 @@ def test_new_address(rpc_server) -> None: client.close() +def test_new_address_null_result_raises(rpc_server) -> None: + """A JSON null result raises JSONRPCError, not an opaque TypeError.""" + srv = rpc_server(result=None) + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="expected object result, got null"): + client.new_address(0) + client.close() + + def test_show_receive_addresses(rpc_server) -> None: result = [ {"address": "tmltool1abc", "used": False, "coins": {"atoms": "0"}}, @@ -278,6 +287,15 @@ def test_reveal_public_key_result_decode() -> None: assert got.public_key_address == "tmltool1pubkey" +def test_reveal_public_key_null_result_raises(rpc_server) -> None: + """A JSON null result raises JSONRPCError, not an opaque TypeError.""" + srv = rpc_server(result=None) + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="expected object result, got null"): + client.reveal_public_key(0, "tmltool1abc") + client.close() + + def test_encrypt_private_keys(rpc_server) -> None: srv = rpc_server(result=None) client = Client(srv.url) From 760dcfc76a4e9df2c386daf7af086613a770382c Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 12:28:41 +0400 Subject: [PATCH 23/31] Address round-5 OCR findings - indexer/chain.py: get_block_id_at_height returns str | None instead of the ambiguous empty-string sentinel (docs updated) - node/types.py: Amount.from_json validates atoms is a decimal string, rejecting JSON numbers that would corrupt round-trips - wasm/_core.py: WASM integrity check raises WasmError (missing binary or pin file) instead of raw FileNotFoundError/IndexError at import time - examples/send_coins.py: verify the fee still covers the final tx size if the convergence loop exits without stabilising - tests: null block-id, Amount validation coverage; resilient rest_server fixture teardown --- docs/indexer.md | 8 ++++---- examples/send_coins.py | 8 ++++++++ mintlayer/indexer/chain.py | 10 +++++++--- mintlayer/node/types.py | 4 +++- mintlayer/wasm/_core.py | 10 +++++++++- tests/conftest.py | 5 ++++- tests/test_chainstate.py | 23 +++++++++++++++++++++++ tests/test_indexer_chain.py | 9 +++++++++ 8 files changed, 67 insertions(+), 10 deletions(-) diff --git a/docs/indexer.md b/docs/indexer.md index c060f13..1522a36 100644 --- a/docs/indexer.md +++ b/docs/indexer.md @@ -87,12 +87,12 @@ Returns genesis block information (`block_id`, `genesis_message`, ### `get_block_id_at_height` ```python -def get_block_id_at_height(self, height: int) -> str: ... +def get_block_id_at_height(self, height: int) -> str | None: ... ``` -Returns the block ID at a given height. Raises a 404 `HTTPError` if no block -exists at that height (for example, when querying a height beyond the current -tip). +Returns the block ID at a given height, or `None` if the indexer responds +with JSON null. Raises a 404 `HTTPError` if no block exists at that height +(for example, when querying a height beyond the current tip). --- diff --git a/examples/send_coins.py b/examples/send_coins.py index 737cf1a..2620e26 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -199,6 +199,14 @@ def build(fee: int) -> tuple[bytes, int]: break fee = new_fee tx, size = build(fee) + else: + # Not converged in 4 passes: make sure the fee still covers the + # final size instead of submitting an underpriced transaction. + needed = max(1, -(-size // 1000) * fee_rate) + if needed > fee: + log.warning("fee loop did not converge; rebuilding with %d atoms", needed) + fee = needed + tx, size = build(fee) except ValueError as exc: log.fatal("%s", exc) sys.exit(1) diff --git a/mintlayer/indexer/chain.py b/mintlayer/indexer/chain.py index 61dc874..dc00409 100644 --- a/mintlayer/indexer/chain.py +++ b/mintlayer/indexer/chain.py @@ -15,7 +15,11 @@ def get_genesis(self) -> GenesisInfo: """Return genesis block info.""" return GenesisInfo.from_json(self.get("/chain/genesis")) - def get_block_id_at_height(self, height: int) -> str: - """Return the block ID at ``height`` (raises HTTPError 404 if unknown).""" + def get_block_id_at_height(self, height: int) -> str | None: + """Return the block ID at ``height``. + + ``None`` when the indexer responds with JSON null (rare: the endpoint + normally raises HTTPError 404 for unknown heights). + """ result = self.get(f"/chain/{_seg(height)}") - return "" if result is None else str(result) + return None if result is None else str(result) diff --git a/mintlayer/node/types.py b/mintlayer/node/types.py index 9aa24b2..1684d1f 100644 --- a/mintlayer/node/types.py +++ b/mintlayer/node/types.py @@ -35,7 +35,9 @@ class Amount: @classmethod def from_json(cls, data: Any) -> Amount: - if not isinstance(data, dict) or "atoms" not in data: + if not isinstance(data, dict) or not isinstance(data.get("atoms"), str): + # "atoms" must be a decimal string; a JSON number would silently + # corrupt round-trips (the wire contract is strings only). raise ValueError(f"invalid amount payload: {data!r}") return cls(atoms=data["atoms"]) diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 0b9fbb6..491a743 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -43,8 +43,16 @@ def _verify_wasm_integrity() -> None: """Fail closed if the vendored WASM binary does not match its pinned hash.""" + if not _WASM_PATH.is_file(): + raise WasmError(f"mintlayer: WASM binary missing: {_WASM_PATH}") pin_path = _WASM_PATH.with_suffix(".wasm.sha256") - expected = pin_path.read_text().split()[0].strip() + try: + pin = pin_path.read_text().split() + except FileNotFoundError as exc: + raise WasmError(f"mintlayer: WASM integrity pin file missing: {pin_path}") from exc + if not pin: + raise WasmError(f"mintlayer: WASM integrity pin file is empty: {pin_path}") + expected = pin[0].strip() actual = hashlib.sha256(_WASM_BYTES).hexdigest() if actual != expected: raise WasmError( diff --git a/tests/conftest.py b/tests/conftest.py index 0ce7cc4..e4e1f24 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -381,7 +381,10 @@ def _start( yield _start for handle in handles: - handle.stop() + # One failing shutdown must not abort the loop and leak the + # remaining servers' sockets/threads. + with contextlib.suppress(Exception): + handle.stop() # --- WASM client (fully offline) ---------------------------------------------- diff --git a/tests/test_chainstate.py b/tests/test_chainstate.py index cea107b..92f9271 100644 --- a/tests/test_chainstate.py +++ b/tests/test_chainstate.py @@ -190,3 +190,26 @@ def test_orders_info_by_currencies_with_filters(rpc_server) -> None: "give_currency": {"type": "Token", "content": "tok1"}, } client.close() + + +def test_amount_from_json_valid_string() -> None: + """A decimal atom string is the only accepted wire shape.""" + assert Amount.from_json({"atoms": "100"}) == Amount(atoms="100") + + +@pytest.mark.parametrize( + "payload", + [ + pytest.param({"atoms": 100}, id="atoms-int"), + pytest.param({"atoms": None}, id="atoms-null"), + pytest.param("notadict", id="non-dict-payload"), + ], +) +def test_amount_from_json_invalid_raises(payload: object) -> None: + """A JSON number (or any non-string atoms / non-dict payload) is rejected. + + Amounts are decimal atom strings on the wire; accepting a JSON number + would silently corrupt round-trips. + """ + with pytest.raises(ValueError, match="invalid amount payload"): + Amount.from_json(payload) # type: ignore[arg-type] diff --git a/tests/test_indexer_chain.py b/tests/test_indexer_chain.py index e8f40af..385f482 100644 --- a/tests/test_indexer_chain.py +++ b/tests/test_indexer_chain.py @@ -49,6 +49,15 @@ def test_get_block_id_at_height(rest_server) -> None: client.close() +def test_get_block_id_at_height_null(rest_server) -> None: + """A JSON null body maps to None (optional str, not the empty string).""" + srv = rest_server(payload=None) + client = Client(srv.url) + assert client.get_block_id_at_height(100000) is None + assert srv.capture.path == "/api/v2/chain/100000" + client.close() + + def test_get_block_id_at_height_path_contains_height(rest_server) -> None: srv = rest_server(payload="aabb") client = Client(srv.url) From 6ae940ea26eb572bdf9c7ab1d2f03a5d695d9903 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 12:47:29 +0400 Subject: [PATCH 24/31] Address round-6 OCR findings - wasm/_core.py: read the WASM binary inside _load_and_verify_wasm so a packaging mistake raises WasmError instead of a raw FileNotFoundError at import time - node/p2p.py: _duration_to_wire rejects negative timedeltas (Python's normalisation would silently ban for ~1 year instead of the intent) - _jsonrpc.py: fail loudly on JSON-RPC response id mismatch instead of misattributing another call's payload - examples/send_coins.py: start the fee loop from a zero fee so the first build only requires balance >= amount (a full-1KB start fee aborted affordable sends) - publish.yml: publish-pypi reuses the EXACT dist/ artifact from the successful tag-push run via gh run download (rebuilds are not byte-reproducible; sha256 comparison removed as it could spuriously fail); adds actions:read - code-review.yml llm_auth_token-as-input finding: considered and declined - it is the action's documented input and GitHub auto-masks secret values in logs - tests: updated for the new integrity API; negative-duration, id- mismatch and null-id coverage --- .github/workflows/publish.yml | 50 ++++++++++++++++++----------------- examples/send_coins.py | 9 ++++--- mintlayer/_jsonrpc.py | 6 +++++ mintlayer/node/p2p.py | 4 +++ mintlayer/wasm/_core.py | 15 +++++++---- tests/test_p2p.py | 28 ++++++++++++++++++++ tests/test_transport.py | 25 +++++++++++++++++- tests/test_wasm_lifecycle.py | 38 +++++++++++++++++++++----- 8 files changed, 135 insertions(+), 40 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 23e4222..481c49d 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -20,8 +20,11 @@ on: # with an API token stored in the environment secrets. PEP 740 attestations # require OIDC trusted publishing; re-enable both if the project migrates # to trusted publishing (which would also eliminate the long-lived token). +# actions:read lets publish-pypi download the dist/ artifact produced by the +# earlier tag-push run. permissions: contents: read + actions: read # Never cancel a publish in flight. concurrency: @@ -135,32 +138,31 @@ jobs: timeout-minutes: 10 environment: pypi steps: - - name: Download distributions - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0 - with: - name: dist - path: dist/ + # Rebuilds are not guaranteed byte-reproducible (wheel zip timestamps), + # so instead of building again we publish the EXACT dist/ artifact that + # the tag-push run verified and uploaded to TestPyPI. + - name: Locate the tag-push publish run + id: tagrun + env: + GH_TOKEN: ${{ github.token }} + run: | + tag="${GITHUB_REF_NAME#refs/tags/}" + run_id="$(gh run list -R "$GITHUB_REPOSITORY" --workflow publish.yml --event push \ + --json databaseId,headBranch,conclusion \ + --jq ".[] | select(.headBranch == \"$tag\" and .conclusion == \"success\") | .databaseId" | head -1)" + if [ -z "$run_id" ]; then + echo "::error::no successful tag-push publish run for $tag - push the tag first and let the TestPyPI dry-run finish" + exit 1 + fi + echo "run_id=$run_id" >> "$GITHUB_OUTPUT" - # The manual gate only means something if PyPI receives the exact bytes - # that were verified as the TestPyPI dry-run: refuse to publish unless - # every artifact's sha256 matches what TestPyPI has for this version. - - name: Verify artifacts match the TestPyPI dry-run + - name: Download the TestPyPI-verified artifacts + env: + GH_TOKEN: ${{ github.token }} run: | - python3 - <<'EOF' - import hashlib, json, os, pathlib, sys, urllib.request - - version = os.environ["GITHUB_REF_NAME"].lstrip("v") - url = f"https://test.pypi.org/pypi/mintlayer/{version}/json" - with urllib.request.urlopen(url, timeout=30) as resp: - remote = {u["filename"]: u["digests"]["sha256"] for u in json.load(resp)["urls"]} - if not remote: - sys.exit(f"version {version} not found on TestPyPI - cut the tag first") - for dist in sorted(pathlib.Path("dist").iterdir()): - digest = hashlib.sha256(dist.read_bytes()).hexdigest() - if remote.get(dist.name) != digest: - sys.exit(f"{dist.name} does not match the TestPyPI dry-run artifact") - print("artifacts match the TestPyPI dry-run") - EOF + rm -rf dist + gh run download "${{ steps.tagrun.outputs.run_id }}" -n dist -D dist -R "$GITHUB_REPOSITORY" + ls -la dist/ - name: Publish uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 diff --git a/examples/send_coins.py b/examples/send_coins.py index 2620e26..367bc80 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -187,10 +187,11 @@ def build(fee: int) -> tuple[bytes, int]: ) return tx, size - # The fee depends on the tx size, which depends on the change amount's - # digit count; the loop converges in a couple of passes. A change of zero - # (exact sweep) simply omits the change output. - fee = fee_rate # start from 1 KB worth of fees + # Start from a zero fee so the first build always succeeds (it only needs + # balance >= send_amt); the loop then converges from the size estimate. + # Starting from the full 1 KB rate would abort builds that are actually + # affordable. + fee = 0 try: tx, size = build(fee) for _ in range(4): diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 0628388..0dacf69 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -123,6 +123,12 @@ def call(self, method: str, params: Any) -> Any: raise JSONRPCError(f"decode response: {exc}") from exc if not isinstance(body, dict): raise JSONRPCError("decode response: unexpected JSON-RPC response shape") + # The daemon must echo the request id (JSON null would be a + # notification). A mismatched id means the payload belongs to some + # other call — fail loudly rather than misattribute it. + resp_id = body.get("id") + if resp_id is not None and resp_id != request_id: + raise JSONRPCError(f"response id mismatch: expected {request_id}, got {resp_id!r}") error = body.get("error") if error is not None: if not isinstance(error, dict): diff --git a/mintlayer/node/p2p.py b/mintlayer/node/p2p.py index cc3d5ba..135bdad 100644 --- a/mintlayer/node/p2p.py +++ b/mintlayer/node/p2p.py @@ -11,6 +11,10 @@ def _duration_to_wire(duration: timedelta) -> list[int]: """Split a duration into the daemon's [seconds, nanoseconds] wire form.""" + if duration.total_seconds() < 0: + # Python normalises negative timedeltas into (days=-1, seconds=86399); + # encoding that naively would ban for ~364 days instead of -1s. + raise ValueError(f"ban duration must not be negative, got {duration!r}") secs = duration.days * 86_400 + duration.seconds nanos = duration.microseconds * 1_000 return [secs, nanos] diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 491a743..d2119d5 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -38,13 +38,17 @@ from .types import Amount, WasmError _WASM_PATH = Path(__file__).parent / "wasm_wrappers_bg.wasm" -_WASM_BYTES = _WASM_PATH.read_bytes() -def _verify_wasm_integrity() -> None: - """Fail closed if the vendored WASM binary does not match its pinned hash.""" +def _load_and_verify_wasm() -> bytes: + """Load the vendored WASM binary, failing closed if it misses its pin. + + The read happens here (not at module scope) so a packaging mistake raises + a descriptive :class:`WasmError` instead of a raw FileNotFoundError. + """ if not _WASM_PATH.is_file(): raise WasmError(f"mintlayer: WASM binary missing: {_WASM_PATH}") + wasm_bytes = _WASM_PATH.read_bytes() pin_path = _WASM_PATH.with_suffix(".wasm.sha256") try: pin = pin_path.read_text().split() @@ -53,15 +57,16 @@ def _verify_wasm_integrity() -> None: if not pin: raise WasmError(f"mintlayer: WASM integrity pin file is empty: {pin_path}") expected = pin[0].strip() - actual = hashlib.sha256(_WASM_BYTES).hexdigest() + actual = hashlib.sha256(wasm_bytes).hexdigest() if actual != expected: raise WasmError( f"mintlayer: WASM binary integrity check failed " f"(expected sha256 {expected}, got {actual})" ) + return wasm_bytes -_verify_wasm_integrity() +_WASM_BYTES = _load_and_verify_wasm() class _CallState: diff --git a/tests/test_p2p.py b/tests/test_p2p.py index 33588e6..38df4c1 100644 --- a/tests/test_p2p.py +++ b/tests/test_p2p.py @@ -7,7 +7,10 @@ from datetime import timedelta +import pytest + from mintlayer.node import BannedPeer, Client, PeerInfo, TrustPolicy +from mintlayer.node.p2p import _duration_to_wire _LIST_BANNED_WIRE = '[["1.2.3.4",{"time":[1700000000,0]}]]' @@ -89,6 +92,31 @@ def test_ban_sub_second_duration(rpc_server) -> None: client.close() +def test_duration_to_wire_rejects_negative_durations() -> None: + """Negative durations fail closed before they can corrupt the wire form. + + Python normalises ``timedelta(seconds=-1)`` to ``(days=-1, seconds=86399)``; + encoding that naively would send [86399, 0] (~a 24h ban) instead of -1s. + """ + with pytest.raises(ValueError, match="must not be negative"): + _duration_to_wire(timedelta(seconds=-1)) + with pytest.raises(ValueError, match="must not be negative"): + _duration_to_wire(timedelta(days=-2)) + + +@pytest.mark.parametrize( + ("duration", "wire"), + [ + pytest.param(timedelta(days=1), [86_400, 0], id="one_day"), + pytest.param(timedelta(seconds=1), [1, 0], id="one_second"), + pytest.param(timedelta(microseconds=1500), [0, 1_500_000], id="sub_second"), + ], +) +def test_duration_to_wire_positive_durations(duration: timedelta, wire: list[int]) -> None: + """Positive durations split into the daemon's [seconds, nanoseconds] pair.""" + assert _duration_to_wire(duration) == wire + + def test_p2p_submit_transaction(rpc_server) -> None: srv = rpc_server(result=None) client = Client(srv.url) diff --git a/tests/test_transport.py b/tests/test_transport.py index badc177..9e499aa 100644 --- a/tests/test_transport.py +++ b/tests/test_transport.py @@ -10,7 +10,7 @@ import pytest -from mintlayer._jsonrpc import JSONRPCClient +from mintlayer._jsonrpc import JSONRPCClient, JSONRPCError from mintlayer.node import Client, RPCError _DUMMY_ENDPOINT = "http://127.0.0.1:3030" @@ -89,6 +89,29 @@ def test_request_ids_increment(rpc_server) -> None: client.close() +def test_response_id_mismatch_raises(rpc_server) -> None: + """A response belonging to another call is not silently misattributed. + + ``rpc_server(raw=...)`` -> ``make_raw_rpc_server`` splices its text + verbatim after ``"result":``, so the text ``1,"id":999`` adds a second + id key that ``json`` keeps (last one wins). The parsed response id is + 999 while this fresh client's first request id is 1. + """ + srv = rpc_server(raw='1,"id":999') + client = JSONRPCClient(srv.url) + with pytest.raises(JSONRPCError, match="response id mismatch: expected 1, got 999"): + client.call("node_version", {}) + client.close() + + +def test_response_null_id_is_tolerated(rpc_server) -> None: + """A JSON null response id (notification-style) does not raise.""" + srv = rpc_server(raw='1,"id":null') + client = JSONRPCClient(srv.url) + assert client.call("node_version", {}) == 1 + client.close() + + class TestCredentialSafetyGuard: """Basic-auth credentials must not go over cleartext http to remote hosts. diff --git a/tests/test_wasm_lifecycle.py b/tests/test_wasm_lifecycle.py index 1caed8c..b9235d7 100644 --- a/tests/test_wasm_lifecycle.py +++ b/tests/test_wasm_lifecycle.py @@ -10,6 +10,7 @@ import hashlib import threading +from pathlib import Path import pytest from wasm_helpers import MemorySpy @@ -27,15 +28,40 @@ def test_integrity_pin_file_matches_binary() -> None: expected = pin_path.read_text().split()[0].strip() actual = hashlib.sha256(wasm_core._WASM_BYTES).hexdigest() assert actual == expected - # The import-time check must also succeed via the same code path. - wasm_core._verify_wasm_integrity() + # Reloading through the loader exercises the same verify path as import. + assert wasm_core._load_and_verify_wasm() == wasm_core._WASM_BYTES -def test_integrity_pin_rejects_tampered_binary(monkeypatch: pytest.MonkeyPatch) -> None: - """A mismatching binary fails closed with a descriptive error.""" - monkeypatch.setattr(wasm_core, "_WASM_BYTES", b"tampered") +def test_integrity_pin_rejects_tampered_binary( + tmp_path: Path, monkeypatch: pytest.MonkeyPatch +) -> None: + """A binary whose hash differs from the pin fails closed.""" + wasm_file = tmp_path / "fake.wasm" + wasm_file.write_bytes(b"tampered") + original = hashlib.sha256(b"original").hexdigest() + wasm_file.with_suffix(".wasm.sha256").write_text(f"{original}\n") + monkeypatch.setattr(wasm_core, "_WASM_PATH", wasm_file) with pytest.raises(WasmError, match="integrity check failed"): - wasm_core._verify_wasm_integrity() + wasm_core._load_and_verify_wasm() + + +def test_missing_pin_file_fails_closed(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + """A binary without its sha256 pin file is a packaging error.""" + wasm_file = tmp_path / "fake.wasm" + wasm_file.write_bytes(b"binary") + monkeypatch.setattr(wasm_core, "_WASM_PATH", wasm_file) # no .sha256 written + with pytest.raises(WasmError, match="pin file missing"): + wasm_core._load_and_verify_wasm() + + +def test_empty_pin_file_fails_closed(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None: + """An empty pin file pins nothing and must not pass verification.""" + wasm_file = tmp_path / "fake.wasm" + wasm_file.write_bytes(b"binary") + wasm_file.with_suffix(".wasm.sha256").write_text("") + monkeypatch.setattr(wasm_core, "_WASM_PATH", wasm_file) + with pytest.raises(WasmError, match="pin file is empty"): + wasm_core._load_and_verify_wasm() # ── lifecycle ───────────────────────────────────────────────────────────────── From 7792cf0dab06c9dfc4b352103477a2285c2c252f Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 13:34:20 +0400 Subject: [PATCH 25/31] Address round-7 OCR findings CRITICAL fix verified against pinned wire fixtures: - examples/send_coins.py: the indexer UTXO output is a tagged union ({"Transfer": {...}}), not {"type": ..., "value": {...}} - the example would never find spendable UTXOs against a real indexer. Rewritten to the actual shape (tests/test_indexer_address.py fixtures) - examples/issue_token.py: only HTTP 404 counts as 'not indexed yet'; 5xx/transport failures now propagate instead of masking a server error - publish.yml: sha256 verification of the downloaded artifact against TestPyPI's published digests (the dry-run uploads are the trust anchor) - wasm/outputs.py: python-side supply_amount/total_supply invariant check - node/types.py: _require_int validation for timestamps/block heights (int(1.9) truncation, bool/str rejection) - indexer/types.py: Amount.from_json requires atoms/decimal keys instead of silently decoding truncated payloads to empty strings - client.py: wasm property reads under the init lock (consistent with init_wasm/close) - indexer/__init__.py: thread-safety docstring clarified (shared session cookie jar is not synchronised) - wasm/host.py: _new_with_length must NOT free its backing store - the module caches such Uint8Arrays in externref table slots (RNG scratch, verified by test) so a call-end free is a use-after-free. OCR 'leak' declined with evidence; a regression test pins the caching behaviour - ci.yml per-leg mypy finding: declined (python_version=3.10 floor already configured; matrix-wide mypy quadruples CI time for marginal value) --- .github/workflows/publish.yml | 21 +++++++++++ examples/issue_token.py | 4 +- examples/send_coins.py | 45 ++++++++++++++-------- mintlayer/client.py | 7 ++-- mintlayer/indexer/__init__.py | 6 ++- mintlayer/indexer/types.py | 4 +- mintlayer/node/types.py | 11 +++++- mintlayer/wasm/host.py | 9 ++++- mintlayer/wasm/outputs.py | 10 ++++- tests/test_chainstate.py | 56 ++++++++++++++++++++++++++++ tests/test_indexer_types.py | 55 +++++++++++++++++++++++++++ tests/test_wasm_lifecycle.py | 70 +++++++++++++++++++++++++++++++++++ tests/test_wasm_outputs.py | 51 ++++++++++++++++++++++++- 13 files changed, 320 insertions(+), 29 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 481c49d..9bf0b5a 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -164,6 +164,27 @@ jobs: gh run download "${{ steps.tagrun.outputs.run_id }}" -n dist -D dist -R "$GITHUB_REPOSITORY" ls -la dist/ + # Integrity check for the cross-run download: only publish bytes that + # are provably identical to what TestPyPI publicly serves for this + # version (the dry-run's uploads are the trust anchor). + - name: Verify artifacts match TestPyPI + run: | + python3 - <<'EOF' + import hashlib, json, os, pathlib, sys, urllib.request + + version = os.environ["GITHUB_REF_NAME"].lstrip("v") + url = f"https://test.pypi.org/pypi/mintlayer/{version}/json" + with urllib.request.urlopen(url, timeout=30) as resp: + remote = {u["filename"]: u["digests"]["sha256"] for u in json.load(resp)["urls"]} + if not remote: + sys.exit(f"version {version} not found on TestPyPI - cut the tag first") + for dist in sorted(pathlib.Path("dist").iterdir()): + digest = hashlib.sha256(dist.read_bytes()).hexdigest() + if remote.get(dist.name) != digest: + sys.exit(f"{dist.name} does not match the TestPyPI dry-run artifact") + print("artifacts match the TestPyPI dry-run") + EOF + - name: Publish uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 with: diff --git a/examples/issue_token.py b/examples/issue_token.py index e9df91a..bf6f85c 100644 --- a/examples/issue_token.py +++ b/examples/issue_token.py @@ -163,7 +163,9 @@ def main() -> None: while True: try: info = indexer.get_transaction(issue_result.tx_id) - except HTTPError: + except HTTPError as exc: + if exc.status_code != 404: + raise # transport/5xx failures are not "not indexed yet" info = None # not indexed yet — keep polling # confirmations is a string; treat "" and "0" as unconfirmed. if info and info.confirmations not in ("", "0"): diff --git a/examples/send_coins.py b/examples/send_coins.py index 367bc80..157fa88 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -56,16 +56,30 @@ def is_coin_transfer(output: object) -> bool: - """Whether a decoded UTXO output is a plain Transfer of native coins.""" - if not isinstance(output, dict) or output.get("type") != "Transfer": + """Whether a decoded UTXO output is a plain Transfer of native coins. + + Indexer wire shape (tagged union, see tests/test_indexer_address.py): + ``{"Transfer": {"destination": ..., "amount": {"atoms": ...}}}``. Native + coins carry a bare ``amount``; token transfers additionally carry a + ``token_id``. + """ + if not isinstance(output, dict): + return False + transfer = output.get("Transfer") + if not isinstance(transfer, dict): return False - value = output.get("value") - return isinstance(value, dict) and value.get("type") == "Coin" + amount = transfer.get("amount") + return ( + isinstance(amount, dict) + and "atoms" in amount + and "token_id" not in amount + and "tokenId" not in amount + ) def output_atoms(output: dict) -> int: """Atom count of a Transfer/Coin output (pre-validated by is_coin_transfer).""" - return int(output["value"]["amount"]["atoms"]) + return int(output["Transfer"]["amount"]["atoms"]) def encode_utxo_entry(wasm: WasmClient, utxo_json: dict, network: Network) -> bytes: @@ -75,16 +89,15 @@ def encode_utxo_entry(wasm: WasmClient, utxo_json: dict, network: Network) -> by if the sighash covers the real output, so a re-encoding failure is fatal rather than silently downgraded to a non-UTXO (``0x00``) entry. """ - if utxo_json.get("type") == "Transfer": - value = utxo_json["value"] - if value.get("type") == "Coin": - encoded = wasm.encode_output_transfer( - Amount(atoms=value["amount"]["atoms"]), - value["destination"], - network, - ) - return b"\x01" + encoded - raise ValueError(f"unsupported UTXO output type for minimal send: {utxo_json.get('type')!r}") + if is_coin_transfer(utxo_json): + transfer = utxo_json["Transfer"] + encoded = wasm.encode_output_transfer( + Amount(atoms=transfer["amount"]["atoms"]), + transfer["destination"], + network, + ) + return b"\x01" + encoded + raise ValueError(f"unsupported UTXO output type for minimal send: {list(utxo_json)!r}") def resolve_mnemonic(cli_value: str) -> str: @@ -135,7 +148,7 @@ def main() -> None: utxos = [u for u in all_utxos if is_coin_transfer(u.output)] for u in all_utxos: if not is_coin_transfer(u.output): - output_type = u.output.get("type") if isinstance(u.output, dict) else None + output_type = next(iter(u.output)) if isinstance(u.output, dict) and u.output else None log.warning("skipping non-Coin UTXO (type=%s)", output_type) if not utxos: diff --git a/mintlayer/client.py b/mintlayer/client.py index 53ffc08..b316f65 100644 --- a/mintlayer/client.py +++ b/mintlayer/client.py @@ -143,9 +143,10 @@ def init_wasm(self) -> None: @property def wasm(self) -> WASMClient: """The WASM cryptography client; :meth:`init_wasm` must be called first.""" - if self._wasm is None: - raise WasmError("mintlayer: init_wasm() must be called before using client.wasm") - return self._wasm + with self._mu: + if self._wasm is None: + raise WasmError("mintlayer: init_wasm() must be called before using client.wasm") + return self._wasm def close(self) -> None: """Release WASM resources and close sessions owned by sub-clients.""" diff --git a/mintlayer/indexer/__init__.py b/mintlayer/indexer/__init__.py index bf785a0..6ae7342 100644 --- a/mintlayer/indexer/__init__.py +++ b/mintlayer/indexer/__init__.py @@ -95,8 +95,10 @@ class Client( ): """REST client for the indexer (api-web-server). - Safe for concurrent use from multiple threads. Any HTTP status >= 400 - raises :class:`HTTPError`. + Requests are thread-safe in the sense that call results are independent; + the underlying ``requests.Session`` is shared, and its cookie jar is not + synchronised (the indexer API is cookie-less, so this is benign here). + Any HTTP status >= 400 raises :class:`HTTPError`. """ def __init__( diff --git a/mintlayer/indexer/types.py b/mintlayer/indexer/types.py index c086f94..4bad190 100644 --- a/mintlayer/indexer/types.py +++ b/mintlayer/indexer/types.py @@ -54,7 +54,9 @@ class Amount: @classmethod def from_json(cls, data: dict) -> Amount: - return cls(atoms=data.get("atoms", ""), decimal=data.get("decimal", "")) + # Required keys: a truncated payload must surface as IndexerError via + # _safe_from_json, not silently decode to a zero-value Amount. + return cls(atoms=data["atoms"], decimal=data["decimal"]) @dataclass(frozen=True) diff --git a/mintlayer/node/types.py b/mintlayer/node/types.py index 1684d1f..e1ef26e 100644 --- a/mintlayer/node/types.py +++ b/mintlayer/node/types.py @@ -45,6 +45,13 @@ def to_json(self) -> dict: return {"atoms": self.atoms} +def _require_int(value: Any, field: str) -> int: + """Reject bool/float/str where the daemon wire contract says integer.""" + if isinstance(value, bool) or not isinstance(value, int): + raise ValueError(f"invalid {field}: {value!r}") + return value + + @dataclass(frozen=True) class Timestamp: """Unix seconds.""" @@ -53,7 +60,7 @@ class Timestamp: @classmethod def from_json(cls, data: Any) -> Timestamp: - return cls(timestamp=int(data["timestamp"])) + return cls(timestamp=_require_int(data["timestamp"], "timestamp")) @dataclass(frozen=True) @@ -67,7 +74,7 @@ class ChainstateInfo: @classmethod def from_json(cls, data: dict) -> ChainstateInfo: return cls( - best_block_height=data["best_block_height"], + best_block_height=_require_int(data["best_block_height"], "best_block_height"), best_block_id=data["best_block_id"], best_block_timestamp=Timestamp.from_json(data["best_block_timestamp"]), median_time=Timestamp.from_json(data["median_time"]), diff --git a/mintlayer/wasm/host.py b/mintlayer/wasm/host.py index 49f9a91..6e3498f 100644 --- a/mintlayer/wasm/host.py +++ b/mintlayer/wasm/host.py @@ -219,8 +219,15 @@ def _length(value: Any) -> int: return 0 def _new_with_length(size: int) -> Any: + # NOTE: the backing store is deliberately NOT freed host-side. The WASM + # module treats these Uint8Arrays as GC-managed JS values: it caches + # them in externref table slots (e.g. the RNG scratch buffer) and + # reuses them across calls. Freeing on call end would be a use-after- + # free; the cost is a bounded, one-time allocation per cached buffer. ptr = invoke("__wbindgen_malloc", size, 1)[0] - client.memory.write(store, b"\x00" * size, ptr) + if client.memory.write(store, b"\x00" * size, ptr) is None: + signal_exception("new Uint8Array: memory write failed") + return None return Uint8ArrayRef(ptr, size) def _prototypesetcall(dst_ptr: int, dst_len: int, src: Any) -> None: diff --git a/mintlayer/wasm/outputs.py b/mintlayer/wasm/outputs.py index 84a68f8..f812afd 100644 --- a/mintlayer/wasm/outputs.py +++ b/mintlayer/wasm/outputs.py @@ -207,9 +207,15 @@ def encode_output_issue_fungible_token( ) -> bytes: """Create an output that issues a new fungible token. - ``supply_amount`` may be ``None`` unless ``total_supply`` is - ``TotalSupply.FIXED``. + ``supply_amount`` is required when ``total_supply`` is + ``TotalSupply.FIXED`` and must be ``None`` otherwise. """ + if (total_supply == TotalSupply.FIXED) != (supply_amount is not None): + raise ValueError( + "supply_amount is required for TotalSupply.FIXED " + "and must be None otherwise " + f"(total_supply={total_supply!r}, supply_amount={supply_amount!r})" + ) auth_ptr, auth_len = self._write_string(authority) tkr_ptr, tkr_len = self._write_string(token_ticker) uri_ptr, uri_len = self._write_string(metadata_uri) diff --git a/tests/test_chainstate.py b/tests/test_chainstate.py index 92f9271..121c6b6 100644 --- a/tests/test_chainstate.py +++ b/tests/test_chainstate.py @@ -197,6 +197,62 @@ def test_amount_from_json_valid_string() -> None: assert Amount.from_json({"atoms": "100"}) == Amount(atoms="100") +# ── strict integer decoding (node wire contract) ───────────────────────────── + + +@pytest.mark.parametrize( + "bad", + [ + pytest.param(1.9, id="float"), + pytest.param("123", id="numeric-string"), + pytest.param(True, id="bool"), + ], +) +def test_timestamp_from_json_rejects_non_int(bad: object) -> None: + """Timestamp seconds must be a JSON integer, not float/str/bool.""" + with pytest.raises(ValueError, match="invalid timestamp"): + Timestamp.from_json({"timestamp": bad}) # type: ignore[dict-item] + + +def test_chainstate_info_best_block_height_rejects_non_int(rpc_server) -> None: + """A float ``best_block_height`` is rejected instead of truncated.""" + payload = { + "best_block_height": 100.5, + "best_block_id": "aabbccdd", + "best_block_timestamp": {"timestamp": 1700000000}, + "median_time": {"timestamp": 1699999500}, + "is_initial_block_download": False, + } + srv = rpc_server(result=payload) + client = Client(srv.url) + with pytest.raises(ValueError, match="invalid best_block_height"): + client.chainstate_info() + client.close() + + +def test_chainstate_info_valid_int_payload_still_decodes(rpc_server) -> None: + """Real integer payloads keep decoding unchanged (no over-tightening).""" + payload = { + "best_block_height": 123456, + "best_block_id": "aabbccdd", + "best_block_timestamp": {"timestamp": 1700000000}, + "median_time": {"timestamp": 1699999500}, + "is_initial_block_download": False, + } + srv = rpc_server(result=payload) + client = Client(srv.url) + info = client.chainstate_info() + assert info.best_block_height == 123456 + assert info.best_block_timestamp == Timestamp(timestamp=1700000000) + client.close() + + +def test_timestamp_from_json_valid_int() -> None: + """A genuine JSON int still decodes (bool is excluded by isinstance checks).""" + assert Timestamp.from_json({"timestamp": 1700000000}) == Timestamp(timestamp=1700000000) + assert Timestamp.from_json({"timestamp": 0}) == Timestamp(timestamp=0) + + @pytest.mark.parametrize( "payload", [ diff --git a/tests/test_indexer_types.py b/tests/test_indexer_types.py index 7398749..017cb58 100644 --- a/tests/test_indexer_types.py +++ b/tests/test_indexer_types.py @@ -31,3 +31,58 @@ def test_indexer_error_from_json_still_lists_transaction_fields() -> None: """Sanity: well-formed payloads keep decoding through the same wrapper.""" tx = Transaction.from_json({"id": "tx01"}) assert tx.id == "tx01" + + +# ── Amount: both wire keys are now required ────────────────────────────────── + + +def _raw_amount_from_json(): + """The unwrapped ``Amount.from_json`` decoder (before _safe_from_json). + + The module wraps every registered class at import time; the original + function is kept in the wrapper's closure so the raw KeyError semantics + stay observable. + """ + wrapper = Amount.from_json.__func__ + for cell in wrapper.__closure__ or (): + candidate = cell.cell_contents + if callable(candidate) and candidate is not wrapper: + return candidate + raise AssertionError("unwrapped Amount.from_json not found in closure") + + +@pytest.mark.parametrize( + "payload", + [ + pytest.param({}, id="both-keys-missing"), + pytest.param({"atoms": "100"}, id="decimal-missing"), + pytest.param({"decimal": "0.000001"}, id="atoms-missing"), + ], +) +def test_amount_from_json_missing_key_raises_key_error(payload: dict) -> None: + """A truncated payload raises KeyError in the raw decoder — no silent defaults.""" + raw = _raw_amount_from_json() + with pytest.raises(KeyError): + raw(Amount, payload) + + +@pytest.mark.parametrize( + "payload", + [ + pytest.param({}, id="both-keys-missing"), + pytest.param({"atoms": "100"}, id="decimal-missing"), + pytest.param({"decimal": "0.000001"}, id="atoms-missing"), + ], +) +def test_amount_from_json_missing_key_raises_indexer_error(payload: dict) -> None: + """Through the _safe_from_json wrapper the same payload is an IndexerError.""" + with pytest.raises(IndexerError, match="Amount: malformed payload") as excinfo: + Amount.from_json(payload) + assert isinstance(excinfo.value.__cause__, KeyError) + + +def test_amount_from_json_both_keys_present_still_decodes() -> None: + """A payload carrying both keys keeps decoding to a frozen Amount.""" + assert Amount.from_json({"atoms": "100", "decimal": "0.000001"}) == Amount( + atoms="100", decimal="0.000001" + ) diff --git a/tests/test_wasm_lifecycle.py b/tests/test_wasm_lifecycle.py index b9235d7..d44fffe 100644 --- a/tests/test_wasm_lifecycle.py +++ b/tests/test_wasm_lifecycle.py @@ -225,3 +225,73 @@ def worker() -> None: assert not errors assert len(keys) == 20 assert len(set(keys)) == 20 + + +# ── host-created Uint8Array scratch buffers ─────────────────────────────────── + + +def test_cached_rng_scratch_buffer_survives_across_calls() -> None: + """The RNG scratch Uint8Array is cached by the module and never freed host-side. + + The wasm module creates its RNG scratch ``Uint8Array`` once (via the + ``__wbg_new_with_length`` host callback) and caches it in an externref + table slot, reusing it for every keygen/signing call — mirroring the JS + glue where ``new Uint8Array(n)`` is GC-managed, not call-scoped. + + Freeing that backing store at the end of a call would therefore be a + use-after-free: the next keygen writes through the cached reference into + freed memory and corrupts the allocator free-list (observed as + ``memory fault``/``unreachable`` traps on subsequent unrelated calls, + e.g. ``encode_multisig_challenge``). The host deliberately keeps + ``_new_with_length`` free of any cleanup — see the NOTE in + ``mintlayer/wasm/host.py``. + + Asserts two invariants: + + * no host-side free ever targets a (ptr, length) still referenced from + the externref table, and + * the SAME cached scratch buffer (ptr, length) is reused across two + consecutive keygen calls, proving the module caches it — and thus why + host-side freeing is forbidden. + """ + from mintlayer.wasm.host import Uint8ArrayRef + + c = Client() + try: + freed: list[tuple[int, int]] = [] + original_free = c._free_wasm + + def spy_free(ptr: int, size: int, align: int = 1) -> None: + freed.append((ptr, size)) + original_free(ptr, size, align) + + c._free_wasm = spy_free # type: ignore[method-assign] + + def cached_refs() -> set[tuple[int, int]]: + refs: set[tuple[int, int]] = set() + for idx in range(c.table.size(c.store)): + value = c.table.get(c.store, idx) + if isinstance(value, Uint8ArrayRef): + refs.add((value.ptr, value.length)) + return refs + + c.make_private_key() + cached_first = cached_refs() + assert cached_first, "expected the module to cache its RNG scratch Uint8Array" + + c.make_private_key() + cached_second = cached_refs() + + reused = cached_first & cached_second + assert reused, ( + "the cached RNG scratch Uint8Array (same ptr, length) must survive and " + "be reused across consecutive keygen calls — proving module-side " + "caching, which is why host-side freeing would be a use-after-free" + ) + still_referenced = cached_second & set(freed) + assert not still_referenced, ( + "use-after-free: host-side free touched buffer(s) still referenced " + f"by the externref table: {sorted(still_referenced)}" + ) + finally: + c.close() diff --git a/tests/test_wasm_outputs.py b/tests/test_wasm_outputs.py index ebef430..d6f67d8 100644 --- a/tests/test_wasm_outputs.py +++ b/tests/test_wasm_outputs.py @@ -194,8 +194,25 @@ def test_encode_output_issue_fungible_token_fixed(wallet: Wallet, wasm: Client) assert len(out) > 0 +def test_encode_output_issue_fungible_token_unlimited(wallet: Wallet, wasm: Client) -> None: + """UNLIMITED supply must not carry a supply_amount (valid combination).""" + out = wasm.encode_output_issue_fungible_token( + wallet.addr, + "GLD", + "", + 8, + TotalSupply.UNLIMITED, + None, + FreezableToken.NO, + HEIGHT, + Network.MAINNET, + ) + assert isinstance(out, bytes) and len(out) > 0 + + def test_issue_fixed_supply_without_amount_raises(wallet: Wallet, wasm: Client) -> None: - with pytest.raises(WasmError, match="fixed total supply"): + """FIXED without supply_amount is rejected before any WASM call.""" + with pytest.raises(ValueError, match="supply_amount is required for TotalSupply.FIXED"): wasm.encode_output_issue_fungible_token( wallet.addr, "GLD", @@ -209,6 +226,38 @@ def test_issue_fixed_supply_without_amount_raises(wallet: Wallet, wasm: Client) ) +def test_issue_non_fixed_supply_with_amount_raises(wallet: Wallet, wasm: Client) -> None: + """A supply_amount together with a non-FIXED supply policy is rejected.""" + with pytest.raises(ValueError, match="must be None otherwise"): + wasm.encode_output_issue_fungible_token( + wallet.addr, + "GLD", + "", + 8, + TotalSupply.UNLIMITED, + Amount.from_atoms("1000000"), + FreezableToken.NO, + HEIGHT, + Network.MAINNET, + ) + + +def test_issue_lockable_supply_with_amount_raises(wallet: Wallet, wasm: Client) -> None: + """LOCKABLE behaves like UNLIMITED: a supply_amount is rejected.""" + with pytest.raises(ValueError, match="must be None otherwise"): + wasm.encode_output_issue_fungible_token( + wallet.addr, + "GLD", + "", + 8, + TotalSupply.LOCKABLE, + Amount.from_atoms("1000000"), + FreezableToken.NO, + HEIGHT, + Network.MAINNET, + ) + + def test_encode_output_issue_nft_minimal(wallet: Wallet, token_id: str, wasm: Client) -> None: out = wasm.encode_output_issue_nft( token_id, From 6805b95de325e8a384b030bd80828f415e0c00b1 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 13:52:22 +0400 Subject: [PATCH 26/31] Address round-8 OCR findings - _jsonrpc.py: a JSON null (or missing) response id on a success payload is now rejected - JSON-RPC 2.0 reserves null ids for server-side error notifications, so such payloads cannot be attributed to this call - wasm/_core.py: externref index-array writes now check the memory.write return (consistent with _write_bytes); a failed write triggers the existing pre-call rollback instead of leaving a garbage index array - declined, with rationale documented in code: freeing result buffers on fallible-call error paths (reference glue zeroes rather than frees - ret[0] is not a valid allocation when the error flag is set); _read_amount bypassing _call (mirrors go-sdk; _call would reset the parent call's captured error state); speculative token-Transfer shape hardening in the send_coins example - tests: null-id expectation flipped to match the tightened contract --- mintlayer/_jsonrpc.py | 8 ++++---- mintlayer/wasm/_core.py | 27 ++++++++++++++++++++++++--- tests/test_transport.py | 14 +++++++++++--- 3 files changed, 39 insertions(+), 10 deletions(-) diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 0dacf69..76b500a 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -123,11 +123,11 @@ def call(self, method: str, params: Any) -> Any: raise JSONRPCError(f"decode response: {exc}") from exc if not isinstance(body, dict): raise JSONRPCError("decode response: unexpected JSON-RPC response shape") - # The daemon must echo the request id (JSON null would be a - # notification). A mismatched id means the payload belongs to some - # other call — fail loudly rather than misattribute it. + # The daemon must echo the request id. JSON-RPC 2.0 reserves a null id + # for server-side error notifications; a success payload with a null + # or mismatched id cannot be attributed to this call — fail loudly. resp_id = body.get("id") - if resp_id is not None and resp_id != request_id: + if resp_id != request_id: raise JSONRPCError(f"response id mismatch: expected {request_id}, got {resp_id!r}") error = body.get("error") if error is not None: diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index d2119d5..61e9c8f 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -183,6 +183,11 @@ def _call_return_bytes(self, name: str, *params: Any) -> bytes: """fn expects [ptr, len, errRef, errFlag].""" ret = self._call(name, *params) if len(ret) >= 4 and ret[3] != 0: + # No buffer cleanup on the error path, matching the reference + # glue: it zeroes the pointer instead of freeing, because ret[0] + # is not a valid allocation once the error flag is set (the Rust + # Err variant allocates no result) - freeing it could corrupt + # the allocator. raise self._extract_error(ret[2]) if len(ret) < 2: raise WasmError(f"mintlayer: unexpected return count from {name}") @@ -213,6 +218,7 @@ def _call_return_string(self, name: str, *params: Any) -> str: """fn expects [ptr, len, errRef, errFlag]; result is UTF-8.""" ret = self._call(name, *params) if len(ret) >= 4 and ret[3] != 0: + # Error-path buffers are not freed: see _call_return_bytes. raise self._extract_error(ret[2]) if len(ret) < 2: raise WasmError(f"mintlayer: unexpected return count from {name}") @@ -337,7 +343,14 @@ def _new_wasm_amount(self, amount: Amount) -> int: raise def _read_amount(self, wasm_ptr: int) -> Amount: - """Read the atom string from a WASM Amount handle (consumes it).""" + """Read the atom string from a WASM Amount handle (consumes it). + + Deliberately uses ``_call_export`` rather than ``_call`` (mirrors + go-sdk's readAmount): ``amount_atoms`` decodes after the parent call + already extracted its error state, and routing it through ``_call`` + would reset the per-call ``err_msg``/``last_json`` the parent + captured. + """ ret = self._call_export("amount_atoms", wasm_ptr) if len(ret) < 2: raise WasmError("mintlayer: amount_atoms failed") @@ -382,7 +395,11 @@ def _write_string_array(self, strs: list[str]) -> tuple[int, list[int]]: idx = self._invoke1("__externref_table_alloc") indices.append(idx) self.table.set(self.store, idx, s) - self.memory.write(self.store, idx.to_bytes(4, "little"), arr_ptr + i * 4) + if ( + self.memory.write(self.store, idx.to_bytes(4, "little"), arr_ptr + i * 4) + is None + ): + raise WasmError("mintlayer: memory write failed") except BaseException: self._dealloc_indices(indices) with contextlib.suppress(Exception): @@ -418,7 +435,11 @@ def _write_uint8_array_array( idx = self._invoke1("__externref_table_alloc") indices.append(idx) self.table.set(self.store, idx, Uint8ArrayRef(wasm_ptr, wasm_len)) - self.memory.write(self.store, idx.to_bytes(4, "little"), arr_ptr + i * 4) + if ( + self.memory.write(self.store, idx.to_bytes(4, "little"), arr_ptr + i * 4) + is None + ): + raise WasmError("mintlayer: memory write failed") except BaseException: self._dealloc_indices(indices) for ptr, length in buffers: diff --git a/tests/test_transport.py b/tests/test_transport.py index 9e499aa..e0a15d9 100644 --- a/tests/test_transport.py +++ b/tests/test_transport.py @@ -104,11 +104,19 @@ def test_response_id_mismatch_raises(rpc_server) -> None: client.close() -def test_response_null_id_is_tolerated(rpc_server) -> None: - """A JSON null response id (notification-style) does not raise.""" +def test_response_null_id_raises(rpc_server) -> None: + """A JSON null response id (server-side notification) cannot be + attributed to this call and must fail loudly. + + ``rpc_server(raw=...)`` -> ``make_raw_rpc_server`` splices its text + verbatim after ``"result":``, so the text ``1,"id":null`` adds a second + id key that ``json`` keeps (last one wins). The parsed response id is + ``None`` while this fresh client's first request id is 1. + """ srv = rpc_server(raw='1,"id":null') client = JSONRPCClient(srv.url) - assert client.call("node_version", {}) == 1 + with pytest.raises(JSONRPCError, match="response id mismatch: expected 1, got None"): + client.call("node_version", {}) client.close() From 6ac9ab2a20ad04ddbe17ae4ad9c9337617451187 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 14:01:09 +0400 Subject: [PATCH 27/31] Address round-9 OCR findings - wallet/__init__.py: export OwnOrder, Outpoint, OutpointSourceID, RevealPublicKeyResult, OrderState, TxStats and Timestamp (types needed to use the public API) - client.py: close already-created sub-clients if a later constructor fails (e.g. cleartext-credential guard) instead of leaking sessions - _jsonrpc.py: document the actual thread-safety contract of the shared session (synchronised id/flow, cookie-less daemons, urllib3 pool) - examples/send_coins.py: drop dust change outputs below a documented threshold (remainder goes to fees) with a warning - publish.yml: distinguish 'artifact missing on TestPyPI' from 'digest mismatch' in the integrity gate - declined: OCR bug-high claiming HTTPError is not exported - it is (mintlayer/indexer/__init__.py exports and documents it) - _free_wasm: document why cleanup failures are swallowed --- .github/workflows/publish.yml | 4 +++- examples/send_coins.py | 13 ++++++++++- mintlayer/_jsonrpc.py | 6 +++++ mintlayer/client.py | 42 ++++++++++++++++++++--------------- mintlayer/wallet/__init__.py | 14 ++++++++++++ mintlayer/wasm/_core.py | 6 +++++ 6 files changed, 65 insertions(+), 20 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 9bf0b5a..3428c70 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -180,7 +180,9 @@ jobs: sys.exit(f"version {version} not found on TestPyPI - cut the tag first") for dist in sorted(pathlib.Path("dist").iterdir()): digest = hashlib.sha256(dist.read_bytes()).hexdigest() - if remote.get(dist.name) != digest: + if dist.name not in remote: + sys.exit(f"{dist.name} is not published on TestPyPI for version {version}") + if remote[dist.name] != digest: sys.exit(f"{dist.name} does not match the TestPyPI dry-run artifact") print("artifacts match the TestPyPI dry-run") EOF diff --git a/examples/send_coins.py b/examples/send_coins.py index 157fa88..f4a1bd2 100644 --- a/examples/send_coins.py +++ b/examples/send_coins.py @@ -54,6 +54,11 @@ FEE_RATE_PER_KB_FALLBACK = 100_000 # atoms/KB used when the indexer has no fee data +# Change outputs below this many atoms are dropped (the remainder goes to +# fees): a dust output may be rejected by nodes and costs more to spend +# than it is worth. +DUST_THRESHOLD_ATOMS = 1_000_000 # 0.00001 ML + def is_coin_transfer(output: object) -> bool: """Whether a decoded UTXO output is a plain Transfer of native coins. @@ -191,8 +196,14 @@ def build(fee: int) -> tuple[bytes, int]: if change < 0: raise ValueError(f"insufficient balance for fee: have {total}, need {send_amt} + {fee}") outputs = wasm.encode_output_transfer(Amount(atoms=str(send_amt)), args.to, network) - if change > 0: + if change > DUST_THRESHOLD_ATOMS: outputs += wasm.encode_output_transfer(Amount(atoms=str(change)), from_addr, network) + elif change > 0: + log.warning( + "dropping dust change of %d atoms (below %d); remainder goes to fees", + change, + DUST_THRESHOLD_ATOMS, + ) tx = wasm.encode_transaction(encoded_inputs, outputs, 0) # The size estimate needs the encoded INPUTS blob (one address per input). size = wasm.estimate_transaction_size( diff --git a/mintlayer/_jsonrpc.py b/mintlayer/_jsonrpc.py index 76b500a..c5cfdd9 100644 --- a/mintlayer/_jsonrpc.py +++ b/mintlayer/_jsonrpc.py @@ -96,6 +96,12 @@ def call(self, method: str, params: Any) -> Any: ``params`` must be a JSON-serialisable object (dict); no-arg methods pass ``{}``. A JSON-RPC error object raises :class:`RPCError`. + + Thread-safety: the id counter and per-call flow are synchronised, and + the daemons are cookie-less, so concurrent calls share the session's + connection pool safely (urllib3 pool is thread-safe). Sessions carry + no per-call state here; a caller-supplied session that mutates state + (cookies, hooks) is the caller's responsibility to synchronise. """ with self._lock: self._id += 1 diff --git a/mintlayer/client.py b/mintlayer/client.py index b316f65..065380e 100644 --- a/mintlayer/client.py +++ b/mintlayer/client.py @@ -110,26 +110,32 @@ def __init__(self, cfg: Config) -> None: self._wasm: WASMClient | None = None self.node: NodeClient | None = None - if cfg.node_url: - self.node = NodeClient( - cfg.node_url, - username=cfg.username, - password=cfg.password, - timeout=cfg.timeout, - ) - self.indexer: IndexerClient | None = None - if cfg.indexer_url: - self.indexer = IndexerClient(cfg.indexer_url, timeout=cfg.timeout) - self.wallet: WalletClient | None = None - if cfg.wallet_url: - self.wallet = WalletClient( - cfg.wallet_url, - username=cfg.username, - password=cfg.password, - timeout=cfg.timeout, - ) + try: + if cfg.node_url: + self.node = NodeClient( + cfg.node_url, + username=cfg.username, + password=cfg.password, + timeout=cfg.timeout, + ) + + if cfg.indexer_url: + self.indexer = IndexerClient(cfg.indexer_url, timeout=cfg.timeout) + + if cfg.wallet_url: + self.wallet = WalletClient( + cfg.wallet_url, + username=cfg.username, + password=cfg.password, + timeout=cfg.timeout, + ) + except BaseException: + # A later constructor failing (e.g. the cleartext-credential guard) + # must not leak the sessions of already-created sub-clients. + self.close() + raise def init_wasm(self) -> None: """Initialise the embedded WASM cryptography runtime (~400 ms). diff --git a/mintlayer/wallet/__init__.py b/mintlayer/wallet/__init__.py index d8c833a..e58fba4 100644 --- a/mintlayer/wallet/__init__.py +++ b/mintlayer/wallet/__init__.py @@ -53,20 +53,27 @@ MnemonicResult, NFTMetadata, OrderCreated, + OrderState, + Outpoint, + OutpointSourceID, OutputValue, OwnedPool, + OwnOrder, RecoverWalletParams, + RevealPublicKeyResult, SendParams, SendResult, SignedTx, StakingStatus, SubmitResult, SweepParams, + Timestamp, TokenMetadata, TokenSendParams, TokenSupply, TxInspection, TxOptions, + TxStats, UnfreezeParams, UnmintParams, UTXOSpendParams, @@ -114,20 +121,27 @@ "MnemonicResult", "NFTMetadata", "OrderCreated", + "OrderState", + "Outpoint", + "OutpointSourceID", "OutputValue", "OwnedPool", + "OwnOrder", "RecoverWalletParams", + "RevealPublicKeyResult", "SendParams", "SendResult", "SignedTx", "StakingStatus", "SubmitResult", "SweepParams", + "Timestamp", "TokenMetadata", "TokenSendParams", "TokenSupply", "TxInspection", "TxOptions", + "TxStats", "UTXOSpendParams", "UnfreezeParams", "UnmintParams", diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 61e9c8f..6029c16 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -314,6 +314,12 @@ def _write_string(self, s: str) -> tuple[int, int]: return self._write_bytes(s.encode("utf-8")) def _free_wasm(self, ptr: int, size: int, align: int = 1) -> None: + """Free a host-owned WASM allocation. + + Failures are deliberately swallowed: a cleanup error must not mask + the call's outcome, and if the allocator is genuinely corrupted the + NEXT wasm call traps loudly anyway (surfaces as WasmError). + """ if ptr == 0: return with contextlib.suppress(Exception): From b8cef424e036239be48de59f7e41b6d663f39079 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 14:07:46 +0400 Subject: [PATCH 28/31] Address round-10 OCR findings - node/_core.py: _call_opt_amount wraps Amount decoding failures into JSONRPCError (was a bare ValueError/KeyError, breaking the documented error contract) - publish.yml: scope actions:read to the publish-pypi job only; build runs project code and must not carry cross-run artifact access - declined with rationale: init_wasm holding the lock through construction is intentional (no half-built client can escape); signal_exception returning normally matches the wasm-bindgen contract and go-sdk/JS hosts (the host cannot force an Err return); _cast_string error-message capture is inert on success paths --- .github/workflows/publish.yml | 8 +++++--- mintlayer/client.py | 4 ++++ mintlayer/node/_core.py | 9 ++++++++- mintlayer/wasm/host.py | 5 +++++ 4 files changed, 22 insertions(+), 4 deletions(-) diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index 3428c70..c62899c 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -20,11 +20,8 @@ on: # with an API token stored in the environment secrets. PEP 740 attestations # require OIDC trusted publishing; re-enable both if the project migrates # to trusted publishing (which would also eliminate the long-lived token). -# actions:read lets publish-pypi download the dist/ artifact produced by the -# earlier tag-push run. permissions: contents: read - actions: read # Never cancel a publish in flight. concurrency: @@ -137,6 +134,11 @@ jobs: runs-on: ubuntu-latest timeout-minutes: 10 environment: pypi + # Only this job needs cross-run artifact download access; build runs + # project code and must not carry it. + permissions: + contents: read + actions: read steps: # Rebuilds are not guaranteed byte-reproducible (wheel zip timestamps), # so instead of building again we publish the EXACT dist/ artifact that diff --git a/mintlayer/client.py b/mintlayer/client.py index 065380e..b433a40 100644 --- a/mintlayer/client.py +++ b/mintlayer/client.py @@ -141,6 +141,10 @@ def init_wasm(self) -> None: """Initialise the embedded WASM cryptography runtime (~400 ms). Subsequent calls are no-ops. Safe for concurrent use. + + The lock is deliberately held for the whole construction: a + concurrent ``wasm`` access must wait for a fully-built client rather + than observe a half-initialised one (or trigger duplicate builds). """ with self._mu: if self._wasm is None: diff --git a/mintlayer/node/_core.py b/mintlayer/node/_core.py index ee68f77..7a0ad60 100644 --- a/mintlayer/node/_core.py +++ b/mintlayer/node/_core.py @@ -52,4 +52,11 @@ def _call_str_list(self, method: str, params: Any) -> list[str]: def _call_opt_amount(self, method: str, params: Any) -> Amount | None: result = self._rpc.call(method, params) - return Amount.from_json(result) if result is not None else None + if result is None: + return None + try: + return Amount.from_json(result) + except (ValueError, KeyError, TypeError) as exc: + # Amount.from_json raises bare ValueError/KeyError; decoding + # failures must surface as the documented JSONRPCError contract. + raise JSONRPCError(f"{method}: invalid amount payload {result!r}") from exc diff --git a/mintlayer/wasm/host.py b/mintlayer/wasm/host.py index 6e3498f..b88159e 100644 --- a/mintlayer/wasm/host.py +++ b/mintlayer/wasm/host.py @@ -106,6 +106,11 @@ def signal_exception(msg: str) -> None: ``__wbindgen_exn_store`` receives the externref holding the exception value (JS stores the ``Error`` object); we store the message string so the WASM unwind path reads this call's payload instead of a stale slot. + + Like the JS glue and go-sdk's host, the host function itself returns + normally after stashing — whether the callee converts the stored + exception into an Err is decided by the module's generated code + (wasm-bindgen contract); the host cannot force an Err return. """ if not state.err_msg: state.err_msg = msg From 121dedfe9dc6b3513926b411969ff444c6dc9820 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 14:23:58 +0400 Subject: [PATCH 29/31] Address round-11 OCR findings - indexer/number.py: parse_per_thousand converts OverflowError (float of a hostile oversized int) into IndexerError; the _safe_from_json wrapper also catches OverflowError - node: new _decode_model helper converts malformed-payload decode failures into the documented JSONRPCError contract at all typed call sites (chainstate_info, token/tokens/order info, orders info by currencies, mempool tx/fee rates); one test expectation updated to the converted exception type - wasm/_core.py: _load_and_verify_wasm docstring no longer contradicts the import-time fail-fast design - declined: wasm property TOCTOU vs concurrent close() - inherent to the property API; the failure is loud (client is closed) by design, and the lock already prevents the half-constructed escape --- mintlayer/indexer/number.py | 6 +++++- mintlayer/indexer/types.py | 2 +- mintlayer/node/_core.py | 26 +++++++++++++++++++------- mintlayer/node/chainstate.py | 30 ++++++++++++++++++++++++------ mintlayer/node/mempool.py | 19 +++++++++++++++---- mintlayer/wasm/_core.py | 6 ++++-- tests/test_chainstate.py | 2 +- 7 files changed, 69 insertions(+), 22 deletions(-) diff --git a/mintlayer/indexer/number.py b/mintlayer/indexer/number.py index a83cc58..68803d5 100644 --- a/mintlayer/indexer/number.py +++ b/mintlayer/indexer/number.py @@ -42,7 +42,11 @@ def parse_per_thousand(data: Any) -> float: if isinstance(data, bool): raise IndexerError(f"PerThousand: invalid value {data!r}") if isinstance(data, (int, float)): - value = float(data) + try: + value = float(data) + except OverflowError as exc: + # float(10**400) raises OverflowError, not ValueError. + raise IndexerError(f"PerThousand: value out of range {data!r}") from exc if not math.isfinite(value): raise IndexerError(f"PerThousand: non-finite value {data!r}") return value diff --git a/mintlayer/indexer/types.py b/mintlayer/indexer/types.py index 4bad190..35f2938 100644 --- a/mintlayer/indexer/types.py +++ b/mintlayer/indexer/types.py @@ -506,7 +506,7 @@ def from_json(cls_: type[_T], data: Any) -> _T: return original(cls_, data) except IndexerError: raise - except (AttributeError, KeyError, TypeError, ValueError) as exc: + except (AttributeError, KeyError, TypeError, ValueError, OverflowError) as exc: raise IndexerError(f"{cls_.__name__}: malformed payload ({exc!r})") from exc return classmethod(from_json) diff --git a/mintlayer/node/_core.py b/mintlayer/node/_core.py index 7a0ad60..af6396f 100644 --- a/mintlayer/node/_core.py +++ b/mintlayer/node/_core.py @@ -2,12 +2,27 @@ from __future__ import annotations -from typing import Any +from collections.abc import Callable +from typing import Any, TypeVar from mintlayer._jsonrpc import BaseJSONRPCClient, JSONRPCError from .types import Amount +_T = TypeVar("_T") + + +def _decode_model(method: str, factory: Callable[[Any], _T], data: Any) -> _T: + """Run a ``from_json`` decoder, converting malformed payloads to the + documented JSONRPCError contract (mirrors the indexer's _safe_from_json). + """ + try: + return factory(data) + except JSONRPCError: + raise + except (KeyError, TypeError, ValueError) as exc: + raise JSONRPCError(f"{method}: malformed result ({exc!r})") from exc + class _NodeCore(BaseJSONRPCClient): """Node-specific typed result helpers over the shared JSON-RPC base.""" @@ -54,9 +69,6 @@ def _call_opt_amount(self, method: str, params: Any) -> Amount | None: result = self._rpc.call(method, params) if result is None: return None - try: - return Amount.from_json(result) - except (ValueError, KeyError, TypeError) as exc: - # Amount.from_json raises bare ValueError/KeyError; decoding - # failures must surface as the documented JSONRPCError contract. - raise JSONRPCError(f"{method}: invalid amount payload {result!r}") from exc + # Amount.from_json raises bare ValueError/KeyError; decoding failures + # must surface as the documented JSONRPCError contract. + return _decode_model(method, Amount.from_json, result) diff --git a/mintlayer/node/chainstate.py b/mintlayer/node/chainstate.py index 258de90..91c466e 100644 --- a/mintlayer/node/chainstate.py +++ b/mintlayer/node/chainstate.py @@ -7,14 +7,18 @@ from typing import Any -from ._core import _NodeCore +from ._core import _decode_model, _NodeCore from .types import Amount, ChainstateInfo, Currency, OrderInfo, Outpoint, TokenInfo class ChainstateMixin(_NodeCore): def chainstate_info(self) -> ChainstateInfo: """Return the current chainstate summary.""" - return ChainstateInfo.from_json(self._call("chainstate_info", {})) + return _decode_model( + "chainstate_info", + ChainstateInfo.from_json, + self._call("chainstate_info", {}), + ) def best_block_id(self) -> str: """Return the best block ID (hex, no 0x prefix).""" @@ -77,17 +81,28 @@ def delegation_share(self, pool_address: str, delegation_address: str) -> Amount def token_info(self, token_id: str) -> TokenInfo | None: """Return token info (tagged union; None if unknown).""" data = self._call("chainstate_token_info", {"token_id": token_id}) - return TokenInfo.from_json(data) if data is not None else None + return ( + _decode_model("chainstate_token_info", TokenInfo.from_json, data) + if data is not None + else None + ) def tokens_info(self, token_ids: list[str]) -> list[TokenInfo]: """Return info for multiple token IDs.""" data = self._call("chainstate_tokens_info", {"token_ids": token_ids}) - return [TokenInfo.from_json(item) for item in data or []] + return [ + _decode_model("chainstate_tokens_info", TokenInfo.from_json, item) + for item in data or [] + ] def order_info(self, order_id: str) -> OrderInfo | None: """Return order info (None if unknown).""" data = self._call("chainstate_order_info", {"order_id": order_id}) - return OrderInfo.from_json(data) if data is not None else None + return ( + _decode_model("chainstate_order_info", OrderInfo.from_json, data) + if data is not None + else None + ) def orders_info_by_currencies( self, ask: Currency | None, give: Currency | None @@ -103,7 +118,10 @@ def orders_info_by_currencies( "give_currency": give.to_json() if give is not None else None, }, ) - return {k: OrderInfo.from_json(v) for k, v in (data or {}).items()} + return { + k: _decode_model("chainstate_orders_info_by_currencies", OrderInfo.from_json, v) + for k, v in (data or {}).items() + } def submit_block(self, block_hex: str) -> None: """Submit a fully serialized block (hex).""" diff --git a/mintlayer/node/mempool.py b/mintlayer/node/mempool.py index b30bec2..d94939e 100644 --- a/mintlayer/node/mempool.py +++ b/mintlayer/node/mempool.py @@ -2,7 +2,7 @@ from __future__ import annotations -from ._core import _NodeCore +from ._core import _decode_model, _NodeCore from .types import FeeRate, FeeRatePoint, MempoolTx, TrustPolicy from .types import policy_value as _policy_value @@ -19,7 +19,11 @@ def contains_orphan_tx(self, tx_id: str) -> bool: def get_transaction(self, tx_id: str) -> MempoolTx | None: """Return the mempool transaction (None if not present).""" data = self._call("mempool_get_transaction", {"tx_id": tx_id}) - return MempoolTx.from_json(data) if data is not None else None + return ( + _decode_model("mempool_get_transaction", MempoolTx.from_json, data) + if data is not None + else None + ) def mempool_submit_transaction(self, tx_hex: str, trust_policy: TrustPolicy | str) -> None: """Submit a transaction to the local mempool only (no P2P broadcast). @@ -35,12 +39,19 @@ def mempool_submit_transaction(self, tx_hex: str, trust_policy: TrustPolicy | st def get_fee_rate(self, in_top_x_mb: int) -> FeeRate | None: """Return the fee rate to land in the top ``in_top_x_mb`` MB of the mempool.""" data = self._call("mempool_get_fee_rate", {"in_top_x_mb": in_top_x_mb}) - return FeeRate.from_json(data) if data is not None else None + return ( + _decode_model("mempool_get_fee_rate", FeeRate.from_json, data) + if data is not None + else None + ) def get_fee_rate_points(self) -> list[FeeRatePoint]: """Return the mempool fee rate histogram.""" data = self._call("mempool_get_fee_rate_points", {}) - return [FeeRatePoint.from_json(item) for item in data or []] + return [ + _decode_model("mempool_get_fee_rate_points", FeeRatePoint.from_json, item) + for item in data or [] + ] def memory_usage(self) -> int: """Return the mempool memory usage in bytes.""" diff --git a/mintlayer/wasm/_core.py b/mintlayer/wasm/_core.py index 6029c16..74659b3 100644 --- a/mintlayer/wasm/_core.py +++ b/mintlayer/wasm/_core.py @@ -43,8 +43,10 @@ def _load_and_verify_wasm() -> bytes: """Load the vendored WASM binary, failing closed if it misses its pin. - The read happens here (not at module scope) so a packaging mistake raises - a descriptive :class:`WasmError` instead of a raw FileNotFoundError. + The read and verification live in this single function so that any + packaging mistake raises a descriptive :class:`WasmError` — at import + time, which is intentional: a broken install must fail fast, not at + first use deep inside a wallet operation. """ if not _WASM_PATH.is_file(): raise WasmError(f"mintlayer: WASM binary missing: {_WASM_PATH}") diff --git a/tests/test_chainstate.py b/tests/test_chainstate.py index 121c6b6..a064911 100644 --- a/tests/test_chainstate.py +++ b/tests/test_chainstate.py @@ -225,7 +225,7 @@ def test_chainstate_info_best_block_height_rejects_non_int(rpc_server) -> None: } srv = rpc_server(result=payload) client = Client(srv.url) - with pytest.raises(ValueError, match="invalid best_block_height"): + with pytest.raises(JSONRPCError, match="invalid best_block_height"): client.chainstate_info() client.close() From e5a533d970c6efc2e05e5ebd075973405bf872fd Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 15:07:28 +0400 Subject: [PATCH 30/31] Address residual findings from OCR thread triage - node/_core.py: _call_opt_str rejects non-string results instead of silently coercing dicts/numbers to garbage strings (all three callers are documented string endpoints; get_block_json covers object payloads) - wallet/staking.py: get_staking_status raises JSONRPCError with the valid enum values instead of a bare ValueError on unknown statuses - wallet/types.py: MnemonicResult.from_json validates content (non-dict and empty dicts are malformed) and wraps kwargs TypeErrors into a descriptive ValueError - tests: coverage for all three guards (6 new tests) --- mintlayer/node/_core.py | 7 ++++++- mintlayer/wallet/staking.py | 10 +++++++++- mintlayer/wallet/types.py | 12 +++++++++++- tests/test_chainstate.py | 13 +++++++++++++ tests/test_wallet_management.py | 30 ++++++++++++++++++++++++++++++ tests/test_wallet_staking.py | 16 ++++++++++++++++ 6 files changed, 85 insertions(+), 3 deletions(-) diff --git a/mintlayer/node/_core.py b/mintlayer/node/_core.py index af6396f..1f408e7 100644 --- a/mintlayer/node/_core.py +++ b/mintlayer/node/_core.py @@ -35,7 +35,12 @@ def _call_str(self, method: str, params: Any) -> str: def _call_opt_str(self, method: str, params: Any) -> str | None: result = self._rpc.call(method, params) - return None if result is None else str(result) + if result is None: + return None + if not isinstance(result, str): + # Coercing a dict/number to str would return garbage silently. + raise JSONRPCError(f"{method}: expected string result, got {result!r}") + return result def _call_int(self, method: str, params: Any) -> int: result = self._rpc.call(method, params) diff --git a/mintlayer/wallet/staking.py b/mintlayer/wallet/staking.py index 24453b6..a137e66 100644 --- a/mintlayer/wallet/staking.py +++ b/mintlayer/wallet/staking.py @@ -2,6 +2,8 @@ from __future__ import annotations +from mintlayer._jsonrpc import JSONRPCError + from ._core import _WalletCore from .types import ( Amount, @@ -51,7 +53,13 @@ def stop_staking(self, account: int) -> None: def get_staking_status(self, account: int) -> StakingStatus: """Return whether the account is currently staking.""" result = self._call("staking_status", {"account": account}) - return StakingStatus(result) + try: + return StakingStatus(result) + except ValueError as exc: + raise JSONRPCError( + f"staking_status: unexpected status {result!r} " + f"(expected one of {[m.value for m in StakingStatus]})" + ) from exc def create_delegation(self, params: CreateDelegationParams) -> CreateDelegationResult: """Create a delegation ID for delegating to a pool.""" diff --git a/mintlayer/wallet/types.py b/mintlayer/wallet/types.py index 01a2d63..b74b344 100644 --- a/mintlayer/wallet/types.py +++ b/mintlayer/wallet/types.py @@ -272,9 +272,19 @@ class MnemonicResult: @classmethod def from_json(cls, data: dict) -> MnemonicResult: content = data.get("content") + if content is not None and not isinstance(content, dict): + raise ValueError(f"MnemonicResult: invalid content {content!r}") + try: + # An empty dict is malformed too: the daemon claimed a mnemonic + # result without the required `mnemonic` key. + decoded = MnemonicContent(**content) if content is not None else None + except TypeError as exc: + # Unexpected/missing keys in the daemon payload must not surface + # as a bare kwargs TypeError. + raise ValueError(f"MnemonicContent: malformed payload ({exc})") from exc return cls( type=data["type"], - content=MnemonicContent(**content) if content else None, + content=decoded, ) diff --git a/tests/test_chainstate.py b/tests/test_chainstate.py index a064911..2a41916 100644 --- a/tests/test_chainstate.py +++ b/tests/test_chainstate.py @@ -84,6 +84,19 @@ def test_block_id_at_height_null(rpc_server) -> None: client.close() +def test_block_id_at_height_non_string_result_raises(rpc_server) -> None: + """A non-string, non-null result raises instead of being str()-coerced. + + Coercing a JSON number/dict to str would return garbage silently; the + optional-string decoder must surface it as the JSONRPCError contract. + """ + srv = rpc_server(result=123456) + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="chainstate_block_id_at_height: expected string result"): + client.block_id_at_height(7) + client.close() + + def test_stake_pool_balance(rpc_server) -> None: srv = rpc_server(result={"atoms": "100000000000"}) client = Client(srv.url) diff --git a/tests/test_wallet_management.py b/tests/test_wallet_management.py index a56c172..f2c361d 100644 --- a/tests/test_wallet_management.py +++ b/tests/test_wallet_management.py @@ -18,6 +18,7 @@ CreateWalletParams, CreateWalletResult, JSONRPCError, + MnemonicResult, RecoverWalletParams, WalletInfo, ) @@ -57,6 +58,35 @@ def test_create_wallet_without_mnemonic(rpc_server) -> None: client.close() +# ── MnemonicResult.from_json content validation (direct decode tests) ──────── + + +def test_mnemonic_result_from_json_valid_content() -> None: + got = MnemonicResult.from_json({"type": "NewlyGenerated", "content": {"mnemonic": _MNEMONIC}}) + assert got.type == "NewlyGenerated" + assert got.content is not None + assert got.content.mnemonic == _MNEMONIC + + +def test_mnemonic_result_from_json_null_content() -> None: + got = MnemonicResult.from_json({"type": "UserProvided", "content": None}) + assert got.type == "UserProvided" + assert got.content is None + + +def test_mnemonic_result_from_json_non_dict_content_raises() -> None: + """A non-dict content raises ValueError, never a str()-coerced field.""" + with pytest.raises(ValueError, match="invalid content"): + MnemonicResult.from_json({"type": "NewlyGenerated", "content": "oops"}) # type: ignore[dict-item] + + +def test_mnemonic_result_from_json_missing_mnemonic_key_raises() -> None: + """A payload without the required ``mnemonic`` key raises ValueError + ("malformed payload") instead of a bare kwargs TypeError.""" + with pytest.raises(ValueError, match="malformed payload"): + MnemonicResult.from_json({"type": "NewlyGenerated", "content": {"seed": "x"}}) + + def test_create_wallet_wire_shape(rpc_server) -> None: srv = rpc_server(result={}) client = Client(srv.url) diff --git a/tests/test_wallet_staking.py b/tests/test_wallet_staking.py index b751e64..089d111 100644 --- a/tests/test_wallet_staking.py +++ b/tests/test_wallet_staking.py @@ -178,6 +178,22 @@ def test_get_staking_status_inactive(rpc_server) -> None: client.close() +def test_get_staking_status_unrecognized_raises_jsonrpc_error(rpc_server) -> None: + """An unrecognized status string raises the documented JSONRPCError + contract — including the offending value and every valid enum value — + not a bare ValueError from the enum constructor. + """ + srv = rpc_server(result="MAYBE") + client = Client(srv.url) + with pytest.raises(JSONRPCError, match="unexpected status") as excinfo: + client.get_staking_status(0) + message = str(excinfo.value) + assert "'MAYBE'" in message + for member in StakingStatus: + assert member.value in message + client.close() + + def test_create_delegation(rpc_server) -> None: srv = rpc_server(result={"delegation_id": "deleg1abc", "tx_id": "delegtx01"}) client = Client(srv.url) From f8346b2fb9756fe4cf6f49dcf554e7611bac9ea5 Mon Sep 17 00:00:00 2001 From: nullPointerEnjoyer Date: Fri, 18 Sep 2026 15:11:29 +0400 Subject: [PATCH 31/31] Narrow example error handling; document datetime semantics - examples/issue_token.py: wallet sync failures catch RPC/JSON-RPC errors specifically instead of Exception (programming errors stay loud) - indexer/pool.py: document naive-datetime interpretation for block stats --- examples/issue_token.py | 7 +++++-- mintlayer/indexer/pool.py | 7 ++++++- 2 files changed, 11 insertions(+), 3 deletions(-) diff --git a/examples/issue_token.py b/examples/issue_token.py index bf6f85c..4a108fd 100644 --- a/examples/issue_token.py +++ b/examples/issue_token.py @@ -40,10 +40,12 @@ import sys import time +from mintlayer._jsonrpc import JSONRPCError from mintlayer.wallet import ( Amount, IssueTokenParams, MintParams, + RPCError, TokenMetadata, TokenSupply, ) @@ -99,8 +101,9 @@ def main() -> None: # ── 2. Sync the wallet ─────────────────────────────────────────────────── try: wallet.sync_wallet() - except Exception as exc: - # Non-fatal: the daemon may already be syncing. + except (RPCError, JSONRPCError) as exc: + # Non-fatal: the daemon may already be syncing. Deliberately narrow — + # programming errors must not be silenced here. log.info("sync wallet: %s (continuing)", exc) # ── 3. Derive a fresh address to act as the token authority ────────────── diff --git a/mintlayer/indexer/pool.py b/mintlayer/indexer/pool.py index 70b44e6..d2e0322 100644 --- a/mintlayer/indexer/pool.py +++ b/mintlayer/indexer/pool.py @@ -19,7 +19,12 @@ def get_pool(self, pool_id: str) -> Pool: return Pool.from_json(self.get(f"/pool/{_seg(pool_id)}")) def get_pool_block_stats(self, pool_id: str, from_time: datetime, to_time: datetime) -> int: - """Return the block count produced in the half-open interval [from, to).""" + """Return the block count produced in the half-open interval [from, to). + + Naive datetimes are interpreted in the system's local timezone + (standard ``datetime.timestamp()`` semantics); pass tz-aware + datetimes for unambiguous absolute times. + """ data = self.get( f"/pool/{_seg(pool_id)}/block-stats", {"from": int(from_time.timestamp()), "to": int(to_time.timestamp())},