synapse-filecoin-sdk 0.1.0__py3-none-any.whl

pynapse/core/typed_data.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from eth_abi import encode as abi_encode
+from eth_account import Account
+from eth_account.messages import encode_structured_data
+from eth_utils import to_bytes
+
+from .chains import Chain
+from .rand import rand_u256
+
+EIP712_TYPES: Dict[str, List[Dict[str, str]]] = {
+    "EIP712Domain": [
+        {"name": "name", "type": "string"},
+        {"name": "version", "type": "string"},
+        {"name": "chainId", "type": "uint256"},
+        {"name": "verifyingContract", "type": "address"},
+    ],
+    "MetadataEntry": [
+        {"name": "key", "type": "string"},
+        {"name": "value", "type": "string"},
+    ],
+    "CreateDataSet": [
+        {"name": "clientDataSetId", "type": "uint256"},
+        {"name": "payee", "type": "address"},
+        {"name": "metadata", "type": "MetadataEntry[]"},
+    ],
+    "Cid": [
+        {"name": "data", "type": "bytes"},
+    ],
+    "PieceMetadata": [
+        {"name": "pieceIndex", "type": "uint256"},
+        {"name": "metadata", "type": "MetadataEntry[]"},
+    ],
+    "AddPieces": [
+        {"name": "clientDataSetId", "type": "uint256"},
+        {"name": "nonce", "type": "uint256"},
+        {"name": "pieceData", "type": "Cid[]"},
+        {"name": "pieceMetadata", "type": "PieceMetadata[]"},
+    ],
+    "SchedulePieceRemovals": [
+        {"name": "clientDataSetId", "type": "uint256"},
+        {"name": "pieceIds", "type": "uint256[]"},
+    ],
+    "DeleteDataSet": [
+        {"name": "clientDataSetId", "type": "uint256"},
+    ],
+    "Permit": [
+        {"name": "owner", "type": "address"},
+        {"name": "spender", "type": "address"},
+        {"name": "value", "type": "uint256"},
+        {"name": "nonce", "type": "uint256"},
+        {"name": "deadline", "type": "uint256"},
+    ],
+}
+
+
+def get_storage_domain(chain: Chain, verifying_contract: Optional[str] = None) -> Dict[str, Any]:
+    return {
+        "name": "FilecoinWarmStorageService",
+        "version": "1",
+        "chainId": chain.id,
+        "verifyingContract": verifying_contract or chain.contracts.warm_storage,
+    }
+
+
+def _sign_typed_data(private_key: str, domain: Dict[str, Any], primary_type: str, message: Dict[str, Any]) -> str:
+    typed = {
+        "types": EIP712_TYPES,
+        "primaryType": primary_type,
+        "domain": domain,
+        "message": message,
+    }
+    msg = encode_structured_data(typed)
+    signed = Account.sign_message(msg, private_key=private_key)
+    return signed.signature.hex()
+
+
+def _piece_cid_bytes(piece_cid: str) -> bytes:
+    """Convert a piece CID string to its raw bytes.
+    
+    Handles both PieceCIDv1 (baga...) and PieceCIDv2 (bafk...) formats
+    by decoding the base32lower multibase encoding directly.
+    """
+    if not (piece_cid.startswith('baga') or piece_cid.startswith('bafk')):
+        raise ValueError(f"Unsupported CID format: {piece_cid}")
+    
+    # Remove 'b' prefix (base32lower multibase prefix)
+    raw = piece_cid[1:]
+    # base32lower uses lowercase RFC 4648 alphabet
+    # Python's base64.b32decode expects uppercase
+    raw_upper = raw.upper()
+    # Add padding
+    padding = (8 - len(raw_upper) % 8) % 8
+    raw_padded = raw_upper + '=' * padding
+    return base64.b32decode(raw_padded)
+
+
+def sign_create_dataset(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    payee: str,
+    metadata: Sequence[Dict[str, str]],
+    verifying_contract: Optional[str] = None,
+) -> str:
+    domain = get_storage_domain(chain, verifying_contract)
+    message = {
+        "clientDataSetId": int(client_data_set_id),
+        "payee": payee,
+        "metadata": list(metadata),
+    }
+    return _sign_typed_data(private_key, domain, "CreateDataSet", message)
+
+
+def sign_schedule_piece_removals(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    piece_ids: Sequence[int],
+    verifying_contract: Optional[str] = None,
+) -> str:
+    domain = get_storage_domain(chain, verifying_contract)
+    message = {
+        "clientDataSetId": int(client_data_set_id),
+        "pieceIds": [int(pid) for pid in piece_ids],
+    }
+    return _sign_typed_data(private_key, domain, "SchedulePieceRemovals", message)
+
+
+def sign_add_pieces_extra_data(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    pieces: Sequence[Tuple[str, Sequence[Dict[str, str]]]],
+    nonce: Optional[int] = None,
+    verifying_contract: Optional[str] = None,
+) -> str:
+    use_nonce = nonce if nonce is not None else rand_u256()
+
+    piece_data = [{"data": _piece_cid_bytes(piece_cid)} for piece_cid, _ in pieces]
+    piece_metadata = []
+    for idx, (_, metadata) in enumerate(pieces):
+        piece_metadata.append(
+            {
+                "pieceIndex": int(idx),
+                "metadata": list(metadata),
+            }
+        )
+
+    domain = get_storage_domain(chain, verifying_contract)
+    message = {
+        "clientDataSetId": int(client_data_set_id),
+        "nonce": int(use_nonce),
+        "pieceData": piece_data,
+        "pieceMetadata": piece_metadata,
+    }
+
+    signature = _sign_typed_data(private_key, domain, "AddPieces", message)
+
+    metadata_keys = [[entry["key"] for entry in metadata] for _, metadata in pieces]
+    metadata_values = [[entry["value"] for entry in metadata] for _, metadata in pieces]
+
+    encoded = abi_encode(
+        ["uint256", "string[][]", "string[][]", "bytes"],
+        [use_nonce, metadata_keys, metadata_values, bytes.fromhex(signature[2:])],
+    )
+    return "0x" + encoded.hex()
+
+
+def sign_delete_dataset(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    verifying_contract: Optional[str] = None,
+) -> str:
+    """
+    Sign a DeleteDataSet typed data message.
+    
+    Args:
+        private_key: Private key to sign with
+        chain: Chain configuration
+        client_data_set_id: Client-side dataset identifier
+        verifying_contract: Optional override for verifying contract address
+        
+    Returns:
+        Hex-encoded signature
+    """
+    domain = get_storage_domain(chain, verifying_contract)
+    message = {
+        "clientDataSetId": int(client_data_set_id),
+    }
+    return _sign_typed_data(private_key, domain, "DeleteDataSet", message)
+
+
+def sign_delete_dataset_extra_data(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    verifying_contract: Optional[str] = None,
+) -> str:
+    """
+    Create encoded extra data for delete dataset operation.
+    
+    This is the ABI-encoded format expected by the warm storage contract.
+    
+    Args:
+        private_key: Private key to sign with
+        chain: Chain configuration  
+        client_data_set_id: Client-side dataset identifier
+        verifying_contract: Optional override for verifying contract address
+        
+    Returns:
+        Hex-encoded extra data (ABI encoded signature)
+    """
+    signature = sign_delete_dataset(private_key, chain, client_data_set_id, verifying_contract)
+    encoded = abi_encode(["bytes"], [bytes.fromhex(signature[2:])])
+    return "0x" + encoded.hex()
+
+
+def sign_create_dataset_extra_data(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    payee: str,
+    metadata: Optional[Sequence[Dict[str, str]]] = None,
+    payer: Optional[str] = None,
+    verifying_contract: Optional[str] = None,
+) -> str:
+    """
+    Create encoded extra data for create dataset operation.
+    
+    This is the ABI-encoded format expected by the warm storage contract.
+    
+    Args:
+        private_key: Private key to sign with
+        chain: Chain configuration
+        client_data_set_id: Client-side dataset identifier
+        payee: Address to receive payments
+        metadata: Optional dataset metadata as list of {key, value} dicts
+        payer: Address that will pay for storage (defaults to signer's address)
+        verifying_contract: Optional override for verifying contract address
+        
+    Returns:
+        Hex-encoded extra data
+    """
+    metadata = metadata or []
+    signature = sign_create_dataset(private_key, chain, client_data_set_id, payee, metadata, verifying_contract)
+    
+    # Derive payer address from private key if not provided
+    if payer is None:
+        acct = Account.from_key(private_key)
+        payer = acct.address
+    
+    metadata_keys = [entry["key"] for entry in metadata]
+    metadata_values = [entry["value"] for entry in metadata]
+    
+    # ABI encoding must match TypeScript SDK:
+    # [payer (address), clientDataSetId (uint256), keys (string[]), values (string[]), signature (bytes)]
+    encoded = abi_encode(
+        ["address", "uint256", "string[]", "string[]", "bytes"],
+        [payer, client_data_set_id, metadata_keys, metadata_values, bytes.fromhex(signature[2:])],
+    )
+    return "0x" + encoded.hex()
+
+
+def sign_schedule_removals_extra_data(
+    private_key: str,
+    chain: Chain,
+    client_data_set_id: int,
+    piece_ids: Sequence[int],
+    verifying_contract: Optional[str] = None,
+) -> str:
+    """
+    Create encoded extra data for schedule piece removals operation.
+    
+    Args:
+        private_key: Private key to sign with
+        chain: Chain configuration
+        client_data_set_id: Client-side dataset identifier
+        piece_ids: List of piece IDs to schedule for removal
+        verifying_contract: Optional override for verifying contract address
+        
+    Returns:
+        Hex-encoded extra data
+    """
+    signature = sign_schedule_piece_removals(private_key, chain, client_data_set_id, piece_ids, verifying_contract)
+    encoded = abi_encode(["bytes"], [bytes.fromhex(signature[2:])])
+    return "0x" + encoded.hex()
+
+
+def sign_erc20_permit(
+    private_key: str,
+    name: str,
+    version: str,
+    chain_id: int,
+    verifying_contract: str,
+    owner: str,
+    spender: str,
+    value: int,
+    nonce: int,
+    deadline: int,
+) -> str:
+    domain = {
+        "name": name,
+        "version": version,
+        "chainId": chain_id,
+        "verifyingContract": verifying_contract,
+    }
+    message = {
+        "owner": owner,
+        "spender": spender,
+        "value": int(value),
+        "nonce": int(nonce),
+        "deadline": int(deadline),
+    }
+    return _sign_typed_data(private_key, domain, "Permit", message)

