Examples

//! Build a Tapedrive inline write instruction with no SDK dependency.
//! Byte-accurate against the program's parser and the SDK builders.

use solana_sdk::instruction::{AccountMeta, Instruction};
use solana_sdk::pubkey::Pubkey;
use solana_sdk::sysvar;

pub const TAPEDRIVE_PROGRAM_ID: Pubkey =
    Pubkey::from_str_const("8R87WfS1qQ5nQTzmu18KtzQY5L4EvoH9GpisuWAVDH4j");

const IX_TRACK_WRITE: u8 = 0xB0; // TapeInstruction::TrackWrite
const KIND_INLINE: u8 = 0x00; // TrackKind::Inline

/// Program-side payload cap. In practice a transaction packet fits
/// roughly 825 payload bytes; beyond that, use the SDK's coded path.
pub const TRACK_WRITE_MAX_BYTES: usize = 10 * 1024;
pub const MAX_NAME_LEN: usize = 1024;

/// Content-type discriminants (full table in the SDK reference).
pub const CONTENT_UNKNOWN: u16 = 0;
pub const CONTENT_TEXT_PLAIN: u16 = 11;
pub const CONTENT_TEXT_MARKDOWN: u16 = 16;
pub const CONTENT_APPLICATION_JSON: u16 = 25;

/// The tape (bucket) account: PDA of ["cassette", authority].
pub fn tape_pda(authority: &Pubkey) -> Pubkey {
    Pubkey::find_program_address(&[b"cassette", authority.as_ref()], &TAPEDRIVE_PROGRAM_ID).0
}

/// The program's system-state account: PDA of ["system"].
pub fn system_pda() -> Pubkey {
    Pubkey::find_program_address(&[b"system"], &TAPEDRIVE_PROGRAM_ID).0
}

/// The track address a write will get: PDA of ["track", tape, track_number LE].
/// Only needed for read-back; the write itself never takes it.
pub fn track_pda(tape: &Pubkey, track_number: u64) -> Pubkey {
    Pubkey::find_program_address(
        &[b"track", tape.as_ref(), &track_number.to_le_bytes()],
        &TAPEDRIVE_PROGRAM_ID,
    )
    .0
}

/// Build the inline write. The tape must already exist (reserve it once with
/// the SDK or CLI), and `signer` must be its authority or delegate.
/// `object` names the track: (name, content type discriminant).
pub fn inline_write_ix(
    fee_payer: &Pubkey,
    signer: &Pubkey,
    tape: &Pubkey,
    payload: &[u8],
    object: Option<(&str, u16)>,
) -> Instruction {
    assert!(!payload.is_empty() && payload.len() <= TRACK_WRITE_MAX_BYTES);

    let mut data = Vec::with_capacity(4 + payload.len());
    data.push(IX_TRACK_WRITE);
    data.push(KIND_INLINE);
    data.extend_from_slice(&(payload.len() as u16).to_le_bytes());
    data.extend_from_slice(payload);
    if let Some((name, content_type)) = object {
        let name = name.as_bytes();
        assert!(!name.is_empty() && name.len() <= MAX_NAME_LEN);
        data.extend_from_slice(&(name.len() as u16).to_le_bytes());
        data.extend_from_slice(&content_type.to_le_bytes());
        data.extend_from_slice(&(payload.len() as u64).to_le_bytes());
        data.extend_from_slice(name);
    }

    Instruction {
        program_id: TAPEDRIVE_PROGRAM_ID,
        accounts: vec![
            AccountMeta::new(*fee_payer, true),
            AccountMeta::new_readonly(*signer, true),
            AccountMeta::new_readonly(system_pda(), false),
            AccountMeta::new(*tape, false),
            AccountMeta::new_readonly(sysvar::slot_hashes::ID, false),
        ],
        data,
    }
}