nado-protocol 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

nado_protocol/client/__init__.py

@@ -33,6 +33,9 @@ class NadoClientMode(StrEnum):
     DEVNET = "devnet"
     TESTING = "testing"
 
+    # testnet
+    TESTNET = "testnet"  # Ink Sepolia
+
 
 class NadoClient:
     """
@@ -125,8 +128,8 @@ def create_nado_client(
             perp_engine_addr=deployment.perp_engine_addr,
             spot_engine_addr=deployment.spot_engine_addr,
             clearinghouse_addr=deployment.clearinghouse_addr,
-            vrtx_airdrop_addr=deployment.vrtx_airdrop_addr,
-            vrtx_staking_addr=deployment.vrtx_staking_addr,
+            airdrop_addr=deployment.airdrop_addr,
+            staking_addr=deployment.staking_addr,
             foundation_rewards_airdrop_addr=deployment.foundation_rewards_airdrop_addr,
         )
     except Exception as e:
@@ -185,6 +188,12 @@ def client_mode_to_setup(
                 NadoBackendURL.DEVNET_TRIGGER.value,
                 NadoNetwork.TESTING.value,
             ),
+            NadoClientMode.TESTNET: (
+                NadoBackendURL.TESTNET_GATEWAY.value,
+                NadoBackendURL.TESTNET_INDEXER.value,
+                NadoBackendURL.TESTNET_TRIGGER.value,
+                NadoNetwork.TESTNET.value,
+            ),
         }[client_mode]
     except KeyError:
         raise Exception(f"Mode provided `{client_mode}` not supported!")

nado_protocol/client/apis/market/execute.py

@@ -1,13 +1,12 @@
 from nado_protocol.engine_client.types.execute import (
-    BurnLpParams,
+    BurnNlpParams,
     CancelAndPlaceParams,
     CancelOrdersParams,
     CancelProductOrdersParams,
     ExecuteResponse,
-    MintLpParams,
+    MintNlpParams,
     PlaceMarketOrderParams,
     PlaceOrderParams,
-    PlaceIsolatedOrderParams,
 )
 from nado_protocol.client.apis.base import NadoBaseAPI
 from nado_protocol.trigger_client.types.execute import (
@@ -32,12 +31,12 @@ class MarketExecuteAPI(NadoBaseAPI):
         This class should not be instantiated directly, it is designed to be used through a NadoClient instance.
     """
 
-    def mint_lp(self, params: MintLpParams) -> ExecuteResponse:
+    def mint_nlp(self, params: MintNlpParams) -> ExecuteResponse:
         """
-        Mint LP tokens through the engine.
+        Mint NLP tokens through the engine.
 
         Args:
-            params (MintLpParams): Parameters required to mint LP tokens.
+            params (MintNlpParams): Parameters required to mint NLP tokens.
 
         Returns:
             ExecuteResponse: The response from the engine execution.
@@ -45,14 +44,14 @@ class MarketExecuteAPI(NadoBaseAPI):
         Raises:
             Exception: If there is an error during the execution or the response status is not "success".
         """
-        return self.context.engine_client.mint_lp(params)
+        return self.context.engine_client.mint_nlp(params)
 
-    def burn_lp(self, params: BurnLpParams) -> ExecuteResponse:
+    def burn_nlp(self, params: BurnNlpParams) -> ExecuteResponse:
         """
-        Burn LP tokens through the engine.
+        Burn NLP tokens through the engine.
 
         Args:
-            params (BurnLpParams): Parameters required to burn LP tokens.
+            params (BurnNlpParams): Parameters required to burn NLP tokens.
 
         Returns:
             ExecuteResponse: The response from the engine execution.
@@ -60,7 +59,7 @@ class MarketExecuteAPI(NadoBaseAPI):
         Raises:
             Exception: If there is an error during the execution or the response status is not "success".
         """
