afp-sdk 0.4.0__py3-none-any.whl → 0.5.1__py3-none-any.whl

afp/__init__.py

@@ -1,10 +1,15 @@
 """Autonomous Futures Protocol Python SDK."""
 
-from afp import bindings
-from .api.admin import Admin
-from .api.builder import Builder
-from .api.clearing import Clearing
-from .api.liquidation import Liquidation
-from .api.trading import Trading
+from . import bindings
+from .afp import AFP
+from .auth import Authenticator, KeyfileAuthenticator, PrivateKeyAuthenticator
+from .exceptions import AFPException
 
-__all__ = ("bindings", "Admin", "Builder", "Clearing", "Liquidation", "Trading")
+__all__ = (
+    "bindings",
+    "AFP",
+    "AFPException",
+    "Authenticator",
+    "KeyfileAuthenticator",
+    "PrivateKeyAuthenticator",
+)

afp/afp.py

@@ -0,0 +1,210 @@
+from .auth import Authenticator, KeyfileAuthenticator, PrivateKeyAuthenticator
+from .config import Config
+from .api.admin import Admin
+from .api.margin_account import MarginAccount
+from .api.product import Product
+from .api.trading import Trading
+from .constants import defaults
+from .exceptions import ConfigurationError
+from .validators import validate_address
+
+
+class AFP:
+    """Application object for interacting with the AFP Clearing System and the AutEx
+    exchange.
+
+    Parameters
+    ----------
+    authenticator : afp.Authenticator, optional
+        The default authenticator for signing transactions & messages. Can also be set
+        with environment variables; use `AFP_PRIVATE_KEY` for private key
+        authentication, `AFP_KEYFILE` and `AFP_KEYFILE_PASSWORD` for keyfile
+        authentication.
+    rpc_url : str, optional
+        The URL of an Autonity RPC provider. Can also be set with the `AFP_RPC_URL`
+        environment variable.
+    exchange_url : str, optional
+        The REST API base URL of the exchange. Defaults to the URL of the AutEx
+        exchange. Its default value can be overridden with the `AFP_EXCHANGE_URL`
+        environment variable.
+    chain_id : str, optional
+        The chain ID of the Autonity network. Defauls to the chain ID of Autonity
+        Mainnet. Its default value can be overridden with the `AFP_CHAIN_ID` environment
+        variable.
+    gas_limit : int, optional
+        The `gasLimit` parameter of blockchain transactions. Estimated with the
+        `eth_estimateGas` JSON-RPC call if not specified. Its default value can be
+        overridden with the `AFP_GAS_LIMIT` environment variable.
+    max_fee_per_gas : int, optional
+        The `maxFeePerGas` parameter of blockchain transactions in ton (wei) units.
+        Defaults to `baseFeePerGas` from the return value of the `eth_getBlock` JSON-RPC
+        call. Its default value can be overridden with the `AFP_MAX_FEE_PER_GAS`
+        environment variable.
+    max_priority_fee_per_gas : int, optional
+        The `maxPriorityFeePerGas` parameter of blockchain transactions in ton (wei)
+        units. Defaults to the return value of the `eth_maxPriorityFeePerGas` JSON-RPC
+        call. Its default value can be overridden with the
+        `AFP_MAX_PRIORITY_FEE_PER_GAS` environment variable.
+    timeout_seconds: int, optional
+        The number of seconds to wait for a blockchain transaction to be mined.
+        Defaults to 10 seconds. Its default value can be overridden with the
+        `AFP_TIMEOUT_SECONDS` environment variable.
+    clearing_diamond_address : str, optional
+        The address of the ClearingDiamond contract. Defaults to the Autonity Mainnet
+        deployment address. Its default value can be overridden with the
+        `AFP_CLEARING_DIAMOND_ADDRESS` environment variable.
+    margin_account_registry_address : str, optional
+        The address of the MarginAccountRegistry contract. Defaults to the Autonity
+        Mainnet deployment address. Its default value can be overridden with the
+        `AFP_MARGIN_ACCOUNT_REGISTRY_ADDRESS` environment variable.
+    oracle_provider_address : str, optional
+        The address of the OracleProvider contract. Defaults to the Autonity Mainnet
+        deployment address. Its default value can be overridden with the
+        `AFP_ORACLE_PROVIDER_ADDRESS` environment variable.
+    product_registry_address: str, optional
+        The address of the ProductRegistry contract. Defaults to the Autonity Mainnet
+        deployment address. Its default value can be overridden with the
+        `AFP_PRODUCT_REGISTRY_ADDRESS` environment variable.
+    system_viewer_address: str, optional
+        The address of the SystemViewer contract. Defaults to the Autonity Mainnet
+        deployment address. Its default value can be overridden with the
+        `AFP_SYSTEM_VIEWER_ADDRESS` environment variable.
+    """
+
+    config: Config
+
+    def __init__(
+        self,
+        *,
+        authenticator: Authenticator | None = None,
+        rpc_url: str | None = defaults.RPC_URL,
+        exchange_url: str = defaults.EXCHANGE_URL,
+        chain_id: int = defaults.CHAIN_ID,
+        gas_limit: int | None = defaults.GAS_LIMIT,
+        max_fee_per_gas: int | None = defaults.MAX_FEE_PER_GAS,
+        max_priority_fee_per_gas: int | None = defaults.MAX_PRIORITY_FEE_PER_GAS,
+        timeout_seconds: int = defaults.TIMEOUT_SECONDS,
+        clearing_diamond_address: str = defaults.CLEARING_DIAMOND_ADDRESS,
+        margin_account_registry_address: str = defaults.MARGIN_ACCOUNT_REGISTRY_ADDRESS,
+        oracle_provider_address: str = defaults.ORACLE_PROVIDER_ADDRESS,
+        product_registry_address: str = defaults.PRODUCT_REGISTRY_ADDRESS,
+        system_viewer_address: str = defaults.SYSTEM_VIEWER_ADDRESS,
+    ) -> None:
+        if authenticator is None:
+            authenticator = _default_authenticator()
+
+        self.config = Config(
+            authenticator=authenticator,
+            exchange_url=exchange_url,
+            rpc_url=rpc_url,
+            chain_id=chain_id,
+            gas_limit=gas_limit,
+            max_fee_per_gas=max_fee_per_gas,
+            max_priority_fee_per_gas=max_priority_fee_per_gas,
+            timeout_seconds=timeout_seconds,
+            clearing_diamond_address=validate_address(clearing_diamond_address),
+            margin_account_registry_address=validate_address(
+                margin_account_registry_address
+            ),
+            oracle_provider_address=validate_address(oracle_provider_address),
+            product_registry_address=validate_address(product_registry_address),
+            system_viewer_address=validate_address(system_viewer_address),
+        )
+
+    def __repr__(self) -> str:
+        return f"AFP(config={repr(self.config)})"
+
+    # Clearing APIs
+
+    def MarginAccount(
+        self, authenticator: Authenticator | None = None
+    ) -> MarginAccount:
+        """API for managing margin accounts.
+
+        Parameters
+        ----------
+        authenticator : afp.Authenticator, optional
+            Authenticator for signing transactions sent to the Clearing System.
+            Defaults to the authenticator specified in the `AFP` constructor.
+        """
+        return MarginAccount(self.config, authenticator=authenticator)
+
+    def Product(self, authenticator: Authenticator | None = None) -> Product:
+        """API for managing products.
+
+        Parameters
+        ----------
+        authenticator : afp.Authenticator, optional
+            Authenticator for signing transactions sent to the Clearing System.
+            Defaults to the authenticator specified in the `AFP` constructor.
+        """
+        return Product(self.config, authenticator=authenticator)
+
+    # Exchange APIs
+
+    def Admin(
+        self,
+        authenticator: Authenticator | None = None,
+        exchange_url: str | None = None,
+    ) -> Admin:
+        """API for AutEx administration, restricted to AutEx admins.
+
+        Authenticates with the exchange on creation.
+
+        Parameters
+        ----------
+        authenticator : afp.Authenticator, optional
+            Authenticator for authenticating with the AutEx exchange. Defaults to the
+            authenticator specified in the `AFP` constructor.
+        exchange_url: str, optional
+            The REST API base URL of the exchange. Defaults to the value specified in
+            the `AFP` constructor.
+
+        Raises
+        ------
+        afp.exceptions.AuthenticationError
+            If the exchange rejects the login attempt.
+        """
+        return Admin(
+            self.config, authenticator=authenticator, exchange_url=exchange_url
+        )
+
+    def Trading(
+        self,
+        authenticator: Authenticator | None = None,
+        exchange_url: str | None = None,
+    ) -> Trading:
+        """API for trading in the AutEx exchange.
+
+        Authenticates with the exchange on creation.
+
+        Parameters
+        ----------
+        authenticator : afp.Authenticator, optional
+            Authenticator for signing intents and authenticating with the AutEx
+            exchange. Defaults to the authenticator specified in the `AFP` constructor.
+        exchange_url: str, optional
+            The REST API base URL of the exchange. Defaults to the value specified in
+            the `AFP` constructor.
+
+        Raises
+        ------
+        afp.exceptions.AuthenticationError
+            If the exchange rejects the login attempt.
+        """
+        return Trading(
+            self.config, authenticator=authenticator, exchange_url=exchange_url
+        )
+
+
+def _default_authenticator() -> Authenticator | None:
+    if defaults.PRIVATE_KEY is not None and defaults.KEYFILE is not None:
+        raise ConfigurationError(
+            "Only one of AFP_PRIVATE_KEY and AFP_KEYFILE environment "
+            "variables should be specified"
+        )
+    if defaults.PRIVATE_KEY is not None:
+        return PrivateKeyAuthenticator(defaults.PRIVATE_KEY)
+    if defaults.KEYFILE is not None:
+        return KeyfileAuthenticator(defaults.KEYFILE, defaults.KEYFILE_PASSWORD)
+    return None

