1119 lines
34 KiB
Python
1119 lines
34 KiB
Python
import json
|
|
import logging
|
|
import secrets
|
|
|
|
import eth_account
|
|
from eth_account.signers.local import LocalAccount
|
|
|
|
from hyperliquid.api import API
|
|
from hyperliquid.info import Info
|
|
from hyperliquid.utils.constants import MAINNET_API_URL
|
|
from hyperliquid.utils.signing import (
|
|
CancelByCloidRequest,
|
|
CancelRequest,
|
|
ModifyRequest,
|
|
OidOrCloid,
|
|
OrderRequest,
|
|
OrderType,
|
|
OrderWire,
|
|
ScheduleCancelAction,
|
|
float_to_usd_int,
|
|
get_timestamp_ms,
|
|
order_request_to_order_wire,
|
|
order_wires_to_order_action,
|
|
sign_agent,
|
|
sign_approve_builder_fee,
|
|
sign_convert_to_multi_sig_user_action,
|
|
sign_l1_action,
|
|
sign_multi_sig_action,
|
|
sign_perp_dex_class_transfer_action,
|
|
sign_spot_transfer_action,
|
|
sign_token_delegate_action,
|
|
sign_usd_class_transfer_action,
|
|
sign_usd_transfer_action,
|
|
sign_withdraw_from_bridge_action,
|
|
)
|
|
from hyperliquid.utils.types import (
|
|
Any,
|
|
BuilderInfo,
|
|
Cloid,
|
|
Dict,
|
|
List,
|
|
Meta,
|
|
Optional,
|
|
PerpDexSchemaInput,
|
|
SpotMeta,
|
|
Tuple,
|
|
)
|
|
|
|
|
|
class Exchange(API):
|
|
# Default Max Slippage for Market Orders 5%
|
|
DEFAULT_SLIPPAGE = 0.05
|
|
|
|
def __init__(
|
|
self,
|
|
wallet: LocalAccount,
|
|
base_url: Optional[str] = None,
|
|
meta: Optional[Meta] = None,
|
|
vault_address: Optional[str] = None,
|
|
account_address: Optional[str] = None,
|
|
spot_meta: Optional[SpotMeta] = None,
|
|
perp_dexs: Optional[List[str]] = None,
|
|
):
|
|
super().__init__(base_url)
|
|
self.wallet = wallet
|
|
self.vault_address = vault_address
|
|
self.account_address = account_address
|
|
self.info = Info(base_url, True, meta, spot_meta, perp_dexs)
|
|
self.expires_after: Optional[int] = None
|
|
|
|
def _post_action(self, action, signature, nonce):
|
|
payload = {
|
|
"action": action,
|
|
"nonce": nonce,
|
|
"signature": signature,
|
|
"vaultAddress": self.vault_address if action["type"] != "usdClassTransfer" else None,
|
|
"expiresAfter": self.expires_after,
|
|
}
|
|
logging.debug(payload)
|
|
return self.post("/exchange", payload)
|
|
|
|
def _slippage_price(
|
|
self,
|
|
name: str,
|
|
is_buy: bool,
|
|
slippage: float,
|
|
px: Optional[float] = None,
|
|
) -> float:
|
|
coin = self.info.name_to_coin[name]
|
|
if not px:
|
|
# Get midprice
|
|
px = float(self.info.all_mids()[coin])
|
|
|
|
asset = self.info.coin_to_asset[coin]
|
|
# spot assets start at 10000
|
|
is_spot = asset >= 10_000
|
|
|
|
# Calculate Slippage
|
|
px *= (1 + slippage) if is_buy else (1 - slippage)
|
|
# We round px to 5 significant figures and 6 decimals for perps, 8 decimals for spot
|
|
return round(float(f"{px:.5g}"), (6 if not is_spot else 8) - self.info.asset_to_sz_decimals[asset])
|
|
|
|
# expires_after will cause actions to be rejected after that timestamp in milliseconds
|
|
# expires_after is not supported on user_signed actions (e.g. usd_transfer) and must be None in order for those
|
|
# actions to work.
|
|
def set_expires_after(self, expires_after: Optional[int]) -> None:
|
|
self.expires_after = expires_after
|
|
|
|
def order(
|
|
self,
|
|
name: str,
|
|
is_buy: bool,
|
|
sz: float,
|
|
limit_px: float,
|
|
order_type: OrderType,
|
|
reduce_only: bool = False,
|
|
cloid: Optional[Cloid] = None,
|
|
builder: Optional[BuilderInfo] = None,
|
|
) -> Any:
|
|
order: OrderRequest = {
|
|
"coin": name,
|
|
"is_buy": is_buy,
|
|
"sz": sz,
|
|
"limit_px": limit_px,
|
|
"order_type": order_type,
|
|
"reduce_only": reduce_only,
|
|
}
|
|
if cloid:
|
|
order["cloid"] = cloid
|
|
return self.bulk_orders([order], builder)
|
|
|
|
def bulk_orders(self, order_requests: List[OrderRequest], builder: Optional[BuilderInfo] = None) -> Any:
|
|
order_wires: List[OrderWire] = [
|
|
order_request_to_order_wire(order, self.info.name_to_asset(order["coin"])) for order in order_requests
|
|
]
|
|
timestamp = get_timestamp_ms()
|
|
|
|
if builder:
|
|
builder["b"] = builder["b"].lower()
|
|
order_action = order_wires_to_order_action(order_wires, builder)
|
|
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
order_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
|
|
return self._post_action(
|
|
order_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def modify_order(
|
|
self,
|
|
oid: OidOrCloid,
|
|
name: str,
|
|
is_buy: bool,
|
|
sz: float,
|
|
limit_px: float,
|
|
order_type: OrderType,
|
|
reduce_only: bool = False,
|
|
cloid: Optional[Cloid] = None,
|
|
) -> Any:
|
|
modify: ModifyRequest = {
|
|
"oid": oid,
|
|
"order": {
|
|
"coin": name,
|
|
"is_buy": is_buy,
|
|
"sz": sz,
|
|
"limit_px": limit_px,
|
|
"order_type": order_type,
|
|
"reduce_only": reduce_only,
|
|
"cloid": cloid,
|
|
},
|
|
}
|
|
return self.bulk_modify_orders_new([modify])
|
|
|
|
def bulk_modify_orders_new(self, modify_requests: List[ModifyRequest]) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
modify_wires = [
|
|
{
|
|
"oid": modify["oid"].to_raw() if isinstance(modify["oid"], Cloid) else modify["oid"],
|
|
"order": order_request_to_order_wire(modify["order"], self.info.name_to_asset(modify["order"]["coin"])),
|
|
}
|
|
for modify in modify_requests
|
|
]
|
|
|
|
modify_action = {
|
|
"type": "batchModify",
|
|
"modifies": modify_wires,
|
|
}
|
|
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
modify_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
|
|
return self._post_action(
|
|
modify_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def market_open(
|
|
self,
|
|
name: str,
|
|
is_buy: bool,
|
|
sz: float,
|
|
px: Optional[float] = None,
|
|
slippage: float = DEFAULT_SLIPPAGE,
|
|
cloid: Optional[Cloid] = None,
|
|
builder: Optional[BuilderInfo] = None,
|
|
) -> Any:
|
|
# Get aggressive Market Price
|
|
px = self._slippage_price(name, is_buy, slippage, px)
|
|
# Market Order is an aggressive Limit Order IoC
|
|
return self.order(
|
|
name, is_buy, sz, px, order_type={"limit": {"tif": "Ioc"}}, reduce_only=False, cloid=cloid, builder=builder
|
|
)
|
|
|
|
def market_close(
|
|
self,
|
|
coin: str,
|
|
sz: Optional[float] = None,
|
|
px: Optional[float] = None,
|
|
slippage: float = DEFAULT_SLIPPAGE,
|
|
cloid: Optional[Cloid] = None,
|
|
builder: Optional[BuilderInfo] = None,
|
|
) -> Any:
|
|
address: str = self.wallet.address
|
|
if self.account_address:
|
|
address = self.account_address
|
|
if self.vault_address:
|
|
address = self.vault_address
|
|
positions = self.info.user_state(address)["assetPositions"]
|
|
for position in positions:
|
|
item = position["position"]
|
|
if coin != item["coin"]:
|
|
continue
|
|
szi = float(item["szi"])
|
|
if not sz:
|
|
sz = abs(szi)
|
|
is_buy = True if szi < 0 else False
|
|
# Get aggressive Market Price
|
|
px = self._slippage_price(coin, is_buy, slippage, px)
|
|
# Market Order is an aggressive Limit Order IoC
|
|
return self.order(
|
|
coin,
|
|
is_buy,
|
|
sz,
|
|
px,
|
|
order_type={"limit": {"tif": "Ioc"}},
|
|
reduce_only=True,
|
|
cloid=cloid,
|
|
builder=builder,
|
|
)
|
|
|
|
def cancel(self, name: str, oid: int) -> Any:
|
|
return self.bulk_cancel([{"coin": name, "oid": oid}])
|
|
|
|
def cancel_by_cloid(self, name: str, cloid: Cloid) -> Any:
|
|
return self.bulk_cancel_by_cloid([{"coin": name, "cloid": cloid}])
|
|
|
|
def bulk_cancel(self, cancel_requests: List[CancelRequest]) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
cancel_action = {
|
|
"type": "cancel",
|
|
"cancels": [
|
|
{
|
|
"a": self.info.name_to_asset(cancel["coin"]),
|
|
"o": cancel["oid"],
|
|
}
|
|
for cancel in cancel_requests
|
|
],
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
cancel_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
|
|
return self._post_action(
|
|
cancel_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def bulk_cancel_by_cloid(self, cancel_requests: List[CancelByCloidRequest]) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
|
|
cancel_action = {
|
|
"type": "cancelByCloid",
|
|
"cancels": [
|
|
{
|
|
"asset": self.info.name_to_asset(cancel["coin"]),
|
|
"cloid": cancel["cloid"].to_raw(),
|
|
}
|
|
for cancel in cancel_requests
|
|
],
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
cancel_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
|
|
return self._post_action(
|
|
cancel_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def schedule_cancel(self, time: Optional[int]) -> Any:
|
|
"""Schedules a time (in UTC millis) to cancel all open orders. The time must be at least 5 seconds after the current time.
|
|
Once the time comes, all open orders will be canceled and a trigger count will be incremented. The max number of triggers
|
|
per day is 10. This trigger count is reset at 00:00 UTC.
|
|
|
|
Args:
|
|
time (int): if time is not None, then set the cancel time in the future. If None, then unsets any cancel time in the future.
|
|
"""
|
|
timestamp = get_timestamp_ms()
|
|
schedule_cancel_action: ScheduleCancelAction = {
|
|
"type": "scheduleCancel",
|
|
}
|
|
if time is not None:
|
|
schedule_cancel_action["time"] = time
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
schedule_cancel_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
schedule_cancel_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def update_leverage(self, leverage: int, name: str, is_cross: bool = True) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
update_leverage_action = {
|
|
"type": "updateLeverage",
|
|
"asset": self.info.name_to_asset(name),
|
|
"isCross": is_cross,
|
|
"leverage": leverage,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
update_leverage_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
update_leverage_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def update_isolated_margin(self, amount: float, name: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
amount = float_to_usd_int(amount)
|
|
update_isolated_margin_action = {
|
|
"type": "updateIsolatedMargin",
|
|
"asset": self.info.name_to_asset(name),
|
|
"isBuy": True,
|
|
"ntli": amount,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
update_isolated_margin_action,
|
|
self.vault_address,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
update_isolated_margin_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def set_referrer(self, code: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
set_referrer_action = {
|
|
"type": "setReferrer",
|
|
"code": code,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
set_referrer_action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
set_referrer_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def create_sub_account(self, name: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
create_sub_account_action = {
|
|
"type": "createSubAccount",
|
|
"name": name,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
create_sub_account_action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
create_sub_account_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def usd_class_transfer(self, amount: float, to_perp: bool) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
str_amount = str(amount)
|
|
if self.vault_address:
|
|
str_amount += f" subaccount:{self.vault_address}"
|
|
|
|
action = {
|
|
"type": "usdClassTransfer",
|
|
"amount": str_amount,
|
|
"toPerp": to_perp,
|
|
"nonce": timestamp,
|
|
}
|
|
signature = sign_usd_class_transfer_action(self.wallet, action, self.base_url == MAINNET_API_URL)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def perp_dex_class_transfer(self, dex: str, token: str, amount: float, to_perp: bool) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
str_amount = str(amount)
|
|
if self.vault_address:
|
|
str_amount += f" subaccount:{self.vault_address}"
|
|
|
|
action = {
|
|
"type": "PerpDexClassTransfer",
|
|
"dex": dex,
|
|
"token": token,
|
|
"amount": str_amount,
|
|
"toPerp": to_perp,
|
|
"nonce": timestamp,
|
|
}
|
|
signature = sign_perp_dex_class_transfer_action(self.wallet, action, self.base_url == MAINNET_API_URL)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def sub_account_transfer(self, sub_account_user: str, is_deposit: bool, usd: int) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
sub_account_transfer_action = {
|
|
"type": "subAccountTransfer",
|
|
"subAccountUser": sub_account_user,
|
|
"isDeposit": is_deposit,
|
|
"usd": usd,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
sub_account_transfer_action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
sub_account_transfer_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def sub_account_spot_transfer(self, sub_account_user: str, is_deposit: bool, token: str, amount: float) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
sub_account_transfer_action = {
|
|
"type": "subAccountSpotTransfer",
|
|
"subAccountUser": sub_account_user,
|
|
"isDeposit": is_deposit,
|
|
"token": token,
|
|
"amount": str(amount),
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
sub_account_transfer_action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
sub_account_transfer_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def vault_usd_transfer(self, vault_address: str, is_deposit: bool, usd: int) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
vault_transfer_action = {
|
|
"type": "vaultTransfer",
|
|
"vaultAddress": vault_address,
|
|
"isDeposit": is_deposit,
|
|
"usd": usd,
|
|
}
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
signature = sign_l1_action(self.wallet, vault_transfer_action, None, timestamp, self.expires_after, is_mainnet)
|
|
return self._post_action(
|
|
vault_transfer_action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def usd_transfer(self, amount: float, destination: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {"destination": destination, "amount": str(amount), "time": timestamp, "type": "usdSend"}
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
signature = sign_usd_transfer_action(self.wallet, action, is_mainnet)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_transfer(self, amount: float, destination: str, token: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"destination": destination,
|
|
"amount": str(amount),
|
|
"token": token,
|
|
"time": timestamp,
|
|
"type": "spotSend",
|
|
}
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
signature = sign_spot_transfer_action(self.wallet, action, is_mainnet)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def token_delegate(self, validator: str, wei: int, is_undelegate: bool) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"validator": validator,
|
|
"wei": wei,
|
|
"isUndelegate": is_undelegate,
|
|
"nonce": timestamp,
|
|
"type": "tokenDelegate",
|
|
}
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
signature = sign_token_delegate_action(self.wallet, action, is_mainnet)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def withdraw_from_bridge(self, amount: float, destination: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {"destination": destination, "amount": str(amount), "time": timestamp, "type": "withdraw3"}
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
signature = sign_withdraw_from_bridge_action(self.wallet, action, is_mainnet)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def approve_agent(self, name: Optional[str] = None) -> Tuple[Any, str]:
|
|
agent_key = "0x" + secrets.token_hex(32)
|
|
account = eth_account.Account.from_key(agent_key)
|
|
timestamp = get_timestamp_ms()
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
action = {
|
|
"type": "approveAgent",
|
|
"agentAddress": account.address,
|
|
"agentName": name or "",
|
|
"nonce": timestamp,
|
|
}
|
|
signature = sign_agent(self.wallet, action, is_mainnet)
|
|
if name is None:
|
|
del action["agentName"]
|
|
|
|
return (
|
|
self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
),
|
|
agent_key,
|
|
)
|
|
|
|
def approve_builder_fee(self, builder: str, max_fee_rate: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
|
|
action = {"maxFeeRate": max_fee_rate, "builder": builder, "nonce": timestamp, "type": "approveBuilderFee"}
|
|
signature = sign_approve_builder_fee(self.wallet, action, self.base_url == MAINNET_API_URL)
|
|
return self._post_action(action, signature, timestamp)
|
|
|
|
def convert_to_multi_sig_user(self, authorized_users: List[str], threshold: int) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
authorized_users = sorted(authorized_users)
|
|
signers = {
|
|
"authorizedUsers": authorized_users,
|
|
"threshold": threshold,
|
|
}
|
|
action = {
|
|
"type": "convertToMultiSigUser",
|
|
"signers": json.dumps(signers),
|
|
"nonce": timestamp,
|
|
}
|
|
signature = sign_convert_to_multi_sig_user_action(self.wallet, action, self.base_url == MAINNET_API_URL)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_register_token(
|
|
self, token_name: str, sz_decimals: int, wei_decimals: int, max_gas: int, full_name: str
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"registerToken2": {
|
|
"spec": {"name": token_name, "szDecimals": sz_decimals, "weiDecimals": wei_decimals},
|
|
"maxGas": max_gas,
|
|
"fullName": full_name,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_user_genesis(
|
|
self, token: int, user_and_wei: List[Tuple[str, str]], existing_token_and_wei: List[Tuple[int, str]]
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"userGenesis": {
|
|
"token": token,
|
|
"userAndWei": [(user.lower(), wei) for (user, wei) in user_and_wei],
|
|
"existingTokenAndWei": existing_token_and_wei,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_enable_freeze_privilege(self, token: int) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"enableFreezePrivilege": {
|
|
"token": token,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_freeze_user(self, token: int, user: str, freeze: bool) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"freezeUser": {
|
|
"token": token,
|
|
"user": user.lower(),
|
|
"freeze": freeze,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_revoke_freeze_privilege(self, token: int) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"revokeFreezePrivilege": {
|
|
"token": token,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_genesis(self, token: int, max_supply: str, no_hyperliquidity: bool) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
genesis = {
|
|
"token": token,
|
|
"maxSupply": max_supply,
|
|
}
|
|
if no_hyperliquidity:
|
|
genesis["noHyperliquidity"] = True
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"genesis": genesis,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_register_spot(self, base_token: int, quote_token: int) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"registerSpot": {
|
|
"tokens": [base_token, quote_token],
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_register_hyperliquidity(
|
|
self, spot: int, start_px: float, order_sz: float, n_orders: int, n_seeded_levels: Optional[int]
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
register_hyperliquidity = {
|
|
"spot": spot,
|
|
"startPx": str(start_px),
|
|
"orderSz": str(order_sz),
|
|
"nOrders": n_orders,
|
|
}
|
|
if n_seeded_levels is not None:
|
|
register_hyperliquidity["nSeededLevels"] = n_seeded_levels
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"registerHyperliquidity": register_hyperliquidity,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def spot_deploy_set_deployer_trading_fee_share(self, token: int, share: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "spotDeploy",
|
|
"setDeployerTradingFeeShare": {
|
|
"token": token,
|
|
"share": share,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def perp_deploy_register_asset(
|
|
self,
|
|
dex: str,
|
|
max_gas: Optional[int],
|
|
coin: str,
|
|
sz_decimals: int,
|
|
oracle_px: str,
|
|
margin_table_id: int,
|
|
only_isolated: bool,
|
|
schema: Optional[PerpDexSchemaInput],
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
schema_wire = None
|
|
if schema is not None:
|
|
schema_wire = {
|
|
"fullName": schema["fullName"],
|
|
"collateralToken": schema["collateralToken"],
|
|
"oracleUpdater": schema["oracleUpdater"].lower() if schema["oracleUpdater"] is not None else None,
|
|
}
|
|
action = {
|
|
"type": "perpDeploy",
|
|
"registerAsset": {
|
|
"maxGas": max_gas,
|
|
"assetRequest": {
|
|
"coin": coin,
|
|
"szDecimals": sz_decimals,
|
|
"oraclePx": oracle_px,
|
|
"marginTableId": margin_table_id,
|
|
"onlyIsolated": only_isolated,
|
|
},
|
|
"dex": dex,
|
|
"schema": schema_wire,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def perp_deploy_set_oracle(
|
|
self,
|
|
dex: str,
|
|
oracle_pxs: Dict[str, str],
|
|
mark_pxs: Optional[Dict[str, str]],
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
oracle_pxs_wire = sorted(list(oracle_pxs.items()))
|
|
mark_pxs_wire = None
|
|
if mark_pxs is not None:
|
|
mark_pxs_wire = sorted(list(mark_pxs.items()))
|
|
action = {
|
|
"type": "perpDeploy",
|
|
"setOracle": {
|
|
"dex": dex,
|
|
"oraclePxs": oracle_pxs_wire,
|
|
"markPxs": mark_pxs_wire,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def c_signer_unjail_self(self) -> Any:
|
|
return self.c_signer_inner("unjailSelf")
|
|
|
|
def c_signer_jail_self(self) -> Any:
|
|
return self.c_signer_inner("jailSelf")
|
|
|
|
def c_signer_inner(self, variant: str) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "CSignerAction",
|
|
variant: None,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def c_validator_register(
|
|
self,
|
|
node_ip: str,
|
|
name: str,
|
|
description: str,
|
|
delegations_disabled: bool,
|
|
commission_bps: int,
|
|
signer: str,
|
|
unjailed: bool,
|
|
initial_wei: int,
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "CValidatorAction",
|
|
"register": {
|
|
"profile": {
|
|
"node_ip": {"Ip": node_ip},
|
|
"name": name,
|
|
"description": description,
|
|
"delegations_disabled": delegations_disabled,
|
|
"commission_bps": commission_bps,
|
|
"signer": signer,
|
|
},
|
|
"unjailed": unjailed,
|
|
"initial_wei": initial_wei,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def c_validator_change_profile(
|
|
self,
|
|
node_ip: Optional[str],
|
|
name: Optional[str],
|
|
description: Optional[str],
|
|
unjailed: bool,
|
|
disable_delegations: Optional[bool],
|
|
commission_bps: Optional[int],
|
|
signer: Optional[str],
|
|
) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "CValidatorAction",
|
|
"changeProfile": {
|
|
"node_ip": None if node_ip is None else {"Ip": node_ip},
|
|
"name": name,
|
|
"description": description,
|
|
"unjailed": unjailed,
|
|
"disable_delegations": disable_delegations,
|
|
"commission_bps": commission_bps,
|
|
"signer": signer,
|
|
},
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def c_validator_unregister(self) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "CValidatorAction",
|
|
"unregister": None,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|
|
|
|
def multi_sig(self, multi_sig_user, inner_action, signatures, nonce, vault_address=None):
|
|
multi_sig_user = multi_sig_user.lower()
|
|
multi_sig_action = {
|
|
"type": "multiSig",
|
|
"signatureChainId": "0x66eee",
|
|
"signatures": signatures,
|
|
"payload": {
|
|
"multiSigUser": multi_sig_user,
|
|
"outerSigner": self.wallet.address.lower(),
|
|
"action": inner_action,
|
|
},
|
|
}
|
|
is_mainnet = self.base_url == MAINNET_API_URL
|
|
signature = sign_multi_sig_action(
|
|
self.wallet,
|
|
multi_sig_action,
|
|
is_mainnet,
|
|
vault_address,
|
|
nonce,
|
|
self.expires_after,
|
|
)
|
|
return self._post_action(
|
|
multi_sig_action,
|
|
signature,
|
|
nonce,
|
|
)
|
|
|
|
def use_big_blocks(self, enable: bool) -> Any:
|
|
timestamp = get_timestamp_ms()
|
|
action = {
|
|
"type": "evmUserModify",
|
|
"usingBigBlocks": enable,
|
|
}
|
|
signature = sign_l1_action(
|
|
self.wallet,
|
|
action,
|
|
None,
|
|
timestamp,
|
|
self.expires_after,
|
|
self.base_url == MAINNET_API_URL,
|
|
)
|
|
return self._post_action(
|
|
action,
|
|
signature,
|
|
timestamp,
|
|
)
|