nado-protocol 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

nado_protocol/contracts/abis/MockERC20.json

@@ -308,4 +308,4 @@
     "stateMutability": "nonpayable",
     "type": "function"
   }
-]
+]

nado_protocol/contracts/deployments/{deployment.test.json → deployment.testing.json}

@@ -1,18 +1,15 @@
 {
-  "nodeUrl": "http://0.0.0.0:8545",
   "publicNodeUrl": "http://0.0.0.0:8545",
   "explorerUrl": "",
   "startBlock": 0,
   "deployer": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
   "quote": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
   "querier": "0x4ed7c70F96B99c776995fB64377f0d4aB3B0e1C1",
-  "feeCalculator": "0xB7f8BC63BbcaD18155201308C8f3540b07f84F5e",
   "clearinghouse": "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853",
-  "clearinghouseLiq": "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9",
   "endpoint": "0x8A791620dd6260079BF849Dc5567aDC3F2FdC318",
   "spotEngine": "0x0DCd1Bf9A1b36cE34237eEaFef220932846BCD82",
   "perpEngine": "0x0B306BF915C4d645ff596e518fAf3F9669b97016",
-  "vrtxAirdrop": "0x0000000000000000000000000000000000000000",
-  "vrtxStaking": "0x0000000000000000000000000000000000000000",
+  "airdrop": "0x0000000000000000000000000000000000000000",
+  "staking": "0x0000000000000000000000000000000000000000",
   "foundationRewardsAirdrop": "0x0000000000000000000000000000000000000000"
 }

nado_protocol/contracts/deployments/deployment.testnet.json

@@ -0,0 +1,15 @@
+{
+  "publicNodeUrl": "https://rpc-gel-sepolia.inkonchain.com",
+  "explorerUrl": "https://explorer-sepolia.inkonchain.com",
+  "startBlock": 27233833,
+  "deployer": "0x8177A1b5bFaAa10A4b1178c6D42aDaa4b75c8146",
+  "quote": "0x5F65358d61A9a281ea3BB930d05889ACa21E3f4f",
+  "querier": "0x5A62e748b2630560Ffe9E928780cF9Fe0e086A21",
+  "clearinghouse": "0x5E9b4336104069467E57E843033e62c79C667F8F",
+  "endpoint": "0xf8963f7860aF7DE9b94893EDb9A3b5c155e1Fc0c",
+  "spotEngine": "0x61AA7A636df5e72eBe34c70a340eB76ABB3A15bE",
+  "perpEngine": "0x3D6Ac7105cA399884739a8CC19cAdB4178844466",
+  "airdrop": "0x0000000000000000000000000000000000000000",
+  "staking": "0x0000000000000000000000000000000000000000",
+  "foundationRewardsAirdrop": "0x0000000000000000000000000000000000000000"
+}

nado_protocol/contracts/eip712/types.py

@@ -69,16 +69,7 @@ def get_nado_eip712_type(tx: NadoTxType) -> dict:
                 {"name": "amount", "type": "int128"},
                 {"name": "expiration", "type": "uint64"},
                 {"name": "nonce", "type": "uint64"},
-            ]
-        },
-        NadoTxType.PLACE_ISOLATED_ORDER: {
-            "IsolatedOrder": [
-                {"name": "sender", "type": "bytes32"},
-                {"name": "priceX18", "type": "int128"},
-                {"name": "amount", "type": "int128"},
-                {"name": "expiration", "type": "uint64"},
-                {"name": "nonce", "type": "uint64"},
-                {"name": "margin", "type": "int128"},
+                {"name": "appendix", "type": "uint128"},
             ]
         },
         NadoTxType.CANCEL_ORDERS: {
@@ -114,21 +105,17 @@ def get_nado_eip712_type(tx: NadoTxType) -> dict:
                 {"name": "nonce", "type": "uint64"},
             ],
         },
