dfns-sdk 0.0.0.dev0__py3-none-any.whl

dfns_sdk/client.py

@@ -0,0 +1,81 @@
+"""Main Dfns client."""
+
+from .types import DfnsClientConfig
+from ._internal import HttpClient
+from .generated.auth import AuthClient
+from .generated.exchanges import ExchangesClient
+from .generated.fee_sponsors import FeeSponsorsClient
+from .generated.keys import KeysClient
+from .generated.networks import NetworksClient
+from .generated.permissions import PermissionsClient
+from .generated.policies import PoliciesClient
+from .generated.signers import SignersClient
+from .generated.staking import StakingClient
+from .generated.wallets import WalletsClient
+from .generated.webhooks import WebhooksClient
+from .generated.swaps import SwapsClient
+from .generated.agreements import AgreementsClient
+from .generated.allocations import AllocationsClient
+
+
+class DfnsClient:
+    """
+    Main client for the Dfns API.
+
+    This client provides access to all Dfns API domains through typed sub-clients.
+
+    Example:
+        >>> from dfns_sdk import DfnsClient, DfnsClientConfig
+        >>> config = DfnsClientConfig(auth_token="your-token")
+        >>> client = DfnsClient(config)
+        >>> wallets = client.wallets.list_wallets()
+    """
+
+    auth: AuthClient
+    exchanges: ExchangesClient
+    fee_sponsors: FeeSponsorsClient
+    keys: KeysClient
+    networks: NetworksClient
+    permissions: PermissionsClient
+    policies: PoliciesClient
+    signers: SignersClient
+    staking: StakingClient
+    wallets: WalletsClient
+    webhooks: WebhooksClient
+    swaps: SwapsClient
+    agreements: AgreementsClient
+    allocations: AllocationsClient
+
+    def __init__(self, config: DfnsClientConfig):
+        """
+        Initialize the Dfns client.
+
+        Args:
+            config: Client configuration.
+        """
+        self._config = config
+        self._http = HttpClient(config)
+        self.auth = AuthClient(self._http)
+        self.exchanges = ExchangesClient(self._http)
+        self.fee_sponsors = FeeSponsorsClient(self._http)
+        self.keys = KeysClient(self._http)
+        self.networks = NetworksClient(self._http)
+        self.permissions = PermissionsClient(self._http)
+        self.policies = PoliciesClient(self._http)
+        self.signers = SignersClient(self._http)
+        self.staking = StakingClient(self._http)
+        self.wallets = WalletsClient(self._http)
+        self.webhooks = WebhooksClient(self._http)
+        self.swaps = SwapsClient(self._http)
+        self.agreements = AgreementsClient(self._http)
+        self.allocations = AllocationsClient(self._http)
+
+    def close(self) -> None:
+        """Close the client and release resources."""
+        self._http.close()
+
+    def __enter__(self) -> "DfnsClient":
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()

dfns_sdk/delegated_client.py

