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

cryptochief/webhook.py

@@ -0,0 +1,191 @@
+"""Webhook verification and typed event parsing.
+
+The signature is ``hex(md5(base64(canonical_json(body)) + api_key))`` - the same
+algorithm used for outgoing requests. The body is re-canonicalized before
+hashing, so any key-order drift is normalized. Framework-agnostic: feed it the
+raw request bytes and the ``Signature`` header.
+"""
+
+from __future__ import annotations
+
+import hmac
+import json
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Union
+
+from ._models import from_dict
+from .errors import CryptoChiefError
+from .sign import canonical_json, sign
+
+#: Case-insensitive header name carrying the webhook signature.
+WEBHOOK_HEADER = "Signature"
+
+#: IP addresses Crypto Chief delivers webhooks from - whitelist for defense in depth.
+WEBHOOK_SENDER_IPS = ("164.90.231.203", "104.248.248.64")
+
+
+class WebhookSignatureError(CryptoChiefError):
+    """Raised when a webhook signature does not match the body."""
+
+    def __init__(self) -> None:
+        super().__init__("cryptochief: invalid webhook signature")
+
+
+def _as_bytes(body: Union[str, bytes, bytearray]) -> bytes:
+    return body.encode("utf-8") if isinstance(body, str) else bytes(body)
+
+
+def verify_webhook_signature(
+    api_key: str,
+    raw_body: Union[str, bytes, bytearray],
+    signature: Optional[str],
+) -> bool:
+    """Verify an incoming webhook against the merchant API key.
+
+    ``raw_body`` MUST be the exact bytes received - do not re-encode it first.
+    Returns ``True`` / ``False``; the comparison is constant-time.
+    """
+    if not api_key:
+        raise CryptoChiefError("cryptochief: api_key is required for webhook verification")
+    raw = _as_bytes(raw_body)
+    if len(raw) == 0 or not signature:
+        return False
+    try:
+        parsed = json.loads(raw.decode("utf-8"))
+    except ValueError:
+        return False  # not JSON -> fail closed
+    expected = sign(canonical_json(parsed), api_key)
+    return hmac.compare_digest(expected, signature)
+
+
+def parse_webhook_event(
+    api_key: str,
+    raw_body: Union[str, bytes, bytearray],
+    signature: Optional[str],
+) -> "WebhookEvent":
+    """Verify and parse a webhook in one step.
+
+    Raises :class:`WebhookSignatureError` if the signature is invalid; otherwise
+    returns the typed event (chosen by the ``event`` name prefix), or the raw
+    ``dict`` for an unrecognized prefix.
+    """
+    if not verify_webhook_signature(api_key, raw_body, signature):
+        raise WebhookSignatureError()
+    data = json.loads(_as_bytes(raw_body).decode("utf-8"))
+    return coerce_webhook_event(data)
+
+
+def coerce_webhook_event(data: Dict[str, Any]) -> "WebhookEvent":
+    """Map a parsed webhook ``dict`` to its typed event by the ``event`` prefix."""
+    prefix = str(data.get("event") or "").split(".")[0]
+    cls = _EVENT_BY_PREFIX.get(prefix)
+    return from_dict(cls, data) if cls is not None else data
+
+
+# -- Typed event payloads -----------------------------------------------------
+
+
+@dataclass(kw_only=True)
+class PayoutWebhookEvent:
+    """Payout webhook. Fires only on terminal status: ``payout.paid`` / ``payout.system_fail``."""
+
+    event: str = ""
+    uuid: str = ""
+    status: str = ""
+    order_id: Optional[str] = None
+    user_id: Optional[str] = None
+    amount_requested: Optional[str] = None
+    amount_to_receive: Optional[str] = None
+    to_address: Optional[str] = None
+    fee_info: Optional[Dict[str, Any]] = None
+    sources: Optional[Any] = None
+    service_operations: Optional[Any] = None
+    created_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    error_reason: Optional[str] = None
+
+
+@dataclass(kw_only=True)
+class TransactionWebhookEvent:
+    """Transaction webhook. Fires only on terminal status (confirmed / failed / expired)."""
+
+    event: str = ""
+    uuid: str = ""
+    status: str = ""
+    network: Optional[str] = None
+    chain_family: Optional[str] = None
+    type: Optional[str] = None
+    from_address: Optional[str] = None
+    to_address: Optional[str] = None
+    value: Optional[str] = None
+    contract: Optional[str] = None
+    tx_hash: Optional[str] = None
+    created_at: Optional[str] = None
+    completed_at: Optional[str] = None
+    error_reason: Optional[str] = None
+
+
+@dataclass(kw_only=True)
+class PayInWebhookEvent:
+    """Pay-in webhook. Event names carry the ``invoice.`` prefix (e.g. ``invoice.paid``)."""
+
+    event: str = ""
+    uuid: str = ""
+    status: str = ""
+    order_id: Optional[str] = None
+    user_id: Optional[str] = None
+    prev_status: Optional[str] = None
+    mode: Optional[str] = None
+    amount_crypto: Optional[str] = None
+    amount_fiat: Optional[str] = None
+    fact_amount_crypto: Optional[str] = None
+    fact_amount_fiat: Optional[str] = None
+    currency: Optional[str] = None
+    payment_coin: Optional[str] = None
+    payment_network: Optional[str] = None
+    to_address: Optional[str] = None
+    txid: Optional[str] = None
+
+
+@dataclass(kw_only=True)
+class StaticDepositWebhookEvent:
+    """Static-deposit webhook. Event names carry the ``static_deposit.`` prefix."""
+
+    event: str = ""
+    uuid: str = ""
+    status: str = ""
+    network: Optional[str] = None
+    chain_family: Optional[str] = None
+    coin: Optional[str] = None
+    contract: Optional[str] = None
+    decimals: Optional[int] = None
+    to_address: Optional[str] = None
+    from_address: Optional[str] = None
+    tx_hash: Optional[str] = None
+    amount: Optional[str] = None
+    amount_fiat: Optional[str] = None
+    confirmations: Optional[int] = None
+    required_confirmations: Optional[int] = None
+    found_in_mempool: Optional[bool] = None
+    log_type: Optional[str] = None
+    block_number: Optional[int] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+    confirmed_at: Optional[str] = None
+    paid_at: Optional[str] = None
+
+
+WebhookEvent = Union[
+    PayoutWebhookEvent,
+    TransactionWebhookEvent,
+    PayInWebhookEvent,
+    StaticDepositWebhookEvent,
+    Dict[str, Any],
+]
+
+_EVENT_BY_PREFIX = {
+    "payout": PayoutWebhookEvent,
+    "transaction": TransactionWebhookEvent,
+    "invoice": PayInWebhookEvent,
+    "static_deposit": StaticDepositWebhookEvent,
+}

