Skip to content

Exchange

Signed exchange-action client.

http

Source code in pkg/src/hyperliquid/exchange/core/mixin.py 
113
114
115
116
117
118
@classmethod
def http(cls, wallet: LocalAccount, *, mainnet: bool = True, validate: bool = True, http: HttpClient | None = None):
  domain = HYPERLIQUID_MAINNET if mainnet else HYPERLIQUID_TESTNET
  http = http or HttpClient()
  client = ExchangeHttpClient(domain=domain, validate=validate, http=http)
  return cls(client=client, wallet=wallet, mainnet=mainnet, validate=validate)

ws_of

Source code in pkg/src/hyperliquid/exchange/core/mixin.py 
121
122
123
124
@classmethod
def ws_of(cls, wallet: LocalAccount, *, ws: SocketClient, mainnet: bool = True, validate: bool = True):
  client = ExchangeSocketClient(ws=ws, validate=validate)
  return cls(client=client, wallet=wallet, mainnet=mainnet, validate=validate)

ws

Source code in pkg/src/hyperliquid/exchange/core/mixin.py 
126
127
128
129
130
@classmethod
def ws(cls, wallet: LocalAccount, *, mainnet: bool = True, validate: bool = True, timeout: timedelta = timedelta(seconds=10)):
  domain = HYPERLIQUID_MAINNET if mainnet else HYPERLIQUID_TESTNET
  ws = SocketClient(url=f'wss://{domain}/ws', timeout=timeout)
  return cls.ws_of(wallet=wallet, ws=ws, mainnet=mainnet, validate=validate)

agent_enable_dex_abstraction