@@ -0,0 +1,97 @@
+"""Delegated Dfns client for external signing orchestration."""
+
+from .types import DfnsDelegatedClientConfig
+from ._internal import HttpClient
+from .generated.auth import DelegatedAuthClient
+from .generated.exchanges import DelegatedExchangesClient
+from .generated.fee_sponsors import DelegatedFeeSponsorsClient
+from .generated.keys import DelegatedKeysClient
+from .generated.networks import DelegatedNetworksClient
+from .generated.permissions import DelegatedPermissionsClient
+from .generated.policies import DelegatedPoliciesClient
+from .generated.signers import DelegatedSignersClient
+from .generated.staking import DelegatedStakingClient
+from .generated.wallets import DelegatedWalletsClient
+from .generated.webhooks import DelegatedWebhooksClient
+from .generated.swaps import DelegatedSwapsClient
+from .generated.agreements import DelegatedAgreementsClient
+from .generated.allocations import DelegatedAllocationsClient
+
+
+class DfnsDelegatedClient:
+    """
+    Delegated client for the Dfns API.
+
+    This client is designed for service accounts that orchestrate signing externally.
+    Operations requiring user action signing are split into *_init() and *_complete()
+    method pairs, allowing external systems to handle the signing process.
+
+    Example:
+        >>> from dfns_sdk import DfnsDelegatedClient, DfnsDelegatedClientConfig
+        >>> config = DfnsDelegatedClientConfig(auth_token="service-account-token")
+        >>> client = DfnsDelegatedClient(config)
+        >>>
+        >>> # Step 1: Initialize action (get challenge)
+        >>> challenge = client.wallets.create_wallet_init(body={"network": "EthereumSepolia"})
+        >>>
+        >>> # Step 2: Sign externally (your signing system)
+        >>> signed = your_external_signer.sign(challenge)
+        >>>
+        >>> # Step 3: Complete action with signed challenge
+        >>> wallet = client.wallets.create_wallet_complete(
+        ...     body={"network": "EthereumSepolia"},
+        ...     signed_challenge={
+        ...         "challengeIdentifier": challenge["challengeIdentifier"],
+        ...         "firstFactor": signed,
+        ...     },
+        ... )
+    """
+
+    auth: DelegatedAuthClient
+    exchanges: DelegatedExchangesClient
+    fee_sponsors: DelegatedFeeSponsorsClient
+    keys: DelegatedKeysClient
+    networks: DelegatedNetworksClient
+    permissions: DelegatedPermissionsClient
+    policies: DelegatedPoliciesClient
+    signers: DelegatedSignersClient
+    staking: DelegatedStakingClient
+    wallets: DelegatedWalletsClient
+    webhooks: DelegatedWebhooksClient
+    swaps: DelegatedSwapsClient
+    agreements: DelegatedAgreementsClient
+    allocations: DelegatedAllocationsClient
+
+    def __init__(self, config: DfnsDelegatedClientConfig):
+        """
+        Initialize the delegated Dfns client.
+
+        Args:
+            config: Client configuration (no signer required).
+        """
+        self._config = config
+        self._http = HttpClient(config)
+        self.auth = DelegatedAuthClient(self._http)
+        self.exchanges = DelegatedExchangesClient(self._http)
+        self.fee_sponsors = DelegatedFeeSponsorsClient(self._http)
+        self.keys = DelegatedKeysClient(self._http)
+        self.networks = DelegatedNetworksClient(self._http)
+        self.permissions = DelegatedPermissionsClient(self._http)
+        self.policies = DelegatedPoliciesClient(self._http)
+        self.signers = DelegatedSignersClient(self._http)
+        self.staking = DelegatedStakingClient(self._http)
+        self.wallets = DelegatedWalletsClient(self._http)
+        self.webhooks = DelegatedWebhooksClient(self._http)
+        self.swaps = DelegatedSwapsClient(self._http)
+        self.agreements = DelegatedAgreementsClient(self._http)
+        self.allocations = DelegatedAllocationsClient(self._http)
+
+    def close(self) -> None:
+        """Close the client and release resources."""
+        self._http.close()
+
+    def __enter__(self) -> "DfnsDelegatedClient":
+        return self
+
+    def __exit__(self, *args) -> None:
+        self.close()

dfns_sdk/generated/__init__.py

@@ -0,0 +1,47 @@
+"""Generated domain clients."""
+
+from .auth import AuthClient, DelegatedAuthClient
+from .exchanges import ExchangesClient, DelegatedExchangesClient
+from .fee_sponsors import FeeSponsorsClient, DelegatedFeeSponsorsClient
+from .keys import KeysClient, DelegatedKeysClient
+from .networks import NetworksClient, DelegatedNetworksClient
+from .permissions import PermissionsClient, DelegatedPermissionsClient
+from .policies import PoliciesClient, DelegatedPoliciesClient
+from .signers import SignersClient, DelegatedSignersClient
+from .staking import StakingClient, DelegatedStakingClient
+from .wallets import WalletsClient, DelegatedWalletsClient
+from .webhooks import WebhooksClient, DelegatedWebhooksClient
+from .swaps import SwapsClient, DelegatedSwapsClient
+from .agreements import AgreementsClient, DelegatedAgreementsClient
+from .allocations import AllocationsClient, DelegatedAllocationsClient
+
+__all__ = [
+    "AuthClient",
+    "DelegatedAuthClient",
+    "ExchangesClient",
+    "DelegatedExchangesClient",
+    "FeeSponsorsClient",
+    "DelegatedFeeSponsorsClient",
+    "KeysClient",
+    "DelegatedKeysClient",
+    "NetworksClient",
+    "DelegatedNetworksClient",
+    "PermissionsClient",
+    "DelegatedPermissionsClient",
+    "PoliciesClient",
+    "DelegatedPoliciesClient",
+    "SignersClient",
+    "DelegatedSignersClient",
+    "StakingClient",
+    "DelegatedStakingClient",
+    "WalletsClient",
+    "DelegatedWalletsClient",
+    "WebhooksClient",
+    "DelegatedWebhooksClient",
+    "SwapsClient",
+    "DelegatedSwapsClient",
+    "AgreementsClient",
+    "DelegatedAgreementsClient",
+    "AllocationsClient",
+    "DelegatedAllocationsClient",
+]

dfns_sdk/generated/agreements/__init__.py

