hypercall_api/directives/

models.rs

use crate::directives::json_types::{Bytes32Hex, JsonU128, JsonU32, JsonU64, JsonU8};
use crate::error::ApiError;
use alloy::sol_types::SolValue;
use hypercall_types::directives::{
    ActionKey, CancelOrderByCloid, CancelOrderByOid, LimitOrder, UpdateApiWallet,
};
use hypercall_types::WalletAddress;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TypedDataRequest {
    pub account: WalletAddress,
    pub nonce: JsonU64,
    pub action: sonic_rs::Value,
}

#[derive(Debug, Clone, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SubmitRequest {
    pub account: WalletAddress,
    pub nonce: JsonU64,
    pub action: sonic_rs::Value,
    pub signature: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct HlLimitOrderAction {
    pub asset: JsonU32,
    pub is_buy: bool,
    pub limit_px: JsonU64,
    pub sz: JsonU64,
    pub reduce_only: bool,
    pub encoded_tif: JsonU8,
    pub cloid: JsonU128,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct HlCancelByOidAction {
    pub asset: JsonU32,
    pub oid: JsonU64,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct HlCancelByCloidAction {
    pub asset: JsonU32,
    pub cloid: JsonU128,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct HcUpdateApiWalletAction {
    pub name: Bytes32Hex,
    pub addr: WalletAddress,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EncodedTif {
    Alo,
    Gtc,
    Ioc,
}

impl EncodedTif {
    pub fn parse(value: u8) -> Result<Self, ApiError> {
        match value {
            1 => Ok(Self::Alo),
            2 => Ok(Self::Gtc),
            3 => Ok(Self::Ioc),
            _ => Err(ApiError::invalid_field(
                "action.encodedTif must be one of 1, 2, or 3",
            )),
        }
    }
}

impl HlLimitOrderAction {
    pub fn encoded_tif_kind(&self) -> Result<EncodedTif, ApiError> {
        EncodedTif::parse(self.encoded_tif.into_inner())
    }

    pub fn validate(&self) -> Result<(), ApiError> {
        self.encoded_tif_kind().map(|_| ())
    }
}

impl From<&HlLimitOrderAction> for LimitOrder {
    fn from(value: &HlLimitOrderAction) -> Self {
        Self {
            asset: value.asset.into_inner(),
            isBuy: value.is_buy,
            limitPx: value.limit_px.into_inner(),
            sz: value.sz.into_inner(),
            reduceOnly: value.reduce_only,
            encodedTif: value.encoded_tif.into_inner(),
            cloid: value.cloid.into_inner(),
        }
    }
}

impl From<&HlCancelByOidAction> for CancelOrderByOid {
    fn from(value: &HlCancelByOidAction) -> Self {
        Self {
            asset: value.asset.into_inner(),
            oid: value.oid.into_inner(),
        }
    }
}

impl From<&HlCancelByCloidAction> for CancelOrderByCloid {
    fn from(value: &HlCancelByCloidAction) -> Self {
        Self {
            asset: value.asset.into_inner(),
            cloid: value.cloid.into_inner(),
        }
    }
}

impl From<&HcUpdateApiWalletAction> for UpdateApiWallet {
    fn from(value: &HcUpdateApiWalletAction) -> Self {
        Self {
            name: value.name.into_inner().into(),
            addr: value.addr.inner(),
        }
    }
}

#[derive(Debug, Clone)]
pub enum ParsedAction {
    HlLimitOrder(HlLimitOrderAction),
    HlCancelByOid(HlCancelByOidAction),
    HlCancelByCloid(HlCancelByCloidAction),
    HcUpdateApiWallet(HcUpdateApiWalletAction),
}

impl ParsedAction {
    pub fn parse(action_key: ActionKey, value: sonic_rs::Value) -> Result<Self, ApiError> {
        match action_key {
            ActionKey::HlLimitOrder => {
                let action: HlLimitOrderAction = sonic_rs::from_value(&value)
                    .map_err(|e| ApiError::invalid_field(e.to_string()))?;
                action.validate()?;
                Ok(Self::HlLimitOrder(action))
            }
            ActionKey::HlCancelByOid => {
                let action: HlCancelByOidAction = sonic_rs::from_value(&value)
                    .map_err(|e| ApiError::invalid_field(e.to_string()))?;
                Ok(Self::HlCancelByOid(action))
            }
            ActionKey::HlCancelByCloid => {
                let action: HlCancelByCloidAction = sonic_rs::from_value(&value)
                    .map_err(|e| ApiError::invalid_field(e.to_string()))?;
                Ok(Self::HlCancelByCloid(action))
            }
            ActionKey::HcUpdateApiWallet => {
                let action: HcUpdateApiWalletAction = sonic_rs::from_value(&value)
                    .map_err(|e| ApiError::invalid_field(e.to_string()))?;
                Ok(Self::HcUpdateApiWallet(action))
            }
            _ => Err(ApiError::unsupported_action(format!(
                "Action '{}' is not supported in MVP",
                action_key.as_str()
            ))),
        }
    }

    pub fn to_json_value(&self) -> sonic_rs::Value {
        let value = match self {
            Self::HlLimitOrder(action) => sonic_rs::to_value(action),
            Self::HlCancelByOid(action) => sonic_rs::to_value(action),
            Self::HlCancelByCloid(action) => sonic_rs::to_value(action),
            Self::HcUpdateApiWallet(action) => sonic_rs::to_value(action),
        };
        value.expect("action serialization should always succeed")
    }

    pub fn encode_inner_abi(&self) -> Vec<u8> {
        match self {
            Self::HlLimitOrder(action) => LimitOrder::from(action).abi_encode(),
            Self::HlCancelByOid(action) => CancelOrderByOid::from(action).abi_encode(),
            Self::HlCancelByCloid(action) => CancelOrderByCloid::from(action).abi_encode(),
            Self::HcUpdateApiWallet(action) => UpdateApiWallet::from(action).abi_encode(),
        }
    }
}

/// How far the directive got in the pipeline.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum DirectiveStage {
    /// Parsed and signature recovered, but rejected by policy/auth.
    Rejected,
    /// Passed engine check, enqueued for async submission (no sync relayer).
    Enqueued,
    /// Submitted synchronously, tx_hash available.
    Submitted,
}

/// A fill from HyperLiquid (best-effort, queried after submission).
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DirectiveFill {
    pub coin: String,
    pub side: String,
    pub size: String,
    pub price: String,
    pub time: u64,
}

/// Single honest response for directive submission.
/// Every field is populated with whatever we know. Nulls mean we don't know.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SubmitResponse {
    /// How far the directive got.
    pub stage: DirectiveStage,
    /// Unique directive identifier.
    pub directive_id: String,
    /// Which action was submitted.
    pub action_key: String,
    /// Account contract address.
    pub account: WalletAddress,
    /// Nonce used for the directive.
    pub nonce: JsonU64,
    /// Recovered signer address (null if signature recovery failed before this point).
    pub recovered_signer: Option<WalletAddress>,
    /// On-chain transaction hash (null if not submitted yet or async path used).
    pub tx_hash: Option<String>,
    /// Rejection reason (null if not rejected).
    pub rejection: Option<DirectiveRejection>,
    /// Best-effort fills from HyperLiquid. Null means we don't know, not "no fills."
    pub fills: Option<Vec<DirectiveFill>>,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct DirectiveRejection {
    pub code: String,
    pub message: String,
}