afp-sdk 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

afp/api/{builder.py → product.py}

@@ -6,31 +6,27 @@ from eth_typing.evm import ChecksumAddress
 from hexbytes import HexBytes
 from web3 import Web3
 
-from .. import config, signing, validators
+from .. import constants, hashing, validators
 from ..bindings import (
+    ClearingDiamond,
     OracleSpecification,
-    Product,
+    Product as OnChainProduct,
     ProductMetadata,
     ProductRegistry,
 )
 from ..bindings.erc20 import ERC20
+from ..bindings.facade import CLEARING_DIAMOND_ABI
 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 ..schemas import ProductSpecification, Transaction
 from .base import ClearingSystemAPI
 
 
-class Builder(ClearingSystemAPI):
-    """API for building and submitting new products.
+class Product(ClearingSystemAPI):
+    """API for managing 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.)
-    """
+    ### Factories ###
 
     @convert_web3_error()
     def create_product(
@@ -38,7 +34,6 @@ class Builder(ClearingSystemAPI):
         *,
         symbol: str,
         description: str,
-        oracle_address: str,
         fsv_decimals: int,
         fsp_alpha: Decimal,
         fsp_beta: Decimal,
@@ -50,10 +45,10 @@ class Builder(ClearingSystemAPI):
         unit_value: Decimal,
         initial_margin_requirement: Decimal,
         maintenance_margin_requirement: Decimal,
-        offer_price_buffer: Decimal,
         auction_bounty: Decimal,
         tradeout_interval: int,
         extended_metadata: str,
+        oracle_address: str | None = None,
     ) -> ProductSpecification:
         """Creates a product specification with the given product data.
 
@@ -64,7 +59,6 @@ class Builder(ClearingSystemAPI):
         ----------
         symbol : str
         description : str
-        oracle_address: str
         fsv_decimals: int
         fsp_alpha: Decimal
         fsp_beta: int
@@ -76,29 +70,33 @@ class Builder(ClearingSystemAPI):
         unit_value : Decimal
         initial_margin_requirement : Decimal
         maintenance_margin_requirement : Decimal
-        offer_price_buffer : Decimal
         auction_bounty : Decimal
         tradeout_interval : int
         extended_metadata : str
+        oracle_address: str, optional
 
         Returns
         -------
         afp.schemas.ProductSpecification
         """
-        product_id = Web3.to_hex(signing.generate_product_id(self._account, symbol))
+        if oracle_address is None:
+            oracle_address = self._config.oracle_provider_address
 
-        erc20_contract = ERC20(self._w3, Web3.to_checksum_address(collateral_asset))
-        price_quotation = erc20_contract.symbol()
-
-        if not price_quotation:
+        if len(self._w3.eth.get_code(Web3.to_checksum_address(collateral_asset))) == 0:
             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}")
 
+        erc20_contract = ERC20(self._w3, Web3.to_checksum_address(collateral_asset))
+        price_quotation = erc20_contract.symbol()
+
+        product_id = Web3.to_hex(
+            hashing.generate_product_id(self._authenticator.address, symbol)
+        )
+
         return ProductSpecification(
             id=product_id,
-            builder_id=self._account.address,
+            builder_id=self._authenticator.address,
             symbol=symbol,
             description=description,
             oracle_address=oracle_address,
@@ -114,14 +112,15 @@ class Builder(ClearingSystemAPI):
             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,
         )
 
+    ### Transactions ###
+
     @convert_web3_error(PRODUCT_REGISTRY_ABI)
-    def register_product(self, product: ProductSpecification) -> str:
+    def register_product(self, product: ProductSpecification) -> Transaction:
         """Submits a product specification to the clearing system.
 
         Parameters
@@ -130,20 +129,56 @@ class Builder(ClearingSystemAPI):
 
         Returns
         -------
