weil-wallet 0.1.0__tar.gz

weil_wallet-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: weil-wallet
+Version: 0.1.0
+Summary: Python SDK for building clients that interact with smart contracts on WeilChain
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: coincurve>=21.0.0
+Requires-Dist: bip_utils>=2.9.0
+Requires-Dist: eth-hash[pycryptodome]>=0.5.0
+Provides-Extra: agents
+Requires-Dist: langchain>=0.1.0; extra == "agents"

weil_wallet-0.1.0/__init__.py

@@ -0,0 +1,52 @@
+"""Weil Wallet SDK for Python — initialize wallet and sign transactions on WeilChain."""
+
+from .client import WeilClient, WeilContractClient
+from .constants import (
+    AUDIT_APPLET_SVC_NAME,
+    IDENTITY_APPLET_SVC_PREFIX,
+    PENSIEVE_APPLET_SVC_NAME,
+    PUBLISHER_APPLET_SVC_NAME,
+)
+from .contract import ContractId, contract_id_from_str
+from .derived_wallet import (
+    MnemonicWallet,
+    WalletAccount,
+    create_wallet,
+    load_wallet,
+    pubkey_to_derived_address,
+)
+from .errors import InvalidContractIdError, WalletNotPermittedError
+from .pensieve import Pensieve
+from .streaming import ByteStream
+from .transaction import BaseTransaction, TransactionResult, TransactionStatus, TransactionHeader
+from .wallet import OrgInfo, OrgMembership, SelectedAccount, Wallet
+from .secure_wallet import harden_process
+
+__all__ = [
+    "WeilClient",
+    "WeilContractClient",
+    "ContractId",
+    "contract_id_from_str",
+    "InvalidContractIdError",
+    "WalletNotPermittedError",
+    "Pensieve",
+    "PENSIEVE_APPLET_SVC_NAME",
+    "AUDIT_APPLET_SVC_NAME",
+    "IDENTITY_APPLET_SVC_PREFIX",
+    "PUBLISHER_APPLET_SVC_NAME",
+    "ByteStream",
+    "BaseTransaction",
+    "TransactionResult",
+    "TransactionStatus",
+    "TransactionHeader",
+    "OrgInfo",
+    "OrgMembership",
+    "SelectedAccount",
+    "Wallet",
+    "harden_process",
+    "MnemonicWallet",
+    "WalletAccount",
+    "create_wallet",
+    "load_wallet",
+    "pubkey_to_derived_address",
+]

weil_wallet-0.1.0/api/__init__.py

@@ -0,0 +1,6 @@
+"""API layer for submitting transactions to the platform."""
+
+from .platform_api import PlatformApi
+from .request import SubmitTxnRequest
+
+__all__ = ["PlatformApi", "SubmitTxnRequest"]

weil_wallet-0.1.0/api/platform_api.py

