cdp-sdk 0.12.0__py3-none-any.whl

cdp/__init__.py

@@ -0,0 +1,42 @@
+from cdp.__version__ import __version__
+from cdp.address import Address
+from cdp.asset import Asset
+from cdp.balance import Balance
+from cdp.balance_map import BalanceMap
+from cdp.cdp import Cdp
+from cdp.contract_invocation import ContractInvocation
+from cdp.faucet_transaction import FaucetTransaction
+from cdp.hash_utils import hash_message, hash_typed_data_message
+from cdp.payload_signature import PayloadSignature
+from cdp.smart_contract import SmartContract
+from cdp.sponsored_send import SponsoredSend
+from cdp.trade import Trade
+from cdp.transaction import Transaction
+from cdp.transfer import Transfer
+from cdp.wallet import Wallet
+from cdp.wallet_address import WalletAddress
+from cdp.wallet_data import WalletData
+from cdp.webhook import Webhook
+
+__all__ = [
+    "__version__",
+    "Cdp",
+    "ContractInvocation",
+    "Wallet",
+    "WalletAddress",
+    "WalletData",
+    "Webhook",
+    "Asset",
+    "Transfer",
+    "Address",
+    "Transaction",
+    "Balance",
+    "BalanceMap",
+    "FaucetTransaction",
+    "Trade",
+    "SponsoredSend",
+    "PayloadSignature",
+    "SmartContract",
+    "hash_message",
+    "hash_typed_data_message",
+]

cdp/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.12.0"

cdp/address.py