pynapse/core/utils.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from decimal import Decimal, ROUND_DOWN, getcontext
+from typing import Union
+
+NumberLike = Union[int, float, str, Decimal]
+
+
+def parse_units(value: NumberLike, decimals: int = 18) -> int:
+    if decimals < 0:
+        raise ValueError("decimals must be >= 0")
+
+    if isinstance(value, Decimal):
+        dec = value
+    else:
+        dec = Decimal(str(value))
+
+    scale = Decimal(10) ** decimals
+    scaled = (dec * scale).quantize(Decimal(1), rounding=ROUND_DOWN)
+    return int(scaled)
+
+
+def format_units(value: int, decimals: int = 18) -> str:
+    if decimals < 0:
+        raise ValueError("decimals must be >= 0")
+
+    getcontext().prec = max(28, decimals + 10)
+    scale = Decimal(10) ** decimals
+    dec = Decimal(value) / scale
+    return format(dec.normalize(), "f")

pynapse/evm/__init__.py

@@ -0,0 +1,3 @@
+from .client import AsyncEVMClient, SyncEVMClient
+
+__all__ = ["AsyncEVMClient", "SyncEVMClient"]

pynapse/evm/client.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from web3 import AsyncWeb3, Web3
+from web3.providers.async_rpc import AsyncHTTPProvider
+from web3.providers.rpc import HTTPProvider
+
+
+@dataclass
+class SyncEVMClient:
+    web3: Web3
+
+    @classmethod
+    def from_rpc_url(cls, rpc_url: str) -> "SyncEVMClient":
+        return cls(web3=Web3(HTTPProvider(rpc_url)))
+
+
+@dataclass
+class AsyncEVMClient:
+    web3: AsyncWeb3
+
+    @classmethod
+    def from_rpc_url(cls, rpc_url: str) -> "AsyncEVMClient":
+        return cls(web3=AsyncWeb3(AsyncHTTPProvider(rpc_url)))

