openzoo 0.51.4 → 0.51.6

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

@@ -1,206 +0,0 @@
-//! `@vercel/kv` on PDAs.
-//!
-//! Key → PDA `["kv", sha256(key)]`. Account data:
-//! `[u8 ver=1][u8 bump][u32 len][len bytes of JSON]`.
-//!
-//! The gateway does not know which keys a handler will touch, so the program
-//! discovers them: a key whose PDA is not in the account list is recorded in
-//! [`KvState::missing`] and the invoke fails with `ERR_KV_MISSING`; the
-//! gateway reads the `ZOOK` logs, appends those PDAs and retries. Accounts
-//! `0` and `1` are the payer and the system program.
-use crate::json;
-use crate::val::Val;
-use crate::Ctx;
-use alloc::{string::String, vec::Vec};
-use pinocchio::{
-    cpi::{Seed, Signer},
-    sysvars::{rent::Rent, Sysvar},
-    Address, Resize,
-};
-use pinocchio_system::instructions::{CreateAccount, Transfer};
-
-pub const HEADER: usize = 6;
-pub const MAX_VALUE: usize = 10_000;
-
-#[derive(Default)]
-pub struct KvState {
-    pub missing: Vec<Address>,
-}
-
-/// The sentinel thrown into the handler when a KV account is missing; the
-/// dispatcher looks at `missing` first, so this never reaches the response.
-pub const MISSING_SENTINEL: &str = "__ZOO_KV_MISSING__";
-
-pub fn key_hash(key: &str) -> [u8; 32] {
-    solana_sha256_hasher::hashv(&[b"zoo-kv", key.as_bytes()]).to_bytes()
-}
-
-pub fn pda_for(program_id: &Address, key: &str) -> (Address, u8, [u8; 32]) {
-    pda_for_ns(program_id, None, key)
-}
-
-/// KV PDA: `["kv", hash]` for a compiled site, `["kv", site_id, hash]` under
-/// the shared runtime.
-pub fn pda_for_ns(program_id: &Address, ns: Option<&[u8; 32]>, key: &str) -> (Address, u8, [u8; 32]) {
-    let h = key_hash(key);
-    let (a, bump) = match ns {
-        Some(n) => Address::find_program_address(&[b"kv", n, &h], program_id),
-        None => Address::find_program_address(&[b"kv", &h], program_id),
-    };
-    (a, bump, h)
-}
-
-struct Slot {
-    idx: usize,
-    bump: u8,
-    hash: [u8; 32],
-}
-
-impl<'a> Ctx<'a> {
-    fn kv_slot(&mut self, key: &Val) -> Result<Slot, Val> {
-        let k = key.to_js_string();
-        let (addr, bump, hash) = pda_for_ns(self.program_id, self.ns.as_ref(), &k);
-        match self.accounts.iter().position(|a| *a.address() == addr) {
-            Some(idx) => Ok(Slot { idx, bump, hash }),
-            None => {
-                if !self.kv.missing.iter().any(|m| *m == addr) {
-                    self.kv.missing.push(addr);
-                }
-                Err(Val::str(MISSING_SENTINEL))
-            }
-        }
-    }
-
-    fn kv_read(&self, idx: usize) -> Val {
-        let acc = &self.accounts[idx];
-        if !acc.owned_by(self.program_id) || acc.data_len() < HEADER {
-            return Val::Null;
-        }
-        let d = match acc.try_borrow() {
-            Ok(d) => d,
-            Err(_) => return Val::Null,
-        };
-        let len = u32::from_le_bytes([d[2], d[3], d[4], d[5]]) as usize;
-        if len == 0 || HEADER + len > d.len() {
-            return Val::Null;
-        }
-        let text = match core::str::from_utf8(&d[HEADER..HEADER + len]) {
-            Ok(t) => t,
-            Err(_) => return Val::Null,
-        };
-        json::parse(text).unwrap_or(Val::Null)
-    }
-
-    /// `kv.get(key)` → value or null.
-    pub fn kv_get(&mut self, key: &Val) -> Result<Val, Val> {
-        let s = self.kv_slot(key)?;
-        Ok(self.kv_read(s.idx))
-    }
-
-    /// `kv.exists(key)` → 0 | 1
-    pub fn kv_exists(&mut self, key: &Val) -> Result<Val, Val> {
-        let s = self.kv_slot(key)?;
-        Ok(Val::Num(if self.kv_read(s.idx).is_nullish() { 0.0 } else { 1.0 }))
-    }
-
-    /// `kv.set(key, value)` → "OK"
-    pub fn kv_set(&mut self, key: &Val, value: &Val) -> Result<Val, Val> {
-        let s = self.kv_slot(key)?;
-        let payload = json::stringify(value).into_bytes();
-        if payload.len() > MAX_VALUE {
-            return Err(Val::str("kv.set: value exceeds 10000 bytes"));
-        }
-        self.kv_write(&s, &payload)?;
-        Ok(Val::str("OK"))
-    }
-
-    /// `kv.incr(key)` / `kv.incrby(key, n)` / `kv.decr`
-    pub fn kv_incrby(&mut self, key: &Val, by: &Val) -> Result<Val, Val> {
-        let s = self.kv_slot(key)?;
-        let cur = self.kv_read(s.idx);
-        let n = if cur.is_nullish() { 0.0 } else { cur.to_num() };
-        if n.is_nan() {
-            return Err(Val::str("ERR value is not an integer or out of range"));
-        }
-        let next = Val::Num(n + by.to_num());
-        let payload = json::stringify(&next).into_bytes();
-        self.kv_write(&s, &payload)?;
-        Ok(next)
-    }
-
-    /// `kv.del(key)` → number of keys removed (0 | 1)
-    pub fn kv_del(&mut self, key: &Val) -> Result<Val, Val> {
-        let s = self.kv_slot(key)?;
-        if self.kv_read(s.idx).is_nullish() {
-            return Ok(Val::Num(0.0));
-        }
-        self.kv_write(&s, &[])?;
-        Ok(Val::Num(1.0))
-    }
-
-    fn kv_write(&mut self, s: &Slot, payload: &[u8]) -> Result<(), Val> {
-        let need = HEADER + payload.len();
-        let program_id = self.program_id;
-        let bump = [s.bump];
-        if self.accounts.len() < 2 {
-            return Err(Val::str("kv.set: payer and system program accounts required"));
-        }
-        if s.idx < 2 {
-            return Err(Val::str("kv: account layout violated"));
-        }
-        let (head, tail) = self.accounts.split_at_mut(s.idx);
-        let payer = &head[0];
-        let acc = &mut tail[0];
-        if !acc.owned_by(program_id) {
-            // First write: create the PDA.
-            if !payer.is_signer() {
-                return Err(Val::str("kv.set: payer must sign"));
-            }
-            let ns = self.ns;
-            let r = match ns.as_ref() {
-                Some(n) => {
-                    let seeds = [Seed::from(b"kv".as_ref()), Seed::from(n.as_ref()), Seed::from(s.hash.as_ref()), Seed::from(bump.as_ref())];
-                    let signer = Signer::from(&seeds);
-                    CreateAccount::with_minimum_balance(payer, acc, need as u64, program_id, None)
-                        .map_err(|e| Val::Str(err_str("kv create", e)))?
-                        .invoke_signed(&[signer])
-                }
-                None => {
-                    let seeds = [Seed::from(b"kv".as_ref()), Seed::from(s.hash.as_ref()), Seed::from(bump.as_ref())];
-                    let signer = Signer::from(&seeds);
-                    CreateAccount::with_minimum_balance(payer, acc, need as u64, program_id, None)
-                        .map_err(|e| Val::Str(err_str("kv create", e)))?
-                        .invoke_signed(&[signer])
-                }
-            };
-            r.map_err(|e| Val::Str(err_str("kv create", e)))?;
-        } else if need > acc.data_len() {
-            let rent = Rent::get().map_err(|e| Val::Str(err_str("rent", e)))?;
-            let min = rent.try_minimum_balance(need).map_err(|e| Val::Str(err_str("rent", e)))?;
-            if min > acc.lamports() {
-                Transfer { from: payer, to: acc, lamports: min - acc.lamports() }
-                    .invoke()
-                    .map_err(|e| Val::Str(err_str("kv rent", e)))?;
-            }
-            acc.resize(need).map_err(|e| Val::Str(err_str("kv resize", e)))?;
-        } else if need < acc.data_len() && payload.is_empty() {
-            acc.resize(HEADER).map_err(|e| Val::Str(err_str("kv resize", e)))?;
-        }
-        let mut d = acc.try_borrow_mut().map_err(|e| Val::Str(err_str("kv borrow", e)))?;
-        d[0] = 1;
-        d[1] = s.bump;
-        d[2..6].copy_from_slice(&(payload.len() as u32).to_le_bytes());
-        if !payload.is_empty() {
-            d[HEADER..HEADER + payload.len()].copy_from_slice(payload);
-        }
-        Ok(())
-    }
-}
-
-pub fn err_str(what: &str, e: pinocchio::error::ProgramError) -> String {
-    let code: u64 = e.into();
-    let mut m = String::from(what);
-    m.push_str(" failed: program error ");
-    crate::fmt::push_u64(&mut m, code);
-    m
-}

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

