Exchange

async def agent_enable_dex_abstraction(self) -> ExchangeResponse[DefaultResponse]:
  """Enable HIP-3 DEX abstraction (agent, deprecated).

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#enable-hip-3-dex-abstraction-agent)
  """
  action: AgentEnableDexAbstractionAction = {'type': 'agentEnableDexAbstraction'}
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def agent_set_abstraction(self, abstraction: AgentAbstraction) -> ExchangeResponse[DefaultResponse]:
  """Set user abstraction (agent).

  Args:
    abstraction: Agent abstraction mode to set.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#set-user-abstraction-agent)
  """
  action: AgentSetAbstractionAction = {
    'type': 'agentSetAbstraction',
    'abstraction': abstraction,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def approve_agent(
  self, *, agent_address: str,
  signature_chain_id: str,
  agent_name: str | None = None,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Approve an API wallet (agent).

  Args:
    agent_address: API wallet address to approve.
    signature_chain_id: Chain id used for the user-signed action.
    agent_name: Optional display name for the API wallet.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-an-api-wallet)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: ApproveAgentAction = {
    'type': 'approveAgent',
    'signatureChainId': signature_chain_id,
    'agentAddress': agent_address,
    'nonce': ts,
  }
  if agent_name is not None:
    action['agentName'] = agent_name
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'agentAddress', 'type': 'address'},
      {'name': 'agentName', 'type': 'string'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:ApproveAgent',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def approve_builder_fee(
  self, *, max_fee_rate: str, builder: str,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Approve a maximum builder fee rate.

  Args:
    max_fee_rate: Maximum fee rate to approve.
    builder: Builder address.
    signature_chain_id: Chain id used for the user-signed action.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#approve-a-builder-fee)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: ApproveBuilderFeeAction = {
    'type': 'approveBuilderFee',
    'signatureChainId': signature_chain_id,
    'maxFeeRate': max_fee_rate,
    'builder': builder,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'maxFeeRate', 'type': 'string'},
      {'name': 'builder', 'type': 'address'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:ApproveBuilderFee',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def cancel(
  self, *cancels: Cancel,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[CancelResponse]:
  """Cancel one or more orders.

  Args:
    cancels: Cancel wire objects with asset + order id.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s)
  """
  action = {
    'type': 'cancel',
    'cancels': cancels,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def cancel_by_cloid(
  self, *cancels: CancelByCloid,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[CancelByCloidResponse]:
  """Cancel one or more orders by cloid.

  Args:
    cancels: Cancel wire objects with asset + cloid.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-order-s-by-cloid)
  """
  action = {
    'type': 'cancelByCloid',
    'cancels': cancels,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def modify_order(
  self, oid: int | str, order: Order,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Modify a single order.

  Args:
    oid: Order id or cloid.
    order: Order wire object.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-an-order)
  """
  action: ModifyOrderAction = {
    'type': 'modify',
    'oid': oid,
    'order': order,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def modify_orders(
  self, *modifies: Modify,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Modify multiple orders.

  Args:
    modifies: Modify wire objects.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#modify-multiple-orders)
  """
  action: BatchModifyAction = {
    'type': 'batchModify',
    'modifies': list(modifies),
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def noop(self, *, expires_after: int | None = None) -> ExchangeResponse[DefaultResponse]:
  """Invalidate a pending nonce (noop).

  Args:
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#invalidate-pending-nonce-noop)
  """
  action: NoopAction = {'type': 'noop'}
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=None,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def order(
  self, *orders: Order, grouping: Grouping = 'na',
  builder: BuilderInfo | None = None,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[OrderResponse]:
  """Place one or more orders.

  Args:
    orders: Order wire objects.
    grouping: Grouping mode for normal or TPSL orders.
    builder: Optional builder fee information.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-an-order)
  """
  action = {
    'type': 'order',
    'orders': [reorder(order) for order in orders],
    'grouping': grouping,
  }
  if builder:
    action['builder'] = builder
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def reserve_request_weight(
  self, *, weight: int,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Reserve additional actions.

  Args:
    weight: Additional request weight to reserve.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#reserve-additional-actions)
  """
  action: ReserveRequestWeightAction = {
    'type': 'reserveRequestWeight',
    'weight': weight,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=None,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def schedule_cancel(
  self, time: int | None = None,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Schedule a cancel-all operation.

  Args:
    time: UTC millis when all open orders should be canceled. If `None`,
      removes the scheduled cancel operation.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#schedule-cancel-dead-man-s-switch)
  """
  action: ScheduleCancelAction = {'type': 'scheduleCancel'}
  if time is not None:
    action['time'] = time
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def send_asset(
  self, *, destination: str, source_dex: str, destination_dex: str,
  token: str, amount: str, from_subaccount: str,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Send assets between DEXs, spot, users, or subaccounts.

  Args:
    destination: Destination user, subaccount, spot account, or DEX address.
    source_dex: Source DEX name. Use an empty string for the main DEX.
    destination_dex: Destination DEX name. Use an empty string for the main DEX.
    token: Token symbol or token id to send.
    amount: Decimal amount string.
    from_subaccount: Source subaccount name, or empty string for the main account.
    signature_chain_id: Chain id used for the user-signed action.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#send-asset)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: SendAssetAction = {
    'type': 'sendAsset',
    'signatureChainId': signature_chain_id,
    'destination': destination,
    'sourceDex': source_dex,
    'destinationDex': destination_dex,
    'token': token,
    'amount': amount,
    'fromSubAccount': from_subaccount,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'destination', 'type': 'string'},
      {'name': 'sourceDex', 'type': 'string'},
      {'name': 'destinationDex', 'type': 'string'},
      {'name': 'token', 'type': 'string'},
      {'name': 'amount', 'type': 'string'},
      {'name': 'fromSubAccount', 'type': 'string'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:SendAsset',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def send_to_evm_with_data(
  self, *, token: str, amount: str, source_dex: str,
  destination_recipient: str, address_encoding: Literal['hex', 'base58'],
  destination_chain_id: int, gas_limit: int, data: str,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Send to EVM with data payload.

  Args:
    token: Token symbol or token id to send.
    amount: Decimal amount string.
    source_dex: Source DEX name. Use an empty string for the main DEX.
    destination_recipient: Recipient on the destination EVM chain.
    address_encoding: Encoding used for the destination recipient.
    destination_chain_id: Destination EVM chain id.
    gas_limit: Gas limit for the destination call.
    data: Hex-encoded calldata.
    signature_chain_id: Chain id used for the user-signed action.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#send-to-evm-with-data)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: SendToEvmWithDataAction = {
    'type': 'sendToEvmWithData',
    'signatureChainId': signature_chain_id,
    'token': token,
    'amount': amount,
    'sourceDex': source_dex,
    'destinationRecipient': destination_recipient,
    'addressEncoding': address_encoding,
    'destinationChainId': destination_chain_id,
    'gasLimit': gas_limit,
    'data': data,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'token', 'type': 'string'},
      {'name': 'amount', 'type': 'string'},
      {'name': 'sourceDex', 'type': 'string'},
      {'name': 'destinationRecipient', 'type': 'string'},
      {'name': 'addressEncoding', 'type': 'string'},
      {'name': 'destinationChainId', 'type': 'uint64'},
      {'name': 'gasLimit', 'type': 'uint64'},
      {'name': 'data', 'type': 'bytes'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:SendToEvmWithData',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def spot_transfer(
  self, *, destination: str, token: str, amount: str,
  signature_chain_id: str,
  time: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Core spot transfer.

  Args:
    destination: Destination address.
    token: Spot token to transfer.
    amount: Decimal amount string.
    signature_chain_id: Chain id used for the user-signed action.
    time: Optional action timestamp. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#core-spot-transfer)
  """
  ts = timestamp.now()
  action: SpotSendAction = {
    'type': 'spotSend',
    'signatureChainId': signature_chain_id,
    'destination': destination,
    'token': token,
    'amount': amount,
    'time': ts if time is None else time,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'destination', 'type': 'string'},
      {'name': 'token', 'type': 'string'},
      {'name': 'amount', 'type': 'string'},
      {'name': 'time', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:SpotSend',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def staking_deposit(
  self, *, wei: int,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Deposit native token into staking.

  Args:
    wei: Amount to deposit in wei.
    signature_chain_id: Chain id used for the user-signed action.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#deposit-into-staking)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: CDepositAction = {
    'type': 'cDeposit',
    'signatureChainId': signature_chain_id,
    'wei': wei,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'wei', 'type': 'uint64'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:Deposit',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def staking_withdraw(
  self, *, wei: int,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Withdraw native token from staking.

  Args:
    wei: Amount to withdraw in wei.
    signature_chain_id: Chain id used for the user-signed action.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#withdraw-from-staking)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: CWithdrawAction = {
    'type': 'cWithdraw',
    'signatureChainId': signature_chain_id,
    'wei': wei,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'wei', 'type': 'uint64'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:WithdrawFromStaking',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def token_delegate(
  self, *, validator: str, is_undelegate: bool, wei: int,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Delegate or undelegate stake to a validator.

  Args:
    validator: Validator address.
    is_undelegate: Whether to undelegate instead of delegate.
    wei: Stake amount in wei.
    signature_chain_id: Chain id used for the user-signed action.
    nonce: Optional action nonce. Defaults to the current timestamp.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#delegate-or-undelegate-stake-from-validator)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: TokenDelegateAction = {
    'type': 'tokenDelegate',
    'signatureChainId': signature_chain_id,
    'validator': validator,
    'isUndelegate': is_undelegate,
    'wei': wei,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'validator', 'type': 'address'},
      {'name': 'wei', 'type': 'uint64'},
      {'name': 'isUndelegate', 'type': 'bool'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:TokenDelegate',
    mainnet=self.mainnet,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': None,
    'expiresAfter': None,
  })
  return adapter.validate_python(result) if self.validate else result

async def twap_cancel(
  self, *, asset: int, twap_id: int,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[TwapCancelResponse]:
  """Cancel a TWAP order.

  Args:
    asset: Asset index.
    twap_id: TWAP order id.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#cancel-a-twap-order)
  """
  action: TwapCancelAction = {
    'type': 'twapCancel',
    'a': asset,
    't': twap_id,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def twap_order(
  self, twap: TwapWire,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[TwapOrderResponse]:
  """Place a TWAP order.

  Args:
    twap: TWAP order wire object.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#place-a-twap-order)
  """
  action: TwapOrderAction = {
    'type': 'twapOrder',
    'twap': twap,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def update_isolated_margin(
  self, *, asset: int, is_buy: bool, ntli: int,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Add or remove margin from an isolated position.

  Args:
    asset: Asset index.
    is_buy: Position side; true for long, false for short.
    ntli: Margin delta in native token lots.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-isolated-margin)
  """
  action: UpdateIsolatedMarginAction = {
    'type': 'updateIsolatedMargin',
    'asset': asset,
    'isBuy': is_buy,
    'ntli': ntli,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result

async def top_up_isolated_only_margin(
  self, *, asset: int, leverage: str,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Target leverage for isolated margin with an alternate action.

  Args:
    asset: Asset index.
    leverage: Target leverage as a decimal string.
    vault_address: Optional vault address for the signed action.
    expires_after: Optional expiration timestamp for the signed action.

  References:
    - [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-isolated-margin)
  """
  action: TopUpIsolatedOnlyMarginAction = {
    'type': 'topUpIsolatedOnlyMargin',
    'asset': asset,
    'leverage': leverage,
  }
  ts = timestamp.now()
  sig = sign_l1_action(
    action,
    wallet=self.wallet,
    nonce=ts,
    mainnet=self.mainnet,
    vault_address=vault_address,
    expires_after=expires_after,
  )
  result = await self.client.request({
    'action': action,
    'nonce': ts,
    'signature': sig,
    'vaultAddress': vault_address,
    'expiresAfter': expires_after,
  })
  return adapter.validate_python(result) if self.validate else result