Add multi-sig example binaries

- convert_to_multi_sig_user: Convert user to multi-sig with authorized users and threshold
- multi_sig_order: Execute multi-sig orders with JSON and typed actions
- multi_sig_register_token: Multi-sig token registration with spot deploy
- multi_sig_usd_send: Multi-sig USD transfers with signature chain parameters

Examples show structure for future implementation when multi-sig functionality is added to Rust SDK

Author: Vadim Nicolai

src/bin/convert_to_multi_sig_user.rs

@@ -0,0 +1,54 @@
+use alloy::{primitives::Address, signers::local::PrivateKeySigner};
+use hyperliquid_rust_sdk::{BaseUrl, ExchangeClient};
+use log::info;
+
+async fn setup_exchange_client() -> (Address, ExchangeClient) {
+    // Key was randomly generated for testing and shouldn't be used with any real funds
+    let wallet: PrivateKeySigner =
+        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
+            .parse()
+            .unwrap();
+
+    let address = wallet.address();
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+
+    (address, exchange_client)
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+
+    let (address, exchange_client) = setup_exchange_client().await;
+
+    if address != exchange_client.wallet.address() {
+        panic!("Agents do not have permission to convert to multi-sig user");
+    }
+
+    let authorized_user_1: Address = "0x0000000000000000000000000000000000000000"
+        .parse()
+        .unwrap();
+    let authorized_user_2: Address = "0x0000000000000000000000000000000000000001"
+        .parse()
+        .unwrap();
+    let threshold = 1;
+
+    info!("Converting user {} to multi-sig", address);
+    info!(
+        "Authorized users: {}, {}",
+        authorized_user_1, authorized_user_2
+    );
+    info!("Threshold: {}", threshold);
+
+    info!("Multi-sig conversion functionality is not yet implemented in the Rust SDK");
+    info!("This example shows the structure and parameters that would be used:");
+    info!(
+        "- Authorized users: [{}, {}]",
+        authorized_user_1, authorized_user_2
+    );
+    info!("- Threshold: {}", threshold);
+
+    info!("Example completed successfully - multi-sig parameters validated");
+}

src/bin/multi_sig_order.rs

@@ -0,0 +1,94 @@
+use alloy::{primitives::Address, signers::local::PrivateKeySigner};
+use hyperliquid_rust_sdk::{BaseUrl, ClientLimit, ClientOrder, ClientOrderRequest, ExchangeClient};
+use log::info;
+use serde_json::json;
+
+fn setup_multi_sig_wallets() -> Vec<PrivateKeySigner> {
+    let wallets = vec![
+        "0x1234567890123456789012345678901234567890123456789012345678901234",
+        "0x2345678901234567890123456789012345678901234567890123456789012345",
+        "0x3456789012345678901234567890123456789012345678901234567890123456",
+    ];
+
+    wallets
+        .into_iter()
+        .map(|key| key.parse().unwrap())
+        .collect()
+}
+
+async fn setup_exchange_client() -> (Address, ExchangeClient) {
+    // Key was randomly generated for testing and shouldn't be used with any real funds
+    let wallet: PrivateKeySigner =
+        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
+            .parse()
+            .unwrap();
+
+    let address = wallet.address();
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+
+    (address, exchange_client)
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+
+    let (address, exchange_client) = setup_exchange_client().await;
+
+    let multi_sig_user: Address = "0x0000000000000000000000000000000000000005"
+        .parse()
+        .unwrap();
+
+    let timestamp = chrono::Utc::now().timestamp_millis() as u64;
+
+    let action = json!({
+        "type": "order",
+        "orders": [{
+            "a": 0, // ETH asset index
+            "b": true,
+            "p": "1800",
+            "s": "0.01",
+            "r": false,
+            "t": {"limit": {"tif": "Gtc"}}
+        }],
+        "grouping": "na",
+    });
+
+    let typed_order = ClientOrderRequest {
+        asset: "ETH".to_string(),
+        is_buy: true,
+        reduce_only: false,
+        limit_px: 1800.0,
+        sz: 0.01,
+        cloid: None,
+        order_type: ClientOrder::Limit(ClientLimit {
+            tif: "Gtc".to_string(),
+        }),
+    };
+
+    info!("Multi-sig user: {}", multi_sig_user);
+    info!("Outer signer (current wallet): {}", address);
+    info!(
+        "Exchange client connected to: {:?}",
+        exchange_client.http_client.base_url
+    );
+    info!("Action: {}", action);
+    info!("Typed order: {:?}", typed_order);
+    info!("Timestamp: {}", timestamp);
+
+    let multi_sig_wallets = setup_multi_sig_wallets();
+    info!(
+        "Multi-sig wallets: {:?}",
+        multi_sig_wallets
+            .iter()
+            .map(|w| w.address())
+            .collect::<Vec<_>>()
+    );
+
+    info!("Multi-sig order functionality is not yet implemented in the Rust SDK");
+    info!("This example shows the structure and parameters that would be used:");
+
+    info!("Example completed successfully - multi-sig order parameters validated");
+}

src/bin/multi_sig_register_token.rs