pynapse/filbeam/__init__.py

@@ -0,0 +1,3 @@
+from .service import DataSetStats, FilBeamService
+
+__all__ = ["FilBeamService", "DataSetStats"]

pynapse/filbeam/service.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import httpx
+
+from pynapse.core.chains import Chain, as_chain
+
+
+@dataclass
+class DataSetStats:
+    cdn_egress_quota: int
+    cache_miss_egress_quota: int
+
+
+class FilBeamService:
+    def __init__(self, chain: Chain, client: httpx.Client | None = None) -> None:
+        self._chain = as_chain(chain)
+        self._client = client or httpx.Client(timeout=30)
+
+    def _stats_base_url(self) -> str:
+        if self._chain.id == 314159:
+            return "https://calibration.stats.filbeam.com"
+        return "https://stats.filbeam.com"
+
+    def get_data_set_stats(self, data_set_id: str | int) -> DataSetStats:
+        url = f"{self._stats_base_url()}/data-set/{data_set_id}"
+        resp = self._client.get(url)
+        if resp.status_code == 404:
+            raise RuntimeError(f"Data set not found: {data_set_id}")
+        if resp.status_code != 200:
+            raise RuntimeError(f"HTTP {resp.status_code}: {resp.text}")
+        data = resp.json()
+        if not isinstance(data, dict):
+            raise RuntimeError("Invalid response from FilBeam")
+        return DataSetStats(
+            cdn_egress_quota=int(data.get("cdnEgressQuota", "0")),
+            cache_miss_egress_quota=int(data.get("cacheMissEgressQuota", "0")),
+        )

pynapse/payments/__init__.py

@@ -0,0 +1,17 @@
+from .service import (
+    AccountInfo,
+    AsyncPaymentsService,
+    RailInfo,
+    ServiceApproval,
+    SettlementResult,
+    SyncPaymentsService,
+)
+
+__all__ = [
+    "AccountInfo",
+    "AsyncPaymentsService",
+    "RailInfo",
+    "ServiceApproval",
+    "SettlementResult",
+    "SyncPaymentsService",
+]