Deploying Programs

To deploy the programs please use the RPC method. TPU clients are not supported. Use the following command if using Anchor: anchor deploy -- --use-rpc or solana program deploy --use-rpc

Alternatively, it can be done with Rust:

pub(crate) async fn deploy_program(
    client: &TestClient,
    payer: &Keypair,
    bytecode: &[u8],
) -> anyhow::Result<Keypair> {
    let program_keypair = Keypair::new();
    let program_pubkey = program_keypair.pubkey();

    let program_data_pubkey = get_program_data_address(&program_pubkey);

    let latest_blockhash = client
        .svm_get_latest_blockhash()
        .await
        .map_err(|e| anyhow!("Failed to retrieve the latest blockhash: {e}"))?;

    let buffer_lamports = client
        .get_minimum_balance_for_rent_exemption(
            bytecode.len() + UpgradeableLoaderState::size_of_buffer_metadata(),
        )
        .await
        .map_err(|e| anyhow!("Failed to get a rent exempt balance: {e}"))?;

    let deploy_txs = create_deploy_program_transactions(
        payer,
        &program_keypair,
        payer,
        bytecode.to_vec(),
        buffer_lamports,
        latest_blockhash,
    )
    .map_err(|e| anyhow!("Failed to initialize transactions for program deployment: {e}"))?;

    for tx in deploy_txs {
        let tx_hash = client
            .svm_send_transaction(&tx)
            .await
            .map_err(|e| anyhow!("Failed to send a transaction: {e}"))?
            .to_string();
    }

    sleep(Duration::from_secs(SLEEP_DURATION_SECONDS)).await;

    let program_account = client
        .svm_get_account_info(program_pubkey)
        .await
        .map_err(|e| anyhow!("Failed to retrieve a program account: {e}"))?;

    let program_account_data: UpgradeableLoaderState = bincode::deserialize(&program_account.data)
        .map_err(|e| anyhow!("Failed to deserialize program account data: {e}"))?;

    if let UpgradeableLoaderState::Program {
        programdata_address,
    } = program_account_data
    {
        assert_eq!(
            programdata_address, program_data_pubkey,
            "Expected programdata_address from program account's metadata to match \
            program_data_pubkey derived for program's pubkey"
        );
    }

    let program_data_account = client
        .svm_get_account_info(program_data_pubkey)
        .await
        .map_err(|e| anyhow!("Failed to retrieve a program data account: {e}"))?;

    let program_data_account_metadata: UpgradeableLoaderState = bincode::deserialize(
        &program_data_account.data[..UpgradeableLoaderState::size_of_programdata_metadata()],
    )
    .map_err(|e| anyhow!("Failed to deserialize program data account metadata: {e}"))?;

    if let UpgradeableLoaderState::ProgramData {
        upgrade_authority_address,
        ..
    } = program_data_account_metadata
    {
        let authority = upgrade_authority_address
            .expect("Expected program data account to have a program authority");
    }

    Ok(program_keypair)
}