afp/api/admin.py

@@ -1,28 +1,34 @@
 from .. import validators
 from ..decorators import refresh_token_on_expiry
-from ..schemas import ExchangeProductSubmission
+from ..enums import ListingState
+from ..schemas import ExchangeProductListingSubmission, ExchangeProductUpdateSubmission
 from .base import ExchangeAPI
 
 
 class Admin(ExchangeAPI):
-    """API for AutEx administration, restricted to AutEx admins.
+    """API for AutEx administration, restricted to AutEx admins."""
 
-    Authenticates with the exchange on creation.
+    @refresh_token_on_expiry
+    def list_product(self, product_id: str) -> None:
+        """Lists a product on the exchange.
+
+        The product is in private state after listing until it is revealed to the public.
 
-    Parameters
-    ----------
-    private_key : str
-        The private key of the exchange adminstrator account.
+        Parameters
+        ----------
+        product_id : str
 
-    Raises
-    ------
-    afp.exceptions.AuthenticationError
-        If the exchange rejects the login attempt.
-    """
+        Raises
+        ------
+        afp.exceptions.AuthorizationError
+            If the configured account is not an exchange administrator.
+        """
+        product_listing = ExchangeProductListingSubmission(id=product_id)
+        self._exchange.list_product(product_listing)
 
     @refresh_token_on_expiry
