cdp package

Subpackages

Submodules

cdp.analytics module

class cdp.analytics.ErrorEventData(**data)

Bases: BaseModel

The data in an error event.

message: str
method: str
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str
stack: str | None
cdp.analytics.EventData

alias of ErrorEventData

async cdp.analytics.send_event(event)

Send an analytics event to the default endpoint.

Parameters:

event (ErrorEventData) – The event data containing event-specific fields

Return type:

None

Returns:

None - resolves when the event is sent

cdp.analytics.should_track_error(error)

Determine if an error should be tracked.

Parameters:

error (Exception) – The error to check.

Return type:

bool

Returns:

True if the error should be tracked, False otherwise.

cdp.analytics.wrap_class_with_error_tracking(cls)

Wrap all methods of a class with error tracking.

Parameters:

cls – The class to wrap.

Returns:

The class with wrapped methods.

cdp.analytics.wrap_with_error_tracking(func)

Wrap a method with error tracking.

Parameters:

func – The function to wrap.

Returns:

The wrapped function.

cdp.api_clients module

class cdp.api_clients.ApiClients(cdp_client)

Bases: object

A container class for all API clients used in the CDP SDK.

This class provides lazy-loaded access to various API clients, ensuring that each client is only instantiated when it’s first accessed.

_cdp_client

The CDP API client used to initialize individual API clients.

Type:

CdpApiClient

_evm_accounts

The EVMAccountsApi client instance.

Type:

Optional[EVMAccountsApi]

_evm_smart_accounts

The EVMSmartAccountsApi client instance.

Type:

Optional[EVMSmartAccountsApi]

_evm_token_balances

The EVMTokenBalancesApi client instance.

Type:

Optional[EVMTokenBalancesApi]

_faucets

The FaucetsApi client instance.

Type:

Optional[FaucetsApi]

_solana_accounts

The SolanaAccountsApi client instance.

Type:

Optional[SolanaAccountsApi]

async close()

Close the CDP client asynchronously.

property evm_accounts: EVMAccountsApi

Get the EVMAccountsApi client instance.

Returns:

The EVMAccountsApi client instance.

Return type:

EVMAccountsApi

Note

This property lazily initializes the EVMAccountsApi client on first access.

property evm_smart_accounts: EVMSmartAccountsApi

Get the EVMSmartAccountsApi client instance.

Returns:

The EVMSmartAccountsApi client instance.

Return type:

EVMSmartAccountsApi

Note

This property lazily initializes the EVMSmartAccountsApi client on first access.

property evm_token_balances: EVMTokenBalancesApi

Get the EVMTokenBalancesApi client instance.

Returns:

The EVMTokenBalancesApi client instance.

Return type:

EVMTokenBalancesApi

Note

This property lazily initializes the EVMTokenBalancesApi client on first access.

property faucets: FaucetsApi

Get the FaucetsApi client instance.

Returns:

The FaucetsApi client instance.

Return type:

FaucetsApi

Note

This property lazily initializes the FaucetsApi client on first access.

property policies: PolicyEngineApi

Get the PolicyEngineApi client instance.

Returns:

The PolicyEngineApi client instance.

Return type:

PolicyEngineApi

Note

This property lazily initializes the PolicyEngineApi client on first access.

property solana_accounts: SolanaAccountsApi

Get the SolanaAccountsApi client instance.

Returns:

The SolanaAccountsApi client instance.

Return type:

SolanaAccountsApi

Note

This property lazily initializes the SolanaAccountsApi client on first access.

cdp.cdp_client module

class cdp.cdp_client.CdpClient(api_key_id=None, api_key_secret=None, wallet_secret=None, debugging=False, base_path='https://api.cdp.coinbase.com/platform', max_network_retries=3, source='sdk', source_version='1.8.1')

Bases: object

The CdpClient class is responsible for configuring and managing the CDP API client.

async close()

Close the CDP client.

property evm: EvmClient

Get the EvmClient instance.

property policies: PoliciesClient

Get the PoliciesClient instance.

property solana: SolanaClient

Get the SolanaClient instance.

cdp.constants module

Specifies package level constants used throughout the package.

cdp.evm_call_types module

class cdp.evm_call_types.EncodedCall(**data)

Bases: BaseModel

Represents an encoded call to a smart contract.

data: Optional[NewType(HexStr, str)]
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to: NewType(HexAddress, NewType(HexStr, str))
value: Optional[NewType(Wei, int)]
class cdp.evm_call_types.FunctionCall(**data)

Bases: BaseModel

Represents a call to a smart contract that needs to be encoded using the ABI.

abi: list[dict[str, Any]]
args: list[Any]
function_name: str
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to: NewType(HexAddress, NewType(HexStr, str))
value: Optional[NewType(Wei, int)]

cdp.evm_client module

class cdp.evm_client.EvmClient(api_clients)

Bases: object

The EvmClient class is responsible for CDP API calls for the EVM.

async create_account(name=None, idempotency_key=None)

Create an EVM account.

Parameters:

  • name (str, optional) – The name. Defaults to None.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The EVM server account.

Return type:

EvmServerAccount

async create_smart_account(owner)

Create an EVM smart account.

Parameters:

owner (BaseAccount) – The owner of the smart account.

Returns:

The EVM smart account.

Return type:

EvmSmartAccount

async get_account(address=None, name=None)

Get an EVM account by address.

Parameters:

  • address (str, optional) – The address of the account.

  • name (str, optional) – The name of the account.

Returns:

The EVM server account.

Return type:

EvmServerAccount