-        str
-            The hash of the transaction.
+        afp.schemas.Transaction
+            Transaction parameters.
         """
         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)
+        product_registry_contract = ProductRegistry(
+            self._w3, self._config.product_registry_address
+        )
+        return self._transact(
+            product_registry_contract.register(
+                self._convert_product_specification(product, decimals)
+            )
+        )
+
+    @convert_web3_error(CLEARING_DIAMOND_ABI)
+    def initiate_final_settlement(
+        self, product_id: str, accounts: list[str]
+    ) -> Transaction:
+        """Initiate final settlement (closeout) process for the specified accounts.
+
+        The product must be in Final Settlement state. The accounts must hold non-zero
+        positions in the product that offset each other (i.e. the sum of their position
+        sizes is 0.)
+
+        Parameters
+        ----------
+        product_id : str
+            The ID of the product.
+        accounts : list of str
+            List of margin account IDs to initiate settlement for.
+
+        Returns
+        -------
+        afp.schemas.Transaction
+            Transaction parameters.
+        """
+        product_id = validators.validate_hexstr32(product_id)
+        addresses = [validators.validate_address(account) for account in accounts]
+
+        clearing_contract = ClearingDiamond(
+            self._w3, self._config.clearing_diamond_address
+        )
+        return self._transact(
+            clearing_contract.initiate_final_settlement(HexBytes(product_id), addresses)
+        )
+
+    ### Views ###
 
     @convert_web3_error(PRODUCT_REGISTRY_ABI)
     def product_state(self, product_id: str) -> str:
@@ -159,15 +194,43 @@ class Builder(ClearingSystemAPI):
         str
         """
         product_id = validators.validate_hexstr32(product_id)
-        product_registry_contract = ProductRegistry(self._w3)
+        product_registry_contract = ProductRegistry(
+            self._w3, self._config.product_registry_address
+        )
         state = product_registry_contract.state(HexBytes(product_id))
         return state.name
 
+    @convert_web3_error(PRODUCT_REGISTRY_ABI)
+    def collateral_asset(self, product_id: str) -> str:
+        """Returns the collateral asset 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, self._config.product_registry_address
+        )
+        collateral_asset = product_registry_contract.collateral_asset(
+            HexBytes(product_id)
+        )
+        if Web3.to_int(hexstr=collateral_asset) == 0:
+            raise NotFoundError("Product not found in the product registry")
+        return collateral_asset
+
+    ### Internal helpers ###
+
     @staticmethod
     def _convert_product_specification(
         product: ProductSpecification, decimals: int
-    ) -> Product:
-        return Product(
+    ) -> OnChainProduct:
+        return OnChainProduct(
             metadata=ProductMetadata(
                 builder=cast(ChecksumAddress, product.builder_id),
                 symbol=product.symbol,
@@ -176,7 +239,7 @@ class Builder(ClearingSystemAPI):
             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_alpha=int(product.fsp_alpha * constants.FULL_PRECISION_MULTIPLIER),
                 fsp_beta=int(product.fsp_beta * 10**product.fsv_decimals),
                 fsv_calldata=HexBytes(product.fsv_calldata),
             ),
@@ -189,13 +252,12 @@ class Builder(ClearingSystemAPI):
             tick_size=product.tick_size,
             unit_value=int(product.unit_value * 10**decimals),
             initial_margin_requirement=int(
-                product.initial_margin_requirement * config.RATE_MULTIPLIER
+                product.initial_margin_requirement * constants.RATE_MULTIPLIER
             ),
             maintenance_margin_requirement=int(
-                product.maintenance_margin_requirement * config.RATE_MULTIPLIER
+                product.maintenance_margin_requirement * constants.RATE_MULTIPLIER
             ),
-            offer_price_buffer=int(product.offer_price_buffer * config.RATE_MULTIPLIER),
-            auction_bounty=int(product.auction_bounty * config.RATE_MULTIPLIER),
+            auction_bounty=int(product.auction_bounty * constants.RATE_MULTIPLIER),
             tradeout_interval=product.tradeout_interval,
             extended_metadata=product.extended_metadata,
         )

afp/api/trading.py

@@ -5,7 +5,7 @@ from typing import Generator
 
 from web3 import Web3
 
-from .. import signing, validators
+from .. import hashing, validators
 from ..decorators import refresh_token_on_expiry
 from ..enums import OrderType
 from ..schemas import (
@@ -25,20 +25,7 @@ from .base import ExchangeAPI
 
 
 class Trading(ExchangeAPI):
-    """API for trading in the AutEx exchange.
-
-    Authenticates with the exchange on creation.
-
-    Parameters
-    ----------
-    private_key : str
-        The private key of the account that submits intents to the exchange.
-
-    Raises
-    ------
-    afp.exceptions.AuthenticationError
-        If the exchange rejects the login attempt.
-    """
+    """API for trading in the AutEx exchange."""
 
     @staticmethod
     def _generate_nonce() -> int:
@@ -89,7 +76,7 @@ class Trading(ExchangeAPI):
         margin_account_id = (
             validators.validate_address(margin_account_id)
             if margin_account_id is not None
-            else self._account.address
+            else self._authenticator.address
         )
 
         intent_data = IntentData(
@@ -104,17 +91,17 @@ class Trading(ExchangeAPI):
             good_until_time=good_until_time,
             nonce=self._generate_nonce(),
         )
-        intent_hash = signing.generate_intent_hash(
+        intent_hash = hashing.generate_intent_hash(
             intent_data=intent_data,
             margin_account_id=margin_account_id,
-            intent_account_id=self._account.address,
+            intent_account_id=self._authenticator.address,
             tick_size=product.tick_size,
         )
-        signature = signing.sign_message(self._account, intent_hash)
+        signature = self._authenticator.sign_message(intent_hash)
         return Intent(
             hash=Web3.to_hex(intent_hash),
             margin_account_id=margin_account_id,
-            intent_account_id=self._account.address,
+            intent_account_id=self._authenticator.address,
             signature=Web3.to_hex(signature),
             data=intent_data,
         )
@@ -160,12 +147,12 @@ class Trading(ExchangeAPI):
             If the exchange rejects the cancellation.
         """
         nonce = self._generate_nonce()