cryptochief_crypto_processing_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,346 @@
+Metadata-Version: 2.4
+Name: cryptochief-crypto-processing-python
+Version: 0.1.0
+Summary: Official async Python SDK for the Crypto Chief crypto payment gateway and crypto processing API. Accept crypto payments, send single and mass crypto payouts, sign on-chain transactions and smart-contract calls, manage wallets, convert fiat to crypto, and verify webhooks across Ethereum, BNB Smart Chain, Polygon, Tron, TON, Solana, Bitcoin, XRP and 20+ blockchains. USDT and USDC stablecoin support with int-precise amounts and asyncio/httpx.
+Project-URL: Homepage, https://crypto-chief.com/processing/
+Project-URL: Documentation, https://docs-sdk.crypto-chief.com/processing/python
+Project-URL: Repository, https://github.com/crypto-chiefs/cryptochief-crypto-processing-python
+Project-URL: Issues, https://github.com/crypto-chiefs/cryptochief-crypto-processing-python/issues
+Author: Crypto Chief
+License: MIT
+License-File: LICENSE
+Keywords: accept-crypto-payments,async,asyncio,batch-payout,bep20,bitcoin,blockchain,bsc,crypto,crypto-invoice,crypto-payment-api,crypto-payment-gateway,crypto-payments,crypto-payout,crypto-processing,crypto-processing-api,cryptochief,cryptocurrency,dogecoin,erc20,ethereum,jetton,litecoin,mass-payout,payment-gateway,payment-processing,payments,payout,polygon,sdk,solana,stablecoin,ton,trc20,tron,usdc,usdt,wallet,web3,webhook,xrp
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: cryptography>=41
+Requires-Dist: httpx>=0.24
+Requires-Dist: pycryptodomex>=3.19
+Requires-Dist: pytoniq-core>=0.1.36
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Crypto Chief Python SDK - Crypto Processing API Client
+
+[![PyPI](https://img.shields.io/pypi/v/cryptochief-crypto-processing-python.svg)](https://pypi.org/project/cryptochief-crypto-processing-python/)
+[![Python](https://img.shields.io/pypi/pyversions/cryptochief-crypto-processing-python.svg)](https://pypi.org/project/cryptochief-crypto-processing-python/)
+[![SDK Docs](https://img.shields.io/badge/docs-SDK%20guide-2ea44f)](https://docs-sdk.crypto-chief.com/processing/python)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+**Crypto Chief Python SDK** is the official **asyncio** client library for the
+[Crypto Chief](https://crypto-chief.com/processing/) **crypto processing API** -
+a unified crypto payment gateway for accepting crypto payments, sending crypto
+payouts (single and mass), signing on-chain transactions, managing wallets, and
+verifying webhooks across **Ethereum, Tron, TON, Solana, Bitcoin and 20+ more
+blockchains**.
+
+Drop it into any async Python backend (FastAPI, aiohttp, Litestar, Django ASGI,
+serverless ...) to add cryptocurrency payment processing - stablecoin
+(USDT / USDC) payouts, pay-ins, swaps, and smart-contract calls - with typed
+dataclass requests / responses, integer-precise amounts, and an `except`-friendly
+error hierarchy.
+
+- One-line setup; a reusable `CryptoChiefClient` you `await`.
+- **Typed dataclasses** for every request and response - editor autocomplete and
+  attribute access (`est.amount_to_receive`), no dict juggling.
+- **Contract calls without hand-encoded calldata** - Solidity ABI for EVM and
+  TRON, Anchor + Borsh for Solana, Jetton / NFT / comment helpers for TON.
+- **Local RSA decryption** of generated wallet private keys.
+- Stable error codes via `APIError.code`, automatic retry on transient failures.
+- Arbitrary-precision amounts via native `int` - never `float`.
+- Webhook verification + typed events, framework-agnostic.
+- `await client.payouts.wait_for(uuid)` polling that resolves when a payout /
+  transaction / pay-in is final.
+
+> The wire format is snake_case and so is Python - the public API uses the same
+> field names the REST API does, with no translation layer in between.
+
+## Install
+
+```bash
+pip install cryptochief-crypto-processing-python
+```
+
+```python
+import cryptochief
+from cryptochief import CryptoChiefClient, Chain
+```
+
+Requires Python 3.10+.
+
+## Quick start
+
+```python
+import asyncio
+from cryptochief import CryptoChiefClient, Chain, EstimatePayoutRequest
+
+async def main():
+    async with CryptoChiefClient(
+        merchant_id="YOUR_MERCHANT_ID",
+        api_key="YOUR_API_KEY",  # signing secret - keep it server-side
+    ) as client:
+        est = await client.payouts.estimate(EstimatePayoutRequest(
+            network=Chain.ETH_SEPOLIA,
+            coin="ETH",
+            amount="0.0001",
+            to_address="0xRecipient...",
+        ))
+        print("amount to receive:", est.amount_to_receive)
+
+asyncio.run(main())
+```
+
+Both credentials come from the Dashboard -> Project.
+
+## What you can do with it
+
+| Domain | Service | Key methods |
+|---|---|---|
+| Single payout (incl. auto-convert swap) | `client.payouts` | `estimate`, `execute`, `info`, `history`, `wait_for` |
+| Mass payout (up to 50 items) | `client.payouts` | `batch_estimate`, `batch_execute` |
+| Two-phase sign / broadcast for arbitrary txs | `client.transactions` | `sign`, `execute`, `info`, `history`, `wait_for` |
+| EVM / TRON contract calls (incl. ERC-20 / TRC-20) | `client.transactions` | `sign_evm_call`, `sign_tron_call`, `erc20_transfer` |
+| Solana programs | `client.transactions` | `sign_anchor_call`, `sign_solana_call` |
+| TON contract calls (Jetton / NFT / text) | `client.transactions` | `jetton_transfer`, `nft_transfer`, `send_ton_comment`, `sign_ton_call` |
+| Accept incoming payments | `client.pay_ins` | `create`, `select_asset`, `reset_asset`, `cancel`, `info`, `history`, `wait_for` |
+| Wallet management + RSA decrypt | `client.wallets` | `generate`, `list`, `info`, `freeze`, `decrypt_private_key` |
+| Treasury sweeps | `client.sweeps` | `force`, `history`, `wallet_history` |
+| Withdrawals (read-only) | `client.withdrawals` | `info`, `history` |
+| Static-deposit history | `client.static_deposits` | `info`, `history` |
+| On-chain queries | `client.blockchain` | `contracts_available`, `wallet_balance`, `transaction_status` |
+| Fiat <-> crypto rate quote | `client.currencies` | `fiat_to_crypto`, `crypto_to_fiat` |
+
+## Accept a crypto payment (pay-in)
+
+Create an invoice, send the customer to the hosted `payment_link`, then settle it
+when the `invoice.*` webhook arrives (recommended) or by polling `wait_for`.
+
+```python
+from cryptochief import CryptoChiefClient, CreatePayInRequest, PayInMode
+
+async def accept():
+    async with CryptoChiefClient(merchant_id="M", api_key="K") as client:
+        invoice = await client.pay_ins.create(CreatePayInRequest(
+            order_id="invoice-1001",   # your id - idempotency key, safe to retry
+            user_id="user-7",
+            mode=PayInMode.FIAT,       # fix a fiat price; the customer pays the crypto equivalent
+            amount_fiat="49.99",
+            currency="USD",
+            url_callback="https://example.com/webhooks/crypto-chief",
+            url_success="https://example.com/thanks",
+        ))
+        print("send the customer to:", invoice.payment_link)
+
+        final = await client.pay_ins.wait_for(invoice.uuid, timeout=1800)
+        print(final.status)  # paid | expired | cancel
+```
+
+For a fixed-crypto invoice use `mode=PayInMode.CRYPTO` with `amount_crypto` and
+`asset=Asset(coin="USDT", network=Chain.TRON_MAINNET)`. For host-to-host flows
+where the customer picks the coin in your own UI, create the order without a fixed
+asset and commit the choice with `client.pay_ins.select_asset(...)`.
+
+## Send a payout (with confirmation)
+
+```python
+from cryptochief import (
+    CryptoChiefClient, Chain, APIError, ErrorCode, ExecutePayoutRequest,
+)
+
+async def pay():
+    async with CryptoChiefClient(merchant_id="M", api_key="K") as client:
+        try:
+            payout = await client.payouts.execute(ExecutePayoutRequest(
+                order_id="order-42",  # idempotency key - safe to retry
+                user_id="user-7",
+                network=Chain.ETH_SEPOLIA,
+                coin="ETH",
+                amount="0.0001",
+                to_address="0xRecipient...",
+                url_callback="https://example.com/webhooks/crypto-chief",
+            ))
+            final = await client.payouts.wait_for(payout.uuid, timeout=300)
+            print(final.status, final.txid)
+        except APIError as e:
+            if e.code == ErrorCode.INSUFFICIENT_FUNDS:
+                ...  # top up and retry
+            raise
+```
+
+## Amounts: always integers, never floats
+
+```python
+from cryptochief import human_to_base, base_to_human
+
+human_to_base("1.5", 18)            # 1500000000000000000
+base_to_human(10_000, 8)            # "0.0001"
+```
+
+`int` is arbitrary-precision in Python, so token values never overflow and
+decimal strings round-trip exactly. Discover an asset's decimals with
+`client.blockchain.contracts_available()`.
+
+## Contract calls without hand-encoding
+
+```python
+from cryptochief import EvmCallRequest, Erc20TransferRequest, Chain, human_to_base
+
+# Any EVM/TRON method by Solidity signature - args are ABI-encoded for you.
+await client.transactions.sign_evm_call(EvmCallRequest(
+    network=Chain.ETH_MAINNET,
+    from_address="0xYourWallet...",
+    contract="0xA0b8...",  # Uniswap router, etc.
+    method="swapExactTokensForTokens(uint256,uint256,address[],address,uint256)",
+    args=[10**6, 0, ["0xTokenIn...", "0xTokenOut..."], "0xYourWallet...", 1750000000],
+))
+
+# ERC-20 / TRC-20 transfer in one line (TRON base58 addresses accepted):
+await client.transactions.erc20_transfer(Erc20TransferRequest(
+    network=Chain.TRON_MAINNET,
+    from_address="TYour...",
+    token_contract="TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",  # USDT
+    recipient="TRecipient...",
+    amount=human_to_base("12.5", 6),
+))
+```
+
+TON Jetton transfers resolve the sender's Jetton wallet automatically and pick a
+sensible gas budget:
+
+```python
+from cryptochief import JettonTransferRequest, Chain, human_to_base
+
+await client.transactions.jetton_transfer(JettonTransferRequest(
+    network=Chain.TON_MAINNET,
+    from_address="UQYour...",
+    jetton_master="EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",  # USDT
+    recipient="UQRecipient...",
+    amount=human_to_base("5", 6),
+    memo="Order #4242",
+))
+```
+
+Solana Anchor calls take explicitly-typed Borsh args:
+
+```python
+from cryptochief import AnchorCallRequest, SolanaAccount, borsh_u64, borsh_string, Chain
+
+await client.transactions.sign_anchor_call(AnchorCallRequest(
+    network=Chain.SOLANA_MAINNET,
+    from_address="YourPubkey...",
+    program="YourProgramId...",
+    method="initialize",
+    args=[borsh_u64(1_000), borsh_string("hello")],
+    accounts=[SolanaAccount(pubkey="...", is_signer=True, is_writable=True)],
+))
+```
+
+## Webhooks
+
+`verify_webhook_signature` and `parse_webhook_event` are framework-agnostic - feed
+them the raw request bytes and the `Signature` header. With FastAPI:
+
+```python
+from fastapi import FastAPI, Request, HTTPException
+from cryptochief import (
+    parse_webhook_event,
+    WebhookSignatureError,
+    PayInWebhookEvent,
+    PayoutWebhookEvent,
+)
+
+app = FastAPI()
+API_KEY = "..."
+
+@app.post("/webhooks/crypto-chief")
+async def hook(request: Request):
+    raw = await request.body()  # the EXACT bytes - do not re-encode
+    try:
+        event = parse_webhook_event(API_KEY, raw, request.headers.get("Signature"))
+    except WebhookSignatureError:
+        raise HTTPException(status_code=401, detail="bad signature")
+
+    if isinstance(event, PayInWebhookEvent):
+        if event.status == "paid":
+            ...  # invoice.paid -> fulfill the order for event.order_id
+    elif isinstance(event, PayoutWebhookEvent):
+        ...  # payout.paid / payout.system_fail -> reconcile your ledger
+    return {"ok": True}
+```
+
+`parse_webhook_event` returns a typed event (`PayoutWebhookEvent`,
+`TransactionWebhookEvent`, `PayInWebhookEvent`, `StaticDepositWebhookEvent`) chosen
+by the event-name prefix, or the raw dict for an unrecognized prefix. Whitelist
+the sender IPs in `WEBHOOK_SENDER_IPS` at your edge for defense in depth.
+
+## Errors
+
+Everything the SDK raises derives from `CryptoChiefError`. API failures are
+`APIError` with a stable `.code` (and `.http_status`); branch on `ErrorCode`
+rather than parsing messages. 5xx and network errors are retried automatically;
+4xx is raised immediately.
+
+```python
+from cryptochief import APIError, ErrorCode
+
+try:
+    await client.payouts.execute(req)
+except APIError as e:
+    if e.code == ErrorCode.DEBT_LIMIT_EXCEEDED:
+        ...
+```
+
+## Wallet private-key decryption
+
+Generated wallets return `private_key_encrypted` (RSA-OAEP / SHA-256, base64).
+Configure your project's RSA private key to decrypt locally - it never touches
+the network:
+
+```python
+client = CryptoChiefClient(
+    merchant_id="M", api_key="K",
+    rsa_private_key=open("project_private_key.pem").read(),
+)
+wallet = await client.wallets.generate(...)
+priv = client.wallets.decrypt_private_key(wallet.private_key_encrypted)
+```
+
+## FAQ - common crypto-processing tasks in Python
+
+- **How do I accept crypto payments in Python?** Create a pay-in with
+  `client.pay_ins.create(...)`, redirect the customer to `pay_in.payment_link`,
+  and confirm via webhook or `client.pay_ins.wait_for(uuid)`.
+- **How do I send a USDT payout?** `client.payouts.execute(...)` with the
+  stablecoin's `coin` / `network`; poll `wait_for`.
+- **How do I send many payouts at once?** `client.payouts.batch_execute(...)` -
+  up to 50 items, funds locked sequentially.
+- **How do I do a crypto swap?** A swap is a payout with `auto_convert=True`.
+- **How do I call a smart contract?** `client.transactions.sign_evm_call` /
+  `sign_anchor_call` / `jetton_transfer`, then `transactions.execute`.
+
+## Documentation
+
+- SDK guide: https://docs-sdk.crypto-chief.com/processing/python
+- REST API reference: https://docs-processing.crypto-chief.com
+- Product: https://crypto-chief.com/processing/
+
+## License
+
+MIT

cryptochief_crypto_processing_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+cryptochief/__init__.py,sha256=q6qGaxOd6MUIKS_41CmY3xIt9PwBsf8EAB32nGgFWGY,8169
+cryptochief/_models.py,sha256=I5jbRtC4Asnr0eZP1IUYcgQqXE-HMhXIq4zGabvMGO4,3195
+cryptochief/_version.py,sha256=-UYTpK8lRuzcw9BEWkdBHyJiS_vjvg0P06Wo2xs--us,77
+cryptochief/amount.py,sha256=UzIc1ZEJYYH8Zj5rUdnnLC01fS5ICKUSQ_rRxF0oeWI,3168
+cryptochief/assets.py,sha256=f4PaC60qoYloLlegWa61bXeG0qmk8j3Hcq4YjVrUVHw,889
+cryptochief/chains.py,sha256=FJ-QplCjf6qNc9frJYF7mJWMpB_DZ3SizI91kYTBNO0,3713
+cryptochief/client.py,sha256=_nLV_shDLWAD9_YKP6GDAmRYdw9uo65gxGGFw-dK6nY,7270
+cryptochief/errors.py,sha256=iFCiTpXbXwLa1nJTT57SKdtQEhUdbxAI-Lcnd8p3OA0,4052
+cryptochief/pagination.py,sha256=pJIzZNjN2mCbmYz66l1E-rUz8fsShZyNZecUncbcXtU,771
+cryptochief/poll.py,sha256=CfWb4OI1CN0gmS-ktt1SIN0yvNu9JQVhOlfi65WCsD8,1817
+cryptochief/rsa.py,sha256=VvXJOJxE_GEdZ5cK4u0dRPkXWVs4GJnTnYHiFWpOhiM,2712
+cryptochief/sign.py,sha256=ghILWz9AEe_jy2JSgdOU2CpYlWGKrsZxJWjg-P9mgcs,3687
+cryptochief/transport.py,sha256=mGQ95JgVpRJposxmVXFhtI2Rkt-G2GRsBtQg2MlPEyw,1578
+cryptochief/webhook.py,sha256=GAx94kf9Bkk5xKSNdQ1LNsM1BUyioAPnney5jfluB4A,6154
+cryptochief/contract/__init__.py,sha256=LF3fAvJOv0pnFeK7XOA69CwnM8GM_McqUiRvmZGj7f8,1398
+cryptochief/contract/base58.py,sha256=Rr-bcqBAHgr-q9_pV-KEwPrOjEGow3qiDUwZ_kicUH8,1172
+cryptochief/contract/borsh.py,sha256=aSsumB5N19BK2eVi11s2nM715M9v_mkFwzcQ2HnXHII,4346
+cryptochief/contract/evm_abi.py,sha256=YKGEdWbedNFZ7KMwmUCP9xqomi7jfIa3UlqIfbdMpko,11028
+cryptochief/contract/keccak.py,sha256=2O467YjK_CWFoPdLhu8Jnv6nS30K4zl669Hu3-NrSxE,437
+cryptochief/contract/tron_address.py,sha256=yLXneYvhbD9G8yIPcGMp-azl79C8brcmrknGE8VOVTA,2012
+cryptochief/services/__init__.py,sha256=6Hn8aGX2dDLO1uK4tDIJ5f2HnADi4kamzSt2nwkk13s,87
+cryptochief/services/base.py,sha256=EAhQxgXF_gokT7Tz5AFkJ2xPNVMbU9RiVua0qAtK1Tw,678
+cryptochief/services/blockchain.py,sha256=Yiu4KBuxDz_XyZIsTpVRax9IoqIMJkMigjvfiSvxgm8,2418
+cryptochief/services/currencies.py,sha256=sZ2JkZUqQMSuzpdRCY3HuuVY9TLLDOgAyCSmvuOm0-A,1611
+cryptochief/services/payins.py,sha256=uPhY6ceRZe8eA5cmsrTfDOtH8N_5vKFWBeGTOgbv3ZY,4568
+cryptochief/services/payouts.py,sha256=QkqnxyXgTqDnh7epZQCgcvhxWnalpxNSZdR1QMl7vI4,5586
+cryptochief/services/static_deposits.py,sha256=8uVM7c4rXb5HPj5n7q0K8bri0Kbxa3d442Uwo4iAMuM,2329
+cryptochief/services/sweeps.py,sha256=_OSfwY-wQcZPjeyThbAx1RNEtDqbfoeuRtJttyroKpA,2675
+cryptochief/services/transactions.py,sha256=EnVWTlbu04GJovI8PMBkxpO438dOny7E58GX_65I9MQ,16788
+cryptochief/services/wallets.py,sha256=g19wqwatVTRY-Zr_JFumQdbjY4Eit8hyEnZC2aerPpw,2956
+cryptochief/services/withdrawals.py,sha256=8UEXSr1VpvYSJl11vTBDOHq9qN96jP-i9p5USezKLHc,1540
+cryptochief/ton/__init__.py,sha256=z5VnZ5zXJkGaWUvOPdxC1YL6LJHz4TfhItVhBRVGKpA,392
+cryptochief/ton/address.py,sha256=Xo9cASWxTAK5-BLZ7ZwZcPEgobnh5fcwGj_gPzK2jz0,3731
+cryptochief/ton/messages.py,sha256=GCAn6TdyHewIwHb6V9HCjRx7BFHq9i1Cl243kDl6JNs,3341
+cryptochief/ton/rpc.py,sha256=fccQG2hecmLDIXyZs_6SzUIVzPb9huJnFFLp3HMrOuc,6109
+cryptochief_crypto_processing_python-0.1.0.dist-info/METADATA,sha256=qxMvCYV9oEyVMjXr6UGBHqZGKeW_ToNXne4PbK_QIWM,14683
+cryptochief_crypto_processing_python-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+cryptochief_crypto_processing_python-0.1.0.dist-info/licenses/LICENSE,sha256=OkQRmg655nJmf2CYF2rYZNq-W961sWnsIPgYPJ5uuE4,1069
+cryptochief_crypto_processing_python-0.1.0.dist-info/RECORD,,

cryptochief_crypto_processing_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

cryptochief_crypto_processing_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Crypto Chief
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.