@@ -0,0 +1,7 @@
+"""Agreements domain module."""
+
+from .client import AgreementsClient
+from .delegated_client import DelegatedAgreementsClient
+from . import types
+
+__all__ = ["AgreementsClient", "DelegatedAgreementsClient", "types"]

dfns_sdk/generated/agreements/client.py

@@ -0,0 +1,55 @@
+"""Client for the agreements domain."""
+
+from typing import Any, Literal, Optional, TypedDict, Union
+
+from ..._internal import HttpClient
+from . import types as T
+
+
+class AgreementsClient:
+    """Client for agreements operations."""
+
+    def __init__(self, http_client: HttpClient):
+        self._http = http_client
+
+    def get_latest_unaccepted_agreement(self, query: T.GetLatestUnacceptedAgreementQuery) -> T.GetLatestUnacceptedAgreementResponse:
+        """
+        Get Latest Unaccepted Agreement.
+
+        Get the latest unaccepted agreement for a specific agreement type
+
+        Args:
+        query: Query parameters.
+
+        Returns:
+            T.GetLatestUnacceptedAgreementResponse: The API response.
+        """
+        return self._http.request(
+            method="GET",
+            path="/agreements/latest-unaccepted",
+            path_params={},
+            query_params=query,
+            body=None,
+            requires_signature=False,
+        )
+
+    def record_agreement_acceptance(self, agreement_id: str) -> T.RecordAgreementAcceptanceResponse:
+        """
+        Record Agreement Acceptance.
+
+        Record the acceptance of a specific agreement by its ID
+
+        Args:
+        agreement_id: Path parameter.
+
+        Returns:
+            T.RecordAgreementAcceptanceResponse: The API response.
+        """
+        return self._http.request(
+            method="POST",
+            path="/agreements/{agreementId}/accept",
+            path_params={"agreementId": agreement_id},
+            query_params=None,
+            body=None,
+            requires_signature=True,
+        )

dfns_sdk/generated/agreements/delegated_client.py

@@ -0,0 +1,95 @@
+"""Delegated client for the agreements domain."""
+
+import json
+from typing import Any, Literal, Optional, TypedDict, Union
+
+from ..._internal import HttpClient
+from ...base_auth_api import (
+    BaseAuthApi,
+    SignUserActionChallengeRequest,
+    UserActionChallengeResponse,
+)
+from . import types as T
+
+
+class DelegatedAgreementsClient:
+    """
+    Delegated client for agreements operations.
+
+    This client separates user action signing into _init() and _complete() method pairs,
+    allowing external systems to handle the signing process.
+    """
+
+    def __init__(self, http_client: HttpClient):
+        self._http = http_client
+
+    def get_latest_unaccepted_agreement(self, query: T.GetLatestUnacceptedAgreementQuery) -> T.GetLatestUnacceptedAgreementResponse:
+        """
+        Get Latest Unaccepted Agreement.
+
+        Get the latest unaccepted agreement for a specific agreement type
+
+        Args:
+        query: Query parameters.
+
+        Returns:
+            T.GetLatestUnacceptedAgreementResponse: The API response.
+        """
+        return self._http.request(
+            method="GET",
+            path="/agreements/latest-unaccepted",
+            path_params={},
+            query_params=query,
+            body=None,
+            requires_signature=False,
+        )
+
+    def record_agreement_acceptance_init(self, agreement_id: str) -> UserActionChallengeResponse:
+        """
+        Initialize Record Agreement Acceptance.
+
+        Creates a user action challenge for external signing.
+
+        Args:
+        agreement_id: Path parameter.
+
+        Returns:
+            UserActionChallengeResponse: The challenge to sign externally.
+        """
+        path = "/agreements/{agreementId}/accept"
+        path = path.replace("{agreementId}", str(agreement_id))
+        payload = ""
+
+        return BaseAuthApi.create_user_action_challenge(
+            self._http,
+            user_action_http_method="POST",
+            user_action_http_path=path,
+            user_action_payload=payload,
+        )
+
+    def record_agreement_acceptance_complete(self, agreement_id: str, signed_challenge: SignUserActionChallengeRequest) -> T.RecordAgreementAcceptanceResponse:
+        """
+        Complete Record Agreement Acceptance.
+
+        Submits the signed challenge and makes the API request.
+
+        Args:
+        agreement_id: Path parameter.
+        signed_challenge: The signed challenge from external signing.
+
+        Returns:
+            T.RecordAgreementAcceptanceResponse: The API response.
+        """
+        user_action_result = BaseAuthApi.sign_user_action_challenge(
+            self._http, signed_challenge
+        )
+        user_action_token = user_action_result["userAction"]
+
+        return self._http.request_with_user_action(
+            method="POST",
+            path="/agreements/{agreementId}/accept",
+            path_params={"agreementId": agreement_id},
+            query_params=None,
+            body=None,
+            user_action=user_action_token,
+        )