-        NadoTxType.MINT_LP: {
-            "MintLp": [
+        NadoTxType.MINT_NLP: {
+            "MintNlp": [
                 {"name": "sender", "type": "bytes32"},
-                {"name": "productId", "type": "uint32"},
-                {"name": "amountBase", "type": "uint128"},
-                {"name": "quoteAmountLow", "type": "uint128"},
-                {"name": "quoteAmountHigh", "type": "uint128"},
+                {"name": "quoteAmount", "type": "uint128"},
                 {"name": "nonce", "type": "uint64"},
             ]
         },
-        NadoTxType.BURN_LP: {
-            "BurnLp": [
+        NadoTxType.BURN_NLP: {
+            "BurnNlp": [
                 {"name": "sender", "type": "bytes32"},
-                {"name": "productId", "type": "uint32"},
-                {"name": "amount", "type": "uint128"},
+                {"name": "nlpAmount", "type": "uint128"},
                 {"name": "nonce", "type": "uint64"},
             ]
         },
@@ -139,6 +126,14 @@ def get_nado_eip712_type(tx: NadoTxType) -> dict:
                 {"name": "nonce", "type": "uint64"},
             ]
         },
+        NadoTxType.TRANSFER_QUOTE: {
+            "TransferQuote": [
+                {"name": "sender", "type": "bytes32"},
+                {"name": "recipient", "type": "bytes32"},
+                {"name": "amount", "type": "uint128"},
+                {"name": "nonce", "type": "uint64"},
+            ]
+        },
         NadoTxType.AUTHENTICATE_STREAM: {
             "StreamAuthentication": [
                 {"name": "sender", "type": "bytes32"},

nado_protocol/contracts/types.py

@@ -11,8 +11,11 @@ class NadoNetwork(StrEnum):
     """
 
     # dev
-    HARDHAT = "localhost"
-    TESTING = "test"
+    HARDHAT = "localhost"  # local hardhat node
+    TESTING = "testing"  # for running local tests
+
+    # testnet
+    TESTNET = "testnet"  # Ink Sepolia
 
 
 class NadoAbiName(StrEnum):
@@ -24,12 +27,11 @@ class NadoAbiName(StrEnum):
     FQUERIER = "FQuerier"
     ICLEARINGHOUSE = "IClearinghouse"
     IENDPOINT = "IEndpoint"
-    IOFFCHAIN_BOOK = "IOffchainBook"
     IPERP_ENGINE = "IPerpEngine"
     ISPOT_ENGINE = "ISpotEngine"
     MOCK_ERC20 = "MockERC20"
     ISTAKING = "IStaking"
-    IVRTX_AIRDROP = "IVrtxAirdrop"
+    IAIRDROP = "IAirdrop"
     IFOUNDATION_REWARDS_AIRDROP = "IFoundationRewardsAirdrop"
 
 
@@ -52,9 +54,9 @@ class NadoDeployment(NadoBaseModel):
 
         perp_engine_addr (str): The address of the perpetual engine contract.
 
-        vrtx_airdrop_addr (str): The address of the VRTX airdrop contract.
+        airdrop_addr (str): The address of the airdrop contract.
 
-        vrtx_staking_addr (str): The address of the VRTX staking contract.
+        staking_addr (str): The address of the staking contract.
 
         foundation_rewards_airdrop_addr (str): The address of Foundation Rewards airdrop contract for the corresponding chain (e.g: Arb airdrop for Arbitrum).
     """
@@ -66,8 +68,8 @@ class NadoDeployment(NadoBaseModel):
     endpoint_addr: str = Field(alias="endpoint")
     spot_engine_addr: str = Field(alias="spotEngine")
     perp_engine_addr: str = Field(alias="perpEngine")
-    vrtx_airdrop_addr: str = Field(alias="vrtxAirdrop")
-    vrtx_staking_addr: str = Field(alias="vrtxStaking")
+    airdrop_addr: str = Field(alias="airdrop")
+    staking_addr: str = Field(alias="staking")
     foundation_rewards_airdrop_addr: str = Field(alias="foundationRewardsAirdrop")
 
 
@@ -91,13 +93,13 @@ class DepositCollateralParams(NadoBaseModel):
     referral_code: Optional[str]
 
 
-class ClaimVrtxParams(NadoBaseModel):
+class ClaimTokensParams(NadoBaseModel):
     epoch: int
     amount: Optional[int]
     claim_all: Optional[bool]
 
 
-class ClaimVrtxContractParams(NadoBaseModel):
+class ClaimTokensContractParams(NadoBaseModel):
     epoch: int
     amount_to_claim: int
     total_claimable_amount: int
@@ -120,15 +122,15 @@ class NadoExecuteType(StrEnum):
     """
 
     PLACE_ORDER = "place_order"
-    PLACE_ISOLATED_ORDER = "place_isolated_order"
     CANCEL_ORDERS = "cancel_orders"
     CANCEL_PRODUCT_ORDERS = "cancel_product_orders"
     CANCEL_AND_PLACE = "cancel_and_place"
     WITHDRAW_COLLATERAL = "withdraw_collateral"
     LIQUIDATE_SUBACCOUNT = "liquidate_subaccount"
-    MINT_LP = "mint_lp"
-    BURN_LP = "burn_lp"
+    MINT_NLP = "mint_nlp"
+    BURN_NLP = "burn_nlp"
     LINK_SIGNER = "link_signer"
+    TRANSFER_QUOTE = "transfer_quote"
 
 
 NadoTxType = StrEnum(

nado_protocol/engine_client/execute.py

@@ -1,4 +1,3 @@
-import time
 import requests
 from functools import singledispatchmethod
 
@@ -8,7 +7,7 @@ from nado_protocol.engine_client.types import (
     EngineClientOpts,
 )
 from nado_protocol.engine_client.types.execute import (
-    BurnLpParams,
+    BurnNlpParams,
     CancelAndPlaceParams,
     CancelOrdersParams,
     CancelProductOrdersParams,
@@ -17,9 +16,8 @@ from nado_protocol.engine_client.types.execute import (
     ExecuteResponse,
     LinkSignerParams,
     LiquidateSubaccountParams,
-    MintLpParams,
+    MintNlpParams,
     OrderParams,
-    PlaceIsolatedOrderParams,
     PlaceMarketOrderParams,
     PlaceOrderParams,
     WithdrawCollateralParams,
@@ -38,6 +36,7 @@ from nado_protocol.utils.math import mul_x18, round_x18, to_x18
 from nado_protocol.utils.model import NadoBaseModel, is_instance_of_union
 from nado_protocol.utils.subaccount import Subaccount, SubaccountParams
 from nado_protocol.utils.execute import NadoBaseExecute
+from nado_protocol.utils.order import build_appendix
 
 
 class EngineExecuteClient(NadoBaseExecute):
@@ -151,26 +150,6 @@ class EngineExecuteClient(NadoBaseExecute):
         )
         return self.execute(params)
 
-    def place_isolated_order(self, params: PlaceIsolatedOrderParams) -> ExecuteResponse:
-        """
-        Execute a place isolated order operation.
-
-        Args:
-            params (PlaceIsolatedOrderParams): Parameters required for placing an isolated order.
-            The parameters include the isolated order details.
-
-        Returns:
-            ExecuteResponse: Response of the execution, including status and potential error message.
-        """
-        params = PlaceIsolatedOrderParams.parse_obj(params)
-        params.isolated_order = self.prepare_execute_params(params.isolated_order, True)
-        params.signature = params.signature or self._sign(
-            NadoExecuteType.PLACE_ISOLATED_ORDER,
-            params.isolated_order.dict(),
-            params.product_id,
-        )
-        return self.execute(params)
-
     def place_market_order(self, params: PlaceMarketOrderParams) -> ExecuteResponse:
         """
         Places an FOK order using top of the book price with provided slippage.
@@ -198,8 +177,9 @@ class EngineExecuteClient(NadoBaseExecute):
             amount=params.market_order.amount,
             nonce=params.market_order.nonce,
             priceX18=round_x18(market_price_x18, price_increment_x18),
-            expiration=get_expiration_timestamp(
-                OrderType.FOK, int(time.time()) + 1000, bool(params.reduce_only)
+            expiration=get_expiration_timestamp(1000),
+            appendix=build_appendix(
+                OrderType.FOK, reduce_only=bool(params.reduce_only)
             ),
         )
         return self.place_order(
@@ -317,38 +297,38 @@ class EngineExecuteClient(NadoBaseExecute):
         )
         return self.execute(params)
 
-    def mint_lp(self, params: MintLpParams) -> ExecuteResponse:
+    def mint_nlp(self, params: MintNlpParams) -> ExecuteResponse:
         """
-        Execute a mint LP tokens operation.
+        Execute a mint NLP tokens operation.
 
         Args:
-            params (MintLpParams): Parameters required for minting LP tokens.
+            params (MintNlpParams): Parameters required for minting NLP tokens.
             The parameters include the LP details.
 
         Returns:
             ExecuteResponse: Response of the execution, including status and potential error message.
         """
-        params = self.prepare_execute_params(MintLpParams.parse_obj(params), False)
+        params = self.prepare_execute_params(MintNlpParams.parse_obj(params), False)
         params.signature = params.signature or self._sign(
-            NadoExecuteType.MINT_LP,
+            NadoExecuteType.MINT_NLP,
             params.dict(),
         )
         return self.execute(params)
 
-    def burn_lp(self, params: BurnLpParams) -> ExecuteResponse:
+    def burn_nlp(self, params: BurnNlpParams) -> ExecuteResponse:
         """
-        Execute a burn LP tokens operation.
+        Execute a burn NLP tokens operation.
 
         Args:
-            params (BurnLpParams): Parameters required for burning LP tokens.
+            params (BurnNlpParams): Parameters required for burning LP tokens.
             The parameters include the LP details.
 
         Returns:
             ExecuteResponse: Response of the execution, including status and potential error message.
         """
-        params = self.prepare_execute_params(BurnLpParams.parse_obj(params), False)
+        params = self.prepare_execute_params(BurnNlpParams.parse_obj(params), False)
         params.signature = params.signature or self._sign(
-            NadoExecuteType.BURN_LP,
+            NadoExecuteType.BURN_NLP,
             params.dict(),
         )
         return self.execute(params)
@@ -408,9 +388,8 @@ class EngineExecuteClient(NadoBaseExecute):
                         closing_price_x18,
                         product.book_info.price_increment_x18,
                     ),
-                    expiration=get_expiration_timestamp(
-                        OrderType.FOK, int(time.time()) + 1000, reduce_only=True
-                    ),
+                    expiration=get_expiration_timestamp(1000),
+                    appendix=build_appendix(OrderType.FOK, reduce_only=True),
                 ),
             )
         )