@@ -1,137 +0,0 @@
-//! zoo-host: the on-chain half of openzoo-transmute.
-//!
-//! A Vercel deployment is, in Vercel's own terms, a set of Lambdas (`*.func`)
-//! plus a `static/` tree plus a `config.json` route table. Vercel's node
-//! bridge feeds each Lambda an `Invoke` event `{method, path, headers, body}`
-//! and expects `{statusCode, headers, body}` back. This crate is that bridge,
-//! re-hosted on Solana:
-//!
-//! * the Invoke event is the instruction data ([`wire::Req`])
-//! * the bridge response is the return data + `sol_log_data` chunks
-//!   ([`wire::Resp`])
-//! * `static/` lives in asset PDAs ([`assets`])
-//! * `@vercel/kv` lives in KV PDAs ([`kv`])
-//! * the handler body is Rust generated by the transmuter, operating on a
-//!   JS-semantics dynamic value ([`val::Val`])
-//!
-//! Generated programs call [`dispatch`] from their entrypoint.
-#![no_std]
-#![allow(clippy::needless_range_loop)]
-
-extern crate alloc;
-
-pub mod assets;
-pub mod ctx;
-pub mod fmt;
-pub mod helpers;
-pub mod site;
-pub mod vm;
-pub mod json;
-pub mod kv;
-pub mod val;
-pub mod wire;
-
-use alloc::{string::String, vec::Vec};
-use pinocchio::{error::ProgramError, AccountView, Address, ProgramResult};
-
-pub use ctx::Ctx;
-pub use val::Val;
-pub use wire::{Req, Resp};
-
-/// A transmuted route handler. `Err(v)` is a thrown JS value.
-pub type Route = fn(&mut Ctx) -> Result<(), Val>;
-
-/// Instruction tags (first byte of instruction data).
-pub const TAG_INVOKE: u8 = 0;
-pub const TAG_ASSET_INIT: u8 = 1;
-pub const TAG_ASSET_WRITE: u8 = 2;
-pub const TAG_ASSET_CLOSE: u8 = 3;
-// Shared runtime (zoo-vm) tags. Instruction data after the tag starts with
-// the 32-byte site id, then the same payloads as the compiled-site tags.
-pub const TAG_SITE_INIT: u8 = 16;
-pub const TAG_SITE_SET_AUTHORITY: u8 = 17;
-pub const TAG_VM_INVOKE: u8 = 18;
-pub const TAG_VM_ASSET_INIT: u8 = 19;
-pub const TAG_VM_ASSET_WRITE: u8 = 20;
-pub const TAG_VM_ASSET_CLOSE: u8 = 21;
-/// Path of a site's bytecode asset under the shared runtime.
-pub const CODE_PATH: &str = "/.zoo/code.bin";
-
-/// Custom program error: a KV account the handler needed was not passed.
-/// The gateway reads the `ZOOK` log lines, adds the accounts and retries.
-pub const ERR_KV_MISSING: u32 = 0x4b56_0001;
-/// Custom program error: the caller is not the program's upgrade authority.
-pub const ERR_NOT_AUTHORITY: u32 = 0x4b56_0002;
-/// Custom program error: malformed instruction data.
-pub const ERR_BAD_WIRE: u32 = 0x4b56_0003;
-
-/// Entry used by generated programs.
-///
-/// `env` is the Lambda's `.vc-config.json` `environment` table, baked in at
-/// build time.
-pub fn dispatch(
-    program_id: &Address,
-    accounts: &mut [AccountView],
-    data: &[u8],
-    routes: &[Route],
-    env: &[(&'static str, &'static str)],
-) -> ProgramResult {
-    let (tag, rest) = match data.split_first() {
-        Some(x) => x,
-        None => return Err(ProgramError::Custom(ERR_BAD_WIRE)),
-    };
-    match *tag {
-        TAG_INVOKE => invoke(program_id, accounts, rest, routes, env),
-        TAG_ASSET_INIT => assets::init(program_id, accounts, rest),
-        TAG_ASSET_WRITE => assets::write(program_id, accounts, rest),
-        TAG_ASSET_CLOSE => assets::close(program_id, accounts, rest),
-        _ => Err(ProgramError::InvalidInstructionData),
-    }
-}
-
-fn invoke(
-    program_id: &Address,
-    accounts: &mut [AccountView],
-    data: &[u8],
-    routes: &[Route],
-    env: &[(&'static str, &'static str)],
-) -> ProgramResult {
-    let req = wire::parse_req(data).map_err(|_| ProgramError::Custom(ERR_BAD_WIRE))?;
-    let route = routes
-        .get(req.route as usize)
-        .copied()
-        .ok_or(ProgramError::InvalidInstructionData)?;
-    let mut cx = Ctx::new(program_id, accounts, req, env);
-    let outcome = route(&mut cx);
-    if !cx.kv.missing.is_empty() {
-        // Account discovery: tell the gateway which PDAs to add, then fail so
-        // nothing half-applied is committed.
-        for pda in cx.kv.missing.iter() {
-            wire::log_kv_missing(pda);
-        }
-        return Err(ProgramError::Custom(ERR_KV_MISSING));
-    }
-    match outcome {
-        Ok(()) => {}
-        Err(thrown) => {
-            // Uncaught throw == a Lambda crash == 500, same as Vercel.
-            let msg: String = match &thrown {
-                Val::Obj(_) => match thrown.get_str("message") {
-                    Val::Undef => thrown.to_js_string(),
-                    m => m.to_js_string(),
-                },
-                _ => thrown.to_js_string(),
-            };
-            cx.res = Resp::json_error(500, &msg);
-            cx.sent = true;
-        }
-    }
-    if !cx.sent {
-        // Handler returned without responding: Vercel answers 504 for a
-        // Lambda that never called res.end(); we mirror that.
-        cx.res = Resp::json_error(504, "handler returned without a response");
-    }
-    let bytes: Vec<u8> = wire::encode_resp(&cx.res);
-    wire::emit(&bytes);
-    Ok(())
-}

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

