defuse/tokens/

mod.rs

#[cfg(feature = "imt")]
pub mod imt;
pub mod nep141;
pub mod nep171;
pub mod nep245;

use core::{
    fmt::{self, Debug, Display},
    str::FromStr,
};

use defuse_core::payload::multi::MultiPayload;
use near_sdk::{AccountId, account_id::ParseAccountError};
use serde::{Deserialize, Serialize};

#[must_use]
#[cfg_attr(feature = "abi", derive(::schemars::JsonSchema))]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DepositMessage {
    pub receiver_id: AccountId,

    #[serde(flatten, default, skip_serializing_if = "Option::is_none")]
    pub action: Option<DepositAction>,
}

impl DepositMessage {
    #[inline]
    pub const fn new(receiver_id: AccountId) -> Self {
        Self {
            receiver_id,
            action: None,
        }
    }

    #[inline]
    pub fn with_action(mut self, action: impl Into<Option<DepositAction>>) -> Self {
        self.action = action.into();
        self
    }
}

impl Display for DepositMessage {
    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.action {
            None => f.write_str(self.receiver_id.as_str()),
            Some(DepositAction::Execute(exec)) if exec.execute_intents.is_empty() => {
                f.write_str(self.receiver_id.as_str())
            }
            Some(_) => f.write_str(&serde_json::to_string(self).unwrap_or_else(|e| panic!("{e}"))),
        }
    }
}

impl FromStr for DepositMessage {
    type Err = ParseDepositMessageError;

    #[inline]
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if s.starts_with('{') {
            serde_json::from_str(s).map_err(Into::into)
        } else {
            s.parse().map(Self::new).map_err(Into::into)
        }
    }
}

#[must_use]
#[cfg_attr(feature = "abi", derive(::schemars::JsonSchema))]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DepositAction {
    Execute(ExecuteIntents),
    // Notify(NotifyOnTransfer),
}

#[must_use]
#[cfg_attr(feature = "abi", derive(::schemars::JsonSchema))]
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExecuteIntents {
    pub execute_intents: Vec<MultiPayload>,

    #[serde(default, skip_serializing_if = "::core::ops::Not::not")]
    pub refund_if_fails: bool,
}

#[derive(Debug, thiserror::Error)]
pub enum ParseDepositMessageError {
    #[error(transparent)]
    Account(#[from] ParseAccountError),
    #[error("JSON: {0}")]
    JSON(#[from] serde_json::Error),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_deserialize_simple() {
        // Simple format: just receiver_id
        let json = r#"{"receiver_id": "alice.near"}"#;
        let msg: DepositMessage = serde_json::from_str(json).unwrap();

        assert_eq!(msg.receiver_id.as_str(), "alice.near");
        assert!(msg.action.is_none());
    }

    // #[test]
    // fn test_deserialize_with_notify() {
    //     // With notify action (flattened untagged)
    //     let json = r#"{
    //         "receiver_id": "alice.near",
    //         "msg": "hello world",
    //         "min_gas": null
    //     }"#;
    //     let msg: DepositMessage = serde_json::from_str(json).unwrap();

    //     assert_eq!(msg.receiver_id.as_str(), "alice.near");
    //     match msg.action {
    //         Some(DepositAction::Notify(notify)) => {
    //             assert_eq!(notify.msg, "hello world");
    //             assert!(notify.min_gas.is_none());
    //         }
    //         _ => panic!("Expected Notify action"),
    //     }
    // }

    #[test]
    fn test_deserialize_with_execute() {
        // With execute action (flattened untagged)
        let json = r#"{
            "receiver_id": "alice.near",
            "execute_intents": [],
            "refund_if_fails": true
        }"#;
        let msg: DepositMessage = serde_json::from_str(json).unwrap();

        assert_eq!(msg.receiver_id.as_str(), "alice.near");
        match msg.action {
            Some(DepositAction::Execute(exec)) => {
                assert!(exec.execute_intents.is_empty());
                assert!(exec.refund_if_fails);
            }
            _ => panic!("Expected Execute action"),
        }
    }

    #[test]
    fn test_serialize_simple() {
        // Simple message serialization
        let msg = DepositMessage::new("alice.near".parse().unwrap());
        let json = serde_json::to_string(&msg).unwrap();

        // Should serialize with just receiver_id (action omitted when None)
        assert!(json.contains("\"receiver_id\":\"alice.near\""));
        assert!(!json.contains("action"));
    }

    // #[test]
    // fn test_serialize_with_notify() {
    //     // Serialization with notify action
    //     let msg = DepositMessage {
    //         receiver_id: "alice.near".parse().unwrap(),
    //         action: Some(DepositAction::Notify(NotifyOnTransfer::new(
    //             "hello".to_string(),
    //         ))),
    //     };
    //     let json = serde_json::to_string(&msg).unwrap();