Enable HIP-3 DEX abstraction (agent, deprecated).

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/agent_enable_dex_abstraction.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
async def agent_enable_dex_abstraction(self) -> ExchangeResponse[DefaultResponse]:
  """Enable HIP-3 DEX abstraction (agent, deprecated).

  > [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

agent_set_abstraction

Set user abstraction (agent).

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/agent_set_abstraction.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
async def agent_set_abstraction(self, abstraction: AgentAbstraction) -> ExchangeResponse[DefaultResponse]:
  """Set user abstraction (agent).

  > [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

approve_agent

Approve an API wallet (agent).

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/approve_agent.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
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).

  > [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

approve_builder_fee

Approve a maximum builder fee rate.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/approve_builder_fee.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
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.

  > [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

cancel

Cancel one or more orders.

  • cancels: Cancel wire objects with asset + order id.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/cancel.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
async def cancel(
  self, *cancels: Cancel,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[CancelResponse]:
  """Cancel one or more orders.

  - `cancels`: Cancel wire objects with asset + order id.

  > [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

cancel_by_cloid

Cancel one or more orders by cloid.

  • cancels: Cancel wire objects with asset + cloid.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/cancel_by_cloid.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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.

  - `cancels`: Cancel wire objects with asset + cloid.

  > [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

modify_order

Modify a single order.

  • oid: Order id or cloid.
  • order: Order wire object.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/modify_order.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
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.

  - `oid`: Order id or cloid.
  - `order`: Order wire object.

  > [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

modify_orders

Modify multiple orders.

  • modifies: Modify wire objects.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/modify_orders.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
async def modify_orders(
  self, *modifies: Modify,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Modify multiple orders.

  - `modifies`: Modify wire objects.

  > [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

noop

Invalidate a pending nonce (noop).

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/noop.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
async def noop(self, *, expires_after: int | None = None) -> ExchangeResponse[DefaultResponse]:
  """Invalidate a pending nonce (noop).

  > [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

order

Source code in pkg/src/hyperliquid/exchange/order.py 
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
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]:
  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

reserve_request_weight

Reserve additional actions.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/reserve_request_weight.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
async def reserve_request_weight(
  self, *, weight: int,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Reserve additional actions.

  > [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

schedule_cancel

Schedule a cancel-all operation.

  • time: UTC millis when all open orders should be canceled. If None, removes the scheduled cancel operation.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/schedule_cancel.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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.

  - `time`: UTC millis when all open orders should be canceled. If `None`,
    removes the scheduled cancel operation.

  > [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

send_asset

Send assets between DEXs, spot, users, or subaccounts.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/send_asset.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
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.

  > [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

send_to_evm_with_data

Send to EVM with data payload.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/send_to_evm_with_data.py 
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
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.

  > [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

spot_transfer

Core spot transfer.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/spot_transfer.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
async def spot_transfer(
  self, *, destination: str, token: str, amount: str,
  signature_chain_id: str,
  time: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Core spot transfer.

  > [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

staking_deposit

Deposit native token into staking.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/staking_deposit.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
async def staking_deposit(
  self, *, wei: int,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Deposit native token into staking.

  > [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

staking_withdraw

Withdraw native token from staking.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/staking_withdraw.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
async def staking_withdraw(
  self, *, wei: int,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Withdraw native token from staking.

  > [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

token_delegate

Delegate or undelegate stake to a validator.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/token_delegate.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
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.

  > [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

twap_cancel

Cancel a TWAP order.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/twap_cancel.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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.

  > [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

twap_order

Place a TWAP order.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/twap_order.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
async def twap_order(
  self, twap: TwapWire,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[TwapOrderResponse]:
  """Place a TWAP order.

  > [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

update_isolated_margin

Add or remove margin from an isolated position.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/update_isolated_margin.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
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.

  > [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

top_up_isolated_only_margin

Target leverage for isolated margin with an alternate action.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/update_isolated_margin.py 
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
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.

  > [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

update_leverage

Update cross or isolated leverage.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/update_leverage.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
async def update_leverage(
  self, *, asset: int, is_cross: bool, leverage: int,
  vault_address: str | None = None,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Update cross or isolated leverage.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#update-leverage)
  """
  action: UpdateLeverageAction = {
    'type': 'updateLeverage',
    'asset': asset,
    'isCross': is_cross,
    '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

usd_class_transfer

Transfer USDC between spot and perp accounts.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/usd_class_transfer.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
async def usd_class_transfer(
  self, *, amount: str, to_perp: bool,
  signature_chain_id: str,
  subaccount: str | None = None,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Transfer USDC between spot and perp accounts.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#transfer-from-spot-account-to-perp-account-and-vice-versa)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: UsdClassTransferAction = {
    'type': 'usdClassTransfer',
    'signatureChainId': signature_chain_id,
    'amount': amount,
    'toPerp': to_perp,
    'nonce': ts,
  }
  if subaccount is not None:
    action['subaccount'] = subaccount
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'amount', 'type': 'string'},
      {'name': 'toPerp', 'type': 'bool'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:UsdClassTransfer',
    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

usdc_transfer

Core USDC transfer.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/usdc_transfer.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
async def usdc_transfer(
  self, *, destination: str, amount: str,
  signature_chain_id: str,
  time: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Core USDC transfer.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#core-usdc-transfer)
  """
  ts = timestamp.now()
  action: UsdSendAction = {
    'type': 'usdSend',
    'signatureChainId': signature_chain_id,
    'destination': destination,
    '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': 'amount', 'type': 'string'},
      {'name': 'time', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:UsdSend',
    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

user_dex_abstraction

Enable HIP-3 DEX abstraction (deprecated).

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/user_dex_abstraction.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
async def user_dex_abstraction(
  self, *, user: str, enabled: bool,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Enable HIP-3 DEX abstraction (deprecated).

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#enable-hip-3-dex-abstraction)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: UserDexAbstractionAction = {
    'type': 'userDexAbstraction',
    'signatureChainId': signature_chain_id,
    'user': user,
    'enabled': enabled,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'user', 'type': 'address'},
      {'name': 'enabled', 'type': 'bool'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:UserDexAbstraction',
    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

user_set_abstraction

Set user abstraction.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/user_set_abstraction.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
async def user_set_abstraction(
  self, *, user: str, abstraction: Abstraction,
  signature_chain_id: str,
  nonce: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Set user abstraction.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#set-user-abstraction)
  """
  ts = timestamp.now() if nonce is None else nonce
  action: UserSetAbstractionAction = {
    'type': 'userSetAbstraction',
    'signatureChainId': signature_chain_id,
    'user': user,
    'abstraction': abstraction,
    'nonce': ts,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'user', 'type': 'address'},
      {'name': 'abstraction', 'type': 'string'},
      {'name': 'nonce', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:UserSetAbstraction',
    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

validator_l1_stream

Vote on risk-free rate for aligned quote asset.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/validator_l1_stream.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
async def validator_l1_stream(self, risk_free_rate: str) -> ExchangeResponse[DefaultResponse]:
  """Vote on risk-free rate for aligned quote asset.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#validator-vote-on-risk-free-rate-for-aligned-quote-asset)
  """
  action: ValidatorL1StreamAction = {
    'type': 'validatorL1Stream',
    'riskFreeRate': risk_free_rate,
  }
  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

vault_transfer

Deposit or withdraw from a vault.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/vault_transfer.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
async def vault_transfer(
  self, *, vault_address: str, is_deposit: bool, usd: float,
  expires_after: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Deposit or withdraw from a vault.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#deposit-or-withdraw-from-a-vault)
  """
  action: VaultTransferAction = {
    'type': 'vaultTransfer',
    'vaultAddress': vault_address,
    'isDeposit': is_deposit,
    'usd': usd,
  }
  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

withdraw3

Initiate a withdrawal request.

Hyperliquid API docs

Source code in pkg/src/hyperliquid/exchange/withdraw3.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
async def withdraw3(
  self, *, amount: str, destination: str,
  signature_chain_id: str,
  time: int | None = None,
) -> ExchangeResponse[DefaultResponse]:
  """Initiate a withdrawal request.

  > [Hyperliquid API docs](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/exchange-endpoint#initiate-a-withdrawal-request)
  """
  ts = timestamp.now()
  action: Withdraw3Action = {
    'type': 'withdraw3',
    'signatureChainId': signature_chain_id,
    'amount': amount,
    'time': ts if time is None else time,
    'destination': destination,
  }
  sig = sign_user_signed_action(
    action,
    wallet=self.wallet,
    payload_types=[
      {'name': 'hyperliquidChain', 'type': 'string'},
      {'name': 'destination', 'type': 'string'},
      {'name': 'amount', 'type': 'string'},
      {'name': 'time', 'type': 'uint64'},
    ],
    primary_type='HyperliquidTransaction:Withdraw',
    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