@@ -1,94 +0,0 @@
-//! The shared runtime's site registry.
-//!
-//! Under the shared runtime program a site is not a program: it is a site
-//! account `["site", site_id]` naming its authority, a code asset
-//! (`/.zoo/code.bin`, the bytecode module), its static assets and its
-//! manifest, all PDAs of the runtime program namespaced by `site_id`, plus KV
-//! accounts `["kv", site_id, hash]`. `site_id` is any 32-byte id the deployer
-//! picks (the CLI uses a fresh keypair's public key so ids look like programs).
-use crate::ERR_NOT_AUTHORITY;
-use pinocchio::{
-    cpi::{Seed, Signer},
-    error::ProgramError,
-    AccountView, Address, ProgramResult,
-};
-use pinocchio_system::instructions::CreateAccount;
-
-pub const SITE_LEN: usize = 2 + 32 + 32; // ver, bump, authority, reserved
-
-pub fn site_pda(program_id: &Address, site_id: &[u8; 32]) -> (Address, u8) {
-    Address::find_program_address(&[b"site", site_id], program_id)
-}
-
-/// `accounts[0]` must sign as the authority recorded in the site account at `accounts[1]`.
-pub fn check_site_authority(program_id: &Address, accounts: &[AccountView], site_id: &[u8; 32]) -> ProgramResult {
-    let authority = accounts.first().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    let site = accounts.get(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
-    if !authority.is_signer() {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let (expected, _) = site_pda(program_id, site_id);
-    if *site.address() != expected || !site.owned_by(program_id) {
-        return Err(ProgramError::Custom(ERR_NOT_AUTHORITY));
-    }
-    let d = site.try_borrow()?;
-    if d.len() < SITE_LEN || d[0] != 1 || d[2..34] != authority.address().as_ref()[..] {
-        return Err(ProgramError::Custom(ERR_NOT_AUTHORITY));
-    }
-    Ok(())
-}
-
-/// `[32 site_id]`; accounts: authority (signer, pays), site PDA (writable), system program.
-/// Creates the site account owned by the runtime with `authority` in charge.
-pub fn init(program_id: &Address, accounts: &mut [AccountView], data: &[u8]) -> ProgramResult {
-    if data.len() < 32 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let mut site_id = [0u8; 32];
-    site_id.copy_from_slice(&data[..32]);
-    let (head, tail) = accounts.split_at_mut(1);
-    let authority = &head[0];
-    let site = tail.first_mut().ok_or(ProgramError::NotEnoughAccountKeys)?;
-    if !authority.is_signer() {
-        return Err(ProgramError::MissingRequiredSignature);
-    }
-    let (addr, bump) = site_pda(program_id, &site_id);
-    if *site.address() != addr {
-        return Err(ProgramError::InvalidSeeds);
-    }
-    if site.owned_by(program_id) {
-        return Err(ProgramError::AccountAlreadyInitialized);
-    }
-    let bump_bytes = [bump];
-    let seeds = [Seed::from(b"site".as_ref()), Seed::from(site_id.as_ref()), Seed::from(bump_bytes.as_ref())];
-    let signer = Signer::from(&seeds);
-    CreateAccount::with_minimum_balance(authority, site, SITE_LEN as u64, program_id, None)?.invoke_signed(&[signer])?;
-    let mut d = site.try_borrow_mut()?;
-    d[0] = 1;
-    d[1] = bump;
-    d[2..34].copy_from_slice(authority.address().as_ref());
-    Ok(())
-}
-
-/// `[32 site_id][32 new_authority]`; accounts: authority (signer), site PDA (writable).
-pub fn set_authority(program_id: &Address, accounts: &mut [AccountView], data: &[u8]) -> ProgramResult {
-    if data.len() < 64 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let mut site_id = [0u8; 32];
-    site_id.copy_from_slice(&data[..32]);
-    check_site_authority(program_id, accounts, &site_id)?;
-    let site = accounts.get_mut(1).ok_or(ProgramError::NotEnoughAccountKeys)?;
-    let mut d = site.try_borrow_mut()?;
-    d[2..34].copy_from_slice(&data[32..64]);
-    Ok(())
-}
-
-pub fn site_id_from(data: &[u8]) -> Result<([u8; 32], &[u8]), ProgramError> {
-    if data.len() < 32 {
-        return Err(ProgramError::InvalidInstructionData);
-    }
-    let mut id = [0u8; 32];
-    id.copy_from_slice(&data[..32]);
-    Ok((id, &data[32..]))
-}