@@ -0,0 +1,142 @@
+from collections.abc import Iterator
+from decimal import Decimal
+
+from cdp.asset import Asset
+from cdp.balance import Balance
+from cdp.balance_map import BalanceMap
+from cdp.cdp import Cdp
+from cdp.faucet_transaction import FaucetTransaction
+from cdp.historical_balance import HistoricalBalance
+from cdp.transaction import Transaction
+
+
+class Address:
+    """A class representing an address."""
+
+    def __init__(self, network_id: str, address_id: str) -> None:
+        """Initialize the Address class.
+
+        Args:
+            network_id (str): The network ID.
+            address_id (str): The address ID.
+
+        """
+        self._network_id = network_id
+        self._id = address_id
+
+    @property
+    def address_id(self) -> str:
+        """Get the address ID.
+
+        Returns:
+            str: The address ID.
+
+        """
+        return self._id
+
+    @property
+    def network_id(self) -> str:
+        """Get the network ID.
+
+        Returns:
+            str: The network ID.
+
+        """
+        return self._network_id
+
+    @property
+    def can_sign(self) -> bool:
+        """Get whether the address can sign.
+
+        Returns:
+            bool: Whether the address can sign.
+
+        """
+        return False
+
+    def faucet(self, asset_id=None) -> FaucetTransaction:
+        """Request faucet funds.
+
+        Args:
+            asset_id (str): The asset ID.
+
+        Returns:
+            FaucetTransaction: The faucet transaction object.
+
+        """
+        model = Cdp.api_clients.external_addresses.request_external_faucet_funds(
+            network_id=self.network_id,
+            address_id=self.address_id,
+            asset_id=asset_id,
+            skip_wait=True,
+        )
+
+        return FaucetTransaction(model)
+
+    def balance(self, asset_id) -> Decimal:
+        """Get the balance of the address.
+
+        Args:
+            asset_id (str): The asset ID.
+
+        Returns:
+            Decimal: The balance of the address.
+
+        """
+        model = Cdp.api_clients.external_addresses.get_external_address_balance(
+            network_id=self.network_id,
+            address_id=self.address_id,
+            asset_id=Asset.primary_denomination(asset_id),
+        )
+
+        return Decimal(0) if model is None else Balance.from_model(model, asset_id).amount
+
+    def balances(self):
+        """List balances of the address.
+
+        Returns:
+           BalanceMap: The balances of the address, keyed by asset ID. Ether balances are denominated in ETH.
+
+        """
+        response = Cdp.api_clients.external_addresses.list_external_address_balances(
+            network_id=self.network_id, address_id=self.address_id
+        )
+
+        return BalanceMap.from_models(response.data)
+
+    def historical_balances(self, asset_id) -> Iterator[HistoricalBalance]:
+        """List historical balances.
+
+        Args:
+            asset_id (str): The asset ID.
+
+        Returns:
+            Iterator[HistoricalBalance]: An iterator of HistoricalBalance objects.
+
+        Raises:
+            Exception: If there's an error listing the historical balances.
+
+        """
+        return HistoricalBalance.list(
+            network_id=self.network_id, address_id=self.address_id, asset_id=asset_id
+        )
+
+    def transactions(self) -> Iterator[Transaction]:
+        """List transactions of the address.
+
+        Returns:
+            Iterator[Transaction]: An iterator of Transaction objects.
+
+        Raises:
+            Exception: If there's an error listing the transactions.
+
+        """
+        return Transaction.list(network_id=self.network_id, address_id=self.address_id)
+
+    def __str__(self) -> str:
+        """Return a string representation of the Address."""
+        return f"Address: (address_id: {self.address_id}, network_id: {self.network_id})"
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Address."""
+        return str(self)

cdp/api_clients.py

@@ -0,0 +1,252 @@
+from cdp.cdp_api_client import CdpApiClient
+from cdp.client.api.addresses_api import AddressesApi
+from cdp.client.api.assets_api import AssetsApi
+from cdp.client.api.balance_history_api import BalanceHistoryApi
+from cdp.client.api.contract_invocations_api import ContractInvocationsApi
+from cdp.client.api.external_addresses_api import ExternalAddressesApi
+from cdp.client.api.fund_api import FundApi
+from cdp.client.api.networks_api import NetworksApi
+from cdp.client.api.smart_contracts_api import SmartContractsApi
+from cdp.client.api.trades_api import TradesApi
+from cdp.client.api.transaction_history_api import TransactionHistoryApi
+from cdp.client.api.transfers_api import TransfersApi
+from cdp.client.api.wallets_api import WalletsApi
+from cdp.client.api.webhooks_api import WebhooksApi
+
+
+class ApiClients:
+    """A container class for all API clients used in the Coinbase SDK.
+
+    This class provides lazy-loaded access to various API clients, ensuring
+    that each client is only instantiated when it's first accessed.
+
+    Attributes:
+        _cdp_client (CdpApiClient): The CDP API client used to initialize individual API clients.
+        _wallets (Optional[WalletsApi]): The WalletsApi client instance.
+        _webhooks (Optional[WebhooksApi]): The WebhooksApi client instance.
+        _addresses (Optional[AddressesApi]): The AddressesApi client instance.
+        _external_addresses (Optional[ExternalAddressesApi]): The ExternalAddressesApi client instance.
+        _transfers (Optional[TransfersApi]): The TransfersApi client instance.
+        _networks (Optional[NetworksApi]): The NetworksApi client instance.
+        _assets (Optional[AssetsApi]): The AssetsApi client instance.
+        _trades (Optional[TradesApi]): The TradesApi client instance.
+        _contract_invocations (Optional[ContractInvocationsApi]): The ContractInvocationsApi client instance.
+
+    """
+
+    def __init__(self, cdp_client: CdpApiClient) -> None:
+        """Initialize the ApiClients instance.
+
+        Args:
+            cdp_client (CdpApiClient): The CDP API client to use for initializing individual API clients.
+
+        """
+        self._cdp_client: CdpApiClient = cdp_client
+        self._wallets: WalletsApi | None = None
+        self._webhooks: WebhooksApi | None = None
+        self._addresses: AddressesApi | None = None
+        self._external_addresses: ExternalAddressesApi | None = None
+        self._transfers: TransfersApi | None = None
+        self._networks: NetworksApi | None = None
+        self._assets: AssetsApi | None = None
+        self._trades: TradesApi | None = None
+        self._contract_invocations: ContractInvocationsApi | None = None
+        self._smart_contracts: SmartContractsApi | None = None
+        self._balance_history: BalanceHistoryApi | None = None
+        self._transaction_history: TransactionHistoryApi | None = None
+        self._fund: FundApi | None = None
+
+    @property
+    def wallets(self) -> WalletsApi:
+        """Get the WalletsApi client instance.
+
+        Returns:
+            WalletsApi: The WalletsApi client instance.
+
+        Note:
+            This property lazily initializes the WalletsApi client on first access.
+
+        """
+        if self._wallets is None:
+            self._wallets = WalletsApi(api_client=self._cdp_client)
+        return self._wallets
+
+    @property
+    def webhooks(self) -> WebhooksApi:
+        """Get the WebhooksApi client instance.
+
+        Returns:
+            WebhooksApi: The WebhooksApi client instance.
+
+        Note:
+            This property lazily initializes the WebhooksApi client on first access.
+
+        """
+        if self._webhooks is None:
+            self._webhooks = WebhooksApi(api_client=self._cdp_client)
+        return self._webhooks
+
+    @property
+    def addresses(self) -> AddressesApi:
+        """Get the AddressesApi client instance.
+
+        Returns:
+            AddressesApi: The AddressesApi client instance.
+
+        Note:
+            This property lazily initializes the AddressesApi client on first access.
+
+        """
+        if self._addresses is None:
+            self._addresses = AddressesApi(api_client=self._cdp_client)
+        return self._addresses
+
+    @property
+    def external_addresses(self) -> ExternalAddressesApi:
+        """Get the ExternalAddressesApi client instance.
+
+        Returns:
+            ExternalAddressesApi: The ExternalAddressesApi client instance.
+
+        Note:
+            This property lazily initializes the ExternalAddressesApi client on first access.
+
+        """
+        if self._external_addresses is None:
+            self._external_addresses = ExternalAddressesApi(api_client=self._cdp_client)
+        return self._external_addresses
+
+    @property
+    def transfers(self) -> TransfersApi:
+        """Get the TransfersApi client instance.
+
+        Returns:
+            TransfersApi: The TransfersApi client instance.
+
+        Note:
+            This property lazily initializes the TransfersApi client on first access.
+
+        """
+        if self._transfers is None:
+            self._transfers = TransfersApi(api_client=self._cdp_client)
+        return self._transfers
+
+    @property
+    def networks(self) -> NetworksApi:
+        """Get the NetworksApi client instance.
+
+        Returns:
+            NetworksApi: The NetworksApi client instance.
+
+        Note:
+            This property lazily initializes the NetworksApi client on first access.
+
+        """
+        if self._networks is None:
+            self._networks = NetworksApi(api_client=self._cdp_client)
+        return self._networks
+
+    @property
+    def assets(self) -> AssetsApi:
+        """Get the AssetsApi client instance.
+
+        Returns:
+            AssetsApi: The AssetsApi client instance.
+
+        Note:
+            This property lazily initializes the AssetsApi client on first access.
+
+        """
+        if self._assets is None:
+            self._assets = AssetsApi(api_client=self._cdp_client)
+        return self._assets
+
+    @property
+    def trades(self) -> TradesApi:
+        """Get the TradesApi client instance.
+
+        Returns:
+            TradesApi: The TradesApi client instance.
+
+        Note:
+            This property lazily initializes the TradesApi client on first access.
+
+        """
+        if self._trades is None:
+            self._trades = TradesApi(api_client=self._cdp_client)
+        return self._trades
+
+    @property
+    def contract_invocations(self) -> ContractInvocationsApi:
+        """Get the ContractInvocationsApi client instance.
+
+        Returns:
+            ContractInvocationsApi: The ContractInvocationsApi client instance.
+
+        Note:
+            This property lazily initializes the ContractInvocationsApi client on first access.
+
+        """
+        if self._contract_invocations is None:
+            self._contract_invocations = ContractInvocationsApi(api_client=self._cdp_client)
+        return self._contract_invocations
+
+    @property
+    def balance_history(self) -> BalanceHistoryApi:
+        """Get the BalanceHistoryApi client instance.
+
+        Returns:
+            BalanceHistoryApi: The BalanceHistoryApi client instance.
+
+        Note:
+            This property lazily initializes the BalanceHistoryApi client on first access.
+
+        """
+        if self._balance_history is None:
+            self._balance_history = BalanceHistoryApi(api_client=self._cdp_client)
+        return self._balance_history
+
+    @property
+    def smart_contracts(self) -> SmartContractsApi:
+        """Get the SmartContractsApi client instance.
+
+        Returns:
+            SmartContractsApi: The SmartContractsApi client instance.
+
+        Note:
+            This property lazily initializes the SmartContractsApi client on first access.
+
+        """
+        if self._smart_contracts is None:
+            self._smart_contracts = SmartContractsApi(api_client=self._cdp_client)
+        return self._smart_contracts
+
+    @property
+    def transaction_history(self) -> TransactionHistoryApi:
+        """Get the TransactionHistoryApi client instance.
+
+        Returns:
+            TransactionHistoryApi: The TransactionHistoryApi client instance.
+
+        Note:
+            This property lazily initializes the TransactionHistoryApi client on first access.
+
+        """
+        if self._transaction_history is None:
+            self._transaction_history = TransactionHistoryApi(api_client=self._cdp_client)
+        return self._transaction_history
+
+    @property
+    def fund(self) -> FundApi:
+        """Get the FundApi client instance.
+
+        Returns:
+            FundApi: The FundApi client instance.
+
+        Note:
+            This property lazily initializes the FundApi client on first access.
+
+        """
+        if self._fund is None:
+            self._fund = FundApi(api_client=self._cdp_client)
+        return self._fund

cdp/asset.py

@@ -0,0 +1,165 @@
+from decimal import Decimal
+
+from cdp.cdp import Cdp
+from cdp.client.models.asset import Asset as AssetModel
+
+# TODO: Move to constants.py
+GWEI_DECIMALS = 9
+
+
+class Asset:
+    """A class representing an asset."""
+
+    def __init__(
+        self, network_id: str, asset_id: str, contract_address: str, decimals: int
+    ) -> None:
+        """Initialize the Asset class.
+
+        Args:
+            network_id (str): The network ID.
+            asset_id (str): The asset ID.
+            contract_address (str): The contract address.
+            decimals (int): The number of decimals.
+
+        """
+        self._network_id = network_id
+        self._asset_id = asset_id
+        self._contract_address = contract_address
+        self._decimals = decimals
+
+    @classmethod
+    def from_model(cls, model: AssetModel, asset_id: str | None = None) -> "Asset":
+        """Create an Asset instance from a model.
+
+        Args:
+            model (AssetModel): The model representing the asset.
+            asset_id (Optional[str]): The asset ID.
+
+        Returns:
+            Asset: The Asset instance.
+
+        """
+        decimals = model.decimals
+
+        if asset_id and asset_id != model.asset_id:
+            match asset_id:
+                case "gwei":
+                    decimals = GWEI_DECIMALS
+                case "wei":
+                    decimals = 0
+                case _:
+                    raise ValueError(f"Unsupported asset ID: {asset_id}")
+
+        return cls(
+            network_id=model.network_id,
+            asset_id=asset_id or model.asset_id,
+            contract_address=model.contract_address,
+            decimals=decimals,
+        )
+
+    @classmethod
+    def fetch(cls, network_id: str, asset_id: str) -> "Asset":
+        """Fetch an asset from the API.
+
+        Args:
+            network_id (str): The network ID.
+            asset_id (str): The asset ID.
+
+        Returns:
+            Asset: The fetched Asset instance.
+
+        """
+        primary_denomination_asset_id = cls.primary_denomination(asset_id)
+
+        model = Cdp.api_clients.assets.get_asset(
+            network_id=network_id, asset_id=primary_denomination_asset_id
+        )
+
+        return cls.from_model(model, asset_id=asset_id)
+
+    @staticmethod
+    def primary_denomination(asset_id: str) -> str:
+        """Get the primary denomination for a given asset ID.
+
+        Args:
+            asset_id (str): The asset ID.
+
+        Returns:
+            str: The primary denomination of the asset.
+
+        """
+        if asset_id in ["wei", "gwei"]:
+            return "eth"
+        return asset_id
+
+    @property
+    def decimals(self) -> int:
+        """Get the number of decimals for the asset.
+
+        Returns:
+            int: The number of decimals.
+
+        """
+        return self._decimals
+
+    @property
+    def asset_id(self) -> str:
+        """Get the asset ID.
+
+        Returns:
+            str: The asset ID.
+
+        """
+        return self._asset_id
+
+    @property
+    def contract_address(self) -> str:
+        """Get the contract address.
+
+        Returns:
+            str: The contract address.
+
+        """
+        return self._contract_address
+
+    @property
+    def network_id(self) -> str:
+        """Get the network ID.
+
+        Returns:
+            str: The network ID.
+
+        """
+        return self._network_id
+
+    def from_atomic_amount(self, atomic_amount: Decimal) -> Decimal:
+        """Convert an atomic amount to a whole amount.
+
+        Args:
+            atomic_amount (Decimal): The atomic amount.
+
+        Returns:
+            Decimal: The whole amount.
+
+        """
+        return Decimal(atomic_amount) / Decimal(10) ** (self.decimals)
+
+    def to_atomic_amount(self, whole_amount: Decimal) -> Decimal:
+        """Convert a whole amount to an atomic amount.
+
+        Args:
+            whole_amount (Decimal): The whole amount.
+
+        Returns:
+            Decimal: The atomic amount.
+
+        """
+        return whole_amount * Decimal(10) ** (self.decimals)
+
+    def __str__(self) -> str:
+        """Return a string representation of the Asset."""
+        return f"Asset: (asset_id: {self.asset_id}, network_id: {self.network_id}, contract_address: {self.contract_address}, decimals: {self.decimals})"
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Asset."""
+        return str(self)