-        cancellation_hash = signing.generate_order_cancellation_hash(nonce, intent_hash)
-        signature = signing.sign_message(self._account, cancellation_hash)
+        cancellation_hash = hashing.generate_order_cancellation_hash(nonce, intent_hash)
+        signature = self._authenticator.sign_message(cancellation_hash)
         cancellation_data = OrderCancellationData(
             intent_hash=intent_hash,
             nonce=nonce,
-            intent_account_id=self._account.address,
+            intent_account_id=self._authenticator.address,
             signature=Web3.to_hex(signature),
         )
         submission = OrderSubmission(
@@ -174,7 +161,6 @@ class Trading(ExchangeAPI):
         )
         return self._exchange.submit_order(submission)
 
-    @refresh_token_on_expiry
     def products(self) -> list[ExchangeProduct]:
         """Retrieves the products approved for trading on the exchange.
 
@@ -184,7 +170,6 @@ class Trading(ExchangeAPI):
         """
         return self._exchange.get_approved_products()
 
-    @refresh_token_on_expiry
     def product(self, product_id: str) -> ExchangeProduct:
         """Retrieves a product for trading by its ID.
 
@@ -226,15 +211,19 @@ class Trading(ExchangeAPI):
         return self._exchange.get_order_by_id(value)
 
     @refresh_token_on_expiry
-    def open_orders(self) -> list[Order]:
+    def open_orders(self, product_id: str | None = None) -> list[Order]:
         """Retrieves all open and partially filled limit orders that have been submitted
         by the authenticated account.
 