    //     // Should serialize with flattened notify fields
    //     assert!(json.contains("\"receiver_id\":\"alice.near\""));
    //     assert!(json.contains("\"msg\":\"hello\""));
    // }

    #[test]
    fn test_serialize_with_execute() {
        // Serialization with execute action
        let msg = DepositMessage {
            receiver_id: "alice.near".parse().unwrap(),
            action: Some(DepositAction::Execute(ExecuteIntents {
                execute_intents: vec![],
                refund_if_fails: true,
            })),
        };
        let json = serde_json::to_string(&msg).unwrap();

        // Should serialize with flattened execute fields
        assert!(json.contains("\"receiver_id\":\"alice.near\""));
        assert!(json.contains("\"execute_intents\""));
        assert!(json.contains("\"refund_if_fails\":true"));
    }

    #[test]
    fn test_display_simple() {
        // Display for simple message (just account ID)
        let msg = DepositMessage::new("alice.near".parse().unwrap());
        assert_eq!(msg.to_string(), "alice.near");
    }

    // #[test]
    // fn test_display_with_action() {
    //     // Display for message with action (should be JSON)
    //     let msg = DepositMessage {
    //         receiver_id: "alice.near".parse().unwrap(),
    //         action: Some(DepositAction::Notify(NotifyOnTransfer::new(
    //             "test".to_string(),
    //         ))),
    //     };
    //     let display = msg.to_string();

    //     assert!(display.starts_with('{'));
    //     assert!(display.contains("alice.near"));
    // }

    #[test]
    fn test_from_str_simple() {
        // Parse simple account ID
        let msg: DepositMessage = "alice.near".parse().unwrap();
        assert_eq!(msg.receiver_id.as_str(), "alice.near");
        assert!(msg.action.is_none());
    }

    #[test]
    fn test_from_str_json_with_execute() {
        // Parse JSON with execute intents
        let json = r#"{"receiver_id":"alice.near","execute_intents":[],"refund_if_fails":true}"#;
        let msg: DepositMessage = json.parse().unwrap();

        assert_eq!(msg.receiver_id.as_str(), "alice.near");
        match msg.action {
            Some(DepositAction::Execute(exec)) => {
                assert!(exec.execute_intents.is_empty());
                assert!(exec.refund_if_fails);
            }
            _ => panic!("Expected Execute action"),
        }
    }

    // #[test]
    // fn test_from_str_json_with_notify() {
    //     // Parse JSON with notify action
    //     let json = r#"{"receiver_id":"alice.near","msg":"test"}"#;
    //     let msg: DepositMessage = json.parse().unwrap();

    //     assert_eq!(msg.receiver_id.as_str(), "alice.near");
    //     match msg.action {
    //         Some(DepositAction::Notify(notify)) => {
    //             assert_eq!(notify.msg, "test");
    //         }
    //         _ => panic!("Expected Notify action"),
    //     }
    // }

    // #[test]
    // fn test_deserialize_execute_takes_precedence_when_both_fields_present() {
    //     // When both execute_intents and msg are present, Execute variant should be matched first
    //     // since it comes first in the untagged enum
    //     let json = r#"{
    //         "receiver_id": "alice.near",
    //         "execute_intents": [],
    //         "refund_if_fails": true,
    //         "msg": "this should be ignored"
    //     }"#;
    //     let deposit_msg: DepositMessage = serde_json::from_str(json).unwrap();

    //     assert_eq!(deposit_msg.receiver_id.as_str(), "alice.near");
    //     match deposit_msg.action {
    //         Some(DepositAction::Execute(exec)) => {
    //             assert!(exec.execute_intents.is_empty());
    //             assert!(exec.refund_if_fails);
    //         }
    //         Some(DepositAction::Notify(_)) => {
    //             panic!("Expected Execute action, got Notify instead");
    //         }
    //         None => panic!("Expected Execute action, got None"),
    //     }
    // }

    #[test]
    fn test_builder_methods() {
        // Test direct construction
        let msg = DepositMessage {
            receiver_id: "alice.near".parse().unwrap(),
            action: Some(DepositAction::Execute(ExecuteIntents {
                execute_intents: vec![],
                refund_if_fails: true,
            })),
        };

        assert_eq!(msg.receiver_id.as_str(), "alice.near");
        match msg.action {
            Some(DepositAction::Execute(exec)) => {
                assert!(exec.refund_if_fails);
            }
            _ => panic!("Expected Execute action"),
        }
    }

    // #[test]
    // fn test_builder_with_notify() {
    //     // Test direct construction with notify
    //     let msg = DepositMessage {
    //         receiver_id: "alice.near".parse().unwrap(),
    //         action: Some(DepositAction::Notify(NotifyOnTransfer::new(
    //             "test".to_string(),
    //         ))),
    //     };

    //     assert_eq!(msg.receiver_id.as_str(), "alice.near");
    //     assert!(matches!(msg.action, Some(DepositAction::Notify(_))));
    // }
}