-    def approve_product(self, product_id: str) -> None:
-        """Approves a product for trading on the exchange.
+    def reveal_product(self, product_id: str) -> None:
+        """Makes a product publicly available for trading on the exchange.
 
         Parameters
         ----------
@@ -33,8 +39,12 @@ class Admin(ExchangeAPI):
         afp.exceptions.AuthorizationError
             If the configured account is not an exchange administrator.
         """
-        product = ExchangeProductSubmission(id=product_id)
-        self._exchange.approve_product(product)
+        product_update = ExchangeProductUpdateSubmission(
+            listing_state=ListingState.PUBLIC
+        )
+        self._exchange.update_product_listing(
+            validators.validate_hexstr32(product_id), product_update
+        )
 
     @refresh_token_on_expiry
     def delist_product(self, product_id: str) -> None:
@@ -51,5 +61,9 @@ class Admin(ExchangeAPI):
         afp.exceptions.AuthorizationError
             If the configured account is not an exchange administrator.
         """
-        value = validators.validate_hexstr32(product_id)
-        self._exchange.delist_product(value)
+        product_update = ExchangeProductUpdateSubmission(
+            listing_state=ListingState.DELISTED
+        )
+        self._exchange.update_product_listing(
+            validators.validate_hexstr32(product_id), product_update
+        )

afp/api/base.py

@@ -1,37 +1,78 @@
 from abc import ABC
 from datetime import datetime
 from functools import cache
-from typing import cast
 from urllib.parse import urlparse
+from typing import cast
 
-from eth_account.account import Account
-from eth_account.signers.local import LocalAccount
 from eth_typing.evm import ChecksumAddress
 from siwe import ISO8601Datetime, SiweMessage, siwe  # type: ignore (untyped library)
 from web3 import Web3, HTTPProvider
-from web3.middleware import Middleware, SignAndSendRawMiddlewareBuilder
+from web3.contract.contract import ContractFunction
+from web3.types import TxParams
 
-from .. import config, signing
+from ..auth import Authenticator
+from ..config import Config
 from ..bindings.erc20 import ERC20
+from ..exceptions import ConfigurationError
 from ..exchange import ExchangeClient
-from ..schemas import LoginSubmission
+from ..schemas import LoginSubmission, Transaction
+
+
+class BaseAPI(ABC):
+    _authenticator: Authenticator
+    _config: Config
 
+    def __init__(self, config: Config, authenticator: Authenticator | None = None):
+        self._config = config
 