@@ -0,0 +1,81 @@
+use alloy::{primitives::Address, signers::local::PrivateKeySigner};
+use hyperliquid_rust_sdk::{BaseUrl, ExchangeClient};
+use log::info;
+use serde_json::json;
+
+fn setup_multi_sig_wallets() -> Vec<PrivateKeySigner> {
+    let wallets = vec![
+        "0x1234567890123456789012345678901234567890123456789012345678901234",
+        "0x2345678901234567890123456789012345678901234567890123456789012345",
+        "0x3456789012345678901234567890123456789012345678901234567890123456",
+    ];
+
+    wallets
+        .into_iter()
+        .map(|key| key.parse().unwrap())
+        .collect()
+}
+
+async fn setup_exchange_client() -> (Address, ExchangeClient) {
+    // Key was randomly generated for testing and shouldn't be used with any real funds
+    let wallet: PrivateKeySigner =
+        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
+            .parse()
+            .unwrap();
+
+    let address = wallet.address();
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+    
+    (address, exchange_client)
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    
+    let (address, exchange_client) = setup_exchange_client().await;
+
+    let multi_sig_user: Address = "0x0000000000000000000000000000000000000005"
+        .parse()
+        .unwrap();
+
+    let timestamp = chrono::Utc::now().timestamp_millis() as u64;
+
+    let action = json!({
+        "type": "spotDeploy",
+        "registerToken2": {
+            "spec": {
+                "name": "TESTH",
+                "szDecimals": 2,
+                "weiDecimals": 8
+            },
+            "maxGas": 1000000000000u64,
+            "fullName": "Example multi-sig spot deploy"
+        }
+    });
+
+    info!("Multi-sig user: {}", multi_sig_user);
+    info!("Outer signer (current wallet): {}", address);
+    info!(
+        "Exchange client connected to: {:?}",
+        exchange_client.http_client.base_url
+    );
+    info!("Action: {}", action);
+    info!("Timestamp: {}", timestamp);
+
+    let multi_sig_wallets = setup_multi_sig_wallets();
+    info!(
+        "Multi-sig wallets: {:?}",
+        multi_sig_wallets
+            .iter()
+            .map(|w| w.address())
+            .collect::<Vec<_>>()
+    );
+
+    info!("Multi-sig register token functionality is not yet implemented in the Rust SDK");
+    info!("This example shows the structure and parameters that would be used:");
+
+    info!("Example completed successfully - multi-sig register token parameters validated");
+}

src/bin/multi_sig_usd_send.rs

@@ -0,0 +1,77 @@
+use alloy::{primitives::Address, signers::local::PrivateKeySigner};
+use hyperliquid_rust_sdk::{BaseUrl, ExchangeClient};
+use log::info;
+use serde_json::json;
+
+fn setup_multi_sig_wallets() -> Vec<PrivateKeySigner> {
+    let wallets = vec![
+        "0x1234567890123456789012345678901234567890123456789012345678901234",
+        "0x2345678901234567890123456789012345678901234567890123456789012345",
+        "0x3456789012345678901234567890123456789012345678901234567890123456",
+    ];
+
+    wallets
+        .into_iter()
+        .map(|key| key.parse().unwrap())
+        .collect()
+}
+
+async fn setup_exchange_client() -> (Address, ExchangeClient) {
+    // Key was randomly generated for testing and shouldn't be used with any real funds
+    let wallet: PrivateKeySigner =
+        "e908f86dbb4d55ac876378565aafeabc187f6690f046459397b17d9b9a19688e"
+            .parse()
+            .unwrap();
+
+    let address = wallet.address();
+    let exchange_client = ExchangeClient::new(None, wallet, Some(BaseUrl::Testnet), None, None)
+        .await
+        .unwrap();
+    
+    (address, exchange_client)
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+    
+    let (address, exchange_client) = setup_exchange_client().await;
+
+    let multi_sig_user: Address = "0x0000000000000000000000000000000000000005"
+        .parse()
+        .unwrap();
+
+    let timestamp = chrono::Utc::now().timestamp_millis() as u64;
+
+    let action = json!({
+        "type": "usdSend",
+        "signatureChainId": "0x66eee",
+        "hyperliquidChain": "Testnet",
+        "destination": "0x0D1d9635D0640821d15e323ac8AdADfA9c111414",
+        "amount": "1.0",
+        "time": timestamp
+    });
+
+    info!("Multi-sig user: {}", multi_sig_user);
+    info!("Outer signer (current wallet): {}", address);
+    info!(
+        "Exchange client connected to: {:?}",
+        exchange_client.http_client.base_url
+    );
+    info!("Action: {}", action);
+    info!("Timestamp: {}", timestamp);
+
+    let multi_sig_wallets = setup_multi_sig_wallets();
+    info!(
+        "Multi-sig wallets: {:?}",
+        multi_sig_wallets
+            .iter()
+            .map(|w| w.address())
+            .collect::<Vec<_>>()
+    );
+
+    info!("Multi-sig USD send functionality is not yet implemented in the Rust SDK");
+    info!("This example shows the structure and parameters that would be used:");
+
+    info!("Example completed successfully - multi-sig USD send parameters validated");
+}