+        Parameters
+        ----------
+        product_id : str, optional
+
         Returns
         -------
         list of afp.schemas.Order
         """
-        return self._exchange.get_open_orders()
+        return self._exchange.get_open_orders(product_id)
 
     @refresh_token_on_expiry
     def order_fills(
@@ -262,7 +251,7 @@ class Trading(ExchangeAPI):
         list of afp.schemas.OrderFill
         """
         filter = OrderFillFilter(
-            intent_account_id=self._account.address,
+            intent_account_id=self._authenticator.address,
             product_id=product_id,
             margin_account_id=margin_account_id,
             intent_hash=intent_hash,
@@ -298,7 +287,7 @@ class Trading(ExchangeAPI):
         afp.schemas.OrderFill
         """
         filter = OrderFillFilter(
-            intent_account_id=self._account.address,
+            intent_account_id=self._authenticator.address,
             product_id=product_id,
             margin_account_id=margin_account_id,
             intent_hash=intent_hash,
@@ -308,7 +297,6 @@ class Trading(ExchangeAPI):
         )
         yield from self._exchange.iter_order_fills(filter)
 
-    @refresh_token_on_expiry
     def market_depth(self, product_id: str) -> MarketDepthData:
         """Retrieves the depth of market for the given product.
 
@@ -328,7 +316,6 @@ class Trading(ExchangeAPI):
         value = validators.validate_hexstr32(product_id)
         return self._exchange.get_market_depth_data(value)
 
-    @refresh_token_on_expiry
     def iter_market_depth(
         self, product_id: str
     ) -> Generator[MarketDepthData, None, None]:

afp/auth.py

@@ -0,0 +1,66 @@
+import json
+import os
+from typing import Protocol, cast
+
+from eth_account.account import Account
+from eth_account.datastructures import SignedTransaction
+from eth_account.messages import encode_defunct
+from eth_account.signers.local import LocalAccount
+from eth_account.types import TransactionDictType
+from eth_typing.evm import ChecksumAddress
+from hexbytes import HexBytes
+from web3.types import TxParams
+
+
+class Authenticator(Protocol):
+    address: ChecksumAddress
+
+    def sign_message(self, message: bytes) -> HexBytes: ...
+
+    def sign_transaction(self, params: TxParams) -> SignedTransaction: ...
+
+
+class PrivateKeyAuthenticator(Authenticator):
+    """Authenticates with a private key specified in a constructor argument.
+
+    Parameters
+    ----------
+    private_key: str
+        The private key of a blockchain account.
+    """
+
+    _account: LocalAccount
+
+    def __init__(self, private_key: str) -> None:
+        self._account = Account.from_key(private_key)
+        self.address = self._account.address
+
+    def sign_message(self, message: bytes) -> HexBytes:
+        eip191_message = encode_defunct(message)
+        signed_message = self._account.sign_message(eip191_message)
+        return signed_message.signature
+
+    def sign_transaction(self, params: TxParams) -> SignedTransaction:
+        return self._account.sign_transaction(cast(TransactionDictType, params))
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(address='{self.address}')"
+
+
+class KeyfileAuthenticator(PrivateKeyAuthenticator):
+    """Authenticates with a private key read from an encrypted keyfile.
+
+    Parameters
+    ----------
+    keyfile : str
+        The path to the keyfile.
+    password : str
+        The password for decrypting the keyfile.
+    """
+
+    def __init__(self, key_file: str, password: str) -> None:
+        with open(os.path.expanduser(key_file), encoding="utf8") as f:
+            key_data = json.load(f)
+
+        private_key = Account.decrypt(key_data, password=password)
+        super().__init__(private_key.to_0x_hex())

afp/bindings/bankruptcy_facet.py

@@ -56,6 +56,11 @@ class BankruptcyFacet:
             abi=ABI,
         )
 