@@ -0,0 +1,75 @@
+"""Platform API: submit transaction (normal and streaming)."""
+
+from typing import AsyncIterator
+
+import httpx
+
+from ..transaction import TransactionResult
+from ..utils import compress
+from .request import SubmitTxnRequest
+
+
+class PlatformApi:
+    """Submit transactions to the WeilChain platform."""
+
+    @staticmethod
+    async def _submit_transaction_inner(
+        payload: SubmitTxnRequest,
+        client: httpx.AsyncClient,
+        *,
+        is_non_blocking: bool,
+    ) -> httpx.Response:
+        """GZIP-compress and POST the transaction payload; raise on HTTP error."""
+        payload_dict = payload.to_payload_dict()
+        tx_payload = compress(payload_dict)
+
+        files = {
+            "transaction": ("transaction_data", tx_payload, "application/octet-stream")
+        }
+
+        headers = {}
+
+        if is_non_blocking:
+            headers["x-non-blocking"] = "true"
+
+        response = await client.post(
+            "/contracts/execute_smartcontract", files=files, headers=headers
+        )
+
+        if not response.is_success:
+            body = response.text[:500] if response.text else ""
+
+            raise RuntimeError(
+                f"failed to submit the transaction: HTTP {response.status_code} {body}"
+            )
+
+        return response
+
+    @staticmethod
+    async def submit_transaction(
+        payload: SubmitTxnRequest,
+        client: httpx.AsyncClient,
+        *,
+        is_non_blocking: bool = False,
+    ) -> TransactionResult:
+        """Submit and return the parsed TransactionResult."""
+        response = await PlatformApi._submit_transaction_inner(
+            payload, client, is_non_blocking=is_non_blocking
+        )
+        data = response.json()
+        return TransactionResult.from_dict(data)
+
+    @staticmethod
+    async def submit_transaction_with_streaming(
+        payload: SubmitTxnRequest,
+        client: httpx.AsyncClient,
+        *,
+        is_non_blocking: bool = False,
+    ) -> AsyncIterator[bytes]:
+        """Submit and return an async iterator of response body chunks."""
+        response = await PlatformApi._submit_transaction_inner(
+            payload, client, is_non_blocking=is_non_blocking
+        )
+        async for chunk in response.aiter_bytes():
+            if chunk:
+                yield chunk

weil_wallet-0.1.0/api/request.py

@@ -0,0 +1,76 @@
+"""Request types for the platform API (submit transaction)."""
+
+from dataclasses import dataclass
+from typing import Any, Optional
+
+from ..contract import ContractId
+from ..transaction import TransactionHeader
+
+
+@dataclass
+class Verifier:
+    """Signature verifier strategy tag sent with every transaction."""
+
+    ty: str = "DefaultVerifier"
+
+
+@dataclass
+class UserTransaction:
+    """The user-visible part of a transaction: which contract method to call and with what args."""
+
+    ty: str = "SmartContractExecutor"
+    contract_address: Optional[ContractId] = None
+    contract_method: str = ""
+    contract_input_bytes: Optional[str] = None
+    should_hide_args: bool = True
+
+
+@dataclass
+class Transaction:
+    """Full transaction envelope: header, verifier, and user payload."""
+
+    is_xpod: bool = False
+    txn_header: Optional[TransactionHeader] = None
+    verifier: Optional[Verifier] = None
+    user_txn: Optional[UserTransaction] = None
+
+
+@dataclass
+class SubmitTxnRequest:
+    """Top-level request wrapper submitted to the platform API."""
+
+    transaction: Optional[Transaction] = None
+
+    def to_payload_dict(self) -> dict[str, Any]:
+        """Build the JSON-serializable payload (with 'type' for serde compatibility)."""
+        txn = self.transaction
+        if not txn or not txn.txn_header or not txn.verifier or not txn.user_txn:
+            raise ValueError("incomplete transaction")
+        h = txn.txn_header
+        return {
+            "transaction": {
+                "is_xpod": txn.is_xpod,
+                "txn_header": {
+                    "nonce": h.nonce,
+                    "public_key": h.public_key,
+                    "from_addr": h.from_addr,
+                    "to_addr": h.to_addr,
+                    "signature": h.signature,
+                    "weilpod_counter": h.weilpod_counter,
+                    "creation_time": h.creation_time,
+                    "salt": h.salt,
+                    # Covered by the signature -- the node rebuilds the digest
+                    # from what actually arrives, so omitting this would make
+                    # every org-bearing transaction fail verification.
+                    "org": h.org.to_dict() if h.org else None,
+                },
+                "verifier": {"type": txn.verifier.ty},
+                "user_txn": {
+                    "type": txn.user_txn.ty,
+                    "contract_address": str(txn.user_txn.contract_address),
+                    "contract_method": txn.user_txn.contract_method,
+                    "contract_input_bytes": txn.user_txn.contract_input_bytes,
+                    "should_hide_args": txn.user_txn.should_hide_args,
+                },
+            }
+        }