async get_or_create_account(name=None)

Get an EVM account, or create one if it doesn’t exist.

Parameters:

name (str, optional) – The name of the account to get or create.

Returns:

The EVM server account.

Return type:

EvmServerAccount

async get_smart_account(address, owner=None)

Get an EVM smart account by address.

Parameters:

  • address (str) – The address of the smart account.

  • owner (BaseAccount, optional) – The owner of the smart account. Defaults to None.

Returns:

The EVM smart account.

Return type:

EvmSmartAccount

async get_user_operation(address, user_op_hash)

Get a user operation by address and hash.

Parameters:

  • address (str) – The address of the smart account that sent the operation.

  • user_op_hash (str) – The hash of the user operation to get.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

async list_accounts(page_size=None, page_token=None)

List all EVM accounts.

Parameters:

  • page_size (int, optional) – The number of accounts to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of accounts, if any. Defaults to None.

Returns:

The list of EVM accounts.

Return type:

ListEvmAccountsResponse

async list_smart_accounts(page_size=None, page_token=None)

List all EVM smart accounts.

Parameters:

  • page_size (int, optional) – The number of accounts to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of accounts, if any. Defaults to None.

Returns:

The list of EVM smart accounts. The smart accounts are not wrapped in the EvmSmartAccount class so these cannot be used to send user operations. Call get_smart_account with an owner to get an EvmSmartAccount instance that can be used to send user operations.

Return type:

ListEvmSmartAccountsResponse

async list_token_balances(address, network, page_size=None, page_token=None)

List the token balances for an address on the given network.

Parameters:

  • address (str) – The address to list the token balances for.

  • network (str) – The network to list the token balances for.

  • page_size (int, optional) – The number of token balances to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of token balances, if any. Defaults to None.

Returns:

The token balances for the address on the network.

Return type:

[ListTokenBalancesResult]

async prepare_user_operation(smart_account, calls, network, paymaster_url=None)

Prepare a user operation for a smart account.

Parameters:

  • smart_account (EvmSmartAccount) – The smart account to prepare the user operation for.

  • calls (list[EncodedCall]) – The calls to prepare the user operation for.

  • network (str) – The network.

  • paymaster_url (str, optional) – The paymaster URL. Defaults to None.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

async request_faucet(address, network, token)

Request a token from the faucet in the test network.

Parameters:

  • address (str) – The address to request the faucet for.

  • network (str) – The network to request the faucet for.

  • token (str) – The token to request the faucet for.

Returns:

The transaction hash of the faucet request.

Return type:

str

async send_transaction(address, transaction, network, idempotency_key=None)

Send an EVM transaction.

Parameters:

  • address (str) – The address of the account.

  • transaction (str | TransactionDictType | DynamicFeeTransaction) –

    The transaction to send.

    This can be either an RLP-encoded transaction to sign and send, as a 0x-prefixed hex string, or an EIP-1559 transaction request object.

    Use TransactionRequestEIP1559 if you would like Coinbase to manage the nonce and gas parameters.

    You can also use DynamicFeeTransaction from eth-account, but you will have to set the nonce and gas parameters manually.

    These are the fields that can be contained in the transaction object:

    • to: (Required) The address of the contract or account to send the transaction to.

    • value: (Optional) The amount of ETH, in wei, to send with the transaction.

    • data: (Optional) The data to send with the transaction; only used for contract calls.

    • gas: (Optional) The amount of gas to use for the transaction.

    • nonce: (Optional) The nonce to use for the transaction. If not provided, the API will assign a nonce to the transaction based on the current state of the account.

    • maxFeePerGas: (Optional) The maximum fee per gas to use for the transaction. If not provided, the API will estimate a value based on current network conditions.

    • maxPriorityFeePerGas: (Optional) The maximum priority fee per gas to use for the transaction. If not provided, the API will estimate a value based on current network conditions.

    • accessList: (Optional) The access list to use for the transaction.

    • chainId: (Ignored) The value of the chainId field in the transaction is ignored.

    • from: (Ignored) Ignored in favor of the account address that is sending the transaction.

    • type: (Ignored) The transaction type must always be 0x2 (EIP-1559).

  • network (str) – The network.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The transaction hash.

Return type:

str

async send_user_operation(smart_account, calls, network, paymaster_url=None)

Send a user operation for a smart account.

Parameters:

  • smart_account (EvmSmartAccount) – The smart account to send the user operation from.

  • calls (List[ContractCall]) – The calls to send.

  • network (str) – The network.

  • paymaster_url (str) – The paymaster URL.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

async sign_hash(address, hash, idempotency_key=None)

Sign an EVM hash.

Parameters:

  • address (str) – The address of the account.

  • hash (str) – The hash to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The signed hash.

Return type:

str

async sign_message(address, message, idempotency_key=None)

Sign an EVM message.

Parameters:

  • address (str) – The address of the account.

  • message (str) – The message to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The signed message.

Return type:

str

async sign_transaction(address, transaction, idempotency_key=None)

Sign an EVM transaction.

Parameters:

  • address (str) – The address of the account.

  • transaction (str) – The transaction to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The signed transaction.

Return type:

str

async sign_typed_data(address, domain, types, primary_type, message, idempotency_key=None)

Sign an EVM typed data.

Parameters:

  • address (str) – The address of the account.

  • domain (EIP712Domain) – The domain of the message.

  • types (Dict[str, Any]) – The types of the message.

  • primary_type (str) – The primary type of the message.

  • message (Dict[str, Any]) – The message to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The signature.

Return type:

str

async update_account(address, update, idempotency_key=None)