cdp/balance.py

@@ -0,0 +1,79 @@
+from decimal import Decimal
+
+from cdp.asset import Asset
+from cdp.client.models.balance import Balance as BalanceModel
+
+
+class Balance:
+    """A class representing a balance."""
+
+    def __init__(self, amount: Decimal, asset: Asset, asset_id: str | None = None):
+        """Initialize the Balance class.
+
+        Args:
+            amount (Decimal): The amount.
+            asset (Asset): The asset.
+            asset_id (Optional[str]): The asset ID.
+
+        """
+        self._amount = amount
+        self._asset = asset
+        self._asset_id = asset_id if asset_id is not None else asset.asset_id
+
+    @staticmethod
+    def from_model(model: BalanceModel, asset_id: str | None = None) -> "Balance":
+        """Create a Balance instance from a model.
+
+        Args:
+            model (BalanceModel): The model representing the balance.
+            asset_id (Optional[str]): The asset ID.
+
+        Returns:
+            Balance: The Balance instance.
+
+        """
+        asset = Asset.from_model(model.asset, asset_id=asset_id)
+
+        return Balance(
+            amount=asset.from_atomic_amount(model.amount),
+            asset=asset,
+            asset_id=asset_id,
+        )
+
+    @property
+    def amount(self) -> Decimal:
+        """Get the amount.
+
+        Returns:
+            Decimal: The amount.
+
+        """
+        return self._amount
+
+    @property
+    def asset(self) -> Asset:
+        """Get the asset.
+
+        Returns:
+            Asset: The asset.
+
+        """
+        return self._asset
+
+    @property
+    def asset_id(self) -> str:
+        """Get the asset ID.
+
+        Returns:
+            str: The asset ID.
+
+        """
+        return self._asset_id
+
+    def __str__(self) -> str:
+        """Return a string representation of the Balance."""
+        return f"Balance: (amount: {self.amount}, asset: {self.asset})"
+
+    def __repr__(self) -> str:
+        """Return a string representation of the Balance."""
+        return str(self)