openzoo 0.51.4 → 0.51.6

package/transmute/runtime/zoo-host/src/assets.rs

@@ -1,214 +0,0 @@
-//! `static/` on PDAs, plus the site manifest.
-//!
-//! Path → PDA `["asset", sha256("zoo-asset" ‖ path)]`. Account data:
-//! `[u8 ver=1][u8 bump][u32 total_len][u8 ct_len][ct bytes][file bytes...]`.
-//!
-//! Writes are gated by the program's upgrade authority: the caller passes the
-//! BPF upgradeable loader's ProgramData account and must sign as the
-//! authority recorded in it. A program whose authority was burned has a
-//! frozen frontend, which is the right default for "deployed to mainnet".
-use crate::{kv::err_str, ERR_NOT_AUTHORITY};
-use pinocchio::{
-    cpi::{Seed, Signer},
-    error::ProgramError,
-    sysvars::{rent::Rent, Sysvar},
-    AccountView, Address, ProgramResult, Resize,
-};
-use pinocchio_system::instructions::{CreateAccount, Transfer};
-
-pub const FIXED_HEADER: usize = 7;
-/// Largest account a single CPI `create_account` may allocate.
-pub const MAX_INITIAL: usize = 10_240;
-pub const MAX_GROW: usize = 10_240;
-
-pub const BPF_LOADER_UPGRADEABLE: Address = Address::from_str_const("BPFLoaderUpgradeab1e11111111111111111111111");
-
-pub fn path_hash(path: &str) -> [u8; 32] {
-    solana_sha256_hasher::hashv(&[b"zoo-asset", path.as_bytes()]).to_bytes()
-}
-
-pub fn pda_for_hash(program_id: &Address, hash: &[u8; 32]) -> (Address, u8) {
-    Address::find_program_address(&[b"asset", hash], program_id)
-}
-
-/// Asset PDA under the shared runtime: `["asset", site_id, hash]`.
-pub fn pda_for_hash_ns(program_id: &Address, ns: Option<&[u8; 32]>, hash: &[u8; 32]) -> (Address, u8) {
-    match ns {
-        Some(n) => Address::find_program_address(&[b"asset", n, hash], program_id),
-        None => pda_for_hash(program_id, hash),
-    }
-}
-
-/// Who may write assets: a compiled site's upgrade authority, or under the
-/// shared runtime the authority recorded in the site account (`accounts[1]`).
-#[derive(Clone, Copy)]
-pub enum Auth {
-    Upgrade,
-    Site([u8; 32]),
-}
-
-pub fn check_auth(program_id: &Address, accounts: &[AccountView], auth: Auth) -> ProgramResult {
-    match auth {
-        Auth::Upgrade => check_authority(program_id, accounts),
-        Auth::Site(site) => crate::site::check_site_authority(program_id, accounts, &site),
-    }
-}
-
-/// Verify `accounts[0]` signs as the upgrade authority of `program_id`
-/// (read off `accounts[1]`, the ProgramData account).
-pub fn check_authority(program_id: &Address, accounts: &[AccountView]) -> ProgramResult {
-    let authority = accounts.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    let program_data = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
-    if !authority.is_signer() {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let (expected, _) = Address::find_program_address(&[program_id.as_ref()], &BPF_LOADER_UPGRADEABLE);
-    if *program_data.address() != expected || !program_data.owned_by(&BPF_LOADER_UPGRADEABLE) {
-        return Err(ProgramError::Custom(ERR_NOT_AUTHORITY));
-    }
-    let d = program_data.try_borrow()?;
-    // UpgradeableLoaderState::ProgramData { slot: u64, upgrade_authority_address: Option<Pubkey> }
-    // bincode: u32 enum tag (3) | u64 slot | u8 option | 32 bytes
-    if d.len() < 45 || u32::from_le_bytes([d[0], d[1], d[2], d[3]]) != 3 || d[12] != 1 {
-        return Err(ProgramError::Custom(ERR_NOT_AUTHORITY));
-    }
-    if d[13..45] != authority.address().as_ref()[..] {
-        return Err(ProgramError::Custom(ERR_NOT_AUTHORITY));
-    }
-    Ok(())
-}
-
-fn split_hash(data: &[u8]) -> Result<(&[u8; 32], &[u8]), ProgramError> {
-    if data.len() < 32 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let (h, rest) = data.split_at(32);
-    let h: &[u8; 32] = match h.try_into() { Ok(h) => h, Err(_) => return Err(ProgramError::InvalidInstructionData) };
-    Ok((h, rest))
-}
-
-/// `[32 hash][u32 total_len][u8 ct_len][ct]`; accounts: authority, program
-/// data, asset PDA, system program.
-pub fn init(program_id: &Address, accounts: &mut [AccountView], data: &[u8]) -> ProgramResult {
-    init_ns(program_id, accounts, data, None, Auth::Upgrade)
-}
-
-pub fn init_ns(program_id: &Address, accounts: &mut [AccountView], data: &[u8], ns: Option<[u8; 32]>, auth: Auth) -> ProgramResult {
-    check_auth(program_id, accounts, auth)?;
-    let (hash, rest) = split_hash(data)?;
-    if rest.len() < 5 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let total = u32::from_le_bytes([rest[0], rest[1], rest[2], rest[3]]) as usize;
-    let ct_len = rest[4] as usize;
-    let ct = rest.get(5..5 + ct_len).ok_or(ProgramError::InvalidInstructionData)?;
-    let header = FIXED_HEADER + ct_len;
-    let (addr, bump) = pda_for_hash_ns(program_id, ns.as_ref(), hash);
-    let (head, tail) = accounts.split_at_mut(2);
-    let authority = &head[0];
-    let asset = tail.first_mut().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    if *asset.address() != addr {
-        return Err(ProgramError::InvalidSeeds);
-    }
-    let space = (header + total).min(MAX_INITIAL).max(header);
-    if asset.owned_by(program_id) {
-        // Re-init of an existing asset (redeploy): resize to the new header.
-        let rent = Rent::get()?;
-        let min = rent.try_minimum_balance(space)?;
-        if min > asset.lamports() {
-            Transfer { from: authority, to: asset, lamports: min - asset.lamports() }.invoke()?;
-        }
-        asset.resize(space)?;
-    } else {
-        let bump_bytes = [bump];
-        match ns.as_ref() {
-            Some(n) => {
-                let seeds = [Seed::from(b"asset".as_ref()), Seed::from(n.as_ref()), Seed::from(hash.as_ref()), Seed::from(bump_bytes.as_ref())];
-                let signer = Signer::from(&seeds);
-                CreateAccount::with_minimum_balance(authority, asset, space as u64, program_id, None)?.invoke_signed(&[signer])?;
-            }
-            None => {
-                let seeds = [Seed::from(b"asset".as_ref()), Seed::from(hash.as_ref()), Seed::from(bump_bytes.as_ref())];
-                let signer = Signer::from(&seeds);
-                CreateAccount::with_minimum_balance(authority, asset, space as u64, program_id, None)?.invoke_signed(&[signer])?;
-            }
-        }
-    }
-    let mut d = asset.try_borrow_mut()?;
-    d[0] = 1;
-    d[1] = bump;
-    d[2..6].copy_from_slice(&(total as u32).to_le_bytes());
-    d[6] = ct_len as u8;
-    d[7..7 + ct_len].copy_from_slice(ct);
-    Ok(())
-}
-
-/// `[32 hash][u32 offset][bytes]`; same accounts as `init`.
-pub fn write(program_id: &Address, accounts: &mut [AccountView], data: &[u8]) -> ProgramResult {
-    write_ns(program_id, accounts, data, None, Auth::Upgrade)
-}
-
-pub fn write_ns(program_id: &Address, accounts: &mut [AccountView], data: &[u8], ns: Option<[u8; 32]>, auth: Auth) -> ProgramResult {
-    check_auth(program_id, accounts, auth)?;
-    let (hash, rest) = split_hash(data)?;
-    if rest.len() < 4 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let offset = u32::from_le_bytes([rest[0], rest[1], rest[2], rest[3]]) as usize;
-    let bytes = &rest[4..];
-    let (addr, _) = pda_for_hash_ns(program_id, ns.as_ref(), hash);
-    let (head, tail) = accounts.split_at_mut(2);
-    let authority = &head[0];
-    let asset = tail.first_mut().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    if *asset.address() != addr || !asset.owned_by(program_id) {
-        return Err(ProgramError::InvalidSeeds);
-    }
-    let (header, total) = {
-        let d = asset.try_borrow()?;
-        if d.len() < FIXED_HEADER || d[0] != 1 {
-            return Err(ProgramError::InvalidAccountData);
-        }
-        (FIXED_HEADER + d[6] as usize, u32::from_le_bytes([d[2], d[3], d[4], d[5]]) as usize)
-    };
-    let end = header + offset + bytes.len();
-    if offset + bytes.len() > total {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    if end > asset.data_len() {
-        if end - asset.data_len() > MAX_GROW {
-            return Err(ProgramError::InvalidRealloc);
-        }
-        let rent = Rent::get()?;
-        let min = rent.try_minimum_balance(end)?;
-        if min > asset.lamports() {
-            Transfer { from: authority, to: asset, lamports: min - asset.lamports() }.invoke()?;
-        }
-        asset.resize(end)?;
-    }
-    let mut d = asset.try_borrow_mut()?;
-    d[header + offset..end].copy_from_slice(bytes);
-    Ok(())
-}
-
-/// `[32 hash]`: reclaim the rent to the authority.
-pub fn close(program_id: &Address, accounts: &mut [AccountView], data: &[u8]) -> ProgramResult {
-    close_ns(program_id, accounts, data, None, Auth::Upgrade)
-}
-
-pub fn close_ns(program_id: &Address, accounts: &mut [AccountView], data: &[u8], ns: Option<[u8; 32]>, auth: Auth) -> ProgramResult {
-    check_auth(program_id, accounts, auth)?;
-    let (hash, _) = split_hash(data)?;
-    let (addr, _) = pda_for_hash_ns(program_id, ns.as_ref(), hash);
-    let (head, tail) = accounts.split_at_mut(2);
-    let authority = &mut head[0];
-    let asset = tail.first_mut().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    if *asset.address() != addr || !asset.owned_by(program_id) {
-        return Err(ProgramError::InvalidSeeds);
-    }
-    let lamports = asset.lamports();
-    asset.set_lamports(0);
-    authority.set_lamports(authority.lamports() + lamports);
-    asset.close()?;
-    let _ = err_str; // keep the helper linked for kv
-    Ok(())
-}

package/transmute/runtime/zoo-host/src/ctx.rs

@@ -1,350 +0,0 @@
-//! Per-invocation context: the Vercel `req`/`res` pair plus the account set.
-use crate::json;
-use crate::kv::KvState;
-use crate::val::{parse_query, Val};
-use crate::wire::{Req, Resp};
-use alloc::{string::String, vec::Vec};
-use crate::fmt::{push_i64, push_padded};
-use pinocchio::{
-    sysvars::{clock::Clock, Sysvar},
-    AccountView, Address,
-};
-
-pub struct Ctx<'a> {
-    pub program_id: &'a Address,
-    pub accounts: &'a mut [AccountView],
-    pub req: Req,
-    pub res: Resp,
-    pub sent: bool,
-    pub env: &'a [(&'static str, &'static str)],
-    /// Environment from a bytecode module (shared runtime); consulted first.
-    pub env_dyn: Vec<(String, String)>,
-    /// Site namespace for KV/asset seeds: `None` for a compiled site program
-    /// (the program id is the namespace), `Some(site_id)` under the shared runtime.
-    pub ns: Option<[u8; 32]>,
-    pub kv: KvState,
-    query_cache: Option<Val>,
-    body_cache: Option<Val>,
-}
-
-impl<'a> Ctx<'a> {
-    pub fn new(
-        program_id: &'a Address,
-        accounts: &'a mut [AccountView],
-        req: Req,
-        env: &'a [(&'static str, &'static str)],
-    ) -> Self {
-        Ctx {
-            program_id,
-            accounts,
-            req,
-            res: Resp::default(),
-            sent: false,
-            env,
-            env_dyn: Vec::new(),
-            ns: None,
-            kv: KvState::default(),
-            query_cache: None,
-            body_cache: None,
-        }
-    }
-
-    // ---- req ----
-
-    pub fn req_method(&self) -> Val {
-        Val::str(self.req.method_str())
-    }
-    pub fn req_path(&self) -> Val {
-        Val::str(&self.req.path)
-    }
-    /// `req.url` as Node sees it: path + query.
-    pub fn req_url(&self) -> Val {
-        if self.req.query.is_empty() {
-            Val::str(&self.req.path)
-        } else {
-            let mut u = String::from(self.req.path.as_str());
-            u.push('?');
-            u.push_str(&self.req.query);
-            Val::Str(u)
-        }
-    }
-    /// Full URL for `new URL(request.url)` in app-router handlers. The origin
-    /// is synthetic; only path/search matter on chain.
-    pub fn req_full_url(&self) -> Val {
-        let mut u = String::from("https://zoo.sol");
-        u.push_str(&self.req_url().to_js_string());
-        Val::Str(u)
-    }
-    pub fn req_query(&mut self) -> Val {
-        if self.query_cache.is_none() {
-            self.query_cache = Some(parse_query(&self.req.query));
-        }
-        self.query_cache.clone().unwrap()
-    }
-    /// `searchParams.get(name)`: string or null.
-    pub fn req_query_get(&mut self, name: &Val) -> Val {
-        match self.req_query().get(name) {
-            Val::Undef => Val::Null,
-            v => v,
-        }
-    }
-    pub fn req_headers(&self) -> Val {
-        self.req.headers_val()
-    }
-    /// `req.headers.get(name)` / `req.headers[name]` (null when absent).
-    pub fn req_header(&self, name: &Val) -> Val {
-        match self.req.header(&name.to_js_string()) {
-            Some(v) => Val::str(v),
-            None => Val::Null,
-        }
-    }
-    pub fn req_text(&self) -> Val {
-        Val::Str(String::from_utf8_lossy(&self.req.body).into_owned())
-    }
-    /// `req.body` with Vercel's helper semantics: JSON when the content type
-    /// says so (or the body parses), urlencoded → object, else the raw string.
-    pub fn req_body(&mut self) -> Val {
-        if let Some(b) = &self.body_cache {
-            return b.clone();
-        }
-        let ct = self.req.header("content-type").unwrap_or("").to_ascii_lowercase();
-        let text = String::from_utf8_lossy(&self.req.body).into_owned();
-        let v = if self.req.body.is_empty() {
-            Val::Undef
-        } else if ct.contains("application/json") {
-            json::parse(&text).unwrap_or(Val::Undef)
-        } else if ct.contains("application/x-www-form-urlencoded") {
-            parse_query(&text)
-        } else if ct.is_empty() {
-            json::parse(&text).unwrap_or(Val::Str(text))
-        } else {
-            Val::Str(text)
-        };
-        self.body_cache = Some(v.clone());
-        v
-    }
-    /// `await request.json()`: throws on a malformed body like fetch does.
-    pub fn req_json(&mut self) -> Result<Val, Val> {
-        let text = String::from_utf8_lossy(&self.req.body).into_owned();
-        json::parse(&text).map_err(|_| Val::str("SyntaxError: Unexpected end of JSON input"))
-    }
-
-    // ---- res (pages-router helpers) ----
-
-    pub fn res_status(&mut self, code: &Val) {
-        let n = code.to_num();
-        if n.is_finite() && (100.0..1000.0).contains(&n) {
-            self.res.status = n as u16;
-        }
-    }
-    pub fn res_header(&mut self, name: &Val, value: &Val) {
-        self.res.set_header(&name.to_js_string(), &value.to_js_string());
-    }
-    pub fn res_json(&mut self, v: &Val) {
-        if !self.res.has_header("content-type") {
-            self.res.set_header("content-type", "application/json; charset=utf-8");
-        }
-        self.res.body = json::stringify(v).into_bytes();
-        self.sent = true;
-    }
-    pub fn res_send(&mut self, v: &Val) {
-        match v {
-            Val::Undef | Val::Null => {
-                self.res.body.clear();
-                self.sent = true;
-            }
-            Val::Str(s) => {
-                if !self.res.has_header("content-type") {
-                    self.res.set_header("content-type", "text/html; charset=utf-8");
-                }
-                self.res.body = s.clone().into_bytes();
-                self.sent = true;
-            }
-            Val::Num(_) | Val::Bool(_) | Val::Arr(_) | Val::Obj(_) => self.res_json(v),
-        }
-    }
-    pub fn res_end(&mut self, v: &Val) {
-        match v {
-            Val::Undef | Val::Null => {}
-            other => self.res.body = other.to_js_string().into_bytes(),
-        }
-        self.sent = true;
-    }
-    pub fn res_redirect(&mut self, status: &Val, url: &Val) {
-        let (code, target) = if url.is_undef() { (Val::Num(307.0), status.clone()) } else { (status.clone(), url.clone()) };
-        self.res_status(&code);
-        self.res.set_header("location", &target.to_js_string());
-        self.sent = true;
-    }
-
-    // ---- app-router / fetch-style responses ----
-
-    fn apply_init(&mut self, init: &Val) {
-        if let Val::Obj(_) = init {
-            let st = init.get_str("status");
-            if !st.is_undef() {
-                self.res_status(&st);
-            }
-            if let Val::Obj(h) = init.get_str("headers") {
-                for (k, v) in h.iter() {
-                    self.res.set_header(k, &v.to_js_string());
-                }
-            }
-        }
-    }
-    /// `Response.json(body, init)` / `NextResponse.json(body, init)`.
-    pub fn respond_json(&mut self, body: &Val, init: &Val) {
-        self.apply_init(init);
-        self.res_json(body);
-    }
-    /// `new Response(body, init)` / `new NextResponse(body, init)`.
-    pub fn respond(&mut self, body: &Val, init: &Val) {
-        self.apply_init(init);
-        match body {
-            Val::Undef | Val::Null => {
-                self.res.body.clear();
-            }
-            other => {
-                if !self.res.has_header("content-type") {
-                    self.res.set_header("content-type", "text/plain; charset=utf-8");
-                }
-                self.res.body = other.to_js_string().into_bytes();
-            }
-        }
-        self.sent = true;
-    }
-    /// `NextResponse.redirect(url, status)` / `Response.redirect`.
-    pub fn respond_redirect(&mut self, url: &Val, status: &Val) {
-        let code = if status.is_undef() { Val::Num(307.0) } else { status.clone() };
-        self.res_redirect(&code, url);
-    }
-
-    // ---- environment / time ----
-
-    pub fn env(&self, name: &Val) -> Val {
-        let n = name.to_js_string();
-        for (k, v) in self.env_dyn.iter() {
-            if *k == n {
-                return Val::str(v);
-            }
-        }
-        for (k, v) in self.env.iter() {
-            if *k == n {
-                return Val::str(v);
-            }
-        }
-        Val::Undef
-    }
-    pub fn env_obj(&self) -> Val {
-        let mut o = Val::obj();
-        for (k, v) in self.env_dyn.iter() {
-            o.set_str(k, Val::str(v));
-        }
-        for (k, v) in self.env.iter() {
-            o.set_str(k, Val::str(v));
-        }
-        o
-    }
-    fn clock(&self) -> Option<Clock> {
-        Clock::get().ok()
-    }
-    /// `Date.now()`: the cluster clock, in ms. 0 off-chain (host tests).
-    pub fn now_ms(&self) -> Val {
-        Val::Num(self.clock().map(|c| c.unix_timestamp as f64 * 1000.0).unwrap_or(0.0))
-    }
-    pub fn slot(&self) -> Val {
-        Val::Num(self.clock().map(|c| c.slot as f64).unwrap_or(0.0))
-    }
-    /// `new Date().toISOString()`.
-    pub fn now_iso(&self) -> Val {
-        Val::Str(iso8601(self.now_ms().to_num()))
-    }
-
-    // ---- misc helpers used by generated code ----
-
-    pub fn throw(msg: &str) -> Val {
-        Val::str(msg)
-    }
-    pub fn new_error(args: &[Val]) -> Val {
-        let mut e = Val::obj();
-        e.set_str("name", Val::str("Error"));
-        e.set_str("message", Val::Str(args.first().map(|v| v.to_js_string()).unwrap_or_default()));
-        e
-    }
-    pub fn payer_address(&self) -> Val {
-        self.accounts.first().map(|a| Val::Str(base58(a.address().as_ref()))).unwrap_or(Val::Null)
-    }
-    pub fn accounts_len(&self) -> usize {
-        self.accounts.len()
-    }
-    pub fn program_address(&self) -> Val {
-        Val::Str(base58(self.program_id.as_ref()))
-    }
-}
-
-/// ms since epoch → `YYYY-MM-DDTHH:MM:SS.mmmZ`
-pub fn iso8601(ms: f64) -> String {
-    let total_ms = if ms.is_finite() { ms as i64 } else { 0 };
-    let secs = total_ms.div_euclid(1000);
-    let milli = total_ms.rem_euclid(1000);
-    let days = secs.div_euclid(86400);
-    let sod = secs.rem_euclid(86400);
-    // civil_from_days (Howard Hinnant)
-    let z = days + 719_468;
-    let era = z.div_euclid(146_097);
-    let doe = z - era * 146_097;
-    let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
-    let y = yoe + era * 400;
-    let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
-    let mp = (5 * doy + 2) / 153;
-    let d = doy - (153 * mp + 2) / 5 + 1;
-    let m = if mp < 10 { mp + 3 } else { mp - 9 };
-    let y = if m <= 2 { y + 1 } else { y };
-    let mut out = String::new();
-    push_i64(&mut out, y);
-    out.push('-');
-    push_padded(&mut out, m as u64, 2);
-    out.push('-');
-    push_padded(&mut out, d as u64, 2);
-    out.push('T');
-    push_padded(&mut out, (sod / 3600) as u64, 2);
-    out.push(':');
-    push_padded(&mut out, ((sod % 3600) / 60) as u64, 2);
-    out.push(':');
-    push_padded(&mut out, (sod % 60) as u64, 2);
-    out.push('.');
-    push_padded(&mut out, milli as u64, 3);
-    out.push('Z');
-    out
-}
-
-
-const B58: &[u8; 58] = b"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-
-pub fn base58(bytes: &[u8]) -> String {
-    let mut digits: Vec<u8> = Vec::with_capacity(bytes.len() * 2);
-    for &b in bytes {
-        let mut carry = b as u32;
-        for d in digits.iter_mut() {
-            carry += (*d as u32) << 8;
-            *d = (carry % 58) as u8;
-            carry /= 58;
-        }
-        while carry > 0 {
-            digits.push((carry % 58) as u8);
-            carry /= 58;
-        }
-    }
-    let mut s = String::new();
-    for &b in bytes {
-        if b == 0 {
-            s.push('1');
-        } else {
-            break;
-        }
-    }
-    for &d in digits.iter().rev() {
-        s.push(B58[d as usize] as char);
-    }
-    s
-}