Update an EVM account.

Parameters:

  • address (str) – The address of the account.

  • update (UpdateAccountOptions) – The updates to apply to the account.

  • idempotency_key (str, optional) – The idempotency key.

Returns:

The updated EVM account.

Return type:

EvmServerAccount

async wait_for_user_operation(smart_account_address, user_op_hash, timeout_seconds=20, interval_seconds=0.2)

Wait for a user operation to be processed.

Parameters:

  • smart_account_address (str) – The address of the smart account that sent the operation.

  • user_op_hash (str) – The hash of the user operation to wait for.

  • timeout_seconds (float, optional) – Maximum time to wait in seconds. Defaults to 20.

  • interval_seconds (float, optional) – Time between checks in seconds. Defaults to 0.2.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

cdp.evm_message_types module

class cdp.evm_message_types.EIP712Domain(**data)

Bases: BaseModel

The domain of the EIP-712 typed data.

as_dict()

Serialize the EIP712Domain object to a dictionary.

Return type:

dict[str, Any]

chain_id: int | None
model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'validate_by_alias': True, 'validate_by_name': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None
salt: str | None
verifying_contract: str | None
version: str | None

cdp.evm_server_account module

class cdp.evm_server_account.EvmServerAccount(evm_server_account_model, evm_accounts_api, api_clients)

Bases: BaseAccount, BaseModel

A class representing an EVM server account.

property address: str

Get the EVM Account Address.

Returns:

The EVM account address.

Return type:

str

async list_token_balances(network, page_size=None, page_token=None)

List the token balances for the account on the given network.

Parameters:

  • network (str) – The network to list the token balances for.

  • page_size (int, optional) – The number of token balances to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of token balances, if any. Defaults to None.

Returns:

The token balances for the account on the network.

Return type:

[ListTokenBalancesResult]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property name: str | None

Get the name of the EVM account.

Returns:

The name of the EVM account.

Return type:

str | None

property policies: list[str]

Gets the list of policies the apply to this account.

Returns:

The list of Policy IDs.

Return type:

str

async request_faucet(network, token)

Request a token from the faucet.

Parameters:

  • network (str) – The network to request the faucet for.

  • token (str) – The token to request the faucet for.

Returns:

The transaction hash of the faucet request.

Return type:

str

async send_transaction(transaction, network, idempotency_key=None)

Send an EVM transaction.

Parameters:

  • transaction (str | TransactionDictType | DynamicFeeTransaction) –

    The transaction to send.

    This can be either an RLP-encoded transaction to sign and send, as a 0x-prefixed hex string, or an EIP-1559 transaction request object.

    Use TransactionRequestEIP1559 if you would like Coinbase to manage the nonce and gas parameters.

    You can also use DynamicFeeTransaction from eth-account, but you will have to set the nonce and gas parameters manually.

    These are the fields that can be contained in the transaction object:

    • to: (Required) The address of the contract or account to send the transaction to.

    • value: (Optional) The amount of ETH, in wei, to send with the transaction.

    • data: (Optional) The data to send with the transaction; only used for contract calls.

    • gas: (Optional) The amount of gas to use for the transaction.

    • nonce: (Optional) The nonce to use for the transaction. If not provided, the API will assign a nonce to the transaction based on the current state of the account.

    • maxFeePerGas: (Optional) The maximum fee per gas to use for the transaction. If not provided, the API will estimate a value based on current network conditions.

    • maxPriorityFeePerGas: (Optional) The maximum priority fee per gas to use for the transaction. If not provided, the API will estimate a value based on current network conditions.

    • accessList: (Optional) The access list to use for the transaction.

    • chainId: (Ignored) The value of the chainId field in the transaction is ignored.

    • from: (Ignored) Ignored in favor of the account address that is sending the transaction.

    • type: (Ignored) The transaction type must always be 0x2 (EIP-1559).

  • network (str) – The network.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The transaction hash.

Return type:

str

async sign_message(signable_message, idempotency_key=None)

Sign the EIP-191 message.

Parameters:

  • signable_message (SignableMessage) – The encoded message, ready for signing

  • idempotency_key (Optional[str]) – Optional idempotency key

Return type:

SignedMessage

Returns:

The signed message

Raises:

AttributeError – If the signature response is missing required fields

async sign_transaction(transaction_dict, idempotency_key=None)

Sign a transaction dict.

Parameters:

  • transaction_dict (Dict[str, Union[Sequence[Dict[str, Union[NewType(HexStr, str), Sequence[NewType(HexStr, str)]]]], bytes, NewType(HexStr, str), int]]) – transaction with all fields specified

  • idempotency_key (Optional[str]) – Optional idempotency key

Return type:

SignedTransaction

Returns:

The signed transaction

Raises:

ValueError – If the signature response is missing required fields

async sign_typed_data(domain, types, primary_type, message, idempotency_key=None)

Sign an EVM typed data.

Parameters:

  • domain (EIP712Domain) – The domain of the message.

  • types (Dict[str, Any]) – The types of the message.

  • primary_type (str) – The primary type of the message.

  • message (Dict[str, Any]) – The message to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The signature.

Return type:

str

classmethod to_evm_account(address, name=None)

Construct an existing EvmAccount by its address and the name.

Parameters:

  • address (str) – The address of the EvmAccount to retrieve.

  • name (str | None) – The name of the EvmAccount.

Returns:

The retrieved EvmAccount object.

Return type:

EvmAccount

Raises:

Exception – If there’s an error retrieving the EvmAccount.

async transfer(to, amount, token, network)