nado_protocol/engine_client/query.py

@@ -356,7 +356,7 @@ class EngineQueryClient:
             MaxWithdrawableData,
         )
 
-    def get_max_lp_mintable(
+    def get_max_nlp_mintable(
         self, product_id: int, sender: str, spot_leverage: Optional[bool] = None
     ) -> MaxLpMintableData:
         """

nado_protocol/engine_client/types/__init__.py

@@ -22,8 +22,8 @@ __all__ = [
     "CancelAndPlaceParams",
     "WithdrawCollateralParams",
     "LiquidateSubaccountParams",
-    "MintLpParams",
-    "BurnLpParams",
+    "MintNlpParams",
+    "BurnNlpParams",
     "LinkSignerParams",
     "ExecuteParams",
     "TxRequest",
@@ -33,8 +33,8 @@ __all__ = [
     "CancelAndPlaceRequest",
     "WithdrawCollateralRequest",
     "LiquidateSubaccountRequest",
-    "MintLpRequest",
-    "BurnLpRequest",
+    "MintNlpRequest",
+    "BurnNlpRequest",
     "LinkSignerRequest",
     "ExecuteRequest",
     "ExecuteResponse",
@@ -75,11 +75,7 @@ __all__ = [
     "QueryResponse",
     "ResponseStatus",
     "EngineStatus",
-    "MintLp",
-    "BurnLp",
     "ApplyDelta",
-    "MintLpTx",
-    "BurnLpTx",
     "ApplyDeltaTx",
     "SubaccountHealth",
     "SpotLpBalance",

nado_protocol/engine_client/types/execute.py

@@ -4,7 +4,6 @@ from nado_protocol.contracts.types import NadoExecuteType
 from nado_protocol.engine_client.types.models import ResponseStatus
 from nado_protocol.utils.execute import (
     BaseParamsSigned,
-    IsolatedOrderParams,
     MarketOrderParams,
     OrderParams,
     SignatureParams,
@@ -45,29 +44,6 @@ class PlaceOrderParams(SignatureParams):
     spot_leverage: Optional[bool]
 
 
-class PlaceIsolatedOrderParams(SignatureParams):
-    """
-    Class for defining the parameters needed to place an isolated order.
-
-    Attributes:
-        id (Optional[int]): An optional custom order id that is echoed back in subscription events e.g: fill orders, etc.
-
-        product_id (int): The id of the product for which the order is being placed.
-
-        isolated_order (IsolatedOrderParams): The parameters of the isolated order.
-
-        digest (Optional[str]): An optional hash of the order data.
-
-        borrow_margin (Optional[bool]): Whether the cross subaccount can borrow quote for the margin transfer into the isolated subaccount. If not provided, it defaults to true.
-    """
-
-    id: Optional[int]
-    product_id: int
-    isolated_order: IsolatedOrderParams
-    digest: Optional[str]
-    borrow_margin: Optional[bool]
-
-
 class PlaceMarketOrderParams(SignatureParams):
     """
     Class for defining the parameters needed to place a market order.
@@ -190,43 +166,33 @@ class LiquidateSubaccountParams(BaseParamsSigned):
         return subaccount_to_bytes32(v)
 
 
-class MintLpParams(BaseParamsSigned):
+class MintNlpParams(BaseParamsSigned):
     """
-    Parameters required for minting a liquidity provider token for a specific product in a subaccount.
+    Parameters required for minting Nado Liquidity Provider (NLP) tokens for a specific product in a subaccount.
 
     Attributes:
-        productId (int): The ID of the product.
-
-        amountBase (int): The amount of base to be consumed by minting LPs multiplied by 1e18.
-
-        quoteAmountLow (int): The minimum amount of quote to be consumed by minting LPs multiplied by 1e18.
-
-        quoteAmountHigh (int): The maximum amount of quote to be consumed by minting LPs multiplied by 1e18.
+        quoteAmount (int): The amount of quote to be consumed by minting NLP multiplied by 1e18.
 
         spot_leverage (Optional[bool]): Indicates whether leverage is to be used. Defaults to True.
         If set to False, the transaction fails if it causes a borrow on the subaccount.
     """
 
-    productId: int
-    amountBase: int
-    quoteAmountLow: int
-    quoteAmountHigh: int
+    quoteAmount: int
     spot_leverage: Optional[bool]
 
 
-class BurnLpParams(BaseParamsSigned):
+class BurnNlpParams(BaseParamsSigned):
     """
-    This class represents the parameters required to burn a liquidity provider
-    token for a specific product in a subaccount.
+    This class represents the parameters required to burn Nado Liquidity Provider (NLP)
+    tokens for a specific subaccount.
 
     Attributes:
         productId (int): The ID of the product.
 
-        amount (int): Combined amount of base + quote to burn multiplied by 1e18.
+        nlpAmount (int): Amount of NLP tokens to burn multiplied by 1e18.
     """
 
-    productId: int
-    amount: int
+    nlpAmount: int
 
 
 class LinkSignerParams(BaseParamsSigned):
@@ -249,13 +215,12 @@ class LinkSignerParams(BaseParamsSigned):
 
 ExecuteParams = Union[
     PlaceOrderParams,
-    PlaceIsolatedOrderParams,
     CancelOrdersParams,
     CancelProductOrdersParams,
     WithdrawCollateralParams,
     LiquidateSubaccountParams,
-    MintLpParams,
-    BurnLpParams,
+    MintNlpParams,
+    BurnNlpParams,
     LinkSignerParams,
     CancelAndPlaceParams,
 ]
@@ -282,33 +247,8 @@ class PlaceOrderRequest(NadoBaseModel):
             raise ValueError("Missing `signature")
         if isinstance(v.order.sender, bytes):
             v.order.serialize_dict(["sender"], bytes32_to_hex)
-        v.order.serialize_dict(["nonce", "priceX18", "amount", "expiration"], str)
-        return v
-
-
-class PlaceIsolatedOrderRequest(NadoBaseModel):
-    """
-    Parameters for a request to place an isolated order.
-
-    Attributes:
-        place_isolated_order (PlaceIsolatedOrderParams): The parameters for the isolated order to be placed.
-
-    Methods:
-        serialize: Validates and serializes the order parameters.
-    """
-
-    place_isolated_order: PlaceIsolatedOrderParams
-
-    @validator("place_isolated_order")
-    def serialize(cls, v: PlaceIsolatedOrderParams) -> PlaceIsolatedOrderParams:
-        if v.isolated_order.nonce is None:
-            raise ValueError("Missing order `nonce`")
-        if v.signature is None:
-            raise ValueError("Missing `signature")
-        if isinstance(v.isolated_order.sender, bytes):
-            v.isolated_order.serialize_dict(["sender"], bytes32_to_hex)
-        v.isolated_order.serialize_dict(
-            ["nonce", "priceX18", "amount", "expiration", "margin"], str
+        v.order.serialize_dict(
+            ["nonce", "priceX18", "amount", "expiration", "appendix"], str
         )
         return v
 
@@ -500,51 +440,50 @@ class LiquidateSubaccountRequest(NadoBaseModel):
     _validator = validator("liquidate_subaccount", allow_reuse=True)(to_tx_request)
 
 
-class MintLpRequest(NadoBaseModel):
+class MintNlpRequest(NadoBaseModel):
     """
-    Parameters for a mint LP request.
+    Parameters for a mint NLP request.
 
     Attributes:
-        mint_lp (MintLpParams): The parameters for minting liquidity.
+        mint_nlp (MintNlpParams): The parameters for minting liquidity.
 
     Methods:
-        serialize: Validates and converts the 'amountBase', 'quoteAmountLow', and 'quoteAmountHigh'
-        attributes of 'mint_lp' to their proper serialized forms.
+        serialize: Validates and converts the 'quoteAmount' attribute of 'mint_nlp' to their proper serialized forms.
 
-        to_tx_request: Validates and converts 'mint_lp' into a transaction request.
+        to_tx_request: Validates and converts 'mint_nlp' into a transaction request.
     """
 
-    mint_lp: MintLpParams
+    mint_nlp: MintNlpParams
 
-    @validator("mint_lp")
-    def serialize(cls, v: MintLpParams) -> MintLpParams:
-        v.serialize_dict(["amountBase", "quoteAmountLow", "quoteAmountHigh"], str)
+    @validator("mint_nlp")
+    def serialize(cls, v: MintNlpParams) -> MintNlpParams:
+        v.serialize_dict(["quoteAmount"], str)
         return v
 
-    _validator = validator("mint_lp", allow_reuse=True)(to_tx_request)
+    _validator = validator("mint_nlp", allow_reuse=True)(to_tx_request)
 
 
-class BurnLpRequest(NadoBaseModel):
+class BurnNlpRequest(NadoBaseModel):
     """
-    Parameters for a burn LP request.
+    Parameters for a burn NLP request.
 
     Attributes:
-        burn_lp (BurnLpParams): The parameters for burning liquidity.
+        burn_nlp (BurnNlpParams): The parameters for burning liquidity.
 
     Methods:
-        serialize: Validates and converts the 'amount' attribute of 'burn_lp' to its proper serialized form.
+        serialize: Validates and converts the 'nlpAmount' attribute of 'burn_nlp' to its proper serialized form.
 
-        to_tx_request: Validates and converts 'burn_lp' into a transaction request.
+        to_tx_request: Validates and converts 'burn_nlp' into a transaction request.
     """
 
-    burn_lp: BurnLpParams
+    burn_nlp: BurnNlpParams
 
-    @validator("burn_lp")
-    def serialize(cls, v: BurnLpParams) -> BurnLpParams:
-        v.serialize_dict(["amount"], str)
+    @validator("burn_nlp")
+    def serialize(cls, v: BurnNlpParams) -> BurnNlpParams:
+        v.serialize_dict(["nlpAmount"], str)
         return v
 
-    _validator = validator("burn_lp", allow_reuse=True)(to_tx_request)
+    _validator = validator("burn_nlp", allow_reuse=True)(to_tx_request)
 
 
 class LinkSignerRequest(NadoBaseModel):
@@ -572,14 +511,13 @@ class LinkSignerRequest(NadoBaseModel):
 
 ExecuteRequest = Union[
     PlaceOrderRequest,
-    PlaceIsolatedOrderRequest,
     CancelOrdersRequest,
     CancelProductOrdersRequest,
     CancelAndPlaceRequest,
     WithdrawCollateralRequest,
     LiquidateSubaccountRequest,
-    MintLpRequest,
-    BurnLpRequest,
+    MintNlpRequest,
+    BurnNlpRequest,
     LinkSignerRequest,
 ]
 
@@ -647,10 +585,6 @@ def to_execute_request(params: ExecuteParams) -> ExecuteRequest:
     """
     execute_request_mapping = {
         PlaceOrderParams: (PlaceOrderRequest, NadoExecuteType.PLACE_ORDER.value),
-        PlaceIsolatedOrderParams: (
-            PlaceIsolatedOrderRequest,
-            NadoExecuteType.PLACE_ISOLATED_ORDER.value,
-        ),
         CancelOrdersParams: (
             CancelOrdersRequest,
             NadoExecuteType.CANCEL_ORDERS.value,
@@ -667,8 +601,8 @@ def to_execute_request(params: ExecuteParams) -> ExecuteRequest:
             LiquidateSubaccountRequest,
             NadoExecuteType.LIQUIDATE_SUBACCOUNT.value,
         ),
-        MintLpParams: (MintLpRequest, NadoExecuteType.MINT_LP.value),
-        BurnLpParams: (BurnLpRequest, NadoExecuteType.BURN_LP.value),
+        MintNlpParams: (MintNlpRequest, NadoExecuteType.MINT_NLP.value),
+        BurnNlpParams: (BurnNlpRequest, NadoExecuteType.BURN_NLP.value),
         LinkSignerParams: (LinkSignerRequest, NadoExecuteType.LINK_SIGNER.value),
         CancelAndPlaceParams: (
             CancelAndPlaceRequest,