use crate::error::{PfError, PfResult};
pub const LEO_WELL_KNOWN_DEV_KEY: &str =
"APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH";
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum NetworkKind {
Local,
Devnet,
Testnet,
Mainnet,
}
impl NetworkKind {
pub fn parse(s: &str) -> PfResult<Self> {
match s.trim().to_ascii_lowercase().as_str() {
"local" | "localhost" | "anvil" | "surfpool" => Ok(Self::Local),
"devnet" => Ok(Self::Devnet),
"testnet" => Ok(Self::Testnet),
"mainnet" => Ok(Self::Mainnet),
other => Err(PfError::Usage(format!(
"unknown network '{other}' (want local|testnet|devnet; mainnet refused in v0)"
))),
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::Local => "local",
Self::Devnet => "devnet",
Self::Testnet => "testnet",
Self::Mainnet => "mainnet",
}
}
pub fn default_endpoint(self) -> &'static str {
match self {
Self::Local => "http://127.0.0.1:8545",
Self::Devnet => "http://localhost:3030",
Self::Testnet => "https://api.explorer.provable.com/v1",
Self::Mainnet => "https://api.explorer.provable.com/v1",
}
}
pub fn is_local(self) -> bool {
self == Self::Local
}
}
pub fn refuse_mainnet(net: NetworkKind) -> PfResult<()> {
if net == NetworkKind::Mainnet {
return Err(PfError::Safety(
"mainnet is refused by pf v0 (product scope: local/devnet/testnet only)".into(),
));
}
Ok(())
}
pub fn refuse_public_chain_broadcast(net: NetworkKind, chain: &str) -> PfResult<()> {
refuse_mainnet(net)?;
if !net.is_local() {
return Err(PfError::Safety(format!(
"{chain}: --broadcast only allowed with --network local in pf v0 \
(no public Devnet/Testnet/Mainnet write; use save-only package or local Anvil/validator)"
)));
}
Ok(())
}
pub fn require_loopback_endpoint(endpoint: &str) -> PfResult<()> {
let e = endpoint.trim().to_ascii_lowercase();
let ok = e.contains("127.0.0.1")
|| e.contains("localhost")
|| e.contains("[::1]")
|| e.contains("0.0.0.0"); if !ok {
return Err(PfError::Safety(format!(
"local broadcast endpoint must be loopback (got '{endpoint}')"
)));
}
for bad in [
"mainnet",
"sepolia",
"goerli",
"holesky",
"alchemy.com",
"infura.io",
"publicnode.com",
"ankr.com",
"api.mainnet",
"api.devnet.solana",
"api.testnet.solana",
"explorer.provable.com",
] {
if e.contains(bad) {
return Err(PfError::Safety(format!(
"refusing non-local endpoint marker '{bad}' in '{endpoint}'"
)));
}
}
Ok(())
}
pub fn resolve_private_key_for_mode(
broadcast: bool,
private_key_env: Option<&str>,
) -> PfResult<String> {
if !broadcast {
if let Some(name) = private_key_env {
let v = std::env::var(name)
.map_err(|_| PfError::Usage(format!("environment variable '{name}' is not set")))?;
if v.trim().is_empty() {
return Err(PfError::Usage(format!(
"environment variable '{name}' is empty"
)));
}
return Ok(v);
}
return Ok(LEO_WELL_KNOWN_DEV_KEY.to_string());
}
let name = private_key_env.ok_or_else(|| {
PfError::Safety(
"--broadcast requires --private-key-env <NAME> (no default key file scan)".into(),
)
})?;
let v = std::env::var(name).map_err(|_| {
PfError::Safety(format!(
"--broadcast: environment variable '{name}' is not set"
))
})?;
let v = v.trim().to_string();
if v.is_empty() {
return Err(PfError::Safety(format!(
"--broadcast: environment variable '{name}' is empty"
)));
}
if v == LEO_WELL_KNOWN_DEV_KEY {
return Err(PfError::Safety(
"--broadcast refuses the well-known Leo local-dev private key".into(),
));
}
Ok(v)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn mainnet_refused() {
assert!(refuse_mainnet(NetworkKind::Mainnet).is_err());
assert!(refuse_mainnet(NetworkKind::Testnet).is_ok());
assert!(refuse_mainnet(NetworkKind::Local).is_ok());
}
#[test]
fn public_broadcast_refused_for_evm_solana() {
assert!(refuse_public_chain_broadcast(NetworkKind::Testnet, "evm").is_err());
assert!(refuse_public_chain_broadcast(NetworkKind::Local, "solana").is_ok());
}
#[test]
fn loopback_endpoint_gate() {
assert!(require_loopback_endpoint("http://127.0.0.1:8545").is_ok());
assert!(require_loopback_endpoint("http://localhost:8899").is_ok());
assert!(require_loopback_endpoint("https://eth.llamarpc.com").is_err());
}
#[test]
fn broadcast_requires_env() {
let err = resolve_private_key_for_mode(true, None).unwrap_err();
assert!(matches!(err, PfError::Safety(_)));
}
#[test]
fn save_only_allows_well_known() {
let k = resolve_private_key_for_mode(false, None).unwrap();
assert_eq!(k, LEO_WELL_KNOWN_DEV_KEY);
}
#[test]
fn broadcast_refuses_well_known() {
std::env::set_var("PF_TEST_DEV_KEY", LEO_WELL_KNOWN_DEV_KEY);
let err = resolve_private_key_for_mode(true, Some("PF_TEST_DEV_KEY")).unwrap_err();
assert!(matches!(err, PfError::Safety(_)));
std::env::remove_var("PF_TEST_DEV_KEY");
}
}