Transfer an amount of a token from an account to another account.

Parameters:

  • to (str | BaseAccount) – The account or 0x-prefixed address to transfer the token to.

  • amount (int) – The amount of the token to transfer, represented as an atomic unit (e.g. 10000 for 0.01 USDC).

  • units. (The cdp module exports a parse_units util to convert to atomic)

  • Otherwise

  • below. (you can pass atomic units directly. See examples)

  • token (str) – The token to transfer.

  • network (str) – The network to transfer the token on.

Returns:

The result of the transfer.

Examples

>>> transfer = await sender.transfer(
...     to="0x9F663335Cd6Ad02a37B633602E98866CF944124d",
...     amount=10000,  # equivalent to 0.01 USDC
...     token="usdc",
...     network="base-sepolia",
... )

Using parse_units to specify USDC amount >>> from cdp import parse_units >>> transfer = await sender.transfer( … to=”0x9F663335Cd6Ad02a37B633602E98866CF944124d”, … amount=parse_units(“0.01”, 6), # USDC uses 6 decimal places … token=”usdc”, … network=”base-sepolia”, … )

Transfer to another account >>> sender = await cdp.evm.create_account(name=”Sender”) >>> receiver = await cdp.evm.create_account(name=”Receiver”) >>> >>> transfer = await sender.transfer({ … “to”: receiver, … “amount”: 10000, # equivalent to 0.01 USDC … “token”: “usdc”, … “network”: “base-sepolia”, … })

async unsafe_sign_hash(message_hash, idempotency_key=None)

Sign the hash of a message.

WARNING: Never sign a hash that you didn’t generate, it can be an arbitrary transaction.

Parameters:

  • message_hash (NewType(Hash32, bytes)) – 32 byte hash of the message to sign

  • idempotency_key (Optional[str]) – Optional idempotency key

Return type:

SignedMessage

Returns:

The signed message

Raises:

ValueError – If the signature response is missing required fields

class cdp.evm_server_account.ListEvmAccountsResponse(**data)

Bases: BaseModel

Response model for listing EVM accounts.

accounts: list[EvmServerAccount]
model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

next_page_token: str | None

cdp.evm_smart_account module

class cdp.evm_smart_account.EvmSmartAccount(address, owner, name=None, api_clients=None)

Bases: BaseModel

A class representing an EVM smart account.

property address: str

Get the Smart Account Address.

Returns:

The Smart Account Address.

Return type:

str

async get_user_operation(user_op_hash)

Get a user operation for the smart account by hash.

Parameters:

user_op_hash (str) – The hash of the user operation to get.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

async list_token_balances(network, page_size=None, page_token=None)

List the token balances for the smart account on the given network.

Parameters:

  • network (str) – The network to list the token balances for.

  • page_size (int, optional) – The number of token balances to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of token balances, if any. Defaults to None.

Returns:

The token balances for the smart account on the network.

Return type:

[ListTokenBalancesResult]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property name: str | None

Get the name of the smart account.

Returns:

The name of the smart account.

Return type:

str | None

property owners: list[BaseAccount]

Get the account owners.

Returns:

List of owner accounts

Return type:

List[BaseAccount]

async request_faucet(network, token)

Request a token from the faucet.

Parameters:

  • network (str) – The network to request the faucet for.

  • token (str) – The token to request the faucet for.

Returns:

The transaction hash of the faucet request.

Return type:

str

async send_user_operation(calls, network, paymaster_url=None)

Send a user operation for the smart account.

Parameters:

  • calls (List[ContractCall]) – The calls to send.

  • network (str) – The network.

  • paymaster_url (str) – The paymaster URL.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

classmethod to_evm_smart_account(address, owner, name=None)

Construct an existing smart account by its address and the owner.

Parameters:

  • address (str) – The address of the evm smart account to retrieve.

  • owner (BaseAccount) – The owner of the evm smart account.

  • name (str | None) – The name of the evm smart account.

Returns:

The retrieved EvmSmartAccount object.

Return type:

EvmSmartAccount

Raises:

Exception – If there’s an error retrieving the EvmSmartAccount.

async transfer(to, amount, token, network, paymaster_url=None)

Transfer an amount of a token from an account to another account.

Parameters:

  • to (str | BaseAccount) – The account or 0x-prefixed address to transfer the token to.

  • amount (int) – The amount of the token to transfer, represented as an atomic unit (e.g. 10000 for 0.01 USDC).

  • units. (The cdp module exports a parse_units util to convert to atomic)

  • Otherwise

  • below. (you can pass atomic units directly. See examples)

  • token (str) – The token to transfer.

  • network (str) – The network to transfer the token on.

  • paymaster_url (Optional[str]) – The paymaster URL to use for the transfer.

Returns:

The result of the transfer.

Examples

>>> transfer = await sender.transfer(
...     to="0x9F663335Cd6Ad02a37B633602E98866CF944124d",
...     amount=10000,  # equivalent to 0.01 USDC
...     token="usdc",
...     network="base-sepolia",
... )

Using parse_units to specify USDC amount >>> from cdp import parse_units >>> transfer = await sender.transfer( … to=”0x9F663335Cd6Ad02a37B633602E98866CF944124d”, … amount=parse_units(“0.01”, 6), # USDC uses 6 decimal places … token=”usdc”, … network=”base-sepolia”, … )

Transfer to another account >>> sender = await cdp.evm.create_smart_account( … owner=await cdp.evm.create_account(name=”Owner”), … ) >>> receiver = await cdp.evm.create_account(name=”Receiver”) >>> >>> transfer = await sender.transfer({ … “to”: receiver, … “amount”: 10000, # equivalent to 0.01 USDC … “token”: “usdc”, … “network”: “base-sepolia”, … })

async wait_for_user_operation(user_op_hash, timeout_seconds=20, interval_seconds=0.2)

Wait for a user operation to be processed.

Parameters:

  • user_op_hash (str) – The hash of the user operation to wait for.

  • timeout_seconds (float, optional) – Maximum time to wait in seconds. Defaults to 20.

  • interval_seconds (float, optional) – Time between checks in seconds. Defaults to 0.2.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

class cdp.evm_smart_account.ListEvmSmartAccountsResponse(**data)

Bases: BaseModel

Response model for listing EVM smart accounts.

accounts: list[EvmSmartAccount]
model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

next_page_token: str | None

cdp.evm_token_balances module

class cdp.evm_token_balances.EvmToken(**data)

Bases: BaseModel

A token on an EVM network, which is either an ERC-20 or a native token (i.e. ETH).

contract_address: str
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None
network: ListEvmTokenBalancesNetwork
symbol: str | None
class cdp.evm_token_balances.EvmTokenAmount(**data)

Bases: BaseModel

A token amount on an EVM network.

amount: int
decimals: int
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class cdp.evm_token_balances.EvmTokenBalance(**data)

Bases: BaseModel

An EVM token balance.

amount: EvmTokenAmount
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

token: EvmToken
class cdp.evm_token_balances.ListTokenBalancesResult(**data)

Bases: BaseModel

The result of listing EVM token balances.

balances: list[EvmTokenBalance]
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

next_page_token: str | None

cdp.evm_transaction_types module

class cdp.evm_transaction_types.TransactionRequestEIP1559(**data)

Bases: BaseModel

Represents a transaction request using EIP-1559. Used with EthAccount’s DynamicFeeTransaction.

accessList: list[dict[str, Any]] | None
as_dict()

Serialize the TransactionRequestEIP1559 object to a dictionary.

Return type:

dict[str, Any]

chainId: int | None
data: Optional[NewType(HexStr, str)]
gas: int | None
maxFeePerGas: int | None
maxPriorityFeePerGas: int | None
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nonce: int | None
to: NewType(HexAddress, NewType(HexStr, str))
type: str | None
value: int | None

cdp.policies_client module

class cdp.policies_client.PoliciesClient(api_clients)

Bases: object

Client for managing policies.

async create_policy(policy, idempotency_key=None)

Create a policy that can be used to govern the behavior of projects and accounts.

Parameters:

  • policy (CreatePolicyOptions) – The policy to create.

  • idempotency_key (str | None, optional) – The idempotency key. Defaults to None.

Returns:

The created policy.

Return type:

Policy

async delete_policy(id, idempotency_key=None)

Delete a policy by its unique identifier.

If a policy is referenced by an active project or account, this operation will fail.

Parameters:

  • id (str) – The unique identifier of the policy to delete.

  • idempotency_key (str | None, optional) – The idempotency key. Defaults to None.

Return type:

None

async get_policy_by_id(id)

Retrieve a policy by its unique identifier.

Parameters:

id (str) – The unique identifier of the policy to retrieve.

Returns:

The requested policy.

Return type:

Policy

async list_policies(page_size=None, page_token=None, scope=None)

List policies belonging to the developer’s CDP Project.

Can be filtered by scope (project or account).

Parameters:

  • page_size (int | None, optional) – The number of policies to return per page. Defaults to None.

  • page_token (str | None, optional) – The token for the next page of policies, if any. Defaults to None.

  • scope (PolicyScope | None, optional) – The scope of the policies to list. Defaults to None.

Returns:

A paginated list of policies.

Return type:

ListPoliciesResult

async update_policy(id, policy, idempotency_key=None)

Update an existing policy by its unique identifier.

This will apply the updated policy to any project or accounts that are currently using it.

Parameters:

  • id (str) – The unique identifier of the policy to update.

  • policy (UpdatePolicyOptions) – The updated policy configuration.

  • idempotency_key (str | None, optional) – The idempotency key. Defaults to None.

Returns:

The updated policy.

Return type:

Policy

cdp.solana_account module

class cdp.solana_account.ListSolanaAccountsResponse(**data)

Bases: BaseModel

Response model for listing Solana accounts.

accounts: list[SolanaAccount]
model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

next_page_token: str | None
class cdp.solana_account.SolanaAccount(solana_account_model, api_clients)

Bases: BaseModel

A class representing a Solana account.

property address: str

Get the address of the Solana account.

Returns:

The address of the Solana account.

Return type:

str

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property name: str | None

Get the name of the Solana account.

Returns:

The name of the Solana account.

Return type:

str | None

property policies: list[str]

Get the list of policies the apply to this account.

Returns:

The list of Policy IDs.

Return type:

str

async request_faucet(token)

Request a faucet for the Solana account.

Parameters:

token (str) – The token to request the faucet for.

Returns:

The response from the faucet.

Return type:

RequestSolanaFaucetResponse

async sign_message(message, idempotency_key=None)

Sign a message.

Parameters:

  • message (str) – The message to sign.

  • idempotency_key (str, optional) – The optional idempotency key.

Returns:

The signature of the message.

Return type:

SignSolanaMessageResponse

async sign_transaction(transaction, idempotency_key=None)

Sign a transaction.

Parameters:

  • transaction (str) – The transaction to sign.

  • idempotency_key (str, optional) – The optional idempotency key.

Returns:

The signature of the transaction.

Return type:

SignSolanaTransactionResponse

async transfer(to, amount, token, network)

Transfer a token from the Solana account to a destination address.

Parameters:

  • to (str) – The account or 0x-prefixed address to transfer the token to.

  • amount (int) – The amount to transfer in atomic units of the token. For example, 0.01 * LAMPORTS_PER_SOL would transfer 0.01 SOL.

  • token (str) – The token to transfer.

  • network (str) – The network to transfer the token on.

Returns:

The signature of the transaction.

Return type:

str

cdp.solana_client module

class cdp.solana_client.SolanaClient(api_clients)

Bases: object

The SolanaClient class is responsible for CDP API calls for Solana.

async create_account(name=None, idempotency_key=None)

Create a Solana account.

Parameters:

  • name (str, optional) – The name. Defaults to None.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The Solana account model.

Return type:

SolanaAccount

async get_account(address=None, name=None)

Get a Solana account by address.

Parameters:

  • address (str, optional) – The address of the account.

  • name (str, optional) – The name of the account.

Returns:

The Solana account model.

Return type:

SolanaAccount

async get_or_create_account(name=None)

Get a Solana account, or create one if it doesn’t exist.

Parameters:

name (str, optional) – The name of the account to get or create.

Returns:

The Solana account model.

Return type:

SolanaAccount

async list_accounts(page_size=None, page_token=None)

List all Solana accounts.

Parameters:

  • page_size (int, optional) – The number of accounts to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of accounts, if any. Defaults to None.

Returns:

The list of Solana accounts, and an optional next page token.

Return type:

ListSolanaAccountsResponse

async request_faucet(address, token)

Request a token from the faucet.

Parameters:

  • address (str) – The address to request the faucet for.

  • token (str) – The token to request the faucet for.

Returns:

The response containing the transaction hash.

Return type:

RequestSolanaFaucetResponse

async sign_message(address, message, idempotency_key=None)

Sign a Solana message.

Parameters:

  • address (str) – The address of the account.

  • message (str) – The message to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The response containing the signature.

Return type:

SignSolanaMessageResponse

async sign_transaction(address, transaction, idempotency_key=None)

Sign a Solana transaction.

Parameters:

  • address (str) – The address of the account.

  • transaction (str) – The transaction to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The response containing the signed transaction.

Return type:

SignSolanaTransactionResponse

async update_account(address, update, idempotency_key=None)

Update a Solana account.

Parameters:

  • address (str) – The address of the account.

  • update (UpdateAccountOptions) – The updates to apply to the account.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The updated Solana account.

Return type:

SolanaAccount

cdp.update_account_types module

class cdp.update_account_types.UpdateAccountOptions(**data)

Bases: BaseModel

Options for updating an account.

account_policy: str | None
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

An optional account policy for the account. The account policy will be applied to the account when it is created.

cdp.utils module

exception cdp.utils.InvalidDecimalNumberError(value)

Bases: Exception

Exception raised for invalid decimal number strings.

Parameters:

value – The invalid decimal number string

async cdp.utils.ensure_awaitable(func, *args, **kwargs)

Ensure a function call returns an awaitable result.

Works with both synchronous and asynchronous functions.

Parameters:

  • func – The function to call

  • *args – Arguments to pass to the function

  • **kwargs – Arguments to pass to the function

Returns:

The awaited result of the function

cdp.utils.parse_units(value, decimals)

Parse a decimal number string into an integer.

Parameters:

  • value (str) – The decimal number string to parse

  • decimals (int) – The number of decimal places

Return type:

int

Returns: The parsed integer

Raises:

InvalidDecimalNumberError – If the value is not a valid decimal number

cdp.utils.serialize_unsigned_transaction(transaction)

Serialize an unsigned transaction.

Parameters:

transaction (DynamicFeeTransaction) – The transaction to serialize

Return type:

str

Returns: The serialized transaction

Module contents

class cdp.CdpClient(api_key_id=None, api_key_secret=None, wallet_secret=None, debugging=False, base_path='https://api.cdp.coinbase.com/platform', max_network_retries=3, source='sdk', source_version='1.8.1')

Bases: object

The CdpClient class is responsible for configuring and managing the CDP API client.

async close()

Close the CDP client.

property evm: EvmClient

Get the EvmClient instance.

property policies: PoliciesClient

Get the PoliciesClient instance.

property solana: SolanaClient

Get the SolanaClient instance.

class cdp.EncodedCall(**data)

Bases: BaseModel

Represents an encoded call to a smart contract.

data: Optional[NewType(HexStr, str)]
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to: NewType(HexAddress, NewType(HexStr, str))
value: Optional[NewType(Wei, int)]
class cdp.EvmServerAccount(evm_server_account_model, evm_accounts_api, api_clients)

Bases: BaseAccount, BaseModel

A class representing an EVM server account.

property address: str

Get the EVM Account Address.

Returns:

The EVM account address.

Return type:

str

async list_token_balances(network, page_size=None, page_token=None)

List the token balances for the account on the given network.

Parameters:

  • network (str) – The network to list the token balances for.

  • page_size (int, optional) – The number of token balances to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of token balances, if any. Defaults to None.

Returns:

The token balances for the account on the network.

Return type:

[ListTokenBalancesResult]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property name: str | None

Get the name of the EVM account.

Returns:

The name of the EVM account.

Return type:

str | None

property policies: list[str]

Gets the list of policies the apply to this account.

Returns:

The list of Policy IDs.

Return type:

str

async request_faucet(network, token)

Request a token from the faucet.

Parameters:

  • network (str) – The network to request the faucet for.

  • token (str) – The token to request the faucet for.

Returns:

The transaction hash of the faucet request.

Return type:

str

async send_transaction(transaction, network, idempotency_key=None)

Send an EVM transaction.

Parameters:

  • transaction (str | TransactionDictType | DynamicFeeTransaction) –

    The transaction to send.

    This can be either an RLP-encoded transaction to sign and send, as a 0x-prefixed hex string, or an EIP-1559 transaction request object.

    Use TransactionRequestEIP1559 if you would like Coinbase to manage the nonce and gas parameters.

    You can also use DynamicFeeTransaction from eth-account, but you will have to set the nonce and gas parameters manually.

    These are the fields that can be contained in the transaction object:

    • to: (Required) The address of the contract or account to send the transaction to.

    • value: (Optional) The amount of ETH, in wei, to send with the transaction.

    • data: (Optional) The data to send with the transaction; only used for contract calls.

    • gas: (Optional) The amount of gas to use for the transaction.

    • nonce: (Optional) The nonce to use for the transaction. If not provided, the API will assign a nonce to the transaction based on the current state of the account.

    • maxFeePerGas: (Optional) The maximum fee per gas to use for the transaction. If not provided, the API will estimate a value based on current network conditions.

    • maxPriorityFeePerGas: (Optional) The maximum priority fee per gas to use for the transaction. If not provided, the API will estimate a value based on current network conditions.

    • accessList: (Optional) The access list to use for the transaction.

    • chainId: (Ignored) The value of the chainId field in the transaction is ignored.

    • from: (Ignored) Ignored in favor of the account address that is sending the transaction.

    • type: (Ignored) The transaction type must always be 0x2 (EIP-1559).

  • network (str) – The network.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The transaction hash.

Return type:

str

async sign_message(signable_message, idempotency_key=None)

Sign the EIP-191 message.

Parameters:

  • signable_message (SignableMessage) – The encoded message, ready for signing

  • idempotency_key (Optional[str]) – Optional idempotency key

Return type:

SignedMessage

Returns:

The signed message

Raises:

AttributeError – If the signature response is missing required fields

async sign_transaction(transaction_dict, idempotency_key=None)

Sign a transaction dict.

Parameters:

  • transaction_dict (Dict[str, Union[Sequence[Dict[str, Union[NewType(HexStr, str), Sequence[NewType(HexStr, str)]]]], bytes, NewType(HexStr, str), int]]) – transaction with all fields specified

  • idempotency_key (Optional[str]) – Optional idempotency key

Return type:

SignedTransaction

Returns:

The signed transaction

Raises:

ValueError – If the signature response is missing required fields

async sign_typed_data(domain, types, primary_type, message, idempotency_key=None)

Sign an EVM typed data.

Parameters:

  • domain (EIP712Domain) – The domain of the message.

  • types (Dict[str, Any]) – The types of the message.

  • primary_type (str) – The primary type of the message.

  • message (Dict[str, Any]) – The message to sign.

  • idempotency_key (str, optional) – The idempotency key. Defaults to None.

Returns:

The signature.

Return type:

str

classmethod to_evm_account(address, name=None)

Construct an existing EvmAccount by its address and the name.

Parameters:

  • address (str) – The address of the EvmAccount to retrieve.

  • name (str | None) – The name of the EvmAccount.

Returns:

The retrieved EvmAccount object.

Return type:

EvmAccount

Raises:

Exception – If there’s an error retrieving the EvmAccount.

async transfer(to, amount, token, network)

Transfer an amount of a token from an account to another account.

Parameters:

  • to (str | BaseAccount) – The account or 0x-prefixed address to transfer the token to.

  • amount (int) – The amount of the token to transfer, represented as an atomic unit (e.g. 10000 for 0.01 USDC).

  • units. (The cdp module exports a parse_units util to convert to atomic)

  • Otherwise

  • below. (you can pass atomic units directly. See examples)

  • token (str) – The token to transfer.

  • network (str) – The network to transfer the token on.

Returns:

The result of the transfer.

Examples

>>> transfer = await sender.transfer(
...     to="0x9F663335Cd6Ad02a37B633602E98866CF944124d",
...     amount=10000,  # equivalent to 0.01 USDC
...     token="usdc",
...     network="base-sepolia",
... )

Using parse_units to specify USDC amount >>> from cdp import parse_units >>> transfer = await sender.transfer( … to=”0x9F663335Cd6Ad02a37B633602E98866CF944124d”, … amount=parse_units(“0.01”, 6), # USDC uses 6 decimal places … token=”usdc”, … network=”base-sepolia”, … )

Transfer to another account >>> sender = await cdp.evm.create_account(name=”Sender”) >>> receiver = await cdp.evm.create_account(name=”Receiver”) >>> >>> transfer = await sender.transfer({ … “to”: receiver, … “amount”: 10000, # equivalent to 0.01 USDC … “token”: “usdc”, … “network”: “base-sepolia”, … })

async unsafe_sign_hash(message_hash, idempotency_key=None)

Sign the hash of a message.

WARNING: Never sign a hash that you didn’t generate, it can be an arbitrary transaction.

Parameters:

  • message_hash (NewType(Hash32, bytes)) – 32 byte hash of the message to sign

  • idempotency_key (Optional[str]) – Optional idempotency key

Return type:

SignedMessage

Returns:

The signed message

Raises:

ValueError – If the signature response is missing required fields

class cdp.EvmSmartAccount(address, owner, name=None, api_clients=None)

Bases: BaseModel

A class representing an EVM smart account.

property address: str

Get the Smart Account Address.

Returns:

The Smart Account Address.

Return type:

str

async get_user_operation(user_op_hash)

Get a user operation for the smart account by hash.

Parameters:

user_op_hash (str) – The hash of the user operation to get.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

async list_token_balances(network, page_size=None, page_token=None)

List the token balances for the smart account on the given network.

Parameters:

  • network (str) – The network to list the token balances for.

  • page_size (int, optional) – The number of token balances to return per page. Defaults to None.

  • page_token (str, optional) – The token for the next page of token balances, if any. Defaults to None.

Returns:

The token balances for the smart account on the network.

Return type:

[ListTokenBalancesResult]

model_config: ClassVar[ConfigDict] = {'arbitrary_types_allowed': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

property name: str | None

Get the name of the smart account.

Returns:

The name of the smart account.

Return type:

str | None

property owners: list[BaseAccount]

Get the account owners.

Returns:

List of owner accounts

Return type:

List[BaseAccount]

async request_faucet(network, token)

Request a token from the faucet.

Parameters:

  • network (str) – The network to request the faucet for.

  • token (str) – The token to request the faucet for.

Returns:

The transaction hash of the faucet request.

Return type:

str

async send_user_operation(calls, network, paymaster_url=None)

Send a user operation for the smart account.

Parameters:

  • calls (List[ContractCall]) – The calls to send.

  • network (str) – The network.

  • paymaster_url (str) – The paymaster URL.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

classmethod to_evm_smart_account(address, owner, name=None)

Construct an existing smart account by its address and the owner.

Parameters:

  • address (str) – The address of the evm smart account to retrieve.

  • owner (BaseAccount) – The owner of the evm smart account.

  • name (str | None) – The name of the evm smart account.

Returns:

The retrieved EvmSmartAccount object.

Return type:

EvmSmartAccount

Raises:

Exception – If there’s an error retrieving the EvmSmartAccount.

async transfer(to, amount, token, network, paymaster_url=None)

Transfer an amount of a token from an account to another account.

Parameters:

  • to (str | BaseAccount) – The account or 0x-prefixed address to transfer the token to.

  • amount (int) – The amount of the token to transfer, represented as an atomic unit (e.g. 10000 for 0.01 USDC).

  • units. (The cdp module exports a parse_units util to convert to atomic)

  • Otherwise

  • below. (you can pass atomic units directly. See examples)

  • token (str) – The token to transfer.

  • network (str) – The network to transfer the token on.

  • paymaster_url (Optional[str]) – The paymaster URL to use for the transfer.

Returns:

The result of the transfer.

Examples

>>> transfer = await sender.transfer(
...     to="0x9F663335Cd6Ad02a37B633602E98866CF944124d",
...     amount=10000,  # equivalent to 0.01 USDC
...     token="usdc",
...     network="base-sepolia",
... )

Using parse_units to specify USDC amount >>> from cdp import parse_units >>> transfer = await sender.transfer( … to=”0x9F663335Cd6Ad02a37B633602E98866CF944124d”, … amount=parse_units(“0.01”, 6), # USDC uses 6 decimal places … token=”usdc”, … network=”base-sepolia”, … )

Transfer to another account >>> sender = await cdp.evm.create_smart_account( … owner=await cdp.evm.create_account(name=”Owner”), … ) >>> receiver = await cdp.evm.create_account(name=”Receiver”) >>> >>> transfer = await sender.transfer({ … “to”: receiver, … “amount”: 10000, # equivalent to 0.01 USDC … “token”: “usdc”, … “network”: “base-sepolia”, … })

async wait_for_user_operation(user_op_hash, timeout_seconds=20, interval_seconds=0.2)

Wait for a user operation to be processed.

Parameters:

  • user_op_hash (str) – The hash of the user operation to wait for.

  • timeout_seconds (float, optional) – Maximum time to wait in seconds. Defaults to 20.

  • interval_seconds (float, optional) – Time between checks in seconds. Defaults to 0.2.

Returns:

The user operation model.

Return type:

EvmUserOperationModel

class cdp.FunctionCall(**data)

Bases: BaseModel

Represents a call to a smart contract that needs to be encoded using the ABI.

abi: list[dict[str, Any]]
args: list[Any]
function_name: str
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

to: NewType(HexAddress, NewType(HexStr, str))
value: Optional[NewType(Wei, int)]
class cdp.TransactionRequestEIP1559(**data)

Bases: BaseModel

Represents a transaction request using EIP-1559. Used with EthAccount’s DynamicFeeTransaction.

accessList: list[dict[str, Any]] | None
as_dict()

Serialize the TransactionRequestEIP1559 object to a dictionary.

Return type:

dict[str, Any]

chainId: int | None
data: Optional[NewType(HexStr, str)]
gas: int | None
maxFeePerGas: int | None
maxPriorityFeePerGas: int | None
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nonce: int | None
to: NewType(HexAddress, NewType(HexStr, str))
type: str | None
value: int | None
class cdp.UpdateAccountOptions(**data)

Bases: BaseModel

Options for updating an account.

account_policy: str | None
model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

name: str | None

An optional account policy for the account. The account policy will be applied to the account when it is created.

cdp.parse_units(value, decimals)

Parse a decimal number string into an integer.

Parameters:

  • value (str) – The decimal number string to parse

  • decimals (int) – The number of decimal places

Return type:

int

Returns: The parsed integer

Raises:

InvalidDecimalNumberError – If the value is not a valid decimal number