avantis-trader-sdk 0.2.1__tar.gz → 0.4.0__tar.gz

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: avantis_trader_sdk
-Version: 0.2.1
+Version: 0.4.0
 Summary: SDK for interacting with Avantis trading contracts.
 Home-page: https://avantisfi.com/
 Author: Avantis Labs
@@ -61,6 +61,12 @@ To get started with the Avantis Trader SDK, follow these steps to install the pa
 1. Ensure you have Python 3.6 or later installed on your system.
 2. Install the SDK using pip:
 
+   ```bash
+    pip install avantis-trader-sdk
+   ```
+
+   or
+
    ```bash
    pip install git+https://github.com/Avantis-Labs/avantis_trader_sdk.git
    ```

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/README.md

@@ -46,6 +46,12 @@ To get started with the Avantis Trader SDK, follow these steps to install the pa
 1. Ensure you have Python 3.6 or later installed on your system.
 2. Install the SDK using pip:
 
+   ```bash
+    pip install avantis-trader-sdk
+   ```
+
+   or
+
    ```bash
    pip install git+https://github.com/Avantis-Labs/avantis_trader_sdk.git
    ```

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/avantis_trader_sdk/__init__.py

@@ -1,4 +1,5 @@
 from .client import TraderClient
 from .feed.feed_client import FeedClient
+from .signers.base import BaseSigner
 
 __version__ = "0.2.1"

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/avantis_trader_sdk/client.py

@@ -13,18 +13,29 @@ from .rpc.trade import TradeRPC
 from .utils import decoder
 from .feed.feed_client import FeedClient
 
+from .signers.base import BaseSigner
+from .signers.local_signer import LocalSigner
+from .signers.kms_signer import KMSSigner
+
 
 class TraderClient:
     """
     This class provides methods to interact with the Avantis smart contracts.
     """
 
