cdp-sdk 0.0.1__py3-none-any.whl

cdp/__init__.py

@@ -0,0 +1,27 @@
+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.faucet_transaction import FaucetTransaction
+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
+
+__all__ = [
+    "__version__",
+    "Cdp",
+    "Wallet",
+    "Asset",
+    "Transfer",
+    "Address",
+    "Transaction",
+    "Balance",
+    "BalanceMap",
+    "FaucetTransaction",
+    "Trade",
+    "SponsoredSend",
+]

cdp/__version__.py

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

cdp/address.py

@@ -0,0 +1,107 @@
+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
+
+
+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
+        )
+
+        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 __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,148 @@
+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.external_addresses_api import ExternalAddressesApi
+from cdp.client.api.networks_api import NetworksApi
+from cdp.client.api.trades_api import TradesApi
+from cdp.client.api.transfers_api import TransfersApi
+from cdp.client.api.wallets_api import WalletsApi
+
+
+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.
+        _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.
+
+    """
+
+    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._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
+
+    @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 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

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=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)

cdp/balance_map.py

@@ -0,0 +1,75 @@
+import json
+from decimal import Decimal
+
+from cdp.balance import Balance
+from cdp.client.models.balance import Balance as BalanceModel
+
+
+class BalanceMap(dict[str, Decimal]):
+    """A class representing asset balances.
+
+    This class extends the built-in dict class, where keys are asset IDs (str)
+    and values are balance amounts (Decimal).
+    """
+
+    @classmethod
+    def from_models(cls, models: list[BalanceModel]) -> "BalanceMap":
+        """Create a BalanceMap instance from a list of BalanceModel objects.
+
+        Args:
+            models (List[BalanceModel]): A list of BalanceModel objects.
+
+        Returns:
+            BalanceMap: A new BalanceMap instance populated with the given models.
+
+        """
+        balance_map = cls()
+
+        for model in models:
+            balance = Balance.from_model(model)
+            balance_map.add(balance)
+
+        return balance_map
+
+    def add(self, balance: Balance) -> None:
+        """Add a Balance object to the BalanceMap.
+
+        Args:
+            balance (Balance): The Balance object to add.
+
+        Raises:
+            ValueError: If the provided balance is not a Balance instance.
+
+        """
+        if not isinstance(balance, Balance):
+            raise ValueError("balance must be a Balance instance")
+
+        self[balance.asset_id] = balance.amount
+
+    def __str__(self) -> str:
+        """Return a JSON string representation of the BalanceMap.
+
+        Returns:
+            str: A JSON string with asset IDs as keys and formatted balance amounts as values.
+
+        """
+        result: dict[str, str] = {}
+
+        for asset_id, amount in self.items():
+            amount_str = format(amount, "f")
+
+            if amount == amount.to_integral():
+                amount_str = str(int(amount))
+
+            result[asset_id] = amount_str
+
+        return json.dumps(result, separators=(",", ":"))
+
+    def __repr__(self) -> str:
+        """Return a string representation of the BalanceMap.
+
+        Returns:
+            str: The string representation of the BalanceMap.
+
+        """
+        return str(self)