NFTデータのハッシュ化

pub struct MetadataArgsV2 {
    /// アセットの名前
    pub name: String,
    /// アセットのシンボル
    pub symbol: String,
    /// アセットを表すJSONを指すURI
    pub uri: String,
    /// 二次販売で作成者に行くロイヤリティベーシスポイント（0-10000）
    pub seller_fee_basis_points: u16,
    /// 不変、一度変更されると、このメタデータのすべての販売は二次とみなされる。
    pub primary_sale_happened: bool,
    /// データ構造が可変かどうか、デフォルトは不変
    pub is_mutable: bool,
    /// トークン標準。現在、`NonFungible`のみが許可されている。
    pub token_standard: Option<TokenStandard>,
    /// 作成者配列
    pub creators: Vec<Creator>,
    /// コレクション。V2では単に`Pubkey`であり、常に検証済みとみなされる。
    pub collection: Option<Pubkey>,
}

/// メタデータのハッシュを計算します。
///
/// ハッシュはメタデータバイトのkeccak256ハッシュとして計算され、
/// 次に`seller_fee_basis_points`でハッシュされます。
pub fn hash_metadata(metadata: &MetadataArgsV2) -> Result<[u8; 32]> {
    let hash = keccak::hashv(&[metadata.try_to_vec()?.as_slice()]);
    // 新しいデータハッシュを計算します。
    Ok(keccak::hashv(&[
        &hash.to_bytes(),
        &metadata.seller_fee_basis_points.to_le_bytes(),
    ])
    .to_bytes())
}

/// クリエイターのハッシュを計算します。
///
/// ハッシュはクリエイターバイトのkeccak256ハッシュとして計算されます。
pub fn hash_creators(creators: &[Creator]) -> [u8; 32] {
    // クリエイターVecをバイトVecに変換します
    let creator_data = creators
        .iter()
        .map(|c| [c.address.as_ref(), &[c.verified as u8], &[c.share]].concat())
        .collect::<Vec<_>>();
    // ハッシュを計算します
    keccak::hashv(
        creator_data
            .iter()
            .map(|c| c.as_slice())
            .collect::<Vec<&[u8]>>()
            .as_ref(),
    )
    .to_bytes()
}

/// `LeafSchemaV2`用のコレクションのハッシュを計算します（`None`の場合はデフォルトを提供）。
pub fn hash_collection_option(collection: Option<Pubkey>) -> Result<[u8; 32]> {
    let collection_key = collection.unwrap_or(DEFAULT_COLLECTION);
    Ok(keccak::hashv(&[collection_key.as_ref()]).to_bytes())
}

/// `LeafSchemaV2`用のアセットデータのハッシュを計算します（`None`の場合はデフォルトを提供）。
pub fn hash_asset_data_option(asset_data: Option<&[u8]>) -> Result<[u8; 32]> {
    let data = asset_data.unwrap_or(b""); // Noneを空データとして扱います
    Ok(keccak::hashv(&[data]).to_bytes())
}

#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Debug, Clone)]
pub enum LeafSchema {
    V1 {
        id: Pubkey,
        owner: Pubkey,
        delegate: Pubkey,
        nonce: u64,
        data_hash: [u8; 32],
        creator_hash: [u8; 32],
    },
    V2 {
        id: Pubkey,
        owner: Pubkey,
        delegate: Pubkey,
        nonce: u64,
        data_hash: [u8; 32],
        creator_hash: [u8; 32],
        collection_hash: [u8; 32],
        asset_data_hash: [u8; 32],
        flags: u8,
    },
}

impl LeafSchema {
    pub fn to_node(&self) -> Node {
        let hashed_leaf = match self {
            LeafSchema::V1 {
                id,
                owner,
                delegate,
                nonce,
                data_hash,
                creator_hash,
            } => keccak::hashv(&[
                &[self.version().to_bytes()],
                id.as_ref(),
                owner.as_ref(),
                delegate.as_ref(),
                nonce.to_le_bytes().as_ref(),
                data_hash.as_ref(),
                creator_hash.as_ref(),
            ])
            .to_bytes(),
            LeafSchema::V2 {
                id,
                owner,
                delegate,
                nonce,
                data_hash,
                creator_hash,
                collection_hash,
                asset_data_hash,
                flags,
            } => keccak::hashv(&[
                &[self.version().to_bytes()],
                id.as_ref(),
                owner.as_ref(),
                delegate.as_ref(),
                nonce.to_le_bytes().as_ref(),
                data_hash.as_ref(),
                creator_hash.as_ref(),
                collection_hash.as_ref(),
                asset_data_hash.as_ref(),
                &[*flags],
            ])
            .to_bytes(),
        };
        hashed_leaf
    }
}