+    @property
+    def LossMutualized(self) -> contract.ContractEvent:
+        """Binding for `event LossMutualized` on the BankruptcyFacet contract."""
+        return self._contract.events.LossMutualized
+
     def last_traded_timestamp(
         self,
         product_id: hexbytes.HexBytes,
@@ -219,6 +224,37 @@ ABI = typing.cast(
             "type": "error",
         },
         {"inputs": [], "name": "QueueIsEmpty", "type": "error"},
+        {
+            "anonymous": False,
+            "inputs": [
+                {
+                    "indexed": True,
+                    "internalType": "address",
+                    "name": "bankruptAccount",
+                    "type": "address",
+                },
+                {
+                    "indexed": True,
+                    "internalType": "address",
+                    "name": "collateralToken",
+                    "type": "address",
+                },
+                {
+                    "indexed": False,
+                    "internalType": "address",
+                    "name": "caller",
+                    "type": "address",
+                },
+                {
+                    "indexed": False,
+                    "internalType": "int256",
+                    "name": "lossAmount",
+                    "type": "int256",
+                },
+            ],
+            "name": "LossMutualized",
+            "type": "event",
+        },
         {
             "inputs": [
                 {"internalType": "bytes32", "name": "productId", "type": "bytes32"},

afp/bindings/clearing_facet.py

@@ -423,6 +423,25 @@ class ClearingFacet:
             ),
         )
 
+    def set_treasury(
+        self,
+        new_treasury: eth_typing.ChecksumAddress,
+    ) -> contract.ContractFunction:
+        """Binding for `setTreasury` on the ClearingFacet contract.
+
+        Parameters
+        ----------
+        new_treasury : eth_typing.ChecksumAddress
+
+        Returns
+        -------
+        web3.contract.contract.ContractFunction
+            A contract function instance to be sent in a transaction.
+        """
+        return self._contract.functions.setTreasury(
+            new_treasury,
+        )
+
     def version(
         self,
     ) -> str:
@@ -1003,6 +1022,15 @@ ABI = typing.cast(
             "stateMutability": "nonpayable",
             "type": "function",
         },
+        {
+            "inputs": [
+                {"internalType": "address", "name": "newTreasury", "type": "address"}
+            ],
+            "name": "setTreasury",
+            "outputs": [],
+            "stateMutability": "nonpayable",
+            "type": "function",
+        },
         {
             "inputs": [],
             "name": "version",

afp/bindings/facade.py

@@ -1,8 +1,9 @@
 from itertools import chain
 
+from eth_typing.evm import ChecksumAddress
+
 from web3 import Web3
 
-from .. import config
 from . import (
     auctioneer_facet,
     bankruptcy_facet,
@@ -14,6 +15,7 @@ from . import (
     product_registry,
     system_viewer,
 )
+from ..constants import defaults
 
 # In order to include a facet in the ClearingDiamond facade:
 # 1. Add its ABI to CLEARING_DIAMOND_ABI
@@ -46,10 +48,10 @@ class ClearingDiamond(
     w3 : web3.Web3
     """
 
-    def __init__(self, w3: Web3):
-        self._contract = w3.eth.contract(
-            address=config.CLEARING_DIAMOND_ADDRESS, abi=CLEARING_DIAMOND_ABI
-        )
+    def __init__(
+        self, w3: Web3, address: ChecksumAddress = defaults.CLEARING_DIAMOND_ADDRESS
+    ):
+        self._contract = w3.eth.contract(address=address, abi=CLEARING_DIAMOND_ABI)
 
 
 class MarginAccountRegistry(margin_account_registry.MarginAccountRegistry):
@@ -60,8 +62,12 @@ class MarginAccountRegistry(margin_account_registry.MarginAccountRegistry):
     w3 : web3.Web3
     """
 
-    def __init__(self, w3: Web3):
-        super().__init__(w3, config.MARGIN_ACCOUNT_REGISTRY_ADDRESS)
+    def __init__(
+        self,
+        w3: Web3,
+        address: ChecksumAddress = defaults.MARGIN_ACCOUNT_REGISTRY_ADDRESS,
+    ):
+        super().__init__(w3, address)
 
 
 class OracleProvider(oracle_provider.OracleProvider):
@@ -72,8 +78,10 @@ class OracleProvider(oracle_provider.OracleProvider):
     w3 : web3.Web3
     """
 
-    def __init__(self, w3: Web3):
-        super().__init__(w3, config.ORACLE_PROVIDER_ADDRESS)
+    def __init__(
+        self, w3: Web3, address: ChecksumAddress = defaults.ORACLE_PROVIDER_ADDRESS
+    ):
+        super().__init__(w3, address)
 
 
 class ProductRegistry(product_registry.ProductRegistry):
@@ -84,8 +92,10 @@ class ProductRegistry(product_registry.ProductRegistry):
     w3 : web3.Web3
     """
 
-    def __init__(self, w3: Web3):
-        super().__init__(w3, config.PRODUCT_REGISTRY_ADDRESS)
+    def __init__(
+        self, w3: Web3, address: ChecksumAddress = defaults.PRODUCT_REGISTRY_ADDRESS
+    ):
+        super().__init__(w3, address)
 
 
 class SystemViewer(system_viewer.SystemViewer):
@@ -96,5 +106,7 @@ class SystemViewer(system_viewer.SystemViewer):
     w3 : web3.Web3
     """
 
-    def __init__(self, w3: Web3):
-        super().__init__(w3, config.SYSTEM_VIEWER_ADDRESS)
+    def __init__(
+        self, w3: Web3, address: ChecksumAddress = defaults.SYSTEM_VIEWER_ADDRESS
+    ):
+        super().__init__(w3, address)