dfns_sdk/generated/agreements/types.py

@@ -0,0 +1,20 @@
+"""Types for the agreements domain."""
+
+from typing import Any, Literal, NotRequired, Optional, TypedDict, Union
+
+class GetLatestUnacceptedAgreementResponse(TypedDict, total=False):
+    """getLatestUnacceptedAgreement response."""
+
+    latest_agreement: Any
+
+class GetLatestUnacceptedAgreementQuery(TypedDict, total=False):
+    """getLatestUnacceptedAgreement query parameters."""
+
+    agreement_type: Literal["PrivacyPolicy", "TermsAndConditions", "UniswapTermsOfService", "UniswapPrivacyPolicy"]
+
+class RecordAgreementAcceptanceResponse(TypedDict, total=False):
+    """recordAgreementAcceptance response."""
+
+    agreement_id: str
+    user_id: str
+    date_accepted: str

dfns_sdk/generated/allocations/__init__.py

@@ -0,0 +1,7 @@
+"""Allocations domain module."""
+
+from .client import AllocationsClient
+from .delegated_client import DelegatedAllocationsClient
+from . import types
+
+__all__ = ["AllocationsClient", "DelegatedAllocationsClient", "types"]

dfns_sdk/generated/allocations/client.py

@@ -0,0 +1,118 @@
+"""Client for the allocations domain."""
+
+from typing import Any, Literal, Optional, TypedDict, Union
+
+from ..._internal import HttpClient
+from . import types as T
+
+
+class AllocationsClient:
+    """Client for allocations operations."""
+
+    def __init__(self, http_client: HttpClient):
+        self._http = http_client
+
+    def list_allocations(self, query: Optional[T.ListAllocationsQuery] = None) -> T.ListAllocationsResponse:
+        """
+        List Allocations.
+
+        Args:
+        query: Query parameters.
+
+        Returns:
+            T.ListAllocationsResponse: The API response.
+        """
+        return self._http.request(
+            method="GET",
+            path="/allocations",
+            path_params={},
+            query_params=query,
+            body=None,
+            requires_signature=False,
+        )
+
+    def create_allocation(self, body: dict[str, Any]) -> T.CreateAllocationResponse:
+        """
+        Create Allocation.
+
+        Create a new allocation.
+
+        Args:
+        body: Request body.
+
+        Returns:
+            T.CreateAllocationResponse: The API response.
+        """
+        return self._http.request(
+            method="POST",
+            path="/allocations",
+            path_params={},
+            query_params=None,
+            body=body,
+            requires_signature=True,
+        )
+
+    def list_allocation_actions(self, allocation_id: str, query: Optional[T.ListAllocationActionsQuery] = None) -> T.ListAllocationActionsResponse:
+        """
+        List Allocation Actions.
+
+        Retrieve the list of actions for a specific allocation.
+
+        Args:
+        allocation_id: Unique identifier for the allocation investment.
+        query: Query parameters.
+
+        Returns:
+            T.ListAllocationActionsResponse: The API response.
+        """
+        return self._http.request(
+            method="GET",
+            path="/allocations/{allocationId}/actions",
+            path_params={"allocationId": allocation_id},
+            query_params=query,
+            body=None,
+            requires_signature=False,
+        )
+
+    def create_allocation_action(self, allocation_id: str, body: T.CreateAllocationActionRequest) -> T.CreateAllocationActionResponse:
+        """
+        Create Allocation Action.
+
+        Create a new action for an existing allocation.
+
+        Args:
+        allocation_id: Unique identifier for the allocation investment.
+        body: Request body.
+
+        Returns:
+            T.CreateAllocationActionResponse: The API response.
+        """
+        return self._http.request(
+            method="POST",
+            path="/allocations/{allocationId}/actions",
+            path_params={"allocationId": allocation_id},
+            query_params=None,
+            body=body,
+            requires_signature=True,
+        )
+
+    def get_allocation(self, allocation_id: str) -> T.GetAllocationResponse:
+        """
+        Get Allocation.
+
+        Retrieve the details of a specific allocation.
+
+        Args:
+        allocation_id: Unique identifier for the allocation investment.
+
+        Returns:
+            T.GetAllocationResponse: The API response.
+        """
+        return self._http.request(
+            method="GET",
+            path="/allocations/{allocationId}",
+            path_params={"allocationId": allocation_id},
+            query_params=None,
+            body=None,
+            requires_signature=False,
+        )