use std::io::{self, Write};
use std::process;
use bs58;
use sha2::{Digest, Sha256};
pub const METADATA_PROGRAM_ID_B58: &str = "ProgM6JCCvbYkfKqJYHePx4xxSUSqJp7rh8Lyv7nk7S";
pub const HEADER_LEN: usize = 96;
pub const SEED_LEN: usize = 16;
pub const DEFAULT_SEED: &[u8] = b"idl";
pub const SYSTEM_PROGRAM_ID_B58: &str = "11111111111111111111111111111111";
pub const DISC_METADATA: u8 = 2;
pub const ENCODING_UTF8: u8 = 1;
pub const COMPRESSION_ZLIB: u8 = 2;
pub const FORMAT_JSON: u8 = 1;
pub const DATA_SOURCE_DIRECT: u8 = 0;
pub const INSTR_WRITE: u8 = 0;
pub const INSTR_INITIALIZE: u8 = 1;
pub const INSTR_SET_DATA: u8 = 3;
pub const INSTR_ALLOCATE: u8 = 7;
pub const BPF_LOADER_UPGRADEABLE_ID_B58: &str = "BPFLoaderUpgradeab1e11111111111111111111111";
pub const MAX_INLINE_PAYLOAD: usize = 800;
pub const WRITE_CHUNK_LEN: usize = 900;
const PDA_MARKER: &[u8] = b"ProgramDerivedAddress";
pub fn pad_seed(seed: &[u8]) -> [u8; SEED_LEN] {
let mut out = [0u8; SEED_LEN];
let n = seed.len().min(SEED_LEN);
out[..n].copy_from_slice(&seed[..n]);
out
}
pub fn metadata_program_id() -> [u8; 32] {
let v = bs58::decode(METADATA_PROGRAM_ID_B58)
.into_vec()
.expect("metadata program id is valid base58");
let mut out = [0u8; 32];
out.copy_from_slice(&v);
out
}
fn create_program_address(seeds: &[&[u8]], bump: u8, program_id: &[u8; 32]) -> Option<[u8; 32]> {
let mut hasher = Sha256::new();
for s in seeds {
if s.len() > 32 {
return None;
}
hasher.update(s);
}
hasher.update([bump]);
hasher.update(program_id);
hasher.update(PDA_MARKER);
let digest = hasher.finalize();
let mut hash = [0u8; 32];
hash.copy_from_slice(&digest);
if is_on_curve(&hash) {
return None;
}
Some(hash)
}
fn find_program_address(seeds: &[&[u8]], program_id: &[u8; 32]) -> ([u8; 32], u8) {
for bump in (0u8..=255).rev() {
if let Some(addr) = create_program_address(seeds, bump, program_id) {
return (addr, bump);
}
}
panic!("no off-curve PDA exists for these seeds");
}
fn is_on_curve(bytes: &[u8; 32]) -> bool {
curve25519_dalek::edwards::CompressedEdwardsY(*bytes)
.decompress()
.is_some()
}
pub fn derive_canonical_pda(program_id: &[u8; 32], seed16: &[u8; SEED_LEN]) -> ([u8; 32], u8) {
let meta = metadata_program_id();
find_program_address(&[program_id.as_ref(), seed16.as_ref()], &meta)
}
pub fn bpf_loader_upgradeable_id() -> [u8; 32] {
let v = bs58::decode(BPF_LOADER_UPGRADEABLE_ID_B58)
.into_vec()
.expect("bpf loader upgradeable id is valid base58");
let mut out = [0u8; 32];
out.copy_from_slice(&v);
out
}
pub fn derive_program_data_pda(program_id: &[u8; 32]) -> ([u8; 32], u8) {
let loader = bpf_loader_upgradeable_id();
find_program_address(&[program_id.as_ref()], &loader)
}
#[allow(dead_code)]
pub fn derive_non_canonical_pda(
program_id: &[u8; 32],
authority: &[u8; 32],
seed16: &[u8; SEED_LEN],
) -> ([u8; 32], u8) {
let meta = metadata_program_id();
find_program_address(
&[program_id.as_ref(), authority.as_ref(), seed16.as_ref()],
&meta,
)
}
#[derive(Debug, Clone)]
pub struct MetadataHeader {
pub discriminator: u8,
pub program: [u8; 32],
pub authority: Option<[u8; 32]>,
pub mutable: bool,
pub canonical: bool,
pub seed: [u8; SEED_LEN],
pub encoding: u8,
pub compression: u8,
pub format: u8,
pub data_source: u8,
pub data_len: u32,
}
impl MetadataHeader {
pub fn canonical_idl(
program: [u8; 32],
seed16: [u8; SEED_LEN],
payload: &PreparedPayload,
) -> Self {
Self::canonical(program, seed16, payload)
}
pub fn decode(bytes: &[u8]) -> Result<Self, String> {
if bytes.len() < HEADER_LEN {
return Err(format!(
"metadata account holds {} bytes; the header alone is {HEADER_LEN}",
bytes.len()
));
}
let mut program = [0u8; 32];
program.copy_from_slice(&bytes[1..33]);
let mut authority = [0u8; 32];
authority.copy_from_slice(&bytes[33..65]);
let mut seed = [0u8; SEED_LEN];
seed.copy_from_slice(&bytes[67..83]);
Ok(MetadataHeader {
discriminator: bytes[0],
program,
authority: (authority != [0u8; 32]).then_some(authority),
mutable: bytes[65] != 0,
canonical: bytes[66] != 0,
seed,
encoding: bytes[83],
compression: bytes[84],
format: bytes[85],
data_source: bytes[86],
data_len: u32::from_le_bytes([bytes[87], bytes[88], bytes[89], bytes[90]]),
})
}
pub fn seed_text(&self) -> String {
let end = self.seed.iter().position(|&b| b == 0).unwrap_or(SEED_LEN);
String::from_utf8_lossy(&self.seed[..end]).into_owned()
}
pub fn canonical(program: [u8; 32], seed16: [u8; SEED_LEN], payload: &PreparedPayload) -> Self {
MetadataHeader {
discriminator: DISC_METADATA,
program,
authority: None,
mutable: true,
canonical: true,
seed: seed16,
encoding: payload.encoding,
compression: payload.compression,
format: payload.format,
data_source: DATA_SOURCE_DIRECT,
data_len: payload.data_len(),
}
}
pub fn encode(&self) -> [u8; HEADER_LEN] {
let mut b = [0u8; HEADER_LEN];
b[0] = self.discriminator;
b[1..33].copy_from_slice(&self.program);
if let Some(auth) = &self.authority {
b[33..65].copy_from_slice(auth);
}
b[65] = self.mutable as u8;
b[66] = self.canonical as u8;
b[67..83].copy_from_slice(&self.seed);
b[83] = self.encoding;
b[84] = self.compression;
b[85] = self.format;
b[86] = self.data_source;
b[87..91].copy_from_slice(&self.data_len.to_le_bytes());
b
}
}
pub fn zlib_compress(data: &[u8]) -> Vec<u8> {
use flate2::write::ZlibEncoder;
use flate2::Compression;
use std::io::Write;
let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
encoder.write_all(data).expect("zlib write");
encoder.finish().expect("zlib finish")
}
pub fn zlib_decompress(data: &[u8]) -> Result<Vec<u8>, String> {
use flate2::read::ZlibDecoder;
use std::io::Read;
let mut out = Vec::new();
ZlibDecoder::new(data)
.read_to_end(&mut out)
.map_err(|e| format!("zlib decompression failed: {e}"))?;
Ok(out)
}
pub struct PreparedPayload {
pub raw_len: usize,
pub compressed: Vec<u8>,
pub encoding: u8,
pub compression: u8,
pub format: u8,
}
impl PreparedPayload {
pub fn from_json(json: &str) -> Self {
let compressed = zlib_compress(json.as_bytes());
PreparedPayload {
raw_len: json.len(),
compressed,
encoding: ENCODING_UTF8,
compression: COMPRESSION_ZLIB,
format: FORMAT_JSON,
}
}
pub fn from_idl_json(idl_json: &str) -> Self {
Self::from_json(idl_json)
}
pub fn data_len(&self) -> u32 {
self.compressed.len() as u32
}
}
pub fn build_initialize_inline_data(
seed16: &[u8; SEED_LEN],
encoding: u8,
compression: u8,
format: u8,
data_source: u8,
payload: &[u8],
) -> Vec<u8> {
let mut d = Vec::with_capacity(1 + SEED_LEN + 4 + payload.len());
d.push(INSTR_INITIALIZE);
d.extend_from_slice(seed16);
d.push(encoding);
d.push(compression);
d.push(format);
d.push(data_source);
d.extend_from_slice(payload);
d
}
pub fn build_initialize_from_buffer_data(
seed16: &[u8; SEED_LEN],
encoding: u8,
compression: u8,
format: u8,
data_source: u8,
) -> Vec<u8> {
let mut d = Vec::with_capacity(1 + SEED_LEN + 4);
d.push(INSTR_INITIALIZE);
d.extend_from_slice(seed16);
d.push(encoding);
d.push(compression);
d.push(format);
d.push(data_source);
d
}
pub fn build_allocate_data(seed16: &[u8; SEED_LEN]) -> Vec<u8> {
let mut d = Vec::with_capacity(1 + SEED_LEN);
d.push(INSTR_ALLOCATE);
d.extend_from_slice(seed16);
d
}
pub fn build_write_data(offset: u32, chunk: &[u8]) -> Vec<u8> {
let mut d = Vec::with_capacity(1 + 4 + chunk.len());
d.push(INSTR_WRITE);
d.extend_from_slice(&offset.to_le_bytes());
d.extend_from_slice(chunk);
d
}
pub fn build_set_data_inline_data(
encoding: u8,
compression: u8,
format: u8,
data_source: u8,
payload: &[u8],
) -> Vec<u8> {
let mut d = Vec::with_capacity(1 + 4 + payload.len());
d.push(INSTR_SET_DATA);
d.push(encoding);
d.push(compression);
d.push(format);
d.push(data_source);
d.extend_from_slice(payload);
d
}
pub fn plan_write_chunks(payload: &[u8], chunk_len: usize) -> Vec<(u32, &[u8])> {
assert!(chunk_len > 0, "chunk_len must be positive");
let mut out = Vec::new();
let mut offset = 0usize;
while offset < payload.len() {
let end = (offset + chunk_len).min(payload.len());
out.push((offset as u32, &payload[offset..end]));
offset = end;
}
out
}
#[allow(dead_code)] pub fn reassemble_write_chunks(payload_len: usize, chunks: &[(u32, &[u8])]) -> Vec<u8> {
let mut buf = vec![0u8; payload_len];
for (offset, chunk) in chunks {
let start = *offset as usize;
buf[start..start + chunk.len()].copy_from_slice(chunk);
}
buf
}
#[allow(dead_code)] pub fn expected_account_image(
program_id: &[u8; 32],
seed16: &[u8; SEED_LEN],
payload: &PreparedPayload,
) -> Vec<u8> {
let header = MetadataHeader::canonical_idl(*program_id, *seed16, payload);
let mut image = Vec::with_capacity(HEADER_LEN + payload.compressed.len());
image.extend_from_slice(&header.encode());
image.extend_from_slice(&payload.compressed);
image
}
fn hex_encode(bytes: &[u8]) -> String {
let mut s = String::with_capacity(bytes.len() * 2);
for b in bytes {
use std::fmt::Write as _;
let _ = write!(s, "{:02x}", b);
}
s
}
pub struct PublishRecord {
pub command: &'static str,
pub noun: &'static str,
pub source: String,
}
impl PublishRecord {
pub fn idl(manifest_name: &str, manifest_version: &str) -> Self {
PublishRecord {
command: "publish-idl",
noun: "IDL",
source: format!(
"Solana IDL v0.1.0 (projected from manifest {manifest_name} v{manifest_version})"
),
}
}
}
pub fn render_dry_run(
program_id: &[u8; 32],
seed16: &[u8; SEED_LEN],
idl_json: &str,
manifest_name: &str,
manifest_version: &str,
) -> String {
render_dry_run_record(
&PublishRecord::idl(manifest_name, manifest_version),
program_id,
seed16,
&PreparedPayload::from_idl_json(idl_json),
)
}
pub fn render_dry_run_record(
record: &PublishRecord,
program_id: &[u8; 32],
seed16: &[u8; SEED_LEN],
payload: &PreparedPayload,
) -> String {
let program_b58 = bs58::encode(program_id).into_string();
let (pda, bump) = derive_canonical_pda(program_id, seed16);
let pda_b58 = bs58::encode(pda).into_string();
let header = MetadataHeader::canonical(*program_id, *seed16, payload);
let header_bytes = header.encode();
let seed_text = header.seed_text();
let mut out = String::new();
use std::fmt::Write as _;
let _ = writeln!(out, "=== hopper {} (dry run) ===", record.command);
let _ = writeln!(out);
let _ = writeln!(out, "Program: {program_b58}");
let _ = writeln!(out, "Metadata program: {METADATA_PROGRAM_ID_B58}");
let _ = writeln!(
out,
"Seed: \"{seed_text}\" (hex {})",
hex_encode(seed16)
);
let _ = writeln!(out, "Derivation: canonical [program, seed]");
let _ = writeln!(out, "Metadata PDA: {pda_b58} (bump {bump})");
let _ = writeln!(out);
let _ = writeln!(out, "Payload:");
let _ = writeln!(out, " Source: {}", record.source);
let _ = writeln!(out, " Raw size: {} bytes", payload.raw_len);
let _ = writeln!(
out,
" Stored size: {} bytes (encoding=Utf8, compression=Zlib, format=Json)",
payload.data_len()
);
let _ = writeln!(out);
let _ = writeln!(out, "Account header ({HEADER_LEN} bytes):");
let _ = writeln!(out, " {}", hex_encode(&header_bytes));
let _ = writeln!(
out,
" disc={} mutable={} canonical={} encoding={} compression={} format={} data_source={} data_len={}",
header.discriminator,
header.mutable as u8,
header.canonical as u8,
header.encoding,
header.compression,
header.format,
header.data_source,
header.data_len,
);
let _ = writeln!(out);
let (program_data, _pd_bump) = derive_program_data_pda(program_id);
let program_data_b58 = bs58::encode(program_data).into_string();
let stored = payload.data_len() as usize;
let inline = stored <= MAX_INLINE_PAYLOAD;
let _ = writeln!(out, "Instruction plan (NOT sent):");
let _ = writeln!(out, " metadata program: {METADATA_PROGRAM_ID_B58}");
let _ = writeln!(out, " program data PDA: {program_data_b58}");
if inline {
let init = build_initialize_inline_data(
seed16,
payload.encoding,
payload.compression,
payload.format,
DATA_SOURCE_DIRECT,
&payload.compressed,
);
let _ = writeln!(out, " path: single inline Initialize (fits one tx)");
let _ = writeln!(
out,
" ix[0]: SystemProgram::transfer (rent pre-fund -> PDA)"
);
let _ = writeln!(
out,
" ix[1]: Initialize (disc {INSTR_INITIALIZE}) data {} bytes",
init.len()
);
let _ = writeln!(
out,
" accounts: [metadata(w) {pda_b58}], [authority(s,w)],"
);
let _ = writeln!(
out,
" [program(r) {program_b58}], [programData(r)], [system(r) {SYSTEM_PROGRAM_ID_B58}]"
);
} else {
let chunks = plan_write_chunks(&payload.compressed, WRITE_CHUNK_LEN);
let _ = writeln!(
out,
" path: Allocate + {} chunked Write(s) + in-place Initialize",
chunks.len()
);
let _ = writeln!(
out,
" tx[0]: transfer(rent) + Allocate (disc {INSTR_ALLOCATE}, seed)"
);
for (idx, (offset, chunk)) in chunks.iter().enumerate() {
let _ = writeln!(
out,
" tx[{}]: Write (disc {INSTR_WRITE}) offset {} len {}",
idx + 1,
offset,
chunk.len()
);
}
let _ = writeln!(
out,
" tx[{}]: Initialize-from-buffer (disc {INSTR_INITIALIZE}, no inline data)",
chunks.len() + 1
);
}
let _ = writeln!(
out,
" result: 96-byte header (above) + {stored} zlib bytes at the PDA"
);
let _ = writeln!(out);
let _ = writeln!(out, "Dry run only. No transaction was created or sent.");
out
}
fn print_usage() {
eprintln!("Usage: hopper publish-idl --manifest <path> --program-id <pubkey>");
eprintln!(" [--cluster <name> | --url <rpc>] [--keypair <path>]");
eprintln!(" [--seed <str>] [--overwrite] [--yes] [--dry-run]");
eprintln!();
eprintln!("Publish a program's Solana IDL v0.1.0 through Program Metadata");
eprintln!("program (canonical [program, \"idl\"] PDA), with zero Node dependencies.");
eprintln!();
eprintln!("Without --dry-run this signs and submits the on-chain transaction(s):");
eprintln!("a single inline Initialize for small IDLs, or Allocate + chunked Write");
eprintln!("+ Initialize for IDLs larger than one transaction. The signer must be");
eprintln!("the program's upgrade authority (canonical metadata).");
eprintln!();
eprintln!("Options:");
eprintln!(" --manifest <path> Hopper program manifest JSON (also accepts inline/@file)");
eprintln!(" --program-id <pubkey> Base58 program id the IDL describes");
eprintln!(" --cluster <name> devnet (default), testnet, mainnet-beta, or localnet");
eprintln!(" --url, --rpc <rpc> Custom RPC endpoint; treated as potentially mainnet");
eprintln!(" SOLANA_RPC_URL is the guarded fallback when set");
eprintln!(" --keypair <path> Upgrade-authority + fee-payer keypair");
eprintln!(" (default: ~/.config/solana/id.json)");
eprintln!(" --seed <str> Metadata seed (default \"idl\", padded to 16 bytes)");
eprintln!(" --overwrite Rewrite an already-initialized metadata account (SetData)");
eprintln!(" --yes, -y Skip mainnet/custom-RPC confirmation");
eprintln!(" --dry-run Preview the header/PDA/plan; no network access or prompt");
}
pub fn cmd_publish_idl(args: &[String]) {
let mut manifest_arg: Option<String> = None;
let mut program_id_arg: Option<String> = None;
let mut seed_arg: Option<String> = None;
let mut url_arg: Option<String> = None;
let mut cluster_arg: Option<String> = None;
let mut keypair_arg: Option<String> = None;
let mut overwrite = false;
let mut dry_run = false;
let mut yes = false;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--url" | "--rpc" | "-u" => {
url_arg = args.get(i + 1).cloned();
if url_arg.is_none() {
eprintln!("{} requires an RPC endpoint argument", args[i]);
process::exit(1);
}
i += 2;
}
"--cluster" => {
cluster_arg = args.get(i + 1).cloned();
if cluster_arg.is_none() {
eprintln!("--cluster requires a cluster moniker argument");
process::exit(1);
}
i += 2;
}
"--keypair" | "--signer" => {
keypair_arg = args.get(i + 1).cloned();
if keypair_arg.is_none() {
eprintln!("--keypair requires a path argument");
process::exit(1);
}
i += 2;
}
"--overwrite" => {
overwrite = true;
i += 1;
}
"--manifest" => {
manifest_arg = args.get(i + 1).cloned();
if manifest_arg.is_none() {
eprintln!("--manifest requires a path argument");
process::exit(1);
}
i += 2;
}
"--program-id" => {
program_id_arg = args.get(i + 1).cloned();
if program_id_arg.is_none() {
eprintln!("--program-id requires a base58 pubkey argument");
process::exit(1);
}
i += 2;
}
"--seed" => {
seed_arg = args.get(i + 1).cloned();
if seed_arg.is_none() {
eprintln!("--seed requires a string argument");
process::exit(1);
}
i += 2;
}
"--dry-run" => {
dry_run = true;
i += 1;
}
"--yes" | "-y" => {
yes = true;
i += 1;
}
"--help" | "-h" => {
print_usage();
return;
}
other => {
eprintln!("Unknown publish-idl argument: {other}");
print_usage();
process::exit(1);
}
}
}
let manifest_arg = manifest_arg.unwrap_or_else(|| {
eprintln!("--manifest is required");
print_usage();
process::exit(1);
});
let program_id_arg = program_id_arg.unwrap_or_else(|| {
eprintln!("--program-id is required");
print_usage();
process::exit(1);
});
let program_bytes = bs58::decode(&program_id_arg)
.into_vec()
.unwrap_or_else(|e| {
eprintln!("invalid base58 program id: {e}");
process::exit(1);
});
if program_bytes.len() != 32 {
eprintln!("program id must be 32 bytes, got {}", program_bytes.len());
process::exit(1);
}
let mut program_id = [0u8; 32];
program_id.copy_from_slice(&program_bytes);
let seed_bytes = seed_arg
.as_deref()
.map(|s| s.as_bytes().to_vec())
.unwrap_or_else(|| DEFAULT_SEED.to_vec());
if seed_bytes.len() > SEED_LEN {
eprintln!(
"seed is {} bytes; the metadata seed field is at most {SEED_LEN} bytes",
seed_bytes.len()
);
process::exit(1);
}
let seed16 = pad_seed(&seed_bytes);
let load_arg = if manifest_arg.starts_with('@') || manifest_arg.trim_start().starts_with('{') {
manifest_arg.clone()
} else {
format!("@{manifest_arg}")
};
let manifest = crate::load_program_manifest(&load_arg);
let projection = hopper_schema::anchor_idl::AnchorIdlFromManifest {
manifest: &manifest,
address: &program_id_arg,
};
if let Err(error) = projection.validate() {
eprintln!("cannot publish a complete Solana IDL v0.1.0: {error}");
process::exit(1);
}
let idl_json = format!("{projection}");
if dry_run {
print!(
"{}",
render_dry_run(
&program_id,
&seed16,
&idl_json,
manifest.name,
manifest.version,
)
);
return;
}
let payload = PreparedPayload::from_idl_json(&idl_json);
if let Err(e) = run_publish_send(
&PublishRecord::idl(manifest.name, manifest.version),
&program_id,
&seed16,
&payload,
url_arg.as_deref(),
cluster_arg.as_deref(),
keypair_arg.as_deref(),
overwrite,
yes,
) {
eprintln!("publish-idl: {e}");
process::exit(1);
}
}
const PUBLISH_DEFAULT_RPC: &str = "https://api.devnet.solana.com";
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct PublishTarget {
pub(crate) url: String,
pub(crate) label: String,
pub(crate) requires_confirmation: bool,
}
impl PublishTarget {
pub(crate) fn display_url(&self) -> String {
crate::cmd::cluster::redact_rpc_url(&self.url)
}
fn destination_label(&self) -> &'static str {
if self.label == "mainnet-beta" {
"MAINNET-BETA"
} else {
"A CUSTOM CLUSTER (POTENTIALLY MAINNET-BETA)"
}
}
}
fn custom_publish_target(url: &str) -> Result<PublishTarget, String> {
let trimmed = url.trim();
if trimmed.chars().any(char::is_control) {
return Err("RPC endpoint must not contain control characters".to_string());
}
let lower = trimmed.to_ascii_lowercase();
if !(lower.starts_with("http://") || lower.starts_with("https://")) {
return Err("RPC endpoint must start with http:// or https://".to_string());
}
Ok(PublishTarget {
url: trimmed.to_string(),
label: "custom".to_string(),
requires_confirmation: true,
})
}
fn named_publish_target(moniker: &str) -> Result<PublishTarget, String> {
if moniker.chars().any(char::is_control) {
return Err("cluster target must not contain control characters".to_string());
}
let (url, label, requires_confirmation) = crate::cmd::cluster::cluster_url(moniker)
.ok_or_else(|| {
format!(
"unknown cluster moniker or RPC URL: {}",
crate::cmd::cluster::redact_rpc_url(moniker)
)
})?;
Ok(PublishTarget {
url,
label,
requires_confirmation,
})
}
pub(crate) fn resolve_publish_target(
cli_url: Option<&str>,
cli_cluster: Option<&str>,
env_url: Option<&str>,
) -> Result<PublishTarget, String> {
if cli_url.is_some() && cli_cluster.is_some() {
return Err("use either --cluster or --url/--rpc, not both".to_string());
}
if let Some(url) = cli_url {
return custom_publish_target(url);
}
if let Some(cluster) = cli_cluster {
return named_publish_target(cluster);
}
if let Some(url) = env_url.filter(|url| !url.trim().is_empty()) {
return custom_publish_target(url);
}
Ok(PublishTarget {
url: PUBLISH_DEFAULT_RPC.to_string(),
label: "devnet".to_string(),
requires_confirmation: false,
})
}
fn confirm_publish_target(
target: &PublishTarget,
yes: bool,
overwrite: bool,
program_id: &str,
noun: &str,
) -> Result<(), String> {
if !target.requires_confirmation || yes {
return Ok(());
}
let action = if overwrite {
format!("overwrite the published {noun}")
} else {
format!("publish the {noun}")
};
eprint!(
"About to {action} for {program_id} on {} ({}). This submits signed transactions. Type 'yes' to continue: ",
target.destination_label(),
target.display_url()
);
io::stderr()
.flush()
.map_err(|e| format!("flush confirmation prompt: {e}"))?;
let mut line = String::new();
io::stdin()
.read_line(&mut line)
.map_err(|e| format!("read confirmation: {e}"))?;
if line.trim() != "yes" {
return Err("aborted".to_string());
}
Ok(())
}
pub(crate) fn redact_rpc_error(target: &PublishTarget, error: impl ToString) -> String {
error
.to_string()
.replace(&target.url, &target.display_url())
}
fn resolve_keypair_path(cli: Option<&str>) -> Result<std::path::PathBuf, String> {
if let Some(p) = cli {
return Ok(std::path::PathBuf::from(p));
}
crate::workspace::default_solana_keypair_path().ok_or_else(|| {
"no --keypair supplied and no default keypair at ~/.config/solana/id.json".to_string()
})
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn run_publish_send(
record: &PublishRecord,
program_id: &[u8; 32],
seed16: &[u8; SEED_LEN],
payload: &PreparedPayload,
url_cli: Option<&str>,
cluster_cli: Option<&str>,
keypair_cli: Option<&str>,
overwrite: bool,
yes: bool,
) -> Result<(), String> {
use solana_client::rpc_client::RpcClient;
use solana_commitment_config::CommitmentConfig;
use solana_instruction::{AccountMeta, Instruction};
use solana_keypair::read_keypair_file;
use solana_pubkey::Pubkey;
use solana_signer::Signer;
use solana_system_interface::instruction as system_instruction;
use solana_transaction::Transaction;
let env_url = std::env::var("SOLANA_RPC_URL").ok();
let target = resolve_publish_target(url_cli, cluster_cli, env_url.as_deref())?;
let program_b58 = bs58::encode(program_id).into_string();
confirm_publish_target(&target, yes, overwrite, &program_b58, record.noun)?;
let display_url = target.display_url();
let url = target.url.clone();
let keypair_path = resolve_keypair_path(keypair_cli)?;
let authority = read_keypair_file(&keypair_path)
.map_err(|e| format!("read keypair {}: {e}", keypair_path.display()))?;
let (pda, _bump) = derive_canonical_pda(program_id, seed16);
let (program_data, _pd_bump) = derive_program_data_pda(program_id);
let pda_b58 = bs58::encode(pda).into_string();
let metadata_program = Pubkey::new_from_array(metadata_program_id());
let system_program = Pubkey::new_from_array([0u8; 32]);
let program_pk = Pubkey::new_from_array(*program_id);
let program_data_pk = Pubkey::new_from_array(program_data);
let pda_pk = Pubkey::new_from_array(pda);
let authority_pk = authority.pubkey();
let stored = payload.compressed.len();
let final_space = HEADER_LEN + stored;
println!("=== hopper {} ===", record.command);
println!("rpc : {display_url}");
println!("signer/authority : {authority_pk}");
println!("program : {program_b58}");
println!("metadata PDA : {pda_b58}");
println!(
"payload : {} raw -> {} zlib bytes",
payload.raw_len, stored
);
println!("source : {}", record.source);
let existing = crate::rpc::get_account_info(&url, &pda_b58).map_err(|e| {
format!(
"getAccountInfo({pda_b58}): {}",
redact_rpc_error(&target, e)
)
})?;
let existing_disc = existing.as_ref().and_then(|a| a.data.first().copied());
let owned_by_metadata = existing
.as_ref()
.map(|a| a.owner == METADATA_PROGRAM_ID_B58)
.unwrap_or(false);
let existing_lamports = existing.as_ref().map(|a| a.lamports).unwrap_or(0);
if let Some(acc) = existing.as_ref() {
if !acc.data.is_empty() && !owned_by_metadata {
return Err(format!(
"PDA {pda_b58} exists but is owned by {} (not the metadata program); refusing to write",
acc.owner
));
}
}
let is_initialized = owned_by_metadata && existing_disc == Some(DISC_METADATA);
let is_leftover_buffer = owned_by_metadata && existing_disc == Some(1 );
if is_initialized && !overwrite {
return Err(format!(
"metadata account {pda_b58} is already initialized; re-run with --overwrite to rewrite it"
));
}
let rpc = RpcClient::new_with_commitment(url.clone(), CommitmentConfig::confirmed());
let rent = rpc
.get_minimum_balance_for_rent_exemption(final_space)
.map_err(|e| {
format!(
"get_minimum_balance_for_rent_exemption({final_space}): {}",
redact_rpc_error(&target, e)
)
})?;
let topup = rent.saturating_sub(existing_lamports);
const BASE_FEE: u64 = 5_000;
let planned_txs: u64 =
if is_initialized || (stored <= MAX_INLINE_PAYLOAD && !is_leftover_buffer) {
1 } else {
plan_write_chunks(&payload.compressed, WRITE_CHUNK_LEN).len() as u64 + 2
};
let required = topup.saturating_add(planned_txs.saturating_mul(BASE_FEE));
let payer_balance = rpc.get_balance(&authority_pk).map_err(|e| {
format!(
"get_balance({authority_pk}): {}",
redact_rpc_error(&target, e)
)
})?;
if payer_balance < required {
let funding_hint = if target.label == "devnet" {
format!("Try `solana airdrop 1 {authority_pk} --url {display_url}`.")
} else {
format!("Fund it on the selected target ({display_url}).")
};
return Err(format!(
"insufficient balance: signer {authority_pk} has {payer_balance} lamports but needs \
~{required} (rent top-up {topup} + {planned_txs} tx fee(s)). {funding_hint}"
));
}
let init_metas = || {
vec![
AccountMeta::new(pda_pk, false), AccountMeta::new(authority_pk, true), AccountMeta::new_readonly(program_pk, false), AccountMeta::new_readonly(program_data_pk, false), AccountMeta::new_readonly(system_program, false), ]
};
let send = |instructions: &[Instruction], label: &str| -> Result<String, String> {
let recent = rpc.get_latest_blockhash().map_err(|e| {
format!(
"get_latest_blockhash ({label}): {}",
redact_rpc_error(&target, e)
)
})?;
let tx = Transaction::new_signed_with_payer(
instructions,
Some(&authority_pk),
&[&authority],
recent,
);
super::transaction_limits::ensure_legacy_transaction_size(
&tx,
&format!("hopper {} {label}", record.command),
)?;
rpc.send_and_confirm_transaction(&tx)
.map(|s| s.to_string())
.map_err(|e| format!("{label}: {}", redact_rpc_error(&target, e)))
};
if is_initialized {
if stored > MAX_INLINE_PAYLOAD {
return Err(format!(
"--overwrite of a {stored}-byte payload needs chunking, which the in-place \
SetData path does not support. Close the metadata account first, then \
re-publish fresh (the fresh large-publish path handles chunking)."
));
}
let mut ixs = Vec::new();
if topup > 0 {
ixs.push(system_instruction::transfer(&authority_pk, &pda_pk, topup));
}
let data = build_set_data_inline_data(
payload.encoding,
payload.compression,
payload.format,
DATA_SOURCE_DIRECT,
&payload.compressed,
);
let metas = vec![
AccountMeta::new(pda_pk, false), AccountMeta::new(authority_pk, true), AccountMeta::new_readonly(metadata_program, false), AccountMeta::new_readonly(program_pk, false), AccountMeta::new_readonly(program_data_pk, false), ];
ixs.push(Instruction {
program_id: metadata_program,
accounts: metas,
data,
});
println!("path : overwrite (inline SetData)");
let sig = send(&ixs, "SetData")?;
println!("signature : {sig}");
println!("status : confirmed (metadata rewritten)");
return Ok(());
}
if stored <= MAX_INLINE_PAYLOAD && !is_leftover_buffer {
let mut ixs = Vec::new();
if topup > 0 {
ixs.push(system_instruction::transfer(&authority_pk, &pda_pk, topup));
}
let data = build_initialize_inline_data(
seed16,
payload.encoding,
payload.compression,
payload.format,
DATA_SOURCE_DIRECT,
&payload.compressed,
);
ixs.push(Instruction {
program_id: metadata_program,
accounts: init_metas(),
data,
});
println!("path : fresh inline Initialize");
let sig = send(&ixs, "Initialize")?;
println!("signature : {sig}");
println!("status : confirmed ({} published)", record.noun);
return Ok(());
}
let chunks = plan_write_chunks(&payload.compressed, WRITE_CHUNK_LEN);
println!(
"path : fresh buffered ({} write chunk(s))",
chunks.len()
);
if is_leftover_buffer {
if topup > 0 {
let sig = send(
&[system_instruction::transfer(&authority_pk, &pda_pk, topup)],
"top-up existing buffer",
)?;
println!("resume buffer : topped up ({sig})");
} else {
println!("resume buffer : reusing existing buffer at PDA");
}
} else {
let mut ixs = Vec::new();
if topup > 0 {
ixs.push(system_instruction::transfer(&authority_pk, &pda_pk, topup));
}
ixs.push(Instruction {
program_id: metadata_program,
accounts: init_metas(),
data: build_allocate_data(seed16),
});
let sig = send(&ixs, "Allocate")?;
println!("allocate : {sig}");
}
for (idx, (offset, chunk)) in chunks.iter().enumerate() {
let metas = vec![
AccountMeta::new(pda_pk, false), AccountMeta::new(authority_pk, true), AccountMeta::new_readonly(metadata_program, false), ];
let ix = Instruction {
program_id: metadata_program,
accounts: metas,
data: build_write_data(*offset, chunk),
};
let sig = send(&[ix], &format!("Write chunk {}/{}", idx + 1, chunks.len()))?;
println!(
"write [{:>2}/{:>2}] : offset {:>6} len {:>4} {sig}",
idx + 1,
chunks.len(),
offset,
chunk.len()
);
}
let data = build_initialize_from_buffer_data(
seed16,
payload.encoding,
payload.compression,
payload.format,
DATA_SOURCE_DIRECT,
);
let ix = Instruction {
program_id: metadata_program,
accounts: init_metas(),
data,
};
let sig = send(&[ix], "Initialize (finalize buffer)")?;
println!("finalize : {sig}");
println!("status : confirmed ({} published)", record.noun);
Ok(())
}
pub struct PublishedRecord {
pub pda_b58: String,
pub header: MetadataHeader,
pub lamports: u64,
pub stored_len: usize,
pub payload: Vec<u8>,
}
pub(crate) fn fetch_published_record(
url: &str,
program_id: &[u8; 32],
seed16: &[u8; SEED_LEN],
) -> Result<Option<PublishedRecord>, String> {
let (pda, _bump) = derive_canonical_pda(program_id, seed16);
let pda_b58 = bs58::encode(pda).into_string();
let Some(account) = crate::rpc::get_account_info(url, &pda_b58)? else {
return Ok(None);
};
if account.owner != METADATA_PROGRAM_ID_B58 {
return Err(format!(
"{pda_b58} is owned by {}, not the Program Metadata program",
account.owner
));
}
let header = MetadataHeader::decode(&account.data)?;
if header.discriminator != DISC_METADATA {
return Err(format!(
"{pda_b58} holds a Program Metadata account with discriminator {} (an unfinalized \
Buffer, not a published record)",
header.discriminator
));
}
let stored_len = header.data_len as usize;
let body = account
.data
.get(HEADER_LEN..HEADER_LEN + stored_len)
.ok_or_else(|| {
format!(
"{pda_b58}: header declares {stored_len} payload bytes but the account holds {}",
account.data.len().saturating_sub(HEADER_LEN)
)
})?;
let payload = match header.compression {
COMPRESSION_ZLIB => zlib_decompress(body)?,
0 => body.to_vec(),
other => {
return Err(format!(
"{pda_b58}: unsupported compression tag {other} (only none and zlib are read)"
))
}
};
Ok(Some(PublishedRecord {
pda_b58,
header,
lamports: account.lamports,
stored_len,
payload,
}))
}
#[cfg(test)]
mod tests {
use super::*;
fn sample_program() -> [u8; 32] {
[1u8; 32]
}
#[test]
fn seed_padding_is_right_padded_and_16_bytes() {
let s = pad_seed(DEFAULT_SEED);
assert_eq!(s.len(), SEED_LEN);
assert_eq!(&s[..3], b"idl");
assert!(s[3..].iter().all(|&b| b == 0), "tail must be zero-padded");
}
#[test]
fn seed_padding_truncates_overlong_input() {
let long = [0xABu8; 20];
let s = pad_seed(&long);
assert_eq!(s, [0xABu8; SEED_LEN]);
}
#[test]
fn metadata_program_id_decodes_to_32_bytes() {
let id = metadata_program_id();
assert_eq!(id.len(), 32);
assert_eq!(bs58::encode(id).into_string(), METADATA_PROGRAM_ID_B58);
}
#[test]
fn canonical_pda_is_deterministic() {
let prog = sample_program();
let seed = pad_seed(DEFAULT_SEED);
let a = derive_canonical_pda(&prog, &seed);
let b = derive_canonical_pda(&prog, &seed);
assert_eq!(a, b, "same inputs must yield the same PDA + bump");
assert!(!is_on_curve(&a.0));
let meta = metadata_program_id();
let redo = create_program_address(&[prog.as_ref(), seed.as_ref()], a.1, &meta);
assert_eq!(redo, Some(a.0));
}
#[test]
fn canonical_and_non_canonical_differ() {
let prog = sample_program();
let authority = [7u8; 32];
let seed = pad_seed(DEFAULT_SEED);
let (canon, _) = derive_canonical_pda(&prog, &seed);
let (non_canon, _) = derive_non_canonical_pda(&prog, &authority, &seed);
assert_ne!(
canon, non_canon,
"adding the authority seed must change the derived address"
);
}
#[test]
fn different_seed_padding_changes_pda() {
let prog = sample_program();
let a = pad_seed(b"idl");
let mut b = pad_seed(b"idl");
b[8] = 0xFF; let (pa, _) = derive_canonical_pda(&prog, &a);
let (pb, _) = derive_canonical_pda(&prog, &b);
assert_ne!(pa, pb);
}
#[test]
fn header_encodes_byte_for_byte_fixture() {
let header = MetadataHeader {
discriminator: DISC_METADATA, program: [0x01; 32],
authority: None, mutable: true, canonical: true, seed: pad_seed(b"idl"),
encoding: ENCODING_UTF8, compression: COMPRESSION_ZLIB, format: FORMAT_JSON, data_source: DATA_SOURCE_DIRECT, data_len: 0x1234_5678, };
let mut expected = [0u8; HEADER_LEN];
expected[0] = 0x02; for b in expected[1..33].iter_mut() {
*b = 0x01; }
expected[65] = 0x01; expected[66] = 0x01; expected[67] = 0x69; expected[68] = 0x64; expected[69] = 0x6c; expected[83] = 0x01; expected[84] = 0x02; expected[85] = 0x01; expected[86] = 0x00; expected[87] = 0x78; expected[88] = 0x56;
expected[89] = 0x34;
expected[90] = 0x12;
assert_eq!(header.encode(), expected);
}
#[test]
fn header_encodes_authority_some() {
let header = MetadataHeader {
discriminator: DISC_METADATA,
program: [0u8; 32],
authority: Some([0xAA; 32]),
mutable: false,
canonical: false,
seed: [0u8; SEED_LEN],
encoding: ENCODING_UTF8,
compression: COMPRESSION_ZLIB,
format: FORMAT_JSON,
data_source: DATA_SOURCE_DIRECT,
data_len: 0,
};
let bytes = header.encode();
assert!(bytes[33..65].iter().all(|&b| b == 0xAA));
assert_eq!(bytes[65], 0); assert_eq!(bytes[66], 0); }
#[test]
fn header_len_is_96() {
let header = MetadataHeader {
discriminator: DISC_METADATA,
program: [9u8; 32],
authority: None,
mutable: true,
canonical: true,
seed: pad_seed(b"idl"),
encoding: ENCODING_UTF8,
compression: COMPRESSION_ZLIB,
format: FORMAT_JSON,
data_source: DATA_SOURCE_DIRECT,
data_len: 42,
};
assert_eq!(header.encode().len(), HEADER_LEN);
assert_eq!(&header.encode()[87..91], &42u32.to_le_bytes());
}
#[test]
fn canonical_idl_reads_payload_tags() {
let payload = PreparedPayload::from_idl_json(r#"{"name":"demo"}"#);
let header = MetadataHeader::canonical_idl([9u8; 32], pad_seed(b"idl"), &payload);
assert_eq!(header.encoding, ENCODING_UTF8);
assert_eq!(header.compression, COMPRESSION_ZLIB);
assert_eq!(header.format, FORMAT_JSON);
assert_eq!(header.data_len, payload.data_len());
}
#[test]
fn zlib_round_trips() {
let sample = br#"{"version":"0.1.0","name":"demo","instructions":[]}"#;
let compressed = zlib_compress(sample);
let restored = zlib_decompress(&compressed).expect("decompress");
assert_eq!(restored, sample);
}
#[test]
fn zlib_round_trips_large_repetitive_payload() {
let big = "{\"field\":\"value\"},".repeat(4096);
let compressed = zlib_compress(big.as_bytes());
assert!(
compressed.len() < big.len(),
"repetitive payload should shrink"
);
let restored = zlib_decompress(&compressed).expect("decompress");
assert_eq!(restored, big.as_bytes());
}
#[test]
fn prepared_payload_reports_utf8_zlib_json() {
let idl = r#"{"version":"0.1.0","name":"demo"}"#;
let prepared = PreparedPayload::from_idl_json(idl);
assert_eq!(prepared.raw_len, idl.len());
assert_eq!(prepared.encoding, ENCODING_UTF8);
assert_eq!(prepared.compression, COMPRESSION_ZLIB);
assert_eq!(prepared.format, FORMAT_JSON);
assert_eq!(prepared.data_len() as usize, prepared.compressed.len());
let restored = zlib_decompress(&prepared.compressed).expect("decompress");
assert_eq!(restored, idl.as_bytes());
}
#[test]
fn dry_run_output_contains_pda_and_header() {
let prog = sample_program();
let seed = pad_seed(DEFAULT_SEED);
let idl = r#"{"version":"0.1.0","name":"demo","instructions":[]}"#;
let report = render_dry_run(&prog, &seed, idl, "demo", "0.1.0");
let (pda, _) = derive_canonical_pda(&prog, &seed);
let pda_b58 = bs58::encode(pda).into_string();
assert!(
report.contains(&pda_b58),
"dry-run must print the derived metadata PDA"
);
let payload = PreparedPayload::from_idl_json(idl);
let header = MetadataHeader::canonical_idl(prog, seed, &payload);
let header_hex = hex_encode(&header.encode());
assert!(
report.contains(&header_hex),
"dry-run must print the 96-byte header hex"
);
assert!(report.contains(METADATA_PROGRAM_ID_B58));
assert!(report.contains("No transaction was created or sent"));
}
#[test]
fn initialize_inline_data_is_disc_seed_tags_payload() {
let seed = pad_seed(b"idl");
let payload = [0xAA, 0xBB, 0xCC];
let d = build_initialize_inline_data(
&seed,
ENCODING_UTF8,
COMPRESSION_ZLIB,
FORMAT_JSON,
DATA_SOURCE_DIRECT,
&payload,
);
assert_eq!(d[0], INSTR_INITIALIZE);
assert_eq!(&d[1..17], &seed);
assert_eq!(d[17], ENCODING_UTF8);
assert_eq!(d[18], COMPRESSION_ZLIB);
assert_eq!(d[19], FORMAT_JSON);
assert_eq!(d[20], DATA_SOURCE_DIRECT);
assert_eq!(&d[21..], &payload);
assert_eq!(d.len(), 1 + SEED_LEN + 4 + payload.len());
}
#[test]
fn initialize_from_buffer_data_omits_payload() {
let seed = pad_seed(b"idl");
let d = build_initialize_from_buffer_data(
&seed,
ENCODING_UTF8,
COMPRESSION_ZLIB,
FORMAT_JSON,
DATA_SOURCE_DIRECT,
);
assert_eq!(d[0], INSTR_INITIALIZE);
assert_eq!(&d[1..17], &seed);
assert_eq!(
&d[17..21],
&[
ENCODING_UTF8,
COMPRESSION_ZLIB,
FORMAT_JSON,
DATA_SOURCE_DIRECT
]
);
assert_eq!(
d.len(),
1 + SEED_LEN + 4,
"no inline payload for the buffer path"
);
}
#[test]
fn allocate_data_is_disc_and_seed() {
let seed = pad_seed(b"idl");
let d = build_allocate_data(&seed);
assert_eq!(d[0], INSTR_ALLOCATE);
assert_eq!(&d[1..], &seed);
assert_eq!(d.len(), 1 + SEED_LEN);
}
#[test]
fn write_data_encodes_offset_le_then_chunk() {
let chunk = [1u8, 2, 3, 4, 5];
let d = build_write_data(0x0000_0900, &chunk);
assert_eq!(d[0], INSTR_WRITE);
assert_eq!(&d[1..5], &2304u32.to_le_bytes());
assert_eq!(&d[5..], &chunk);
}
#[test]
fn set_data_inline_is_disc_tags_payload() {
let payload = [0xDE, 0xAD];
let d = build_set_data_inline_data(
ENCODING_UTF8,
COMPRESSION_ZLIB,
FORMAT_JSON,
DATA_SOURCE_DIRECT,
&payload,
);
assert_eq!(d[0], INSTR_SET_DATA);
assert_eq!(
&d[1..5],
&[
ENCODING_UTF8,
COMPRESSION_ZLIB,
FORMAT_JSON,
DATA_SOURCE_DIRECT
]
);
assert_eq!(&d[5..], &payload);
}
#[test]
fn chunking_boundaries_are_contiguous_and_cover_payload() {
let payload: Vec<u8> = (0..2050u32).map(|i| (i % 251) as u8).collect();
let chunks = plan_write_chunks(&payload, WRITE_CHUNK_LEN);
assert_eq!(chunks.len(), 3);
assert_eq!(chunks[0].0, 0);
assert_eq!(chunks[0].1.len(), 900);
assert_eq!(chunks[1].0, 900);
assert_eq!(chunks[1].1.len(), 900);
assert_eq!(chunks[2].0, 1800);
assert_eq!(chunks[2].1.len(), 250);
let mut expected_off = 0u32;
for (off, ch) in &chunks {
assert_eq!(*off, expected_off);
assert!(ch.len() <= WRITE_CHUNK_LEN);
expected_off += ch.len() as u32;
}
assert_eq!(expected_off as usize, payload.len());
}
#[test]
fn chunks_reassemble_to_original_payload() {
let payload: Vec<u8> = (0..5000u32).map(|i| (i * 7 % 256) as u8).collect();
let chunks = plan_write_chunks(&payload, WRITE_CHUNK_LEN);
let rebuilt = reassemble_write_chunks(payload.len(), &chunks);
assert_eq!(
rebuilt, payload,
"buffered writes must reproduce the payload byte-for-byte"
);
}
#[test]
fn program_data_pda_is_deterministic_and_off_curve() {
let prog = sample_program();
let a = derive_program_data_pda(&prog);
let b = derive_program_data_pda(&prog);
assert_eq!(a, b);
assert!(!is_on_curve(&a.0));
let (meta_pda, _) = derive_canonical_pda(&prog, &pad_seed(DEFAULT_SEED));
assert_ne!(a.0, meta_pda);
}
#[test]
fn expected_account_image_is_header_then_payload() {
let prog = sample_program();
let seed = pad_seed(DEFAULT_SEED);
let idl = r#"{"version":"0.1.0","name":"demo","instructions":[]}"#;
let payload = PreparedPayload::from_idl_json(idl);
let image = expected_account_image(&prog, &seed, &payload);
let header = MetadataHeader::canonical_idl(prog, seed, &payload);
assert_eq!(&image[..HEADER_LEN], &header.encode());
assert_eq!(&image[HEADER_LEN..], &payload.compressed[..]);
assert_eq!(image.len() - HEADER_LEN, header.data_len as usize);
}
#[test]
fn dry_run_vs_send_parity_inline() {
let prog = sample_program();
let seed = pad_seed(DEFAULT_SEED);
let idl = r#"{"version":"0.1.0","name":"demo","instructions":[]}"#;
let payload = PreparedPayload::from_idl_json(idl);
assert!(payload.compressed.len() <= MAX_INLINE_PAYLOAD);
let init = build_initialize_inline_data(
&seed,
payload.encoding,
payload.compression,
payload.format,
DATA_SOURCE_DIRECT,
&payload.compressed,
);
let carried = &init[1 + SEED_LEN + 4..];
assert_eq!(carried, &payload.compressed[..]);
let image = expected_account_image(&prog, &seed, &payload);
let (pda, _) = derive_canonical_pda(&prog, &seed);
let report = render_dry_run(&prog, &seed, idl, "demo", "0.1.0");
assert!(report.contains(&hex_encode(&image[..HEADER_LEN])));
assert!(report.contains(&bs58::encode(pda).into_string()));
}
#[test]
fn dry_run_vs_send_parity_buffered() {
let prog = sample_program();
let seed = pad_seed(DEFAULT_SEED);
let mut names = String::new();
for i in 0..400 {
names.push_str(&format!("\"ix_{i:04x}_{}\",", (i * 2654435761u64) & 0xffff));
}
let idl = format!(
r#"{{"version":"0.1.0","name":"big","docs":[{}]}}"#,
names.trim_end_matches(',')
);
let payload = PreparedPayload::from_idl_json(&idl);
assert!(
payload.compressed.len() > MAX_INLINE_PAYLOAD,
"test fixture must exceed the inline threshold (got {})",
payload.compressed.len()
);
let chunks = plan_write_chunks(&payload.compressed, WRITE_CHUNK_LEN);
assert!(chunks.len() >= 2, "fixture should need multiple chunks");
let data_section = reassemble_write_chunks(payload.compressed.len(), &chunks);
let mut buffered_image = MetadataHeader::canonical_idl(prog, seed, &payload)
.encode()
.to_vec();
buffered_image.extend_from_slice(&data_section);
let inline_image = expected_account_image(&prog, &seed, &payload);
assert_eq!(
buffered_image, inline_image,
"buffered and inline paths must converge on identical account bytes"
);
let report = render_dry_run(&prog, &seed, &idl, "big", "0.1.0");
assert!(report.contains("Allocate"));
assert!(report.contains("Write"));
}
#[test]
fn bpf_loader_id_round_trips() {
let id = bpf_loader_upgradeable_id();
assert_eq!(
bs58::encode(id).into_string(),
BPF_LOADER_UPGRADEABLE_ID_B58
);
}
#[test]
fn publish_target_defaults_to_named_devnet() {
let target = resolve_publish_target(None, None, None).unwrap();
assert_eq!(target.url, PUBLISH_DEFAULT_RPC);
assert_eq!(target.label, "devnet");
assert!(!target.requires_confirmation);
}
#[test]
fn named_clusters_have_conservative_confirmation_classes() {
for name in ["devnet", "testnet", "localnet"] {
let target = resolve_publish_target(None, Some(name), None).unwrap();
assert_eq!(target.label, name);
assert!(!target.requires_confirmation, "{name} should not prompt");
}
let mainnet = resolve_publish_target(None, Some("mainnet-beta"), None).unwrap();
assert_eq!(mainnet.label, "mainnet-beta");
assert!(mainnet.requires_confirmation);
}
#[test]
fn every_raw_rpc_url_is_treated_as_potentially_mainnet() {
let devnet_url =
resolve_publish_target(Some("https://api.devnet.solana.com"), None, None).unwrap();
assert_eq!(devnet_url.label, "custom");
assert!(devnet_url.requires_confirmation);
let custom_via_cluster =
resolve_publish_target(None, Some("https://rpc.example.invalid/project"), None)
.unwrap();
assert_eq!(custom_via_cluster.label, "custom");
assert!(custom_via_cluster.requires_confirmation);
}
#[test]
fn environment_rpc_cannot_silently_bypass_guard() {
let target =
resolve_publish_target(None, None, Some("https://api.mainnet-beta.solana.com"))
.unwrap();
assert_eq!(target.label, "custom");
assert!(target.requires_confirmation);
let named_cli =
resolve_publish_target(None, Some("devnet"), Some("https://mainnet.invalid")).unwrap();
assert_eq!(named_cli.label, "devnet");
assert!(!named_cli.requires_confirmation);
}
#[test]
fn publish_target_rejects_ambiguous_or_invalid_overrides() {
assert!(
resolve_publish_target(Some("https://rpc.example.invalid"), Some("devnet"), None)
.is_err()
);
assert!(resolve_publish_target(Some("devnet"), None, None).is_err());
assert!(resolve_publish_target(
Some("https://rpc.example.invalid/\nterminal-injection"),
None,
None
)
.is_err());
assert!(resolve_publish_target(
None,
Some("https://rpc.example.invalid/\nterminal-injection"),
None
)
.is_err());
assert!(resolve_publish_target(None, Some("unknown"), None).is_err());
}
#[test]
fn publish_target_display_redacts_credentials_and_query() {
let target = resolve_publish_target(
Some("https://user:secret@rpc.example.invalid/path?api-key=secret"),
None,
None,
)
.unwrap();
assert_eq!(
target.display_url(),
"https://<redacted>@rpc.example.invalid/path?<redacted>"
);
let rendered_error = redact_rpc_error(&target, format!("request to {} failed", target.url));
assert!(!rendered_error.contains("secret"));
assert!(rendered_error.contains(&target.display_url()));
let invalid =
named_publish_target("ftp://user:secret@rpc.example.invalid/path?api-key=secret")
.unwrap_err();
assert!(!invalid.contains("secret"));
}
}