Revive read-tickets WIP

soroban-env-host/Cargo.toml

@@ -36,6 +36,7 @@ k256 = {version = "0.13.1", features=["ecdsa", "arithmetic"]}
 # is needed to build the host for wasm (a rare but supported config).
 getrandom = { version = "0.2", features=["js"] }
 sha3 = "0.10.8"
+bs = "0.1.0"
 
 [dev-dependencies]
 env_logger = "0.9.0"

soroban-env-host/src/auth.rs

@@ -700,7 +700,7 @@ impl AuthorizationManager {
             // Use the respective push (like
             // `push_create_contract_host_fn_frame`) functions instead to push
             // the frame with the required info.
-            Frame::HostFunction(_) => return Ok(()),
+            Frame::InitialInvokeHostFunctionOp(_) => return Ok(()),
             Frame::Token(id, fn_name, ..) => (id.metered_clone(host.budget_ref())?, *fn_name),
             #[cfg(any(test, feature = "testutils"))]
             Frame::TestContract(tc) => (tc.id.clone(), tc.func),

soroban-env-host/src/cost_runner/cost_types/visit_object.rs

@@ -1,6 +1,6 @@
 use std::hint::black_box;
 
-use crate::{cost_runner::CostRunner, host_object::HostObject, xdr::ContractCostType, Object};
+use crate::{cost_runner::CostRunner, host_object::HostObjectBody, xdr::ContractCostType, Object};
 
 pub struct VisitObjectRun;
 
@@ -17,7 +17,7 @@ impl CostRunner for VisitObjectRun {
                 host.unchecked_visit_val_obj(sample[iter as usize % sample.len()], |obj| match obj
                     .unwrap()
                 {
-                    HostObject::I64(i) => Ok(*i),
+                    HostObjectBody::I64(i) => Ok(*i),
                     _ => panic!("unexpected type, check HCM"),
                 })
                 .unwrap(),

soroban-env-host/src/events/diagnostic.rs

@@ -65,7 +65,7 @@ impl Host {
     pub(crate) fn get_current_contract_id_unmetered(&self) -> Result<Option<Hash>, HostError> {
         self.with_current_frame_opt(|frame| match frame {
             Some(Frame::ContractVM(vm, ..)) => Ok(Some(vm.contract_id.clone())),
-            Some(Frame::HostFunction(_)) => Ok(None),
+            Some(Frame::InitialInvokeHostFunctionOp(_)) => Ok(None),
             Some(Frame::Token(id, ..)) => Ok(Some(id.clone())),
             #[cfg(any(test, feature = "testutils"))]
             Some(Frame::TestContract(tc)) => Ok(Some(tc.id.clone())),

soroban-env-host/src/host.rs

@@ -10,7 +10,7 @@ use crate::{
     err,
     events::{diagnostic::DiagnosticLevel, Events, InternalEventsBuffer},
     expiration_ledger_bumps::{ExpirationLedgerBumps, LedgerBump},
-    host_object::{HostMap, HostObject, HostObjectType, HostVec},
+    host_object::{HostMap, HostObject, HostObjectType, HostVec, Ticket},
     impl_bignum_host_fns_rhs_u32, impl_wrapping_obj_from_num, impl_wrapping_obj_to_num,
     num::*,
     storage::{InstanceStorageMap, Storage},
@@ -94,6 +94,7 @@ pub(crate) struct HostImpl {
     source_account: RefCell<Option<AccountId>>,
     ledger: RefCell<Option<LedgerInfo>>,
     pub(crate) objects: RefCell<Vec<HostObject>>,
+    pub(crate) ticket: RefCell<Ticket>,
     storage: RefCell<Storage>,
     pub(crate) context: RefCell<Vec<Context>>,
     // Note: budget is refcounted and is _not_ deep-cloned when you call HostImpl::deep_clone,
@@ -164,6 +165,7 @@ impl_checked_borrow_helpers!(
     try_borrow_objects,
     try_borrow_objects_mut
 );
+impl_checked_borrow_helpers!(ticket, Ticket, try_borrow_ticket, try_borrow_ticket_mut);
 impl_checked_borrow_helpers!(storage, Storage, try_borrow_storage, try_borrow_storage_mut);
 impl_checked_borrow_helpers!(
     context,
@@ -234,6 +236,7 @@ impl Host {
             source_account: RefCell::new(None),
             ledger: RefCell::new(None),
             objects: Default::default(),
+            ticket: Default::default(),
             storage: RefCell::new(storage),
             context: Default::default(),
             budget,
@@ -1491,7 +1494,7 @@ impl VmCallerEnv for Host {
         m: MapObject,
         k: Val,
     ) -> Result<Val, HostError> {
-        self.visit_obj(m, move |hm: &HostMap| {
+        self.visit_obj_propagating_tickets(m, move |hm: &HostMap| {
             hm.get(&k, self)?.copied().ok_or_else(|| {
                 self.err(
                     ScErrorType::Object,
@@ -1540,7 +1543,7 @@ impl VmCallerEnv for Host {
         m: MapObject,
         k: Val,
     ) -> Result<Val, HostError> {
-        self.visit_obj(m, |hm: &HostMap| {
+        self.visit_obj_propagating_tickets(m, |hm: &HostMap| {
             if let Some((pk, _)) = hm.get_prev(&k, self)? {
                 Ok(*pk)
             } else {
@@ -1559,7 +1562,7 @@ impl VmCallerEnv for Host {
         m: MapObject,
         k: Val,
     ) -> Result<Val, HostError> {
-        self.visit_obj(m, |hm: &HostMap| {
+        self.visit_obj_propagating_tickets(m, |hm: &HostMap| {
             if let Some((pk, _)) = hm.get_next(&k, self)? {
                 Ok(*pk)
             } else {
@@ -1573,7 +1576,7 @@ impl VmCallerEnv for Host {
     }
 
     fn map_min_key(&self, _vmcaller: &mut VmCaller<Host>, m: MapObject) -> Result<Val, HostError> {
-        self.visit_obj(m, |hm: &HostMap| match hm.get_min(self)? {
+        self.visit_obj_propagating_tickets(m, |hm: &HostMap| match hm.get_min(self)? {
             Some((pk, pv)) => Ok(*pk),
             None => Ok(
                 Error::from_type_and_code(ScErrorType::Object, ScErrorCode::IndexBounds).to_val(),
@@ -1582,7 +1585,7 @@ impl VmCallerEnv for Host {
     }
 
     fn map_max_key(&self, _vmcaller: &mut VmCaller<Host>, m: MapObject) -> Result<Val, HostError> {
-        self.visit_obj(m, |hm: &HostMap| match hm.get_max(self)? {
+        self.visit_obj_propagating_tickets(m, |hm: &HostMap| match hm.get_max(self)? {
             Some((pk, pv)) => Ok(*pk),
             None => Ok(
                 Error::from_type_and_code(ScErrorType::Object, ScErrorCode::IndexBounds).to_val(),
@@ -1755,7 +1758,7 @@ impl VmCallerEnv for Host {
         i: U32Val,
     ) -> Result<Val, HostError> {
         let i: u32 = i.into();
-        self.visit_obj(v, move |hv: &HostVec| {
+        self.visit_obj_propagating_tickets(v, move |hv: &HostVec| {
             hv.get(i as usize, self.as_budget()).map(|r| *r)
         })
     }
@@ -1818,13 +1821,13 @@ impl VmCallerEnv for Host {
     }
 
     fn vec_front(&self, _vmcaller: &mut VmCaller<Host>, v: VecObject) -> Result<Val, HostError> {
-        self.visit_obj(v, |hv: &HostVec| {
+        self.visit_obj_propagating_tickets(v, |hv: &HostVec| {
             hv.front(self.as_budget()).map(|hval| *hval)
         })
     }
 
     fn vec_back(&self, _vmcaller: &mut VmCaller<Host>, v: VecObject) -> Result<Val, HostError> {
-        self.visit_obj(v, |hv: &HostVec| {
+        self.visit_obj_propagating_tickets(v, |hv: &HostVec| {
             hv.back(self.as_budget()).map(|hval| *hval)
         })
     }
@@ -2816,7 +2819,7 @@ impl VmCallerEnv for Host {
                 Frame::ContractVM(vm, function, ..) => {
                     get_host_val_tuple(&vm.contract_id, &function)?
                 }
-                Frame::HostFunction(_) => continue,
+                Frame::InitialInvokeHostFunctionOp(_) => continue,
                 Frame::Token(id, function, ..) => get_host_val_tuple(id, function)?,
                 #[cfg(any(test, feature = "testutils"))]
                 Frame::TestContract(tc) => get_host_val_tuple(&tc.id, &tc.func)?,
@@ -2873,7 +2876,7 @@ impl VmCallerEnv for Host {
         let args = self.with_current_frame(|f| {
             let args = match f {
                 Frame::ContractVM(_, _, args, _) => args,
-                Frame::HostFunction(_) => {
+                Frame::InitialInvokeHostFunctionOp(_) => {
                     return Err(self.err(
                         ScErrorType::Context,
                         ScErrorCode::InvalidAction,

soroban-env-host/src/host/comparison.rs

@@ -16,7 +16,7 @@ use soroban_env_common::{
 
 use crate::{
     budget::{AsBudget, Budget},
-    host_object::HostObject,
+    host_object::HostObjectBody,
     Host, HostError,
 };
 
@@ -28,30 +28,30 @@ use super::declared_size::DeclaredSizeForMetering;
 //
 // Note that these must have the same order as the impl
 // of Ord for ScVal, re https://github.com/stellar/rs-soroban-env/issues/743
-fn host_obj_discriminant(ho: &HostObject) -> usize {
+fn host_obj_discriminant(ho: &HostObjectBody) -> usize {
     match ho {
-        HostObject::U64(_) => 0,
-        HostObject::I64(_) => 1,
-        HostObject::TimePoint(_) => 2,
-        HostObject::Duration(_) => 3,
-        HostObject::U128(_) => 4,
-        HostObject::I128(_) => 5,
-        HostObject::U256(_) => 6,
-        HostObject::I256(_) => 7,
-        HostObject::Bytes(_) => 8,
-        HostObject::String(_) => 9,
-        HostObject::Symbol(_) => 10,
-        HostObject::Vec(_) => 11,
-        HostObject::Map(_) => 12,
-        HostObject::Address(_) => 13,
+        HostObjectBody::U64(_) => 0,
+        HostObjectBody::I64(_) => 1,
+        HostObjectBody::TimePoint(_) => 2,
+        HostObjectBody::Duration(_) => 3,
+        HostObjectBody::U128(_) => 4,
+        HostObjectBody::I128(_) => 5,
+        HostObjectBody::U256(_) => 6,
+        HostObjectBody::I256(_) => 7,
+        HostObjectBody::Bytes(_) => 8,
+        HostObjectBody::String(_) => 9,
+        HostObjectBody::Symbol(_) => 10,
+        HostObjectBody::Vec(_) => 11,
+        HostObjectBody::Map(_) => 12,
+        HostObjectBody::Address(_) => 13,
     }
 }
 
-impl Compare<HostObject> for Host {
+impl Compare<HostObjectBody> for Host {
     type Error = HostError;
 
-    fn compare(&self, a: &HostObject, b: &HostObject) -> Result<Ordering, Self::Error> {
-        use HostObject::*;
+    fn compare(&self, a: &HostObjectBody, b: &HostObjectBody) -> Result<Ordering, Self::Error> {
+        use HostObjectBody::*;
         match (a, b) {
             (U64(a), U64(b)) => self.as_budget().compare(a, b),
             (I64(a), I64(b)) => self.as_budget().compare(a, b),

soroban-env-host/src/host/conversion.rs

@@ -3,7 +3,7 @@ use std::rc::Rc;
 use super::metered_clone::{self, charge_container_bulk_init_with_elts, MeteredClone};
 use crate::budget::AsBudget;
 use crate::err;
-use crate::host_object::{HostMap, HostObject, HostVec};
+use crate::host_object::{HostMap, HostObjectBody, HostVec};
 use crate::xdr::{Hash, LedgerKey, LedgerKeyContractData, ScVal, ScVec, Uint256};
 use crate::{xdr::ContractCostType, Host, HostError, Val};
 use soroban_env_common::num::{
@@ -413,7 +413,7 @@ impl Host {
                         ));
                     }
                     Some(ho) => match ho {
-                        HostObject::Vec(vv) => {
+                        HostObjectBody::Vec(vv) => {
                             metered_clone::charge_heap_alloc::<ScVal>(
                                 vv.len() as u64,
                                 self.as_budget(),
@@ -425,24 +425,24 @@ impl Host {
                             )?;
                             ScVal::Vec(Some(ScVec(self.map_err(sv.try_into())?)))
                         }
-                        HostObject::Map(mm) => ScVal::Map(Some(self.host_map_to_scmap(mm)?)),
-                        HostObject::U64(u) => ScVal::U64(*u),
-                        HostObject::I64(i) => ScVal::I64(*i),
-                        HostObject::TimePoint(tp) => {
+                        HostObjectBody::Map(mm) => ScVal::Map(Some(self.host_map_to_scmap(mm)?)),
+                        HostObjectBody::U64(u) => ScVal::U64(*u),
+                        HostObjectBody::I64(i) => ScVal::I64(*i),
+                        HostObjectBody::TimePoint(tp) => {
                             ScVal::Timepoint(tp.metered_clone(self.as_budget())?)
                         }
-                        HostObject::Duration(d) => {
+                        HostObjectBody::Duration(d) => {
                             ScVal::Duration(d.metered_clone(self.as_budget())?)
                         }
-                        HostObject::U128(u) => ScVal::U128(UInt128Parts {
+                        HostObjectBody::U128(u) => ScVal::U128(UInt128Parts {
                             hi: int128_helpers::u128_hi(*u),
                             lo: int128_helpers::u128_lo(*u),
                         }),
-                        HostObject::I128(i) => ScVal::I128(Int128Parts {
+                        HostObjectBody::I128(i) => ScVal::I128(Int128Parts {
                             hi: int128_helpers::i128_hi(*i),
                             lo: int128_helpers::i128_lo(*i),
                         }),
-                        HostObject::U256(u) => {
+                        HostObjectBody::U256(u) => {
                             let (hi_hi, hi_lo, lo_hi, lo_lo) = u256_into_pieces(*u);
                             ScVal::U256(UInt256Parts {
                                 hi_hi,
@@ -451,7 +451,7 @@ impl Host {
                                 lo_lo,
                             })
                         }
-                        HostObject::I256(i) => {
+                        HostObjectBody::I256(i) => {
                             let (hi_hi, hi_lo, lo_hi, lo_lo) = i256_into_pieces(*i);
                             ScVal::I256(Int256Parts {
                                 hi_hi,
@@ -460,10 +460,16 @@ impl Host {
                                 lo_lo,
                             })
                         }
-                        HostObject::Bytes(b) => ScVal::Bytes(b.metered_clone(self.as_budget())?),
-                        HostObject::String(s) => ScVal::String(s.metered_clone(self.as_budget())?),
-                        HostObject::Symbol(s) => ScVal::Symbol(s.metered_clone(self.as_budget())?),
-                        HostObject::Address(addr) => {
+                        HostObjectBody::Bytes(b) => {
+                            ScVal::Bytes(b.metered_clone(self.as_budget())?)
+                        }
+                        HostObjectBody::String(s) => {
+                            ScVal::String(s.metered_clone(self.as_budget())?)
+                        }
+                        HostObjectBody::Symbol(s) => {
+                            ScVal::Symbol(s.metered_clone(self.as_budget())?)
+                        }
+                        HostObjectBody::Address(addr) => {
                             ScVal::Address(addr.metered_clone(self.as_budget())?)
                         }
                     },

soroban-env-host/src/host/declared_size.rs

@@ -95,7 +95,7 @@ impl_declared_size_type!(SymbolStr, SCSYMBOL_LIMIT);
 impl_declared_size_type!(SymbolSmallIter, 8);
 impl_declared_size_type!(U256, 32);
 impl_declared_size_type!(I256, 32);
-impl_declared_size_type!(HostObject, 48);
+impl_declared_size_type!(HostObject, 72);
 impl_declared_size_type!(LedgerBump, 20);
 // xdr types
 impl_declared_size_type!(TimePoint, 8);