cryptochief-crypto-processing-python 0.1.0__py3-none-any.whl

cryptochief/client.py

@@ -0,0 +1,189 @@
+"""The asynchronous Crypto Chief client and its low-level signed transport."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Mapping, Optional, Union
+
+import httpx
+
+from ._version import __version__
+from .errors import CryptoChiefError, is_retryable
+from .rsa import RsaKeyNotConfiguredError, decrypt_rsa_oaep, load_rsa_private_key_pem
+from .services.blockchain import BlockchainService
+from .services.currencies import CurrenciesService
+from .services.payins import PayInsService
+from .services.payouts import PayoutsService
+from .services.static_deposits import StaticDepositsService
+from .services.sweeps import SweepsService
+from .services.transactions import TransactionsService
+from .services.wallets import WalletsService
+from .services.withdrawals import WithdrawalsService
+from .sign import sign_value
+from .ton.rpc import TonRpc
+from .transport import backoff_delay, network_error, parse_api_error
+
+#: SDK version, reported in the default ``User-Agent``.
+VERSION = __version__
+
+#: Production processing API endpoint. Test-mode projects share this host.
+DEFAULT_BASE_URL = "https://api-processing.crypto-chief.com"
+
+_MAX_RAW_IN_ERROR = 512
+
+
+class CryptoChiefClient:
+    """Entry point to the Crypto Chief processing API.
+
+    Construct once and reuse - the client is stateless beyond its configuration.
+    It owns an :class:`httpx.AsyncClient`, so close it when done (or use it as an
+    async context manager)::
+
+        async with CryptoChiefClient(merchant_id="M", api_key="K") as client:
+            est = await client.payouts.estimate(EstimatePayoutRequest(
+                network=Chain.ETH_SEPOLIA, coin="ETH", amount="0.0001",
+                to_address="0x...",
+            ))
+    """
+
+    def __init__(
+        self,
+        *,
+        merchant_id: str,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 60.0,
+        retries: int = 3,
+        retry_backoff: Optional[Mapping[str, float]] = None,
+        user_agent: Optional[str] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+        rsa_private_key: Optional[Union[str, bytes, Any]] = None,
+        ton_rpc_base_url: Optional[str] = None,
+    ) -> None:
+        if not merchant_id:
+            raise CryptoChiefError("cryptochief: merchant_id is required")
+        if not api_key:
+            raise CryptoChiefError("cryptochief: api_key is required")
+
+        self.merchant_id = merchant_id
+        self._api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._retries = retries
+        backoff = retry_backoff or {}
+        self._base_ms = backoff.get("base_ms", 200)
+        self._max_ms = backoff.get("max_ms", 5000)
+        self._user_agent = user_agent or f"cryptochief-python/{VERSION}"
+
+        self._owns_http = http_client is None
+        self._http = http_client or httpx.AsyncClient(timeout=timeout, transport=transport)
+
+        self._rsa_input = rsa_private_key
+        self._rsa_key: Any = None
+        self._rsa_error: Optional[CryptoChiefError] = None
+
+        self._ton_rpc_base_url = ton_rpc_base_url
+        self._ton_rpc: Optional[TonRpc] = None
+
+        self.payouts = PayoutsService(self)
+        self.transactions = TransactionsService(self)
+        self.pay_ins = PayInsService(self)
+        self.wallets = WalletsService(self)
+        self.sweeps = SweepsService(self)
+        self.withdrawals = WithdrawalsService(self)
+        self.static_deposits = StaticDepositsService(self)
+        self.blockchain = BlockchainService(self)
+        self.currencies = CurrenciesService(self)
+
+    async def request(self, path: str, body: Any = None) -> Any:
+        """Low-level signed POST against an API path (e.g. ``/v1/payout/estimate``).
+
+        Canonicalizes + signs the body, sends it, retries transient failures, and
+        returns the parsed JSON. Service methods are thin wrappers over this;
+        reach for it directly only to hit an endpoint the SDK doesn't model yet.
+        """
+        canonical, signature = sign_value(body, self._api_key)
+        url = self.base_url + path
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Merchant": self.merchant_id,
+            "Signature": signature,
+            "User-Agent": self._user_agent,
+        }
+        body_bytes = canonical.encode("utf-8")
+        attempts = self._retries + 1
+        last_err: Optional[Exception] = None
+
+        for attempt in range(attempts):
+            if attempt > 0:
+                await asyncio.sleep(backoff_delay(attempt, self._base_ms, self._max_ms))
+            try:
+                resp = await self._http.post(url, content=body_bytes, headers=headers)
+            except httpx.HTTPError as err:
+                last_err = network_error(str(err))
+                if not is_retryable(last_err):
+                    raise last_err
+                continue
+
+            text = resp.text
+            status = resp.status_code
+            if 200 <= status < 300:
+                if not text:
+                    return None
+                try:
+                    return json.loads(text)
+                except ValueError as err:
+                    raise CryptoChiefError(
+                        f"cryptochief: decode {path} response: {err} "
+                        f"(raw={text[:_MAX_RAW_IN_ERROR]})"
+                    ) from err
+
+            api_err = parse_api_error(status, text)
+            if status >= 500:
+                last_err = api_err
+                continue
+            raise api_err
+
+        raise last_err or CryptoChiefError("cryptochief: retry budget exhausted")
+
+    async def aclose(self) -> None:
+        """Close the underlying HTTP client (only if this client created it)."""
+        if self._owns_http:
+            await self._http.aclose()
+
+    async def __aenter__(self) -> "CryptoChiefClient":
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.aclose()
+
+    def rsa_decrypt(self, encrypted: str) -> str:
+        """Decrypt a wallet ``private_key_encrypted`` field. Used by ``wallets``."""
+        if self._rsa_error:
+            raise self._rsa_error
+        if self._rsa_key is None:
+            if self._rsa_input is None:
+                raise RsaKeyNotConfiguredError()
+            try:
+                if isinstance(self._rsa_input, (str, bytes, bytearray)):
+                    self._rsa_key = load_rsa_private_key_pem(self._rsa_input)
+                else:
+                    self._rsa_key = self._rsa_input  # already a private-key object
+            except CryptoChiefError as err:
+                self._rsa_error = err
+                raise
+        return decrypt_rsa_oaep(self._rsa_key, encrypted)
+
+    def ton_rpc(self) -> TonRpc:
+        """Lazily built TON RPC helper, sharing the merchant credential + HTTP client."""
+        if self._ton_rpc is None:
+            self._ton_rpc = TonRpc(
+                merchant_id=self.merchant_id,
+                http=self._http,
+                base_url=self._ton_rpc_base_url,
+                user_agent=self._user_agent,
+            )
+        return self._ton_rpc

cryptochief/contract/__init__.py

@@ -0,0 +1,69 @@
+"""Contract-call encoders: EVM/TRON ABI, Solana Borsh/Anchor, base58, TRON addresses."""
+
+from __future__ import annotations
+
+from .base58 import base58_decode, base58_encode
+from .borsh import (
+    BorshValue,
+    anchor_discriminator,
+    borsh_bool,
+    borsh_bytes,
+    borsh_fixed_bytes,
+    borsh_i8,
+    borsh_i16,
+    borsh_i32,
+    borsh_i64,
+    borsh_option,
+    borsh_pubkey,
+    borsh_string,
+    borsh_struct,
+    borsh_u8,
+    borsh_u16,
+    borsh_u32,
+    borsh_u64,
+    borsh_u128,
+    borsh_vec,
+    decode_solana_pubkey,
+    encode_anchor_instruction,
+)
+from .evm_abi import (
+    canonical_signature,
+    encode_evm_call,
+    encode_evm_call_hex,
+    evm_selector,
+)
+from .keccak import keccak_256
+from .tron_address import hex_to_tron, tron_to_hex
+
+__all__ = [
+    "base58_decode",
+    "base58_encode",
+    "BorshValue",
+    "anchor_discriminator",
+    "borsh_bool",
+    "borsh_bytes",
+    "borsh_fixed_bytes",
+    "borsh_i8",
+    "borsh_i16",
+    "borsh_i32",
+    "borsh_i64",
+    "borsh_option",
+    "borsh_pubkey",
+    "borsh_string",
+    "borsh_struct",
+    "borsh_u8",
+    "borsh_u16",
+    "borsh_u32",
+    "borsh_u64",
+    "borsh_u128",
+    "borsh_vec",
+    "decode_solana_pubkey",
+    "encode_anchor_instruction",
+    "canonical_signature",
+    "encode_evm_call",
+    "encode_evm_call_hex",
+    "evm_selector",
+    "keccak_256",
+    "hex_to_tron",
+    "tron_to_hex",
+]

cryptochief/contract/base58.py

@@ -0,0 +1,40 @@
+"""Base58 (Bitcoin / Tron / Solana alphabet).
+
+Shared by the TRON address codec and Solana pubkey decoding. Pure ``int``
+arithmetic - no external dependency.
+"""
+
+from __future__ import annotations
+
+from ..errors import CryptoChiefError
+
+_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+_DECODE = {c: i for i, c in enumerate(_ALPHABET)}
+
+
+def base58_encode(data: bytes) -> str:
+    zeros = 0
+    while zeros < len(data) and data[zeros] == 0:
+        zeros += 1
+    num = int.from_bytes(data, "big")
+    out = ""
+    while num > 0:
+        num, rem = divmod(num, 58)
+        out = _ALPHABET[rem] + out
+    return _ALPHABET[0] * zeros + out
+
+
+def base58_decode(s: str) -> bytes:
+    if s == "":
+        raise CryptoChiefError("cryptochief: base58: empty input")
+    zeros = 0
+    while zeros < len(s) and s[zeros] == _ALPHABET[0]:
+        zeros += 1
+    num = 0
+    for ch in s:
+        v = _DECODE.get(ch, -1)
+        if v < 0:
+            raise CryptoChiefError(f"cryptochief: base58: invalid char {ch!r}")
+        num = num * 58 + v
+    body = num.to_bytes((num.bit_length() + 7) // 8, "big") if num > 0 else b""
+    return b"\x00" * zeros + body

cryptochief/contract/borsh.py

@@ -0,0 +1,141 @@
+"""Borsh encoding + Anchor instruction building for Solana.
+
+Anchor instruction data is ``[8-byte discriminator][Borsh-encoded args]``. Borsh
+has no on-wire type tags, so the caller must describe each argument's type
+explicitly - the ``borsh_*`` constructors below force that. Each returns a
+:class:`BorshValue`; pass them to :func:`encode_anchor_instruction`.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from typing import List, Optional, Union
+
+from ..errors import CryptoChiefError
+from .base58 import base58_decode
+
+
+class BorshError(CryptoChiefError):
+    def __init__(self, message: str) -> None:
+        super().__init__(f"cryptochief/anchor: {message}")
+
+
+class BorshValue:
+    """A value paired with its Borsh encoding, ready to concatenate."""
+
+    __slots__ = ("_data",)
+
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+
+    def encode(self) -> bytes:
+        return self._data
+
+
+def _le(value: int, width: int) -> bytes:
+    return (value & ((1 << (8 * width)) - 1)).to_bytes(width, "little")
+
+
+# Unsigned little-endian integers.
+def borsh_u8(n: int) -> BorshValue:
+    return BorshValue(_le(n, 1))
+
+
+def borsh_u16(n: int) -> BorshValue:
+    return BorshValue(_le(n, 2))
+
+
+def borsh_u32(n: int) -> BorshValue:
+    return BorshValue(_le(n, 4))
+
+
+def borsh_u64(n: int) -> BorshValue:
+    return BorshValue(_le(n, 8))
+
+
+# Signed little-endian integers (two's complement - same wire bytes as unsigned).
+borsh_i8 = borsh_u8
+borsh_i16 = borsh_u16
+borsh_i32 = borsh_u32
+borsh_i64 = borsh_u64
+
+
+def borsh_u128(n: int) -> BorshValue:
+    """128-bit unsigned little-endian. Must be non-negative and < 2^128."""
+    if n < 0:
+        raise BorshError("u128 negative")
+    if n >= (1 << 128):
+        raise BorshError("u128 overflow")
+    return BorshValue(_le(n, 16))
+
+
+def borsh_bool(b: bool) -> BorshValue:
+    """1-byte boolean (0x00 / 0x01)."""
+    return BorshValue(b"\x01" if b else b"\x00")
+
+
+def borsh_string(s: str) -> BorshValue:
+    """UTF-8 string: 4-byte LE length prefix + bytes."""
+    data = s.encode("utf-8")
+    return BorshValue(_le(len(data), 4) + data)
+
+
+def borsh_bytes(b: bytes) -> BorshValue:
+    """Raw byte slice: 4-byte LE length prefix + bytes (same wire form as a string)."""
+    b = bytes(b)
+    return BorshValue(_le(len(b), 4) + b)
+
+
+def borsh_fixed_bytes(b: bytes, n: int) -> BorshValue:
+    """Fixed-length bytes with NO length prefix (Anchor's ``[u8; N]``)."""
+    b = bytes(b)
+    if len(b) != n:
+        raise BorshError(f"borsh_fixed_bytes: expected {n} bytes, got {len(b)}")
+    return BorshValue(b)
+
+
+def borsh_pubkey(pk: Union[str, bytes]) -> BorshValue:
+    """A Solana 32-byte pubkey (base58 string or raw 32 bytes)."""
+    return BorshValue(decode_solana_pubkey(pk))
+
+
+def borsh_option(inner: Optional[BorshValue]) -> BorshValue:
+    """Nullable value: ``None`` -> 0x00; otherwise 0x01 + inner encoding."""
+    if inner is None:
+        return BorshValue(b"\x00")
+    return BorshValue(b"\x01" + inner.encode())
+
+
+def borsh_vec(items: List[BorshValue]) -> BorshValue:
+    """Homogeneous ``Vec<T>``: 4-byte LE length + elements."""
+    body = b"".join(it.encode() for it in items)
+    return BorshValue(_le(len(items), 4) + body)
+
+
+def borsh_struct(*fields: BorshValue) -> BorshValue:
+    """Heterogeneous struct / tuple: fields in order, no length prefix."""
+    return BorshValue(b"".join(f.encode() for f in fields))
+
+
+def anchor_discriminator(method: str) -> bytes:
+    """The 8-byte Anchor instruction discriminator: ``sha256("global:" + method)[:8]``."""
+    return hashlib.sha256(f"global:{method}".encode("utf-8")).digest()[:8]
+
+
+def encode_anchor_instruction(method: str, *args: BorshValue) -> bytes:
+    """Raw Anchor instruction data: 8-byte discriminator + Borsh-encoded args."""
+    parts = [anchor_discriminator(method)]
+    parts.extend(a.encode() for a in args)
+    return b"".join(parts)
+
+
+def decode_solana_pubkey(pk: Union[str, bytes]) -> bytes:
+    """Decode a Solana pubkey (base58 string or raw 32 bytes) to its 32-byte form."""
+    if isinstance(pk, (bytes, bytearray)):
+        if len(pk) != 32:
+            raise BorshError(f"solana pubkey: want 32 bytes, got {len(pk)}")
+        return bytes(pk)
+    raw = base58_decode(pk)
+    if len(raw) != 32:
+        raise BorshError(f"solana pubkey: decoded length {len(raw)}, want 32")
+    return raw