afp-sdk 0.1.0__py3-none-any.whl

afp/__init__.py

@@ -0,0 +1,10 @@
+"""Autonity 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
+
+__all__ = ("bindings", "Admin", "Builder", "Clearing", "Liquidation", "Trading")

afp/api/admin.py

@@ -0,0 +1,55 @@
+from .. import validators
+from ..decorators import refresh_token_on_expiry
+from ..schemas import ExchangeProductSubmission
+from .base import ExchangeAPI
+
+
+class Admin(ExchangeAPI):
+    """API for AutEx administration, restricted to AutEx admins.
+
+    Authenticates with the exchange on creation.
+
+    Parameters
+    ----------
+    private_key : str
+        The private key of the exchange adminstrator account.
+
+    Raises
+    ------
+    afp.exceptions.AuthenticationError
+        If the exchange rejects the login attempt.
+    """
+
+    @refresh_token_on_expiry
+    def approve_product(self, product_id: str) -> None:
+        """Approves a product for trading on the exchange.
+
+        Parameters
+        ----------
+        product_id : str
+
+        Raises
+        ------
+        afp.exceptions.AuthorizationError
+            If the configured account is not an exchange administrator.
+        """
+        product = ExchangeProductSubmission(id=product_id)
+        self._exchange.approve_product(product)
+
+    @refresh_token_on_expiry
+    def delist_product(self, product_id: str) -> None:
+        """Delists a product from the exchange.
+
+        New order submissions of this product will be rejected.
+
+        Parameters
+        ----------
+        product_id : str
+
+        Raises
+        ------
+        afp.exceptions.AuthorizationError
+            If the configured account is not an exchange administrator.
+        """
+        value = validators.validate_hexstr32(product_id)
+        self._exchange.delist_product(value)

afp/api/base.py

@@ -0,0 +1,76 @@
+from abc import ABC
+from datetime import datetime
+from functools import cache
+from typing import cast
+from urllib.parse import urlparse
+
+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 .. import config, signing
+from ..bindings.erc20 import ERC20
+from ..exchange import ExchangeClient
+from ..schemas import LoginSubmission
+
+
+EXCHANGE_DOMAIN = urlparse(config.EXCHANGE_URL).netloc
+
+
+class ClearingSystemAPI(ABC):
+    _account: LocalAccount
+    _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))
+
+        # 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))
+
+    @cache
+    def _decimals(self, collateral_asset: ChecksumAddress) -> int:
+        token_contract = ERC20(self._w3, collateral_asset)
+        return token_contract.decimals()
+
+
+class ExchangeAPI(ABC):
+    _account: LocalAccount
+    _exchange: ExchangeClient
+    _trading_protocol_id: str
+
+    def __init__(self, private_key: str):
+        self._account = Account.from_key(private_key)
+        self._exchange = ExchangeClient()
+        self._login()
+
+    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"))
+
+        login_submission = LoginSubmission(
+            message=message, signature=Web3.to_hex(signature)
+        )
+        exchange_parameters = self._exchange.login(login_submission)
+
+        self._trading_protocol_id = exchange_parameters.trading_protocol_id
+
+    @staticmethod
+    def _generate_eip4361_message(account: LocalAccount, nonce: str) -> str:
+        message = SiweMessage(
+            domain=EXCHANGE_DOMAIN,
+            address=account.address,
+            uri=config.EXCHANGE_URL,
+            version=siwe.VersionEnum.one,  # type: ignore
+            chain_id=config.CHAIN_ID,
+            issued_at=ISO8601Datetime.from_datetime(datetime.now()),
+            nonce=nonce,
+            statement=None,
+        )
+        return message.prepare_message()

afp/api/builder.py

@@ -0,0 +1,201 @@
+from datetime import datetime
+from decimal import Decimal
+from typing import cast
+
+from eth_typing.evm import ChecksumAddress
+from hexbytes import HexBytes
+from web3 import Web3
+
+from .. import config, signing, validators
+from ..bindings import (
+    OracleSpecification,
+    Product,
+    ProductMetadata,
+    ProductRegistry,
+)
+from ..bindings.erc20 import ERC20
+from ..bindings.product_registry import ABI as PRODUCT_REGISTRY_ABI
+from ..decorators import convert_web3_error
+from ..exceptions import NotFoundError
+from ..schemas import ProductSpecification
+from .base import ClearingSystemAPI
+
+
+class Builder(ClearingSystemAPI):
+    """API for building and submitting new products.
+
+    Parameters
+    ----------
+    private_key : str
+        The private key of the blockchain account that submits the product.
+    autonity_rpc_url : str
+        The URL of a JSON-RPC provider for Autonity. (HTTPS only.)
+    """
+
+    @convert_web3_error()
+    def create_product(
+        self,
+        *,
+        symbol: str,
+        description: str,
+        oracle_address: str,
+        fsv_decimals: int,
+        fsp_alpha: Decimal,
+        fsp_beta: int,
+        fsv_calldata: str,
+        start_time: datetime,
+        earliest_fsp_submission_time: datetime,
+        collateral_asset: str,
+        tick_size: int,
+        unit_value: Decimal,
+        initial_margin_requirement: Decimal,
+        maintenance_margin_requirement: Decimal,
+        offer_price_buffer: Decimal,
+        auction_bounty: Decimal,
+        tradeout_interval: int,
+        extended_metadata: str,
+    ) -> ProductSpecification:
+        """Creates a product specification with the given product data.
+
+        The builder account's address is derived from the private key; the price
+        quotation symbol is retrieved from the collateral asset.
+
+        Parameters
+        ----------
+        symbol : str
+        description : str
+        oracle_address: str
+        fsv_decimals: int
+        fsp_alpha: Decimal
+        fsp_beta: int
+        fsv_calldata: str
+        start_time : datetime
+        earliest_fsp_submission_time : datetime
+        collateral_asset : str
+        tick_size : int
+        unit_value : Decimal
+        initial_margin_requirement : Decimal
+        maintenance_margin_requirement : Decimal
+        offer_price_buffer : Decimal
+        auction_bounty : Decimal
+        tradeout_interval : int
+        extended_metadata : str
+
+        Returns
+        -------
+        afp.schemas.ProductSpecification
+        """
+        product_id = Web3.to_hex(signing.generate_product_id(self._account, symbol))
+
+        erc20_contract = ERC20(self._w3, Web3.to_checksum_address(collateral_asset))
+        price_quotation = erc20_contract.symbol()
+
+        if not price_quotation:
+            raise NotFoundError(f"No ERC20 token found at address {collateral_asset}")
+
+        if len(self._w3.eth.get_code(Web3.to_checksum_address(oracle_address))) == 0:
+            raise NotFoundError(f"No contract found at oracle address {oracle_address}")
+
+        return ProductSpecification(
+            id=product_id,
+            builder_id=self._account.address,
+            symbol=symbol,
+            description=description,
+            oracle_address=oracle_address,
+            fsv_decimals=fsv_decimals,
+            fsp_alpha=fsp_alpha,
+            fsp_beta=fsp_beta,
+            fsv_calldata=fsv_calldata,
+            price_quotation=price_quotation,
+            collateral_asset=collateral_asset,
+            start_time=start_time,
+            earliest_fsp_submission_time=earliest_fsp_submission_time,
+            tick_size=tick_size,
+            unit_value=unit_value,
+            initial_margin_requirement=initial_margin_requirement,
+            maintenance_margin_requirement=maintenance_margin_requirement,
+            offer_price_buffer=offer_price_buffer,
+            auction_bounty=auction_bounty,
+            tradeout_interval=tradeout_interval,
+            extended_metadata=extended_metadata,
+        )
+
+    @convert_web3_error(PRODUCT_REGISTRY_ABI)
+    def register_product(self, product: ProductSpecification) -> str:
+        """Submits a product specification to the clearing system.
+
+        Parameters
+        ----------
+        product : afp.schemas.ProductSpecification
+
+        Returns
+        -------
+        str
+            The hash of the transaction.
+        """
+        erc20_contract = ERC20(
+            self._w3, cast(ChecksumAddress, product.collateral_asset)
+        )
+        decimals = erc20_contract.decimals()
+
+        product_registry_contract = ProductRegistry(self._w3)
+        tx_hash = product_registry_contract.register(
+            self._convert_product_specification(product, decimals)
+        ).transact()
+        self._w3.eth.wait_for_transaction_receipt(tx_hash)
+        return Web3.to_hex(tx_hash)
+
+    @convert_web3_error(PRODUCT_REGISTRY_ABI)
+    def product_state(self, product_id: str) -> str:
+        """Returns the current state of a product.
+
+        Parameters
+        ----------
+        product_id : str
+            The ID of the product.
+
+        Returns
+        -------
+        str
+        """
+        product_id = validators.validate_hexstr32(product_id)
+        product_registry_contract = ProductRegistry(self._w3)
+        state = product_registry_contract.state(HexBytes(product_id))
+        return state.name
+
+    @staticmethod
+    def _convert_product_specification(
+        product: ProductSpecification, decimals: int
+    ) -> Product:
+        return Product(
+            metadata=ProductMetadata(
+                builder=cast(ChecksumAddress, product.builder_id),
+                symbol=product.symbol,
+                description=product.description,
+            ),
+            oracle_spec=OracleSpecification(
+                oracle_address=cast(ChecksumAddress, product.oracle_address),
+                fsv_decimals=product.fsv_decimals,
+                fsp_alpha=int(product.fsp_alpha * config.FULL_PRECISION_MULTIPLIER),
+                fsp_beta=product.fsp_beta,
+                fsv_calldata=HexBytes(product.fsv_calldata),
+            ),
+            price_quotation=product.price_quotation,
+            collateral_asset=cast(ChecksumAddress, product.collateral_asset),
+            start_time=int(product.start_time.timestamp()),
+            earliest_fsp_submission_time=int(
+                product.earliest_fsp_submission_time.timestamp()
+            ),
+            tick_size=product.tick_size,
+            unit_value=int(product.unit_value * 10**decimals),
+            initial_margin_requirement=int(
+                product.initial_margin_requirement * config.RATE_MULTIPLIER
+            ),
+            maintenance_margin_requirement=int(
+                product.maintenance_margin_requirement * config.RATE_MULTIPLIER
+            ),
+            offer_price_buffer=int(product.offer_price_buffer * config.RATE_MULTIPLIER),
+            auction_bounty=int(product.auction_bounty * config.RATE_MULTIPLIER),
+            tradeout_interval=product.tradeout_interval,
+            extended_metadata=product.extended_metadata,
+        )