deBridge Core Protocol Solana Contracts - deBridge

Several newly added functions lacks an accompanying documentation. Proper documentation is essential in development, as it provides crucial context about the function’s purpose, parameters, return values, and expected behavior. Without documentation, developers and maintainers may struggle to understand the function’s intent, leading to potential misuses, maintenance challenges, and increased onboarding time for new team members.

The mentioned functions are:

• update_mint_bridge_token_names in crates/client/src/client/settings_client.rs in line 1335

• new_update_mint_bridge_token_names in crates/client/src/settings_instructions_builder.rs in line 1049

• update_mint_bridge_token_names in programs/settings/src/lib.rs in line1659

  
  

Which can be seen in the snippets below:

settings_client.rs

#[async_trait]
pub trait UpdateMintBridgeTokenNames: SendTransactionBy<Role> {
    async fn update_mint_bridge_token_names(
        &self,
        token_mint: Pubkey,
        name: String,
        symbol: String,
    ) -> Result<Signature, Error> {
        self.send_by(
            &[Role::ProtocolAuthority],
            &[Instruction::new_update_mint_bridge_token_names(
                self.get_role_pubkey(Role::ProtocolAuthority)
                    .ok_or_else(|| {
                        Error::NotEnoughAuthorization(Role::ProtocolAuthority.to_string())
                    })?,
                token_mint,
                name,
                symbol,
            )],
        )
        .await
    }
}
impl<C: SendTransactionBy<Role>> UpdateMintBridgeTokenNames for C {}

settings_instructions_builder.rs

pub trait NewUpdateMintBridgeTokenNames {
    fn new_update_mint_bridge_token_names(
        protocol_authority: Pubkey,
        token_mint: Pubkey,
        new_name: String,
        new_symbol: String,
    ) -> Instruction {
        Instruction::new_with_bytes(
            settings::ID,
            &settings::instruction::UpdateMintBridgeTokenNames {
                new_name,
                new_symbol,
            }
            .data(),
            settings::accounts::UpdateMintBridgeTokenMetadata {
                update_bridge: settings::accounts::UpdateBridge {
                    state: *STATE_PUBKEY,
                    protocol_authority,
                    bridge_data: Pubkey::find_bridge_address(&token_mint).0,
                    token_mint,
                    token_program: token::ID,
                },
                token_metadata: token_metadata::pda::find_metadata_account(&token_mint).0,
                token_metadata_program: token_metadata::ID,
                token_metadata_master: Pubkey::find_token_metadata_master_address().0,
            }
            .to_account_metas(None),
        )
    }
}
impl NewUpdateMintBridgeTokenNames for Instruction {}

lib.rs

    pub fn update_mint_bridge_token_names(
        ctx: Context<UpdateMintBridgeTokenMetadata>,
        new_name: String,
        new_symbol: String,
    ) -> Result<()> {
        let token_metadata::state::Metadata {
            data:
                token_metadata::state::Data {
                    uri,
                    seller_fee_basis_points,
                    creators,
                    ..
                },
            ..
        } = token_metadata::state::Metadata::from_account_info(&ctx.accounts.token_metadata)?; // todo compute offset, only serialize necessary data

        invoke_signed(
            &token_metadata::instruction::update_metadata_accounts_v2(
                token_metadata::ID,
                ctx.accounts.token_metadata.key(),
                ctx.accounts.update_bridge.bridge_data.key(),
                None,
                Some(TokenMetadata {
                    name: new_name,
                    symbol: new_symbol,
                    seller_fee_basis_points,
                    creators,
                    uri,
                    collection: None,
                    uses: None,
                }),
                None,
                None,
            ),
            &[
                ctx.accounts.token_metadata.to_account_info(),
                ctx.accounts.update_bridge.bridge_data.to_account_info(),
            ],
            &[&[
                Bridge::SEED,
                ctx.accounts.update_bridge.token_mint.key().as_ref(),
                &[ctx.accounts.update_bridge.bridge_data.bumps.bridge],
            ]],
        )?;
        Ok(())
    }

Documenting code is widely recognized as a best practice in software development, particularly for functions performing complex or business-critical tasks. Clear documentation:

• Enhances readability, allowing developers to quickly understand the function’s logic.

• Improves maintainability by reducing time spent deciphering undocumented code.

• Reduces the risk of introducing bugs, as developers can more easily identify the function’s intended behavior.

• Simplifies onboarding for new developers by providing clear guidance on existing code functionality.

Consider adding inline documentation for each of the mentioned functions, detailing:

1. Function Purpose: A brief overview of what the function does.

2. Parameters: Descriptions of each parameter, including data types and expected values.

3. Return Values: Information on what the function returns and under what conditions.

4. Error Handling: Notes on potential errors or edge cases that the function may encounter.

ACKNOWLEDGED: The deBridge team acknowledged this finding.