Add SendAsset action with EIP-712 signing (#155)

Implement sendAsset functionality using proper EIP-712 typed data
signing, aligned with the Hyperliquid API and hyperliquid-python-sdk
specification.

Key changes:
- Add SendAsset struct with EIP-712 implementation
- Implement send_asset() method using sign_typed_data
- Support all required parameters: destination, sourceDex,
destinationDex, token, amount
- Handle fromSubAccount for vault/subaccount transfers
- Support mainnet/testnet chain selection
- Set vault_address to None for sendAsset actions (handled in post
method)
- Add comprehensive tests for signing with mainnet/testnet and vault
scenarios

This follows the same pattern as usdClassTransfer, replacing legacy L1
action signing with EIP-712 typed data for proper API compatibility.

Author: BillyWooo

src/exchange/actions.rs

@@ -197,6 +197,42 @@ pub struct ClassTransfer {
     pub to_perp: bool,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct SendAsset {
+    #[serde(serialize_with = "serialize_hex")]
+    pub signature_chain_id: u64,
+    pub hyperliquid_chain: String,
+    pub destination: String,
+    pub source_dex: String,
+    pub destination_dex: String,
+    pub token: String,
+    pub amount: String,
+    pub from_sub_account: String,
+    pub nonce: u64,
+}
+
+impl Eip712 for SendAsset {
+    fn domain(&self) -> Eip712Domain {
+        eip_712_domain(self.signature_chain_id)
+    }
+
+    fn struct_hash(&self) -> B256 {
+        let items = (
+            keccak256("HyperliquidTransaction:SendAsset(string hyperliquidChain,string destination,string sourceDex,string destinationDex,string token,string amount,string fromSubAccount,uint64 nonce)"),
+            keccak256(&self.hyperliquid_chain),
+            keccak256(&self.destination),
+            keccak256(&self.source_dex),
+            keccak256(&self.destination_dex),
+            keccak256(&self.token),
+            keccak256(&self.amount),
+            keccak256(&self.from_sub_account),
+            &self.nonce,
+        );
+        keccak256(items.abi_encode())
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct VaultTransfer {

src/exchange/exchange_client.rs

@@ -12,8 +12,8 @@ use crate::{
     exchange::{
         actions::{
             ApproveAgent, ApproveBuilderFee, BulkCancel, BulkModify, BulkOrder, ClaimRewards,
-            EvmUserModify, ScheduleCancel, SetReferrer, UpdateIsolatedMargin, UpdateLeverage,
-            UsdSend,
+            EvmUserModify, ScheduleCancel, SendAsset, SetReferrer, UpdateIsolatedMargin,
+            UpdateLeverage, UsdSend,
         },
         cancel::{CancelRequest, CancelRequestCloid, ClientCancelRequestCloid},
         modify::{ClientModifyRequest, ModifyRequest},
@@ -74,6 +74,7 @@ pub enum Actions {
     ApproveAgent(ApproveAgent),
     Withdraw3(Withdraw3),
     SpotUser(SpotUser),
+    SendAsset(SendAsset),
     VaultTransfer(VaultTransfer),
     SpotSend(SpotSend),
     SetReferrer(SetReferrer),
@@ -238,6 +239,49 @@ impl ExchangeClient {
         self.post(action, signature, timestamp).await
     }
 
+    pub async fn send_asset(
+        &self,
+        destination: &str,
+        source_dex: &str,
+        destination_dex: &str,
+        token: &str,
+        amount: f64,
+        wallet: Option<&PrivateKeySigner>,
+    ) -> Result<ExchangeResponseStatus> {
+        let wallet = wallet.unwrap_or(&self.wallet);
+
+        let hyperliquid_chain = if self.http_client.is_mainnet() {
+            "Mainnet".to_string()
+        } else {
+            "Testnet".to_string()
+        };
+
+        let timestamp = next_nonce();
+
+        // Build fromSubAccount string (similar to Python SDK)
+        let from_sub_account = self
+            .vault_address
+            .map_or_else(String::new, |vault_addr| format!("{vault_addr:?}"));
+
+        let send_asset = SendAsset {
+            signature_chain_id: 421614,
+            hyperliquid_chain,
+            destination: destination.to_string(),
+            source_dex: source_dex.to_string(),
+            destination_dex: destination_dex.to_string(),
+            token: token.to_string(),
+            amount: amount.to_string(),
+            from_sub_account,
+            nonce: timestamp,
+        };
+
+        let signature = sign_typed_data(&send_asset, wallet)?;
+        let action = serde_json::to_value(Actions::SendAsset(send_asset))
+            .map_err(|e| Error::JsonParse(e.to_string()))?;
+
+        self.post(action, signature, timestamp).await
+    }
+
     pub async fn vault_transfer(
         &self,
         is_deposit: bool,
@@ -1063,4 +1107,61 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_send_asset_signing() -> Result<()> {
+        let wallet = get_wallet()?;
+
+        // Test mainnet - send asset to another address
+        let mainnet_send = SendAsset {
+            signature_chain_id: 421614,
+            hyperliquid_chain: "Mainnet".to_string(),
+            destination: "0x1234567890123456789012345678901234567890".to_string(),
+            source_dex: "".to_string(),
+            destination_dex: "spot".to_string(),
+            token: "PURR:0xc4bf3f870c0e9465323c0b6ed28096c2".to_string(),
+            amount: "100".to_string(),
+            from_sub_account: "".to_string(),
+            nonce: 1583838,
+        };
+
+        let mainnet_signature = sign_typed_data(&mainnet_send, &wallet)?;
+        // Signature generated successfully - just verify it's a valid signature object
+
+        // Test testnet - send different token
+        let testnet_send = SendAsset {
+            signature_chain_id: 421614,
+            hyperliquid_chain: "Testnet".to_string(),
+            destination: "0x1234567890123456789012345678901234567890".to_string(),
+            source_dex: "spot".to_string(),
+            destination_dex: "".to_string(),
+            token: "USDC".to_string(),
+            amount: "50".to_string(),
+            from_sub_account: "".to_string(),
+            nonce: 1583838,
+        };
+
+        let testnet_signature = sign_typed_data(&testnet_send, &wallet)?;
+        // Verify signatures are different for mainnet vs testnet
+        assert_ne!(mainnet_signature, testnet_signature);
+
+        // Test with vault/subaccount
+        let vault_send = SendAsset {
+            signature_chain_id: 421614,
+            hyperliquid_chain: "Mainnet".to_string(),
+            destination: "0x1234567890123456789012345678901234567890".to_string(),
+            source_dex: "".to_string(),
+            destination_dex: "spot".to_string(),
+            token: "PURR:0xc4bf3f870c0e9465323c0b6ed28096c2".to_string(),
+            amount: "100".to_string(),
+            from_sub_account: "0xabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd".to_string(),
+            nonce: 1583838,
+        };
+
+        let vault_signature = sign_typed_data(&vault_send, &wallet)?;
+        // Verify vault signature is different from non-vault signature
+        assert_ne!(mainnet_signature, vault_signature);
+
+        Ok(())
+    }
 }

src/info/info_client.rs

@@ -7,8 +7,9 @@ use tokio::sync::mpsc::UnboundedSender;
 
 use crate::{
     info::{
-        CandlesSnapshotResponse, FundingHistoryResponse, L2SnapshotResponse, OpenOrdersResponse,
-        OrderInfo, RecentTradesResponse, UserFillsResponse, UserStateResponse, ActiveAssetDataResponse,
+        ActiveAssetDataResponse, CandlesSnapshotResponse, FundingHistoryResponse,
+        L2SnapshotResponse, OpenOrdersResponse, OrderInfo, RecentTradesResponse, UserFillsResponse,
+        UserStateResponse,
     },
     meta::{AssetContext, Meta, SpotMeta, SpotMetaAndAssetCtxs},
     prelude::*,
@@ -311,7 +312,11 @@ impl InfoClient {
         self.send_info_request(input).await
     }
 
-    pub async fn active_asset_data(&self, user: Address, coin: String) -> Result<ActiveAssetDataResponse> {
+    pub async fn active_asset_data(
+        &self,
+        user: Address,
+        coin: String,
+    ) -> Result<ActiveAssetDataResponse> {
         let input = InfoRequest::ActiveAssetData { user, coin };
         self.send_info_request(input).await
     }