Rust的trait bounds自动识别绑定机制

在 Rust 中，当你为一个类型实现某个 trait 并且在作用域中引入这个 trait 时，Rust 编译器会自动识别并使该类型拥有该 trait 的方法。这是因为 Rust 使用了一种称为“trait bounds”的机制，它会在编译时将适当的 trait 绑定到相应的类型上。

具体过程

1. 定义和实现 trait:
   首先，你需要为某个类型实现一个 trait。例如，你在 signature.rs 中为 Signature 类型实现了 TryFrom trait。
2. use ed25519_dalek;
use std::convert::TryFrom;
impl TryFrom<&Signature> for ed25519_dalek::Signature {
type Error = ed25519_dalek::SignatureError;
fn try_from(sig: &Signature) -> Result<Self, Self::Error> { ed25519_dalek::Signature::from_bytes(&sig.0).map_err(|_| ed25519_dalek::SignatureError::new()) }
}
3. 引入 trait:
   然后，你需要在需要使用该 trait 的地方引入它。例如，在 verify_signature 函数中，你需要引入 TryFrom trait。 use std::convert::TryInto; // TryInto 自动引入了 TryFrom
4. 自动绑定:
   当你引入了 TryFrom trait 后，Rust 编译器会自动将 TryFrom 的方法（如 try_from）绑定到实现了该 trait 的类型上。在你的例子中，就是将 try_from 方法绑定到 Signature 类型上。

为什么需要引入 trait

Rust 的这种设计有几个重要原因：

1. 命名空间管理:
   Rust 使用模块系统来管理命名空间，引入 trait 可以避免命名冲突。只有在你明确引入了某个 trait 后，才能使用该 trait 的方法。这有助于减少全局命名空间的污染。
2. 代码清晰度:
   通过显式地引入 trait，代码的读者可以很清楚地知道某个方法来自于哪个 trait。这增加了代码的可读性和可维护性。
3. 编译效率:
   Rust 的编译器可以通过这种方式更高效地进行类型检查和方法查找，因为它不需要在全局范围内查找所有可能的方法实现。

示例

以下是一个完整的示例，展示了如何使用 TryFrom trait 将 signature::Signature 转换为 ed25519_dalek::Signature 并调用 verify 方法：

// 在 signature.rs 中实现 TryFrom trait
use ed25519_dalek;
use std::convert::TryFrom;
use generic_array::typenum::U64;
use generic_array::GenericArray;
use serde::{Deserialize, Serialize};
use std::fmt::{self, Debug};
use std::str::FromStr;

#[derive(Serialize, Deserialize, Clone)]
pub struct Signature(GenericArray<u8, U64>);

impl Signature {
    pub fn new(signature_slice: &[u8]) -> Self {
        let mut signature = GenericArray::default();
        signature.copy_from_slice(signature_slice);
        Signature(signature)
    }

    pub fn new_unique() -> Self {
        use rand::Rng;
        let mut rng = rand::thread_rng();
        let mut signature = GenericArray::default();
        rng.fill(&mut signature[..]);
        Signature(signature)
    }
}

impl Debug for Signature {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "Signature({:?})", &self.0[..])
    }
}

impl From<[u8; 64]> for Signature {
    fn from(bytes: [u8; 64]) -> Self {
        Signature(GenericArray::from(bytes))
    }
}

impl From<&[u8]> for Signature {
    fn from(bytes: &[u8]) -> Self {
        let mut array = [0u8; 64];
        array.copy_from_slice(bytes);
        Signature(GenericArray::from(array))
    }
}

impl TryFrom<&[u8]> for Signature {
    type Error = ();
    fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
        if bytes.len() == 64 {
            let mut array = [0u8; 64];
            array.copy_from_slice(bytes);
            Ok(Signature(GenericArray::from(array)))
        } else {
            Err(())
        }
    }
}

impl FromStr for Signature {
    type Err = ();
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let bytes = hex::decode(s).map_err(|_| ())?;
        Signature::try_from(bytes.as_slice())
    }
}

// 实现 TryFrom trait
impl TryFrom<&Signature> for ed25519_dalek::Signature {
    type Error = ed25519_dalek::SignatureError;

    fn try_from(sig: &Signature) -> Result<Self, Self::Error> {
        ed25519_dalek::Signature::from_bytes(&sig.0).map_err(|_| ed25519_dalek::SignatureError::new())
    }
}

在需要验证签名的地方使用：

use ed25519_dalek::{PublicKey, Verifier};
use sdk::signature::Signature; // 确保引入 Signature 结构体
use std::convert::TryInto;

fn verify_signature(publickey: &PublicKey, message: &[u8], signature: &Signature) -> Result<(), PrecompileError> {
    // 使用 try_into 方法进行类型转换
    let ed25519_signature: ed25519_dalek::Signature = signature.try_into().map_err(|_| PrecompileError::InvalidSignature)?;
    publickey.verify(message, &ed25519_signature).map_err(|_| PrecompileError::InvalidSignature)
}

这样，你就可以利用 TryFrom trait 实现类型转换，并在调用 verify 方法时确保类型正确。