agents fixed

Author: ControlCplusControlV

tests/agent_integration_test.rs

@@ -0,0 +1,75 @@
+use ferrofluid::{
+    providers::RawExchangeProvider,
+    signers::LocalWallet,
+    types::responses::ExchangeResponseStatus,
+};
+
+#[tokio::test]
+async fn test_agent_approval_format() {
+    // Use a fixed test key for reproducible testing
+    let private_key = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+    let signer = LocalWallet::from_hex_key(private_key).unwrap();
+    
+    // Create testnet provider
+    let exchange = RawExchangeProvider::testnet(signer.clone());
+    
+    // Test approving a specific agent
+    let agent_key = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
+    let agent_signer = LocalWallet::from_hex_key(agent_key).unwrap();
+    let agent_address = agent_signer.address();
+    
+    println!("Testing agent approval for address: {}", agent_address);
+    
+    // This will attempt to approve the agent
+    // In a real test, we'd mock the HTTP client, but for now we'll just
+    // verify the request format is correct by checking the debug output
+    match exchange.approve_agent(agent_address, None).await {
+        Ok(_) => println!("Request sent successfully"),
+        Err(e) => println!("Expected error (no real network): {:?}", e),
+    }
+}
+
+#[test]
+fn test_agent_address_serialization() {
+    use alloy::primitives::Address;
+    use serde_json;
+    
+    // Test the ApproveAgent struct directly
+    use ferrofluid::types::actions::ApproveAgent;
+    
+    let agent = ApproveAgent {
+        signature_chain_id: 421614,
+        hyperliquid_chain: "Testnet".to_string(),
+        agent_address: "0x70997970c51812dc3a010c7d01b50e0d17dc79c8".parse::<Address>().unwrap(),
+        agent_name: Some("test".to_string()),
+        nonce: 12345,
+    };
+    
+    let json = serde_json::to_string(&agent).unwrap();
+    
+    // Should serialize with 0x prefix and lowercase
+    assert!(json.contains(r#""agentAddress":"0x70997970c51812dc3a010c7d01b50e0d17dc79c8""#));
+}
+
+#[test] 
+fn test_approve_agent_serialization() {
+    use ferrofluid::types::actions::ApproveAgent;
+    use alloy::primitives::Address;
+    
+    let agent = ApproveAgent {
+        signature_chain_id: 421614,
+        hyperliquid_chain: "Testnet".to_string(),
+        agent_address: "0x70997970c51812dc3a010c7d01b50e0d17dc79c8".parse::<Address>().unwrap(),
+        agent_name: None,
+        nonce: 1234567890,
+    };
+    
+    let json = serde_json::to_value(&agent).unwrap();
+    
+    // Check the serialized format
+    assert_eq!(json["signatureChainId"], 421614);
+    assert_eq!(json["hyperliquidChain"], "Testnet");
+    assert_eq!(json["agentAddress"], "0x70997970c51812dc3a010c7d01b50e0d17dc79c8");
+    assert_eq!(json["agentName"], serde_json::Value::Null);
+    assert_eq!(json["nonce"], 1234567890);
+}

tests/approve_agent_test.rs

@@ -0,0 +1,56 @@
+//! Test for ApproveAgent EIP-712 signing
+
+#[cfg(test)]
+mod tests {
+    use ferrofluid::types::actions::ApproveAgent;
+    use ferrofluid::types::eip712::HyperliquidAction;
+    use alloy::primitives::{address, keccak256};
+    
+    #[test]
+    fn test_approve_agent_type_hash() {
+        let expected = keccak256(
+            "HyperliquidTransaction:ApproveAgent(string hyperliquidChain,address agentAddress,string agentName,uint64 nonce)"
+        );
+        assert_eq!(ApproveAgent::type_hash(), expected);
+    }
+    
+    #[test]
+    fn test_approve_agent_serialization() {
+        let action = ApproveAgent {
+            signature_chain_id: 421614,
+            hyperliquid_chain: "Testnet".to_string(),
+            agent_address: address!("1234567890123456789012345678901234567890"),
+            agent_name: Some("Test Agent".to_string()),
+            nonce: 1234567890,
+        };
+        
+        // Serialize to JSON
+        let json = serde_json::to_string(&action).unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(&json).unwrap();
+        
+        // Check that address is serialized as hex string
+        assert_eq!(
+            parsed["agentAddress"].as_str().unwrap(),
+            "0x1234567890123456789012345678901234567890"
+        );
+        assert_eq!(parsed["hyperliquidChain"].as_str().unwrap(), "Testnet");
+        assert_eq!(parsed["agentName"].as_str().unwrap(), "Test Agent");
+        assert_eq!(parsed["nonce"].as_u64().unwrap(), 1234567890);
+    }
+    
+    #[test]
+    fn test_approve_agent_struct_hash() {
+        let action = ApproveAgent {
+            signature_chain_id: 421614,
+            hyperliquid_chain: "Testnet".to_string(),
+            agent_address: address!("0D1d9635D0640821d15e323ac8AdADfA9c111414"),
+            agent_name: None,
+            nonce: 1690393044548,
+        };
+        
+        // Test that struct hash is computed
+        let struct_hash = action.struct_hash();
+        // Just verify it's not zero
+        assert_ne!(struct_hash, alloy::primitives::B256::ZERO);
+    }
+}

tests/managed_exchange_test.rs

@@ -0,0 +1,142 @@
+//! Tests for ManagedExchangeProvider
+
+use ferrofluid::{
+    providers::{ManagedExchangeProvider, OrderHandle},
+    types::requests::{OrderRequest, OrderType, Limit},
+    constants::*,
+};
+use alloy::signers::local::PrivateKeySigner;
+use std::time::Duration;
+
+#[tokio::test]
+async fn test_managed_provider_creation() {
+    // Initialize CryptoProvider for rustls
+    rustls::crypto::CryptoProvider::install_default(
+        rustls::crypto::ring::default_provider()
+    ).ok();
+    
+    // Create a test signer
+    let signer = PrivateKeySigner::random();
+    
+    // Create managed provider with default config
+    let exchange = ManagedExchangeProvider::builder(signer)
+        .with_network(ferrofluid::Network::Testnet)
+        .build()
+        .await;
+    
+    assert!(exchange.is_ok());
+}
+
+#[tokio::test]
+async fn test_managed_provider_with_batching() {
+    // Initialize CryptoProvider for rustls
+    rustls::crypto::CryptoProvider::install_default(
+        rustls::crypto::ring::default_provider()
+    ).ok();
+    
+    let signer = PrivateKeySigner::random();
+    
+    // Create with batching enabled
+    let exchange = ManagedExchangeProvider::builder(signer)
+        .with_network(ferrofluid::Network::Testnet)
+        .with_auto_batching(Duration::from_millis(50))
+        .without_agent_rotation() // Disable for testing
+        .build()
+        .await
+        .unwrap();
+    
+    // Create a test order
+    let order = OrderRequest {
+        asset: 0,
+        is_buy: true,
+        limit_px: "50000".to_string(),
+        sz: "0.01".to_string(),
+        reduce_only: false,
+        order_type: OrderType::Limit(Limit { tif: TIF_GTC.to_string() }),
+        cloid: None,
+    };
+    
+    // Place order should return pending handle
+    let handle = exchange.place_order(&order).await.unwrap();
+    
+    match handle {
+        OrderHandle::Pending { .. } => {
+            // Expected for batched orders
+        }
+        OrderHandle::Immediate(_) => {
+            panic!("Expected pending handle for batched order");
+        }
+    }
+}
+
+#[tokio::test] 
+async fn test_alo_order_detection() {
+    let order = OrderRequest {
+        asset: 0,
+        is_buy: true,
+        limit_px: "50000".to_string(),
+        sz: "0.01".to_string(),
+        reduce_only: false,
+        order_type: OrderType::Limit(Limit { tif: "Alo".to_string() }),
+        cloid: None,
+    };
+    
+    assert!(order.is_alo());
+    
+    let regular_order = OrderRequest {
+        asset: 0,
+        is_buy: true,
+        limit_px: "50000".to_string(),
+        sz: "0.01".to_string(),
+        reduce_only: false,
+        order_type: OrderType::Limit(Limit { tif: "Gtc".to_string() }),
+        cloid: None,
+    };
+    
+    assert!(!regular_order.is_alo());
+}
+
+#[test]
+fn test_nonce_generation() {
+    use ferrofluid::providers::nonce::NonceManager;
+    
+    let manager = NonceManager::new(false);
+    
+    let nonce1 = manager.next_nonce(None);
+    let nonce2 = manager.next_nonce(None);
+    
+    assert!(nonce2 > nonce1);
+    assert!(NonceManager::is_valid_nonce(nonce1));
+    assert!(NonceManager::is_valid_nonce(nonce2));
+}
+
+#[test]
+fn test_nonce_isolation() {
+    use ferrofluid::providers::nonce::NonceManager;
+    use alloy::primitives::Address;
+    
+    let manager = NonceManager::new(true);
+    let addr1 = Address::new([1u8; 20]);
+    let addr2 = Address::new([2u8; 20]);
+    
+    // Get initial nonces - these should have different millisecond timestamps
+    let n1_1 = manager.next_nonce(Some(addr1));
+    std::thread::sleep(std::time::Duration::from_millis(1));
+    let n2_1 = manager.next_nonce(Some(addr2));
+    std::thread::sleep(std::time::Duration::from_millis(1));
+    let n1_2 = manager.next_nonce(Some(addr1));
+    std::thread::sleep(std::time::Duration::from_millis(1));
+    let n2_2 = manager.next_nonce(Some(addr2));
+    
+    // Each address should have independent, increasing nonces
+    assert!(n1_2 > n1_1, "addr1 nonces should increase");
+    assert!(n2_2 > n2_1, "addr2 nonces should increase");
+    
+    // Verify counter independence using the manager's get_counter method
+    assert_eq!(manager.get_counter(Some(addr1)), 2); // addr1 has 2 nonces
+    assert_eq!(manager.get_counter(Some(addr2)), 2); // addr2 has 2 nonces
+    
+    // The nonces themselves should be unique
+    assert_ne!(n1_1, n2_1);
+    assert_ne!(n1_2, n2_2);
+}