-        return self.context.engine_client.burn_lp(params)
+        return self.context.engine_client.burn_nlp(params)
 
     def place_order(self, params: PlaceOrderParams) -> ExecuteResponse:
         """
@@ -77,21 +76,6 @@ class MarketExecuteAPI(NadoBaseAPI):
         """
         return self.context.engine_client.place_order(params)
 
-    def place_isolated_order(self, params: PlaceIsolatedOrderParams) -> ExecuteResponse:
-        """
-        Places an isolated order through the engine.
-
-        Args:
-            params (PlaceIsolatedOrderParams): Parameters required to place an isolated order.
-
-        Returns:
-            ExecuteResponse: The response from the engine execution.
-
-        Raises:
-            Exception: If there is an error during the execution or the response status is not "success".
-        """
-        return self.context.engine_client.place_isolated_order(params)
-
     def place_market_order(self, params: PlaceMarketOrderParams) -> ExecuteResponse:
         """
         Places a market order through the engine.

nado_protocol/client/apis/market/query.py

@@ -193,7 +193,7 @@ class MarketQueryAPI(NadoBaseAPI):
         """
         return self.context.engine_client.get_max_order_size(params)
 
-    def get_max_lp_mintable(
+    def get_max_nlp_mintable(
         self, product_id: int, sender: str, spot_leverage: Optional[bool] = None
     ) -> MaxLpMintableData:
         """
@@ -209,7 +209,7 @@ class MarketQueryAPI(NadoBaseAPI):
         Returns:
             MaxLpMintableData: Maximum base amount that can be contributed for minting LPs, in string format.
         """
-        return self.context.engine_client.get_max_lp_mintable(
+        return self.context.engine_client.get_max_nlp_mintable(
             product_id, sender, spot_leverage
         )
 

nado_protocol/client/apis/rewards/execute.py

@@ -2,28 +2,28 @@ from typing import Optional
 from nado_protocol.contracts.types import (
     ClaimFoundationRewardsContractParams,
     ClaimFoundationRewardsProofStruct,
-    ClaimVrtxContractParams,
-    ClaimVrtxParams,
+    ClaimTokensContractParams,
+    ClaimTokensParams,
 )
 from nado_protocol.client.apis.base import NadoBaseAPI
 from eth_account.signers.local import LocalAccount
 
-from nado_protocol.utils.exceptions import InvalidVrtxClaimParams
+from nado_protocol.utils.exceptions import InvalidTokenClaimParams
 
 
 class RewardsExecuteAPI(NadoBaseAPI):
-    def _validate_claim_params(self, params: ClaimVrtxParams):
-        p = ClaimVrtxParams.parse_obj(params)
+    def _validate_claim_params(self, params: ClaimTokensParams):
+        p = ClaimTokensParams.parse_obj(params)
         if p.amount is None and p.claim_all is None:
-            raise InvalidVrtxClaimParams()
+            raise InvalidTokenClaimParams()
 
-    def claim_vrtx(
-        self, params: ClaimVrtxParams, signer: Optional[LocalAccount] = None
+    def claim(
+        self, params: ClaimTokensParams, signer: Optional[LocalAccount] = None
     ) -> str:
         self._validate_claim_params(params)
         signer = self._get_signer(signer)
-        claim_params = self._get_claim_vrtx_contract_params(params, signer)
-        return self.context.contracts.claim_vrtx(
+        claim_params = self._get_claim_tokens_contract_params(params, signer)
+        return self.context.contracts.claim(
             claim_params.epoch,
             claim_params.amount_to_claim,
             claim_params.total_claimable_amount,
@@ -31,13 +31,13 @@ class RewardsExecuteAPI(NadoBaseAPI):
             signer,
         )
 
-    def claim_and_stake_vrtx(
-        self, params: ClaimVrtxParams, signer: Optional[LocalAccount] = None
+    def claim_and_stake(
+        self, params: ClaimTokensParams, signer: Optional[LocalAccount] = None
     ) -> str:
         self._validate_claim_params(params)
         signer = self._get_signer(signer)
-        claim_params = self._get_claim_vrtx_contract_params(params, signer)
-        return self.context.contracts.claim_and_stake_vrtx(
+        claim_params = self._get_claim_tokens_contract_params(params, signer)
+        return self.context.contracts.claim_and_stake(
             claim_params.epoch,
             claim_params.amount_to_claim,
             claim_params.total_claimable_amount,
@@ -45,17 +45,17 @@ class RewardsExecuteAPI(NadoBaseAPI):
             signer,
         )
 
-    def stake_vrtx(self, amount: int, signer: Optional[LocalAccount] = None) -> str:
+    def stake(self, amount: int, signer: Optional[LocalAccount] = None) -> str:
         signer = self._get_signer(signer)
-        return self.context.contracts.stake_vrtx(amount, signer)
+        return self.context.contracts.stake(amount, signer)
 
-    def unstake_vrtx(self, amount: int, signer: Optional[LocalAccount] = None) -> str:
+    def unstake(self, amount: int, signer: Optional[LocalAccount] = None) -> str:
         signer = self._get_signer(signer)
-        return self.context.contracts.unstake_vrtx(amount, signer)
+        return self.context.contracts.unstake(amount, signer)
 
-    def withdraw_unstaked_vrtx(self, signer: Optional[LocalAccount] = None):
+    def withdraw_unstaked(self, signer: Optional[LocalAccount] = None):
         signer = self._get_signer(signer)
-        return self.context.contracts.withdraw_unstaked_vrtx(signer)
+        return self.context.contracts.withdraw_unstaked(signer)
 
     def claim_usdc_rewards(self, signer: Optional[LocalAccount] = None):
         signer = self._get_signer(signer)
@@ -75,22 +75,22 @@ class RewardsExecuteAPI(NadoBaseAPI):
             claim_params.claim_proofs, signer
         )
 
-    def _get_claim_vrtx_contract_params(
-        self, params: ClaimVrtxParams, signer: LocalAccount
-    ) -> ClaimVrtxContractParams:
-        epoch_merkle_proofs = self.context.indexer_client.get_vrtx_merkle_proofs(
+    def _get_claim_tokens_contract_params(
+        self, params: ClaimTokensParams, signer: LocalAccount
+    ) -> ClaimTokensContractParams:
+        epoch_merkle_proofs = self.context.indexer_client.get_token_merkle_proofs(
             signer.address
         ).merkle_proofs[params.epoch]
         total_claimable_amount = int(epoch_merkle_proofs.total_amount)
         if params.amount is not None:
             amount_to_claim = params.amount
         else:
-            assert self.context.contracts.vrtx_airdrop is not None
-            amount_claimed = self.context.contracts.vrtx_airdrop.functions.getClaimed(
+            assert self.context.contracts.airdrop is not None
+            amount_claimed = self.context.contracts.airdrop.functions.getClaimed(
                 signer.address
             ).call()
             amount_to_claim = total_claimable_amount - amount_claimed[params.epoch]
-        return ClaimVrtxContractParams(
+        return ClaimTokensContractParams(
             epoch=params.epoch,
             amount_to_claim=amount_to_claim,
             total_claimable_amount=total_claimable_amount,

nado_protocol/client/apis/rewards/query.py

@@ -2,11 +2,12 @@ from nado_protocol.client.apis.base import NadoBaseAPI
 
 
 class RewardsQueryAPI(NadoBaseAPI):
-    def get_claim_and_stake_estimated_vrtx(self, wallet: str) -> int:
+    # TODO: revise once staking contract is deployed
+    def get_claim_and_stake_estimated_tokens(self, wallet: str) -> int:
         """
-        Estimates the amount of USDC -> VRTX swap when claiming + staking USDC rewards
+        Estimates the amount of USDC -> TOKEN swap when claiming + staking USDC rewards
         """
-        assert self.context.contracts.vrtx_staking is not None
-        return self.context.contracts.vrtx_staking.functions.getEstimatedVrtxToStake(
+        assert self.context.contracts.staking is not None
+        return self.context.contracts.staking.functions.getEstimatedTokensToStake(
             wallet
         ).call()

nado_protocol/client/apis/subaccount/query.py

@@ -59,7 +59,7 @@ class SubaccountQueryAPI(NadoBaseAPI):
 
     def get_subaccount_token_rewards(self, address: str) -> IndexerTokenRewardsData:
         """
-        Query the $VRTX token rewards accumulated per epoch for a specified wallet from the indexer.
+        Query the token rewards accumulated per epoch for a specified wallet from the indexer.
 
         Args:
             address (str): Wallet address to be queried.

nado_protocol/client/context.py

@@ -67,7 +67,6 @@ def create_nado_client_context(
     try:
         contracts = engine_client.get_contracts()
         engine_client.endpoint_addr = contracts.endpoint_addr
-        engine_client.book_addrs = contracts.book_addrs
         engine_client.chain_id = int(contracts.chain_id)
 
         if opts.trigger_endpoint_url is not None:
@@ -75,7 +74,6 @@ def create_nado_client_context(
                 TriggerClientOpts(url=opts.trigger_endpoint_url, signer=signer)
             )
             trigger_client.endpoint_addr = contracts.endpoint_addr
-            trigger_client.book_addrs = contracts.book_addrs
             trigger_client.chain_id = int(contracts.chain_id)
     except Exception as e:
         logging.warning(

nado_protocol/contracts/__init__.py

@@ -33,11 +33,11 @@ class NadoContractsContext(BaseModel):
 
         clearinghouse_addr (Optional[str]): The clearinghouse address. This may be None.
 
-        vrtx_airdrop_addr (Optional[str]): The VRTX airdrop address. This may be None.
+        airdrop_addr (Optional[str]): The airdrop address. This may be None.
 
-        vrtx_staking_addr (Optional[str]): The VRTX staking address. This may be None.
+        staking_addr (Optional[str]): The staking address. This may be None.
 
-        foundation_rewards_airdrop_addr (Optional[str]): The Foundation Rewards airdrop address of the corresponding chain (e.g: Arb airdrop for Arbitrum). This may be None.
+        foundation_rewards_airdrop_addr (Optional[str]): The Foundation Rewards airdrop address of the corresponding chain (e.g: Ink airdrop for Ink). This may be None.
     """
 
     network: Optional[NadoNetwork]
@@ -46,8 +46,8 @@ class NadoContractsContext(BaseModel):
     spot_engine_addr: Optional[str]
     perp_engine_addr: Optional[str]
     clearinghouse_addr: Optional[str]
-    vrtx_airdrop_addr: Optional[str]
-    vrtx_staking_addr: Optional[str]
+    airdrop_addr: Optional[str]
+    staking_addr: Optional[str]
     foundation_rewards_airdrop_addr: Optional[str]
 
 
@@ -64,8 +64,8 @@ class NadoContracts:
     clearinghouse: Optional[Contract]
     spot_engine: Optional[Contract]
     perp_engine: Optional[Contract]
-    vrtx_airdrop: Optional[Contract]
-    vrtx_staking: Optional[Contract]
+    airdrop: Optional[Contract]
+    staking: Optional[Contract]
     foundation_rewards_airdrop: Optional[Contract]
 
     def __init__(self, node_url: str, contracts_context: NadoContractsContext):
@@ -113,16 +113,16 @@ class NadoContracts:
                 abi=load_abi(NadoAbiName.IPERP_ENGINE),  # type: ignore
             )
 
-        if self.contracts_context.vrtx_staking_addr:
-            self.vrtx_staking: Contract = self.w3.eth.contract(
-                address=self.contracts_context.vrtx_staking_addr,
+        if self.contracts_context.staking_addr:
+            self.staking: Contract = self.w3.eth.contract(
+                address=self.contracts_context.staking_addr,
                 abi=load_abi(NadoAbiName.ISTAKING),  # type: ignore
             )
 
-        if self.contracts_context.vrtx_airdrop_addr:
-            self.vrtx_airdrop: Contract = self.w3.eth.contract(
-                address=self.contracts_context.vrtx_airdrop_addr,
-                abi=load_abi(NadoAbiName.IVRTX_AIRDROP),  # type: ignore
+        if self.contracts_context.airdrop_addr:
+            self.airdrop: Contract = self.w3.eth.contract(
+                address=self.contracts_context.airdrop_addr,
+                abi=load_abi(NadoAbiName.IAIRDROP),  # type: ignore
             )
 
         if self.contracts_context.foundation_rewards_airdrop_addr:
@@ -191,7 +191,8 @@ class NadoContracts:
         to = to or self.endpoint.address
         return self.execute(erc20.functions.approve(to, amount), signer)
 
-    def claim_vrtx(
+    # TODO: revise once airdrop contract is deployed
+    def claim(
         self,
         epoch: int,
         amount_to_claim: int,
@@ -199,15 +200,16 @@ class NadoContracts:
         merkle_proof: list[str],
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_airdrop is not None
+        assert self.airdrop is not None
         return self.execute(
-            self.vrtx_airdrop.functions.claim(
+            self.airdrop.functions.claim(
                 epoch, amount_to_claim, total_claimable_amount, merkle_proof
             ),
             signer,
         )
 
-    def claim_and_stake_vrtx(
+    # TODO: revise once airdrop contract is deployed
+    def claim_and_stake(
         self,
         epoch: int,
         amount_to_claim: int,
@@ -215,66 +217,72 @@ class NadoContracts:
         merkle_proof: list[str],
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_airdrop is not None
+        assert self.airdrop is not None
         return self.execute(
-            self.vrtx_airdrop.functions.claimAndStake(
+            self.airdrop.functions.claimAndStake(
                 epoch, amount_to_claim, total_claimable_amount, merkle_proof
             ),
             signer,
         )
 
-    def stake_vrtx(
+    # TODO: revise once staking contract is deployed
+    def stake(
         self,
         amount: int,
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_staking is not None
+        assert self.staking is not None
         return self.execute(
-            self.vrtx_staking.functions.stake(amount),
+            self.staking.functions.stake(amount),
             signer,
         )
 
-    def unstake_vrtx(
+    # TODO: revise once staking contract is deployed
+    def unstake(
         self,
         amount: int,
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_staking is not None
+        assert self.staking is not None
         return self.execute(
-            self.vrtx_staking.functions.withdraw(amount),
+            self.staking.functions.withdraw(amount),
             signer,
         )
 
-    def withdraw_unstaked_vrtx(
+    # TODO: revise once staking contract is deployed
+    def withdraw_unstaked(
         self,
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_staking is not None
+        assert self.staking is not None
         return self.execute(
-            self.vrtx_staking.functions.claimVrtx(),
+            self.staking.functions.claim(),
             signer,
         )
 
+    # TODO: revise once staking contract is deployed
     def claim_usdc_rewards(
         self,
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_staking is not None
+        assert self.staking is not None
         return self.execute(
-            self.vrtx_staking.functions.claimUsdc(),
+            self.staking.functions.claimUsdc(),
             signer,
         )
 
+    # TODO: revise once staking contract is deployed
     def claim_and_stake_usdc_rewards(
         self,
         signer: LocalAccount,
     ) -> str:
-        assert self.vrtx_staking is not None
+        assert self.staking is not None
         return self.execute(
-            self.vrtx_staking.functions.claimUsdcAndStake(),
+            self.staking.functions.claimUsdcAndStake(),
             signer,
         )
 
+    # TODO: revise once foundation rewards contract is deployed
     def claim_foundation_rewards(
         self,
         claim_proofs: list[ClaimFoundationRewardsProofStruct],