-    def __init__(self, provider_url, l1_provider_url="https://eth.llamarpc.com"):
+    def __init__(
+        self,
+        provider_url,
+        l1_provider_url="https://eth.llamarpc.com",
+        signer: BaseSigner = None,
+    ):
         """
         Constructor for the TraderClient class.
 
         Args:
             provider_url: The URL of the Ethereum node provider.
+            l1_provider_url (optional): The URL of the L1 Ethereum node provider.
+            signer (optional): The signer to use for signing transactions.
         """
         self.web3 = Web3(
             Web3.HTTPProvider(provider_url, request_kwargs={"timeout": 60})
@@ -57,6 +68,8 @@ class TraderClient:
         self.snapshot = SnapshotRPC(self)
         self.trade = TradeRPC(self, FeedClient)
 
+        self.signer = signer
+
     def load_contract(self, name):
         """
         Loads the contract ABI and address from the local filesystem.
@@ -105,46 +118,87 @@ class TraderClient:
 
         return raw_data
 
-    async def write_contract(
-        self, private_key, contract_name, function_name, *args, **kwargs
-    ):
+    async def write_contract(self, contract_name, function_name, *args, **kwargs):
         """
         Calls a write function of a contract.
 
         Args:
-            private_key: The private key of the wallet.
             contract_name: The name of the contract.
             function_name: The name of the function.
             args: The arguments to the function.
 
         Returns:
-            The transaction hash or the transaction object if private key is None.
+            The transaction hash or the transaction object if signer is None.
         """
         contract = self.contracts.get(contract_name)
         if not contract:
             raise ValueError(f"Contract {contract_name} not found")
 
-        transaction = contract.functions[function_name](*args).build_transaction(kwargs)
+        if self.has_signer() and "from" not in kwargs:
+            kwargs["from"] = self.get_signer().get_ethereum_address()
+
+        transaction = await contract.functions[function_name](*args).build_transaction(
+            kwargs
+        )
 
-        if private_key is None:
+        if not self.has_signer():
             return transaction
 
-        signed_txn = await self.sign_transaction(private_key, transaction)
+        signed_txn = await self.sign_transaction(transaction)
         tx_hash = await self.send_and_get_transaction_hash(signed_txn)
         return tx_hash
 
-    async def sign_transaction(self, private_key, transaction):
+    def set_signer(self, signer: BaseSigner):
+        """
+        Sets the signer.
+        """
+        self.signer = signer
+
+    def get_signer(self):
+        """
+        Gets the signer.
+        """
+        return self.signer
+
+    def remove_signer(self):
+        """
+        Removes the signer.
+        """
+        self.signer = None
+
+    def has_signer(self):
+        """
+        Checks if the signer is set.
+        """
+        return self.signer is not None
+
+    def set_local_signer(self, private_key):
+        """
+        Sets the local signer.
+        """
+        self.signer = LocalSigner(private_key, self.async_web3)
+
+    def set_aws_kms_signer(self, kms_key_id, region_name="us-east-1"):
+        """
+        Sets the AWS KMS signer.
+        """
+        self.signer = KMSSigner(self.async_web3, kms_key_id, region_name)
+
+    async def sign_transaction(self, transaction):
         """
         Signs a transaction.
 
         Args:
-            private_key: The private key of the wallet.
             transaction: The transaction object.
 
         Returns:
             The signed transaction object.
         """
-        return self.async_web3.eth.account.sign_transaction(transaction, private_key)
+        if not self.has_signer():
+            raise ValueError(
+                "No signer is set. Please set a signer using `set_signer`."
+            )
+        return await self.signer.sign_transaction(transaction)
 
     async def send_and_get_transaction_hash(self, signed_txn):
         """
@@ -170,31 +224,34 @@ class TraderClient:
         """
         return await self.async_web3.eth.wait_for_transaction_receipt(tx_hash)
 
-    async def sign_and_get_receipt(self, private_key, transaction):
+    async def sign_and_get_receipt(self, transaction):
         """
         Signs a transaction and waits for it to be mined.
 
         Args:
-            private_key: The private key of the wallet.
             transaction: The transaction object.
 
         Returns:
             The transaction receipt.
         """
-        signed_txn = await self.sign_transaction(private_key, transaction)
+        gas_estimate = await self.get_gas_estimate(transaction)
+        transaction["gas"] = gas_estimate
+        signed_txn = await self.sign_transaction(transaction)
         tx_hash = await self.send_and_get_transaction_hash(signed_txn)
         return await self.wait_for_transaction_receipt(tx_hash)
 
-    async def get_transaction_count(self, address):
+    async def get_transaction_count(self, address=None):
         """
         Gets the transaction count.
 
         Args:
-            address: The address.
+            address (optional): The address.
 
         Returns:
             The transaction count.
         """
+        if address is None:
+            address = self.get_signer().get_ethereum_address()
         return await self.async_web3.eth.get_transaction_count(address)
 
     async def get_gas_price(self):
@@ -215,31 +272,70 @@ class TraderClient:
         """
         return await self.async_web3.eth.chain_id
 
-    async def get_balance(self, address):
+    async def get_balance(self, address=None):
         """
         Gets the balance.
 
         Args:
-            address: The address.
+            address (optional): The address.
 
         Returns:
             The balance.
         """
+        if address is None:
+            address = self.get_signer().get_ethereum_address()
         return await self.async_web3.eth.get_balance(address)
 
-    async def get_usdc_balance(self, address):
+    async def get_usdc_balance(self, address=None):
         """
         Gets the USDC balance.
 
         Args:
-            address: The address.
+            address (optional): The address.
 
         Returns:
             The USDC balance.
         """
+        if address is None:
+            address = self.get_signer().get_ethereum_address()
         balance = await self.read_contract("USDC", "balanceOf", address, decode=False)
         return balance / 10**6
 
+    async def get_usdc_allowance_for_trading(self, address=None):
+        """
+        Gets the USDC allowance for the Trading Storage contract.
+
+        Args:
+            address (optional): The address.
+
+        Returns:
+            The USDC allowance.
+        """
+        if address is None:
+            address = self.get_signer().get_ethereum_address()
+
+        trading_storage_address = self.contracts["TradingStorage"].address
+
+        allowance = await self.read_contract(
+            "USDC", "allowance", address, trading_storage_address, decode=False
+        )
+        return allowance / 10**6
+
+    async def approve_usdc_for_trading(self, amount=100000):
+        """
+        Approves the USDC amount for the Trading Storage contract.
+
+        Args:
+            amount (optional): The amount to approve. Defaults to $100,000.
+
+        Returns:
+            The transaction hash.
+        """
+        trading_storage_address = self.contracts["TradingStorage"].address
+        return await self.write_contract(
+            "USDC", "approve", trading_storage_address, int(amount * 10**6)
+        )
+
     async def get_gas_estimate(self, transaction):
         """
         Gets the gas estimate.

avantis_trader_sdk-0.4.0/avantis_trader_sdk/crypto/spki.py

@@ -0,0 +1,98 @@
+from typing import Tuple
+
+from Crypto.Hash import keccak
+from eth_account.account import Account
+from eth_utils import to_checksum_address
+from pyasn1.codec.der.decoder import decode as der_decode
+from pyasn1.type import namedtype, univ
+
+
+class SPKIAlgorithmIdentifierRecord(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("algorithm", univ.ObjectIdentifier()),
+        namedtype.OptionalNamedType("parameters", univ.Any()),
+    )
+
+
+class SPKIRecord(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("algorithm", SPKIAlgorithmIdentifierRecord()),
+        namedtype.NamedType("subjectPublicKey", univ.BitString()),
+    )
+
+
+class ECDSASignatureRecord(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType("r", univ.Integer()),
+        namedtype.NamedType("s", univ.Integer()),
+    )
+
+
+def public_key_int_to_eth_address(pubkey: int) -> str:
+    """
+    Given an integer public key, calculate the ethereum address.
+    """
+    hex_string = hex(pubkey).replace("0x", "")
+    padded_hex_string = hex_string.replace("0x", "").zfill(130)[2:]
+
+    k = keccak.new(digest_bits=256)
+    k.update(bytes.fromhex(padded_hex_string))
+    return to_checksum_address(bytes.fromhex(k.hexdigest())[-20:].hex())
+
+
+def der_encoded_public_key_to_eth_address(pubkey: bytes) -> str:
+    """
+    Given a KMS Public Key, calculate the ethereum address.
+    """
+    received_record, _ = der_decode(pubkey, asn1Spec=SPKIRecord())
+    return public_key_int_to_eth_address(
+        int(received_record["subjectPublicKey"].asBinary(), 2)
+    )
+
+
+def get_sig_r_s(signature: bytes) -> Tuple[int, int]:
+    """
+    Given a KMS signature, calculate r and s.
+    """
+    received_record, _ = der_decode(signature, asn1Spec=ECDSASignatureRecord())
+    r = int(received_record["r"].prettyPrint())
+    s = int(received_record["s"].prettyPrint())
+
+    max_value_on_curve = (
+        0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
+    )
+
+    if 2 * s >= max_value_on_curve:
+        # s is on wrong side of curve, flip it
+        s = max_value_on_curve - s
+    return r, s
+
+
+def get_sig_v(msg_hash: bytes, r: int, s: int, expected_address: str) -> int:
+    """
+    Given a message hash, r, s and an ethereum address, recover the
+    recovery parameter v.
+    """
+    acc = Account()
+    recovered = acc._recover_hash(msg_hash, vrs=(27, r, s))
+    recovered2 = acc._recover_hash(msg_hash, vrs=(28, r, s))
+    expected_checksum_address = to_checksum_address(expected_address)
+
+    if recovered == expected_checksum_address:
+        return 0
+    elif recovered2 == expected_checksum_address:
+        return 1
+
+    raise ValueError("Invalid Signature, cannot compute v, addresses do not match!")
+
+
+def get_sig_r_s_v(
+    msg_hash: bytes, signature: bytes, address: str
+) -> Tuple[int, int, int]:
+    """
+    Given a message hash, a KMS signature and an ethereum address calculate r,
+    s, and v.
+    """
+    r, s = get_sig_r_s(signature)
+    v = get_sig_v(msg_hash, r, s, address)
+    return r, s, v

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/avantis_trader_sdk/feed/feedIds.json

@@ -182,5 +182,33 @@
   "XAU/USD": {
     "id": "0x765d2ba906dbc32ca17cc11f5310a89e9ee1f6420508c63861f2f8ba4ee34bb2",
     "group": "metal"
+  },
+  "ZRO/USD": {
+    "id": "0x3bd860bea28bf982fa06bcf358118064bb114086cc03993bd76197eaab0b8018",
+    "group": "crypto"
+  },
+  "INJ/USD": {
+    "id": "0x7a5bc1d2b56ad029048cd63964b3ad2776eadf812edc1a43a31406cb54bff592",
+    "group": "crypto"
+  },
+  "ZK/USD": {
+    "id": "0xcc03dc09298fb447e0bf9afdb760d5b24340fd2167fd33d8967dd8f9a141a2e8",
+    "group": "crypto"
+  },
+  "AAVE/USD": {
+    "id": "0x2b9ab1e972a281585084148ba1389800799bd4be63b957507db1349314e47445",
+    "group": "crypto"
+  },
+  "SUI/USD": {
+    "id": "0x23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744",
+    "group": "crypto"
+  },
+  "TAO/USD": {
+    "id": "0x410f41de235f2db824e562ea7ab2d3d3d4ff048316c61d629c0b93f58584e1af",
+    "group": "crypto"
+  },
+  "EIGEN/USD": {
+    "id": "0xc65db025687356496e8653d0d6608eec64ce2d96e2e28c530e574f0e4f712380",
+    "group": "crypto"
   }
 }

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/avantis_trader_sdk/rpc/fee_parameters.py

@@ -75,28 +75,19 @@ class FeeParametersRPC:
         is_long: Optional[bool] = None,
         pair_index: int = None,
         pair: str = None,
-        trade_input: TradeInput = None,
     ):
         """
-        Retrieves the opening fee for all trading pairs.
+        Retrieves the opening fee for all trading pairs in bps.
 
         Args:
             is_long: A boolean indicating if the position is a buy or sell. Defaults to None. If None, the opening fee for both buy and sell will be returned.
             position_size: The size of the position (collateral * leverage). Supports upto 6 decimals. Defaults to 0.
             pair_index: The pair index for which the opening fee is to be calculated. Defaults to None. If None, the opening fee for all trading pairs will be returned.
             pair: The trading pair for which the opening fee is to be calculated. Defaults to None. If None, the opening fee for all trading pairs will be returned.
-            trade_input: The trade input object. Defaults to None. If provided, the pair index will be extracted from the trade input.
 
         Returns:
-            A Fee instance containing the opening Fee for each trading pair in bps or final opening fee in USDC if trade_input is provided.
+            A Fee instance containing the opening Fee for each trading pair in bps.
         """
-        if trade_input is not None:
-            position_size = (
-                trade_input.positionSizeUSDC / 10**6 * trade_input.leverage / 10**10
-            )
-            pair_index = trade_input.pairIndex
-            is_long = trade_input.buy
-
         position_size = int(position_size * 10**6)
 
         Multicall = self.client.contracts.get("Multicall")
@@ -204,16 +195,43 @@ class FeeParametersRPC:
                     ],
                 )
                 return Fee(short=decoded_response)
-        elif trade_input is not None:
-            referral_rebate_percentage = await self.client.trading_parameters.get_trade_referral_rebate_percentage(
-                trade_input.trader
-            )
-            referral_rebate_percentage = 1 - (referral_rebate_percentage / 100)
-            return round(
-                response / 10**12 * position_size / 10**6 * referral_rebate_percentage,
-                18,
-            )
         elif is_long:
             return Fee(long={pair: response / 10**10 * 100})
         else:
             return Fee(short={pair: response / 10**10 * 100})
+
+    async def get_new_trade_opening_fee(
+        self,
+        trade_input: TradeInput,
+    ):
+        """
+        Retrieves the opening fee for a trade with referral rebate in USDC.
+
+        Args:
+            trade_input: The trade input object.
+
+        Returns:
+            Final opening fee in USDC
+        """
+        position_size = (
+            trade_input.positionSizeUSDC / 10**6 * trade_input.leverage / 10**10
+        )
+
+        position_size = int(position_size * 10**6)
+
+        PriceAggregator = self.client.contracts.get("PriceAggregator")
+
+        response = await PriceAggregator.functions.openFeeP(
+            trade_input.pairIndex, position_size, trade_input.buy
+        ).call()
+
+        referral_rebate_percentage = (
+            await self.client.trading_parameters.get_trade_referral_rebate_percentage(
+                trade_input.trader
+            )
+        )
+        referral_rebate_percentage = 1 - (referral_rebate_percentage / 100)
+        return round(
+            response / 10**12 * position_size / 10**6 * referral_rebate_percentage,
+            18,
+        )

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/avantis_trader_sdk/rpc/pairs_cache.py

@@ -46,6 +46,9 @@ class PairsCache:
                 decoded_data.append(PairInfo(**decoded))
 
             for index, pair_info in enumerate(decoded_data):
+                if not pair_info.from_:
+                    pair_info.from_ = f"DELISTED_{index}"
+                    pair_info.to = f"DELISTED_{index}"
                 self._pair_info_cache[index] = pair_info
 
             group_indexes = set([pair.group_index for pair in decoded_data])

{avantis_trader_sdk-0.2.1 → avantis_trader_sdk-0.4.0}/avantis_trader_sdk/rpc/trade.py

@@ -7,6 +7,7 @@ from ..types import (
     PendingLimitOrderExtendedResponse,
     MarginUpdateType,
 )
+from typing import Optional
 import math
 
 
@@ -31,6 +32,7 @@ class TradeRPC:
         trade_input: TradeInput,
         trade_input_order_type: TradeInputOrderType,
         slippage_percentage: int,
+        execution_fee: Optional[float] = None,
     ):
         """
         Builds a transaction to open a trade.
@@ -45,7 +47,16 @@ class TradeRPC:
         """
         Trading = self.client.contracts.get("Trading")
 
-        execution_fee = await self.get_trade_execution_fee()
+        if (
+            trade_input.trader == "0x1234567890123456789012345678901234567890"
+            and self.client.get_signer() is not None
+        ):
+            trade_input.trader = await self.client.get_signer().get_ethereum_address()
+
+        if execution_fee is not None:
+            execution_fee_wei = int(execution_fee * 10**18)
+        else:
+            execution_fee_wei = await self.get_trade_execution_fee()
 
         if (
             trade_input_order_type == TradeInputOrderType.MARKET
@@ -73,7 +84,7 @@ class TradeRPC:
         ).build_transaction(
             {
                 "from": trade_input.trader,
-                "value": execution_fee,
+                "value": execution_fee_wei,
                 "chainId": self.client.chain_id,
                 "nonce": await self.client.get_transaction_count(trade_input.trader),
             }
@@ -89,6 +100,7 @@ class TradeRPC:
             The trade execution fee
         """
         execution_fee = round(0.00035, 18)  # default value
+        execution_fee_wei = int(execution_fee * 10**18)
 
         try:
             feeScalar = 0.001
@@ -107,9 +119,9 @@ class TradeRPC:
             return feeEstimate
         except Exception as e:
             print("Error getting correct trade execution fee. Using fallback: ", e)
-            return execution_fee
+            return execution_fee_wei
 
-    async def get_trades(self, trader: str):
+    async def get_trades(self, trader: Optional[str] = None):
         """
         Gets the trades.
 
@@ -119,6 +131,9 @@ class TradeRPC:
         Returns:
             The trades.
         """
+        if trader is None:
+            trader = self.client.get_signer().get_ethereum_address()
+
         result = (
             await self.client.contracts.get("Multicall")
             .functions.getPositions(trader)
@@ -198,7 +213,11 @@ class TradeRPC:
         return trades, pendingOpenLimitOrders
 
     async def build_trade_close_tx(
-        self, trader: str, pair_index: int, trade_index: int, collateral_to_close: float
+        self,
+        pair_index: int,
+        trade_index: int,
+        collateral_to_close: float,
+        trader: Optional[str] = None,
     ):
         """
         Builds a transaction to close a trade.
@@ -207,12 +226,16 @@ class TradeRPC:
             pair_index: The pair index.
             trade_index: The trade index.
             collateral_to_close: The collateral to close.
+            trader (optional): The trader's wallet address.
 
         Returns:
             A transaction object.
         """
         Trading = self.client.contracts.get("Trading")
 
+        if trader is None:
+            trader = self.client.get_signer().get_ethereum_address()
+
         execution_fee = await self.get_trade_execution_fee()
 
         transaction = await Trading.functions.closeTradeMarket(
@@ -229,7 +252,7 @@ class TradeRPC:
         return transaction
 
     async def build_order_cancel_tx(
-        self, trader: str, pair_index: int, trade_index: int
+        self, pair_index: int, trade_index: int, trader: Optional[str] = None
     ):
         """
         Builds a transaction to cancel an order.
@@ -237,13 +260,16 @@ class TradeRPC:
         Args:
             pair_index: The pair index.
             trade_index: The trade/order index.
-            position_size: The position size.
+            trader (optional): The trader's wallet address.
 
         Returns:
             A transaction object.
         """
         Trading = self.client.contracts.get("Trading")
 
+        if trader is None:
+            trader = self.client.get_signer().get_ethereum_address()
+
         transaction = await Trading.functions.cancelOpenLimitOrder(
             pair_index, trade_index
         ).build_transaction(
@@ -258,11 +284,11 @@ class TradeRPC:
 
     async def build_trade_margin_update_tx(
         self,
-        trader: str,
         pair_index: int,
         trade_index: int,
         margin_update_type: MarginUpdateType,
         collateral_change: float,
+        trader: Optional[str] = None,
     ):
         """
         Builds a transaction to update the margin of a trade.
@@ -272,12 +298,15 @@ class TradeRPC:
             trade_index: The trade index.
             margin_update_type: The margin update type.
             collateral_change: The collateral change.
-
+            trader (optional): The trader's wallet address.
         Returns:
             A transaction object.
         """
         Trading = self.client.contracts.get("Trading")
 
+        if trader is None:
+            trader = self.client.get_signer().get_ethereum_address()
+
         collateral_change = int(collateral_change * 10**6)
         fee_in_wei = 1 * 10**18