You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: integration.rs
    path of file: ./repos/wormhole/solana/modules/nft_bridge/program/tests
    
    the code of the file until where you have to start completion: use bridge::{
    accounts::{
        PostedVAA,
        PostedVAADerivationData,
    },
    SerializePayload,
};

use libsecp256k1::SecretKey;
use nft_bridge::{
    accounts::{
        ConfigAccount,
        WrappedDerivationData,
        WrappedMint,
    },
    messages::{
        PayloadGovernanceRegisterChain,
        PayloadTransfer,
    },
    types::Config,
};
use
    
async fn transfer_native_in() {
    let mut context = set_up().await.unwrap();
    register_chain(&mut context).await;
    let Context {
        ref payer,
        ref mut client,
        bridge,
        nft_bridge,
        mint_authority: _,
        ref mint,
        ref token_account,
        ref token_authority,
        ref guardian_keys,
        ..
    } = context;

    // Do an initial transfer so that the bridge account owns the NFT.
    let message = &Keypair::new();
    common::transfer_native(
        client,
        nft_bridge,
        bridge,
        payer,
        message,
        token_account,
        token_authority,
        mint.pubkey(),
    )
    .await
    .unwrap();

    let nonce = rand::thread_rng().gen();

    let token_address = [1u8; 32];
    let token_chain = 1;
    let token_id = U256::from_big_endian(&mint.pubkey().to_bytes());

    let associated_addr = spl_associated_token_account::get_associated_token_address(
        &token_authority.pubkey(),
        &mint.pubkey(),
    );

    let payload = PayloadTransfer {
        token_address,
        token_chain,
        symbol: "NFT".into(),
        name: "Non-Fungible Token".into(),
        token_id,
        uri: "https://example.com".to_string(),
        to: associated_addr.to_bytes(),
        to_chain: 1,
    };
    let message = payload.try_to_vec().unwrap();

    let (vaa, body, _) = common::generate_vaa([0u8; 32], 2, message, nonce, 1);
    let signature_set = common::verify_signatures(client, &bridge, payer, body, guardian_keys, 0)
        .await
        .unwrap();
    common::post_vaa(client, bridge, payer, signature_set, vaa.clone())
        .await
        .unwrap();
    let msg_derivation_data = &PostedVAADerivationData {
        payload_hash: body.to_vec(),
    };
    let message_key =
        PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(msg_derivation_data, &bridge);

    common::complete_native(
        client,
        nft_bridge,
        bridge,
        message_key,
        vaa,
        payload,
        payer,
        token_authority.pubkey(),
        mint.pubkey(),
    )
    .await
    .unwrap();
}