-EXCHANGE_DOMAIN = urlparse(config.EXCHANGE_URL).netloc
+        if authenticator is None:
+            if config.authenticator is None:
+                raise ConfigurationError("Authenticator not specified")
+            self._authenticator = config.authenticator
+        else:
+            self._authenticator = authenticator
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(authenticator={repr(self._authenticator)})"
 
-class ClearingSystemAPI(ABC):
-    _account: LocalAccount
+
+class ClearingSystemAPI(BaseAPI, ABC):
+    _config: Config
     _w3: Web3
 
-    def __init__(self, private_key: str, autonity_rpc_url: str):
-        self._account = Account.from_key(private_key)
-        self._w3 = Web3(HTTPProvider(autonity_rpc_url))
+    def __init__(self, config: Config, authenticator: Authenticator | None = None):
+        super().__init__(config, authenticator)
+
+        if self._config.rpc_url is None:
+            raise ConfigurationError("RPC URL not specified")
+
+        self._w3 = Web3(HTTPProvider(self._config.rpc_url))
+        self._w3.eth.default_account = self._authenticator.address
 
-        # Configure the default sender account
-        self._w3.eth.default_account = self._account.address
-        signing_middleware = SignAndSendRawMiddlewareBuilder.build(self._account)
-        self._w3.middleware_onion.add(cast(Middleware, signing_middleware))
+    def _transact(self, func: ContractFunction) -> Transaction:
+        tx_count = self._w3.eth.get_transaction_count(self._authenticator.address)
+        tx_params = {
+            "from": self._authenticator.address,
+            "nonce": tx_count,
+            "gasLimit": self._config.gas_limit,
+            "maxFeePerGas": self._config.max_fee_per_gas,
+            "maxPriorityFeePerGas": self._config.max_priority_fee_per_gas,
+        }
+
+        prepared_tx = func.build_transaction(
+            cast(TxParams, {k: v for k, v in tx_params.items() if v is not None})
+        )
+        signed_tx = self._authenticator.sign_transaction(prepared_tx)
+        tx_hash = self._w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+        tx_receipt = self._w3.eth.wait_for_transaction_receipt(
+            tx_hash, timeout=self._config.timeout_seconds
+        )
+
+        return Transaction(
+            hash=tx_hash.to_0x_hex(),
+            data=dict(prepared_tx),
+            receipt=dict(tx_receipt),
+        )
 
     @cache
     def _decimals(self, collateral_asset: ChecksumAddress) -> int:
@@ -39,20 +80,33 @@ class ClearingSystemAPI(ABC):
         return token_contract.decimals()
 
 
-class ExchangeAPI(ABC):
-    _account: LocalAccount
+class ExchangeAPI(BaseAPI, ABC):
     _exchange: ExchangeClient
     _trading_protocol_id: str
 
-    def __init__(self, private_key: str):
-        self._account = Account.from_key(private_key)
-        self._exchange = ExchangeClient()
+    def __init__(
+        self,
+        config: Config,
+        authenticator: Authenticator | None = None,
+        exchange_url: str | None = None,
+    ):
+        if exchange_url is None:
+            exchange_url = config.exchange_url
+
+        super().__init__(config, authenticator)
+        self._exchange = ExchangeClient(exchange_url)
         self._login()
 
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(authenticator={repr(self._authenticator)}, "
+            f"exchange={repr(self._exchange)})"
+        )
+
     def _login(self):
         nonce = self._exchange.generate_login_nonce()
-        message = self._generate_eip4361_message(self._account, nonce)
-        signature = signing.sign_message(self._account, message.encode("ascii"))
+        message = self._generate_eip4361_message(nonce)
+        signature = self._authenticator.sign_message(message.encode("ascii"))
 
         login_submission = LoginSubmission(
             message=message, signature=Web3.to_hex(signature)
@@ -61,14 +115,13 @@ class ExchangeAPI(ABC):
 
         self._trading_protocol_id = exchange_parameters.trading_protocol_id
 
-    @staticmethod
-    def _generate_eip4361_message(account: LocalAccount, nonce: str) -> str:
+    def _generate_eip4361_message(self, nonce: str) -> str:
         message = SiweMessage(
-            domain=EXCHANGE_DOMAIN,
-            address=account.address,
-            uri=config.EXCHANGE_URL,
+            domain=urlparse(self._config.exchange_url).netloc,
+            address=self._authenticator.address,
+            uri=self._config.exchange_url,
             version=siwe.VersionEnum.one,  # type: ignore
-            chain_id=config.CHAIN_ID,
+            chain_id=self._config.chain_id,
             issued_at=ISO8601Datetime.from_datetime(datetime.now()),
             nonce=nonce,
             statement=None,