From e124b1295ae2a3c0145941c832c54796b7f14b2a Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Tue, 12 May 2020 09:25:30 -0400 Subject: [PATCH 01/42] implemented state --- vm/actor/src/builtin/mod.rs | 1 + vm/actor/src/builtin/verifreg/mod.rs | 48 ++++++++++ vm/actor/src/builtin/verifreg/state.rs | 128 +++++++++++++++++++++++++ vm/actor/src/builtin/verifreg/types.rs | 40 ++++++++ 4 files changed, 217 insertions(+) create mode 100644 vm/actor/src/builtin/verifreg/mod.rs create mode 100644 vm/actor/src/builtin/verifreg/state.rs create mode 100644 vm/actor/src/builtin/verifreg/types.rs diff --git a/vm/actor/src/builtin/mod.rs b/vm/actor/src/builtin/mod.rs index 563a730e04c2..a1e52b92f3c7 100644 --- a/vm/actor/src/builtin/mod.rs +++ b/vm/actor/src/builtin/mod.rs @@ -14,6 +14,7 @@ pub mod reward; mod shared; mod singletons; pub mod system; +pub mod verifreg; pub use self::codes::*; pub(crate) use self::shared::*; diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs new file mode 100644 index 000000000000..7ebedcb7cce0 --- /dev/null +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -0,0 +1,48 @@ +pub mod state; +pub mod types; +pub use self::types::*; +pub use self::state::State; +use address::{Address, Protocol}; +use ipld_blockstore::BlockStore; +use num_derive::FromPrimitive; +use num_traits::FromPrimitive; +use runtime::{ActorCode, Runtime}; +use vm::{ActorError, ExitCode, MethodNum, Serialized, METHOD_CONSTRUCTOR}; +use crate::{StoragePower, HAMT_BIT_WIDTH,SYSTEM_ACTOR_ADDR}; +use ipld_hamt::Hamt; + +/// Account actor methods available +#[derive(FromPrimitive)] +#[repr(u64)] +pub enum Method { + Constructor = METHOD_CONSTRUCTOR, + AddVerifier = 2, + RemoveVerifier =3, + AddVerifiedClient =4, + UseBytes =5, + RestoreBytes =6 +} + + +pub struct Actor; +impl Actor { + /// Constructor for Registry Actor + pub fn constructor(rt: &mut RT,root_key:Address) -> Result<(), ActorError> + where + BS: BlockStore, + RT: Runtime, + { + rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; + let empty_root = Hamt::::new_with_bit_width(rt.store(), HAMT_BIT_WIDTH) + .flush() + .map_err(|e| { + rt.abort( + ExitCode::ErrIllegalState, + format!("failed to create storage power state: {}", e), + ) + })?; + let st = State::new(empty_root,root_key); + rt.create(&st)?; + Ok(()) + } +} \ No newline at end of file diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs new file mode 100644 index 000000000000..88073c2d61f1 --- /dev/null +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -0,0 +1,128 @@ +use crate::{StoragePower, HAMT_BIT_WIDTH}; +use address::Address; +use cid::Cid; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use vm::{Serialized, TokenAmount}; +use ipld_blockstore::BlockStore; +use encoding::Cbor; +use ipld_hamt::{Hamt,BytesKey}; +use num_bigint::biguint_ser::{BigUintSer,BigUintDe}; +use crate::builtin::verifreg::types::Datacap; + + + + +#[derive(Default)] +pub struct State { + pub root_key : Address, + pub verifiers : Cid, + pub verified_clients : Cid +} + + +impl State +{ + pub fn new(empty_map:Cid,root_key : Address) ->State + { + State + { + root_key, + verifiers : empty_map.clone(), + verified_clients : empty_map + } + } + + pub fn put_verified(&mut self, store: &BS,verified_addr : Address, verifier_cap : Datacap) ->Result<(), String> + { + Self::put(&mut self.verifiers,store,verified_addr,verifier_cap) + } + + pub fn get_verifier(&mut self,store: &BS,address_get:Address) ->Result,String> + { + Self::get(&mut self.verifiers,store,address_get) + } + + pub fn delete_verifier(&mut self,store: &BS,address:Address) ->Result<(),String> + { + Self::delete(&mut self.verifiers,store,address) + } + + pub fn put_verified_client(&mut self, store: &BS,verified_addr : Address, verifier_cap : Datacap) ->Result<(), String> + { + Self::put(&mut self.verified_clients,store,verified_addr,verifier_cap) + } + + pub fn get_verified_clients(&mut self,store: &BS,address:Address) ->Result,String> + { + Self::get(&mut self.verified_clients,store,address) + } + + pub fn delete_verified_clients(&mut self,store: &BS,address:Address) ->Result<(),String> + { + Self::delete(&mut self.verified_clients,store,address) + } + + + + //private helper functions + fn put(storage : &mut Cid,store: &BS,verified_addr : Address, verifier_cap : Datacap) ->Result<(), String> + { + let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; + map.set(verified_addr.to_bytes().into(),&verifier_cap)?; + map.flush()?; + Ok(()) + } + + fn get( storage : &mut Cid,store: &BS,verified_addr : Address) ->Result, String> + { + let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; + map.get(&verified_addr.to_bytes()).map_err(|e|e.to_string()) + } + + fn delete(storage : &mut Cid,store: &BS,verified_addr : Address) ->Result<(), String> + { + let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; + map.delete(&verified_addr.to_bytes())?; + map.flush()?; + Ok(()) + } + + +} + + +impl Cbor for State {} + +impl Serialize for State { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + ( + + &self.root_key, + &self.verifiers, + &self.verified_clients, + ) + .serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for State { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let ( + + root_key, + verifiers, + verified_clients, + ) = Deserialize::deserialize(deserializer)?; + Ok(Self { + root_key, + verifiers, + verified_clients, + }) + } +} \ No newline at end of file diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs new file mode 100644 index 000000000000..e47c1f428a78 --- /dev/null +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -0,0 +1,40 @@ +use address::Address; +use crate::StoragePower; +use num_bigint::biguint_ser::{BigUintDe,BigUintSer}; + +use serde::{Deserialize, Deserializer, Serialize, Serializer}; + +pub struct VerifierParams { + pub miner: Address, + pub allowance : Datacap +} + + +pub type AddVerifierParams = VerifierParams; +pub type AddVerifierClientParams = VerifierParams; + +pub struct Datacap(StoragePower); + +impl Serialize for Datacap +{ + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + ( + BigUintSer(&self.0) + ) + .serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for Datacap +{ + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let (BigUintDe(datacap)) = Deserialize::deserialize(deserializer)?; + Ok(Self(datacap)) + } +} \ No newline at end of file From 75fd786d76bcd141abef585fb00d9dfb14bbf93d Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Tue, 12 May 2020 10:16:44 -0400 Subject: [PATCH 02/42] added add and delete verifier methods --- vm/actor/src/builtin/verifreg/mod.rs | 36 ++++++++++++++++++++++++++ vm/actor/src/builtin/verifreg/types.rs | 2 +- 2 files changed, 37 insertions(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 7ebedcb7cce0..65c38206e274 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -45,4 +45,40 @@ impl Actor { rt.create(&st)?; Ok(()) } + + pub fn add_verifier(rt: &mut RT,params:AddVerifierParams) -> Result<(), ActorError> + where + BS: BlockStore, + RT: Runtime, + { + let state : State = rt.state()?;; + rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; + + rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt|{ + st.put_verified(rt.store(),params.address,params.allowance)?; + Ok(()) + })? + .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; + + Ok(()) + + } + + pub fn delete_verifier(rt: &mut RT,params:AddVerifierParams) -> Result<(), ActorError> + where + BS: BlockStore, + RT: Runtime, + { + let state : State = rt.state()?;; + rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; + + rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt|{ + st.delete_verifier(rt.store(),params.address)?; + Ok(()) + })? + .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; + + Ok(()) + + } } \ No newline at end of file diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index e47c1f428a78..4dd253678d2f 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -5,7 +5,7 @@ use num_bigint::biguint_ser::{BigUintDe,BigUintSer}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; pub struct VerifierParams { - pub miner: Address, + pub address: Address, pub allowance : Datacap } From 3e63c001089b9f837af7ca38986084f0aa2b4cb6 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Tue, 12 May 2020 10:18:05 -0400 Subject: [PATCH 03/42] applied cargo fix --- vm/actor/src/builtin/verifreg/mod.rs | 13 ++++++------- vm/actor/src/builtin/verifreg/state.rs | 8 ++++---- vm/actor/src/builtin/verifreg/types.rs | 2 +- 3 files changed, 11 insertions(+), 12 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 65c38206e274..62076a269841 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -2,13 +2,12 @@ pub mod state; pub mod types; pub use self::types::*; pub use self::state::State; -use address::{Address, Protocol}; +use address::{Address}; use ipld_blockstore::BlockStore; use num_derive::FromPrimitive; -use num_traits::FromPrimitive; -use runtime::{ActorCode, Runtime}; -use vm::{ActorError, ExitCode, MethodNum, Serialized, METHOD_CONSTRUCTOR}; -use crate::{StoragePower, HAMT_BIT_WIDTH,SYSTEM_ACTOR_ADDR}; +use runtime::{Runtime}; +use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; +use crate::{HAMT_BIT_WIDTH,SYSTEM_ACTOR_ADDR}; use ipld_hamt::Hamt; /// Account actor methods available @@ -51,7 +50,7 @@ impl Actor { BS: BlockStore, RT: Runtime, { - let state : State = rt.state()?;; + let state : State = rt.state()?; rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt|{ @@ -69,7 +68,7 @@ impl Actor { BS: BlockStore, RT: Runtime, { - let state : State = rt.state()?;; + let state : State = rt.state()?; rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt|{ diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 88073c2d61f1..afc5f551ed5d 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -1,12 +1,12 @@ -use crate::{StoragePower, HAMT_BIT_WIDTH}; +use crate::{HAMT_BIT_WIDTH}; use address::Address; use cid::Cid; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use vm::{Serialized, TokenAmount}; + use ipld_blockstore::BlockStore; use encoding::Cbor; use ipld_hamt::{Hamt,BytesKey}; -use num_bigint::biguint_ser::{BigUintSer,BigUintDe}; + use crate::builtin::verifreg::types::Datacap; @@ -75,7 +75,7 @@ impl State fn get( storage : &mut Cid,store: &BS,verified_addr : Address) ->Result, String> { - let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; + let map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.get(&verified_addr.to_bytes()).map_err(|e|e.to_string()) } diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 4dd253678d2f..4c97613f666b 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -34,7 +34,7 @@ impl<'de> Deserialize<'de> for Datacap where D: Deserializer<'de>, { - let (BigUintDe(datacap)) = Deserialize::deserialize(deserializer)?; + let BigUintDe(datacap) = Deserialize::deserialize(deserializer)?; Ok(Self(datacap)) } } \ No newline at end of file From de1c05d6989a34c130a9640f20b4771e407ef410 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Tue, 12 May 2020 13:52:27 -0400 Subject: [PATCH 04/42] implemented all the methods --- vm/actor/src/builtin/verifreg/mod.rs | 104 ++++++++++++++++++++++++- vm/actor/src/builtin/verifreg/types.rs | 17 +++- 2 files changed, 119 insertions(+), 2 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 62076a269841..afad03535689 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -9,7 +9,8 @@ use runtime::{Runtime}; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; use crate::{HAMT_BIT_WIDTH,SYSTEM_ACTOR_ADDR}; use ipld_hamt::Hamt; - +use message::Message; +use crate::StoragePower; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] @@ -80,4 +81,105 @@ impl Actor { Ok(()) } + + pub fn add_verified_client(rt: &mut RT,params:AddVerifierClientParams) -> Result<(), ActorError> + where + BS: BlockStore, + RT: Runtime, + { + if params.allowance.0 <= StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) + { + return Err(ActorError::new(ExitCode::ErrIllegalState,format!("Allowance {:} below MinVerifiedDealSize for add verified client {:}", params.allowance.0, params.address))) + } + + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt|{ + let message : Box<&dyn Message> = Box::new(rt.message()); + let verify_addr = message.from(); + + let verifier_cap = st.get_verifier(rt.store(),*verify_addr) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get Verifier {:?}",verify_addr)))? + .ok_or_else(||ActorError::new(ExitCode::ErrNotFound,format!("Invalid Verifier {:}",verify_addr)))?; + + if verifier_cap.0 < params.allowance.0 + { + return Err(ActorError::new(ExitCode::ErrIllegalArgument,format!("Add more DataCap {:?} for VerifiedClient than allocated {:?}",params.allowance,verifier_cap.0))) + } + let new_verifier_cap = verifier_cap.0 - params.allowance.clone().0; + st.put_verified(rt.store(),*verify_addr,Datacap(new_verifier_cap.clone())) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to update new verifier cap {:?} for {:?}", new_verifier_cap.clone(), params.allowance)))?; + st + .get_verified_clients(rt.store(),params.address) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get verified client{:}",params.address)))? + .ok_or_else(||ActorError::new(ExitCode::ErrNotFound,format!("Illegal Argument{:}",params.address)))?; + st.put_verified(rt.store(),params.address,params.allowance.clone()) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to add verified client {:?} with cap {:?}", params.address, params.allowance)))?; + + Ok(()) + })??; + + Ok(()) + } + + pub fn use_bytes(rt: &mut RT,params:UseBytesParams) -> Result<(), ActorError> + where + BS: BlockStore, + RT: Runtime, + { + rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; + if params.deal_size.0 < StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) + { + return Err(ActorError::new(ExitCode::ErrIllegalState,format!("Verified Dealsize {:} is below minimum in usedbytes", params.deal_size.0))) + } + + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt|{ + let verifier_cap = st.get_verifier(rt.store(),params.address.clone()) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get Verifier {:?}",params.address.clone())))? + .ok_or_else(||ActorError::new(ExitCode::ErrNotFound,format!("Invalid Verifier {:}",params.address)))?; + + if verifier_cap.0 >= StoragePower::new([0].to_vec()) + { + + panic!("new verifier cap should be greater than or equal to 0"); + } + let new_verifier_cap = verifier_cap.0 - params.deal_size.clone().0; + if new_verifier_cap < StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) + { + st.delete_verified_clients(rt.store(),params.address) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to delete verified client{:} with bytes {:?}",params.clone().address,params.deal_size))) + } + else + { + st.put_verified_client(rt.store(),params.address,Datacap(new_verifier_cap)) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to put verified client{:} with bytes {:}",params.address,params.deal_size.0))) + } + + })??; + + Ok(()) + } + + pub fn restore_bytes(rt: &mut RT,params:UseBytesParams) -> Result<(), ActorError> + where + BS: BlockStore, + RT: Runtime, + { + rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; + if params.deal_size.0 < StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) + { + return Err(ActorError::new(ExitCode::ErrIllegalState,format!("Verified Dealsize {:} is below minimum in usedbytes", params.deal_size.0))) + } + + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt|{ + let verifier_cap = st.get_verifier(rt.store(),params.address.clone()) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get Verifier {:?}",params.address.clone())))? + .unwrap_or_else(||Datacap(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()))); + + let new_verifier_cap = verifier_cap.0 + params.deal_size.clone().0; + st.put_verified_client(rt.store(),params.address,Datacap(new_verifier_cap)) + .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to put verified client{:} with bytes {:}",params.address,params.deal_size.0))) + + })??; + + Ok(()) + } } \ No newline at end of file diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 4c97613f666b..60751476290d 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -4,6 +4,7 @@ use num_bigint::biguint_ser::{BigUintDe,BigUintSer}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; +#[derive(Clone, Debug, PartialEq)] pub struct VerifierParams { pub address: Address, pub allowance : Datacap @@ -13,7 +14,21 @@ pub struct VerifierParams { pub type AddVerifierParams = VerifierParams; pub type AddVerifierClientParams = VerifierParams; -pub struct Datacap(StoragePower); +pub const MINIMUM_VERIFIED_SIZE : u32 = 1<<20; + +#[derive(Clone, Debug, PartialEq)] +pub struct Datacap(pub StoragePower); + +#[derive(Clone, Debug, PartialEq)] +pub struct BytesParams +{ + pub address : Address, + pub deal_size : Datacap +} + +pub type UseBytesParams = BytesParams; +pub type RestoreBytesParams = BytesParams; + impl Serialize for Datacap { From 8e415cd0a595c7d18a1e4f03dabab2848abd0bc0 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Tue, 12 May 2020 14:57:29 -0400 Subject: [PATCH 05/42] added traits --- vm/actor/src/builtin/verifreg/mod.rs | 271 +++++++++++++++++-------- vm/actor/src/builtin/verifreg/state.rs | 145 +++++++------ vm/actor/src/builtin/verifreg/types.rs | 68 +++++-- 3 files changed, 309 insertions(+), 175 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index afad03535689..60f5cca1dd24 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -1,33 +1,32 @@ pub mod state; pub mod types; -pub use self::types::*; pub use self::state::State; -use address::{Address}; +pub use self::types::*; +use crate::StoragePower; +use crate::{HAMT_BIT_WIDTH, SYSTEM_ACTOR_ADDR}; +use address::Address; use ipld_blockstore::BlockStore; -use num_derive::FromPrimitive; -use runtime::{Runtime}; -use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; -use crate::{HAMT_BIT_WIDTH,SYSTEM_ACTOR_ADDR}; use ipld_hamt::Hamt; use message::Message; -use crate::StoragePower; +use num_derive::FromPrimitive; +use runtime::Runtime; +use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] pub enum Method { Constructor = METHOD_CONSTRUCTOR, AddVerifier = 2, - RemoveVerifier =3, - AddVerifiedClient =4, - UseBytes =5, - RestoreBytes =6 + RemoveVerifier = 3, + AddVerifiedClient = 4, + UseBytes = 5, + RestoreBytes = 6, } - pub struct Actor; impl Actor { /// Constructor for Registry Actor - pub fn constructor(rt: &mut RT,root_key:Address) -> Result<(), ActorError> + pub fn constructor(rt: &mut RT, root_key: Address) -> Result<(), ActorError> where BS: BlockStore, RT: Runtime, @@ -41,145 +40,241 @@ impl Actor { format!("failed to create storage power state: {}", e), ) })?; - let st = State::new(empty_root,root_key); + let st = State::new(empty_root, root_key); rt.create(&st)?; Ok(()) } - pub fn add_verifier(rt: &mut RT,params:AddVerifierParams) -> Result<(), ActorError> + pub fn add_verifier(rt: &mut RT, params: AddVerifierParams) -> Result<(), ActorError> where BS: BlockStore, RT: Runtime, { - let state : State = rt.state()?; + let state: State = rt.state()?; rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; - rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt|{ - st.put_verified(rt.store(),params.address,params.allowance)?; + rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt| { + st.put_verified(rt.store(), params.address, params.allowance)?; Ok(()) })? .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; Ok(()) - } - pub fn delete_verifier(rt: &mut RT,params:AddVerifierParams) -> Result<(), ActorError> + pub fn delete_verifier(rt: &mut RT, params: AddVerifierParams) -> Result<(), ActorError> where BS: BlockStore, RT: Runtime, { - let state : State = rt.state()?; + let state: State = rt.state()?; rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; - rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt|{ - st.delete_verifier(rt.store(),params.address)?; + rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt| { + st.delete_verifier(rt.store(), params.address)?; Ok(()) })? .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; Ok(()) - } - pub fn add_verified_client(rt: &mut RT,params:AddVerifierClientParams) -> Result<(), ActorError> + pub fn add_verified_client( + rt: &mut RT, + params: AddVerifierClientParams, + ) -> Result<(), ActorError> where - BS: BlockStore, - RT: Runtime, + BS: BlockStore, + RT: Runtime, { - if params.allowance.0 <= StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) - { - return Err(ActorError::new(ExitCode::ErrIllegalState,format!("Allowance {:} below MinVerifiedDealSize for add verified client {:}", params.allowance.0, params.address))) + if params.allowance <= Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { + return Err(ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Allowance {:} below MinVerifiedDealSize for add verified client {:}", + params.allowance, params.address + ), + )); } - rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt|{ - let message : Box<&dyn Message> = Box::new(rt.message()); + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + let message: Box<&dyn Message> = Box::new(rt.message()); let verify_addr = message.from(); - let verifier_cap = st.get_verifier(rt.store(),*verify_addr) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get Verifier {:?}",verify_addr)))? - .ok_or_else(||ActorError::new(ExitCode::ErrNotFound,format!("Invalid Verifier {:}",verify_addr)))?; - - if verifier_cap.0 < params.allowance.0 - { - return Err(ActorError::new(ExitCode::ErrIllegalArgument,format!("Add more DataCap {:?} for VerifiedClient than allocated {:?}",params.allowance,verifier_cap.0))) + let verifier_cap = st + .get_verifier(rt.store(), *verify_addr) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!("Failed to get Verifier {:?}", verify_addr), + ) + })? + .ok_or_else(|| { + ActorError::new( + ExitCode::ErrNotFound, + format!("Invalid Verifier {:}", verify_addr), + ) + })?; + + if verifier_cap < params.allowance { + return Err(ActorError::new( + ExitCode::ErrIllegalArgument, + format!( + "Add more DataCap {:} for VerifiedClient than allocated {:}", + params.allowance, verifier_cap + ), + )); } - let new_verifier_cap = verifier_cap.0 - params.allowance.clone().0; - st.put_verified(rt.store(),*verify_addr,Datacap(new_verifier_cap.clone())) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to update new verifier cap {:?} for {:?}", new_verifier_cap.clone(), params.allowance)))?; - st - .get_verified_clients(rt.store(),params.address) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get verified client{:}",params.address)))? - .ok_or_else(||ActorError::new(ExitCode::ErrNotFound,format!("Illegal Argument{:}",params.address)))?; - st.put_verified(rt.store(),params.address,params.allowance.clone()) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to add verified client {:?} with cap {:?}", params.address, params.allowance)))?; - + let new_verifier_cap = verifier_cap - params.allowance.clone(); + st.put_verified(rt.store(), *verify_addr, new_verifier_cap.clone()) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Failed to update new verifier cap {:?} for {:?}", + new_verifier_cap.clone(), + params.allowance + ), + ) + })?; + st.get_verified_clients(rt.store(), params.address) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!("Failed to get verified client{:}", params.address), + ) + })? + .ok_or_else(|| { + ActorError::new( + ExitCode::ErrNotFound, + format!("Illegal Argument{:}", params.address), + ) + })?; + st.put_verified(rt.store(), params.address, params.allowance.clone()) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Failed to add verified client {:?} with cap {:?}", + params.address, params.allowance + ), + ) + })?; + Ok(()) })??; Ok(()) } - pub fn use_bytes(rt: &mut RT,params:UseBytesParams) -> Result<(), ActorError> + pub fn use_bytes(rt: &mut RT, params: UseBytesParams) -> Result<(), ActorError> where - BS: BlockStore, - RT: Runtime, + BS: BlockStore, + RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - if params.deal_size.0 < StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) - { - return Err(ActorError::new(ExitCode::ErrIllegalState,format!("Verified Dealsize {:} is below minimum in usedbytes", params.deal_size.0))) + if params.deal_size < Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { + return Err(ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Verified Dealsize {:} is below minimum in usedbytes", + params.deal_size + ), + )); } - rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt|{ - let verifier_cap = st.get_verifier(rt.store(),params.address.clone()) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get Verifier {:?}",params.address.clone())))? - .ok_or_else(||ActorError::new(ExitCode::ErrNotFound,format!("Invalid Verifier {:}",params.address)))?; + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + let verifier_cap = st + .get_verifier(rt.store(), params.address.clone()) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!("Failed to get Verifier {:?}", params.address.clone()), + ) + })? + .ok_or_else(|| { + ActorError::new( + ExitCode::ErrNotFound, + format!("Invalid Verifier {:}", params.address), + ) + })?; - if verifier_cap.0 >= StoragePower::new([0].to_vec()) - { - + if verifier_cap >= Datacap::new(StoragePower::new([0].to_vec())) { panic!("new verifier cap should be greater than or equal to 0"); } - let new_verifier_cap = verifier_cap.0 - params.deal_size.clone().0; - if new_verifier_cap < StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) + let new_verifier_cap = verifier_cap - params.deal_size.clone(); + if new_verifier_cap < Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { - st.delete_verified_clients(rt.store(),params.address) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to delete verified client{:} with bytes {:?}",params.clone().address,params.deal_size))) + st.delete_verified_clients(rt.store(), params.address) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Failed to delete verified client{:} with bytes {:?}", + params.clone().address, + params.deal_size + ), + ) + }) + } else { + st.put_verified_client(rt.store(), params.address, new_verifier_cap) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Failed to put verified client{:} with bytes {:}", + params.address, params.deal_size + ), + ) + }) } - else - { - st.put_verified_client(rt.store(),params.address,Datacap(new_verifier_cap)) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to put verified client{:} with bytes {:}",params.address,params.deal_size.0))) - } - })??; Ok(()) } - pub fn restore_bytes(rt: &mut RT,params:UseBytesParams) -> Result<(), ActorError> + pub fn restore_bytes(rt: &mut RT, params: UseBytesParams) -> Result<(), ActorError> where - BS: BlockStore, - RT: Runtime, + BS: BlockStore, + RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - if params.deal_size.0 < StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()) - { - return Err(ActorError::new(ExitCode::ErrIllegalState,format!("Verified Dealsize {:} is below minimum in usedbytes", params.deal_size.0))) + if params.deal_size < Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { + return Err(ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Verified Dealsize {:} is below minimum in usedbytes", + params.deal_size + ), + )); } - rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt|{ - let verifier_cap = st.get_verifier(rt.store(),params.address.clone()) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to get Verifier {:?}",params.address.clone())))? - .unwrap_or_else(||Datacap(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec()))); - - let new_verifier_cap = verifier_cap.0 + params.deal_size.clone().0; - st.put_verified_client(rt.store(),params.address,Datacap(new_verifier_cap)) - .map_err(|_|ActorError::new(ExitCode::ErrIllegalState,format!("Failed to put verified client{:} with bytes {:}",params.address,params.deal_size.0))) - + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + let verifier_cap = st + .get_verifier(rt.store(), params.address.clone()) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!("Failed to get Verifier {:?}", params.address.clone()), + ) + })? + .unwrap_or_else(|| { + Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) + }); + + let new_verifier_cap = verifier_cap + params.deal_size.clone(); + st.put_verified_client(rt.store(), params.address, new_verifier_cap) + .map_err(|_| { + ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Failed to put verified client{:} with bytes {:}", + params.address, params.deal_size + ), + ) + }) })??; Ok(()) } -} \ No newline at end of file +} diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index afc5f551ed5d..925690953c6a 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -1,96 +1,122 @@ -use crate::{HAMT_BIT_WIDTH}; +use crate::HAMT_BIT_WIDTH; use address::Address; use cid::Cid; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use ipld_blockstore::BlockStore; use encoding::Cbor; -use ipld_hamt::{Hamt,BytesKey}; +use ipld_blockstore::BlockStore; +use ipld_hamt::{BytesKey, Hamt}; use crate::builtin::verifreg::types::Datacap; - - - #[derive(Default)] pub struct State { - pub root_key : Address, - pub verifiers : Cid, - pub verified_clients : Cid + pub root_key: Address, + pub verifiers: Cid, + pub verified_clients: Cid, } - -impl State -{ - pub fn new(empty_map:Cid,root_key : Address) ->State - { - State - { +impl State { + pub fn new(empty_map: Cid, root_key: Address) -> State { + State { root_key, - verifiers : empty_map.clone(), - verified_clients : empty_map + verifiers: empty_map.clone(), + verified_clients: empty_map, } } - pub fn put_verified(&mut self, store: &BS,verified_addr : Address, verifier_cap : Datacap) ->Result<(), String> - { - Self::put(&mut self.verifiers,store,verified_addr,verifier_cap) + pub fn put_verified( + &mut self, + store: &BS, + verified_addr: Address, + verifier_cap: Datacap, + ) -> Result<(), String> { + Self::put(&mut self.verifiers, store, verified_addr, verifier_cap) } - pub fn get_verifier(&mut self,store: &BS,address_get:Address) ->Result,String> - { - Self::get(&mut self.verifiers,store,address_get) + pub fn get_verifier( + &mut self, + store: &BS, + address_get: Address, + ) -> Result, String> { + Self::get(&mut self.verifiers, store, address_get) } - pub fn delete_verifier(&mut self,store: &BS,address:Address) ->Result<(),String> - { - Self::delete(&mut self.verifiers,store,address) + pub fn delete_verifier( + &mut self, + store: &BS, + address: Address, + ) -> Result<(), String> { + Self::delete(&mut self.verifiers, store, address) } - pub fn put_verified_client(&mut self, store: &BS,verified_addr : Address, verifier_cap : Datacap) ->Result<(), String> - { - Self::put(&mut self.verified_clients,store,verified_addr,verifier_cap) + pub fn put_verified_client( + &mut self, + store: &BS, + verified_addr: Address, + verifier_cap: Datacap, + ) -> Result<(), String> { + Self::put( + &mut self.verified_clients, + store, + verified_addr, + verifier_cap, + ) } - pub fn get_verified_clients(&mut self,store: &BS,address:Address) ->Result,String> - { - Self::get(&mut self.verified_clients,store,address) + pub fn get_verified_clients( + &mut self, + store: &BS, + address: Address, + ) -> Result, String> { + Self::get(&mut self.verified_clients, store, address) } - pub fn delete_verified_clients(&mut self,store: &BS,address:Address) ->Result<(),String> - { - Self::delete(&mut self.verified_clients,store,address) + pub fn delete_verified_clients( + &mut self, + store: &BS, + address: Address, + ) -> Result<(), String> { + Self::delete(&mut self.verified_clients, store, address) } - - //private helper functions - fn put(storage : &mut Cid,store: &BS,verified_addr : Address, verifier_cap : Datacap) ->Result<(), String> - { - let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; - map.set(verified_addr.to_bytes().into(),&verifier_cap)?; + fn put( + storage: &mut Cid, + store: &BS, + verified_addr: Address, + verifier_cap: Datacap, + ) -> Result<(), String> { + let mut map: Hamt = + Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; + map.set(verified_addr.to_bytes().into(), &verifier_cap)?; map.flush()?; Ok(()) } - fn get( storage : &mut Cid,store: &BS,verified_addr : Address) ->Result, String> - { + fn get( + storage: &mut Cid, + store: &BS, + verified_addr: Address, + ) -> Result, String> { let map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; - map.get(&verified_addr.to_bytes()).map_err(|e|e.to_string()) + map.get(&verified_addr.to_bytes()) + .map_err(|e| e.to_string()) } - fn delete(storage : &mut Cid,store: &BS,verified_addr : Address) ->Result<(), String> - { - let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; + fn delete( + storage: &mut Cid, + store: &BS, + verified_addr: Address, + ) -> Result<(), String> { + let mut map: Hamt = + Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.delete(&verified_addr.to_bytes())?; map.flush()?; Ok(()) } - - } - impl Cbor for State {} impl Serialize for State { @@ -98,13 +124,7 @@ impl Serialize for State { where S: Serializer, { - ( - - &self.root_key, - &self.verifiers, - &self.verified_clients, - ) - .serialize(serializer) + (&self.root_key, &self.verifiers, &self.verified_clients).serialize(serializer) } } @@ -113,16 +133,11 @@ impl<'de> Deserialize<'de> for State { where D: Deserializer<'de>, { - let ( - - root_key, - verifiers, - verified_clients, - ) = Deserialize::deserialize(deserializer)?; + let (root_key, verifiers, verified_clients) = Deserialize::deserialize(deserializer)?; Ok(Self { root_key, verifiers, verified_clients, }) } -} \ No newline at end of file +} diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 60751476290d..92171ce11694 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -1,50 +1,74 @@ -use address::Address; use crate::StoragePower; -use num_bigint::biguint_ser::{BigUintDe,BigUintSer}; +use address::Address; +use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use std::{ + fmt, + ops::{Add, Sub}, +}; -#[derive(Clone, Debug, PartialEq)] -pub struct VerifierParams { +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct VerifierParams { pub address: Address, - pub allowance : Datacap + pub allowance: Datacap, } - pub type AddVerifierParams = VerifierParams; pub type AddVerifierClientParams = VerifierParams; -pub const MINIMUM_VERIFIED_SIZE : u32 = 1<<20; +pub const MINIMUM_VERIFIED_SIZE: u32 = 1 << 20; -#[derive(Clone, Debug, PartialEq)] -pub struct Datacap(pub StoragePower); +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub struct Datacap(StoragePower); + +impl Datacap { + pub fn new(storage_power: StoragePower) -> Self { + Self(storage_power) + } +} #[derive(Clone, Debug, PartialEq)] -pub struct BytesParams -{ - pub address : Address, - pub deal_size : Datacap +pub struct BytesParams { + pub address: Address, + pub deal_size: Datacap, } pub type UseBytesParams = BytesParams; pub type RestoreBytesParams = BytesParams; +impl Add for Datacap { + type Output = Self; + + fn add(self, other: Self) -> Self { + Self(self.0 + other.0) + } +} + +impl Sub for Datacap { + type Output = Self; + + fn sub(self, other: Self) -> Self { + Self(self.0 - other.0) + } +} -impl Serialize for Datacap -{ +impl fmt::Display for Datacap { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl Serialize for Datacap { fn serialize(&self, serializer: S) -> Result where S: Serializer, { - ( - BigUintSer(&self.0) - ) - .serialize(serializer) + (BigUintSer(&self.0)).serialize(serializer) } } -impl<'de> Deserialize<'de> for Datacap -{ +impl<'de> Deserialize<'de> for Datacap { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, @@ -52,4 +76,4 @@ impl<'de> Deserialize<'de> for Datacap let BigUintDe(datacap) = Deserialize::deserialize(deserializer)?; Ok(Self(datacap)) } -} \ No newline at end of file +} From 7f52fc1747516f50fa6accf8e73b0713d514c0f0 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 07:30:16 -0400 Subject: [PATCH 06/42] takes reference instead --- vm/actor/src/builtin/verifreg/mod.rs | 39 +++++++++++++------------- vm/actor/src/builtin/verifreg/state.rs | 24 ++++++++-------- 2 files changed, 32 insertions(+), 31 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 60f5cca1dd24..98008b5df6ec 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -2,7 +2,6 @@ pub mod state; pub mod types; pub use self::state::State; pub use self::types::*; -use crate::StoragePower; use crate::{HAMT_BIT_WIDTH, SYSTEM_ACTOR_ADDR}; use address::Address; use ipld_blockstore::BlockStore; @@ -11,6 +10,8 @@ use message::Message; use num_derive::FromPrimitive; use runtime::Runtime; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; +use num_traits::{Zero}; +use num_bigint::ToBigUint; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] @@ -54,7 +55,7 @@ impl Actor { rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt| { - st.put_verified(rt.store(), params.address, params.allowance)?; + st.put_verified(rt.store(), ¶ms.address, ¶ms.allowance)?; Ok(()) })? .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; @@ -71,7 +72,7 @@ impl Actor { rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt| { - st.delete_verifier(rt.store(), params.address)?; + st.delete_verifier(rt.store(), ¶ms.address)?; Ok(()) })? .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; @@ -87,7 +88,7 @@ impl Actor { BS: BlockStore, RT: Runtime, { - if params.allowance <= Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { + if params.allowance <= Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -102,7 +103,7 @@ impl Actor { let verify_addr = message.from(); let verifier_cap = st - .get_verifier(rt.store(), *verify_addr) + .get_verifier(rt.store(), &*verify_addr) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -126,7 +127,7 @@ impl Actor { )); } let new_verifier_cap = verifier_cap - params.allowance.clone(); - st.put_verified(rt.store(), *verify_addr, new_verifier_cap.clone()) + st.put_verified(rt.store(), &*verify_addr, &new_verifier_cap.clone()) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -137,7 +138,7 @@ impl Actor { ), ) })?; - st.get_verified_clients(rt.store(), params.address) + st.get_verified_clients(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -150,7 +151,7 @@ impl Actor { format!("Illegal Argument{:}", params.address), ) })?; - st.put_verified(rt.store(), params.address, params.allowance.clone()) + st.put_verified(rt.store(), ¶ms.address, ¶ms.allowance) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -173,7 +174,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - if params.deal_size < Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { + if params.deal_size < Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -185,11 +186,11 @@ impl Actor { rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { let verifier_cap = st - .get_verifier(rt.store(), params.address.clone()) + .get_verifier(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, - format!("Failed to get Verifier {:?}", params.address.clone()), + format!("Failed to get Verifier {:?}", ¶ms.address), ) })? .ok_or_else(|| { @@ -199,13 +200,13 @@ impl Actor { ) })?; - if verifier_cap >= Datacap::new(StoragePower::new([0].to_vec())) { + if verifier_cap >= Datacap::new(Zero::zero()) { panic!("new verifier cap should be greater than or equal to 0"); } let new_verifier_cap = verifier_cap - params.deal_size.clone(); - if new_verifier_cap < Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) + if new_verifier_cap < Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { - st.delete_verified_clients(rt.store(), params.address) + st.delete_verified_clients(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -217,7 +218,7 @@ impl Actor { ) }) } else { - st.put_verified_client(rt.store(), params.address, new_verifier_cap) + st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -239,7 +240,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - if params.deal_size < Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) { + if params.deal_size < Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -251,7 +252,7 @@ impl Actor { rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { let verifier_cap = st - .get_verifier(rt.store(), params.address.clone()) + .get_verifier(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -259,11 +260,11 @@ impl Actor { ) })? .unwrap_or_else(|| { - Datacap::new(StoragePower::new([MINIMUM_VERIFIED_SIZE].to_vec())) + Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) }); let new_verifier_cap = verifier_cap + params.deal_size.clone(); - st.put_verified_client(rt.store(), params.address, new_verifier_cap) + st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 925690953c6a..fa2fa752384f 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -28,8 +28,8 @@ impl State { pub fn put_verified( &mut self, store: &BS, - verified_addr: Address, - verifier_cap: Datacap, + verified_addr: &Address, + verifier_cap: &Datacap, ) -> Result<(), String> { Self::put(&mut self.verifiers, store, verified_addr, verifier_cap) } @@ -37,7 +37,7 @@ impl State { pub fn get_verifier( &mut self, store: &BS, - address_get: Address, + address_get: &Address, ) -> Result, String> { Self::get(&mut self.verifiers, store, address_get) } @@ -45,7 +45,7 @@ impl State { pub fn delete_verifier( &mut self, store: &BS, - address: Address, + address: &Address, ) -> Result<(), String> { Self::delete(&mut self.verifiers, store, address) } @@ -53,8 +53,8 @@ impl State { pub fn put_verified_client( &mut self, store: &BS, - verified_addr: Address, - verifier_cap: Datacap, + verified_addr: &Address, + verifier_cap: &Datacap, ) -> Result<(), String> { Self::put( &mut self.verified_clients, @@ -67,7 +67,7 @@ impl State { pub fn get_verified_clients( &mut self, store: &BS, - address: Address, + address: &Address, ) -> Result, String> { Self::get(&mut self.verified_clients, store, address) } @@ -75,7 +75,7 @@ impl State { pub fn delete_verified_clients( &mut self, store: &BS, - address: Address, + address: &Address, ) -> Result<(), String> { Self::delete(&mut self.verified_clients, store, address) } @@ -84,8 +84,8 @@ impl State { fn put( storage: &mut Cid, store: &BS, - verified_addr: Address, - verifier_cap: Datacap, + verified_addr: &Address, + verifier_cap: &Datacap, ) -> Result<(), String> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; @@ -97,7 +97,7 @@ impl State { fn get( storage: &mut Cid, store: &BS, - verified_addr: Address, + verified_addr: &Address, ) -> Result, String> { let map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.get(&verified_addr.to_bytes()) @@ -107,7 +107,7 @@ impl State { fn delete( storage: &mut Cid, store: &BS, - verified_addr: Address, + verified_addr: &Address, ) -> Result<(), String> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; From 0224c24c2a3e198d74ced7eddcb7194120437857 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 08:50:58 -0400 Subject: [PATCH 07/42] made a few fixes --- vm/actor/src/builtin/verifreg/mod.rs | 99 +++++++++++++++++++------- vm/actor/src/builtin/verifreg/state.rs | 28 ++++---- 2 files changed, 87 insertions(+), 40 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 98008b5df6ec..77ffed66b22b 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -7,11 +7,11 @@ use address::Address; use ipld_blockstore::BlockStore; use ipld_hamt::Hamt; use message::Message; +use num_bigint::ToBigUint; use num_derive::FromPrimitive; +use num_traits::Zero; use runtime::Runtime; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; -use num_traits::{Zero}; -use num_bigint::ToBigUint; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] @@ -36,9 +36,9 @@ impl Actor { let empty_root = Hamt::::new_with_bit_width(rt.store(), HAMT_BIT_WIDTH) .flush() .map_err(|e| { - rt.abort( + ActorError::new( ExitCode::ErrIllegalState, - format!("failed to create storage power state: {}", e), + format!("Failed to create registry state {:}", e), ) })?; let st = State::new(empty_root, root_key); @@ -54,11 +54,16 @@ impl Actor { let state: State = rt.state()?; rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; - rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt| { - st.put_verified(rt.store(), ¶ms.address, ¶ms.allowance)?; + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + st.put_verifier(rt.store(), ¶ms.address, ¶ms.allowance) + .map_err(|e| { + ActorError::new( + ExitCode::ErrIllegalState, + format!("failed to add verifier: {:}", e), + ) + })?; Ok(()) - })? - .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; + })??; Ok(()) } @@ -71,11 +76,16 @@ impl Actor { let state: State = rt.state()?; rt.validate_immediate_caller_is(std::iter::once(&state.root_key))?; - rt.transaction::<_, Result<_, String>, _>(|st: &mut State, rt| { - st.delete_verifier(rt.store(), ¶ms.address)?; + rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + st.delete_verifier(rt.store(), ¶ms.address) + .map_err(|e| { + ActorError::new( + ExitCode::ErrIllegalState, + format!("failed to add verifier: {:}", e), + ) + })?; Ok(()) - })? - .map_err(|e| ActorError::new(ExitCode::ErrIllegalState, e))?; + })??; Ok(()) } @@ -88,7 +98,13 @@ impl Actor { BS: BlockStore, RT: Runtime, { - if params.allowance <= Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { + if params.allowance + <= Datacap::new( + MINIMUM_VERIFIED_SIZE + .to_biguint() + .expect("Could not convert size to big int"), + ) + { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -99,6 +115,7 @@ impl Actor { } rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + // Validate caller is one of the verifiers. let message: Box<&dyn Message> = Box::new(rt.message()); let verify_addr = message.from(); @@ -117,6 +134,7 @@ impl Actor { ) })?; + // Compute new verifier cap and update. if verifier_cap < params.allowance { return Err(ActorError::new( ExitCode::ErrIllegalArgument, @@ -127,18 +145,22 @@ impl Actor { )); } let new_verifier_cap = verifier_cap - params.allowance.clone(); - st.put_verified(rt.store(), &*verify_addr, &new_verifier_cap.clone()) + st.put_verifier(rt.store(), &*verify_addr, &new_verifier_cap) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, format!( "Failed to update new verifier cap {:?} for {:?}", - new_verifier_cap.clone(), - params.allowance + new_verifier_cap, params.allowance ), ) })?; - st.get_verified_clients(rt.store(), ¶ms.address) + + // Write-once entry and does not get changed for simplicity. + // If parties neeed more allowance, they can get another VerifiedClient account. + // This is a one-time, upfront allocation. + // Returns error if VerifiedClient already exists + st.get_verified_client(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -151,7 +173,7 @@ impl Actor { format!("Illegal Argument{:}", params.address), ) })?; - st.put_verified(rt.store(), ¶ms.address, ¶ms.allowance) + st.put_verifier(rt.store(), ¶ms.address, ¶ms.allowance) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -173,8 +195,14 @@ impl Actor { BS: BlockStore, RT: Runtime, { - rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - if params.deal_size < Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { + rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; + if params.deal_size + < Datacap::new( + MINIMUM_VERIFIED_SIZE + .to_biguint() + .expect("Could not convert size to big int"), + ) + { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -204,9 +232,16 @@ impl Actor { panic!("new verifier cap should be greater than or equal to 0"); } let new_verifier_cap = verifier_cap - params.deal_size.clone(); - if new_verifier_cap < Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) + if new_verifier_cap + < Datacap::new( + MINIMUM_VERIFIED_SIZE + .to_biguint() + .expect("Could not convert size to big int"), + ) { - st.delete_verified_clients(rt.store(), ¶ms.address) + // Delete entry if remaining DataCap is less than MinVerifiedDealSize. + // Will be restored later if the deal did not get activated with a ProvenSector. + st.delete_verified_client(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -234,13 +269,21 @@ impl Actor { Ok(()) } + // Called by HandleInitTimeoutDeals from StorageMarketActor when a VerifiedDeal fails to init. + // Restore allowable cap for the client, creating new entry if the client has been deleted. pub fn restore_bytes(rt: &mut RT, params: UseBytesParams) -> Result<(), ActorError> where BS: BlockStore, RT: Runtime, { - rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - if params.deal_size < Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) { + rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; + if params.deal_size + < Datacap::new( + MINIMUM_VERIFIED_SIZE + .to_biguint() + .expect("Could not convert size to big int"), + ) + { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -260,11 +303,15 @@ impl Actor { ) })? .unwrap_or_else(|| { - Datacap::new(MINIMUM_VERIFIED_SIZE.to_biguint().expect("Could not convert size to big int")) + Datacap::new( + MINIMUM_VERIFIED_SIZE + .to_biguint() + .expect("Could not convert size to big int"), + ) }); let new_verifier_cap = verifier_cap + params.deal_size.clone(); - st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) + st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index fa2fa752384f..07cb3fe50e71 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -16,6 +16,7 @@ pub struct State { pub verified_clients: Cid, } +type StateResult = Result; impl State { pub fn new(empty_map: Cid, root_key: Address) -> State { State { @@ -25,12 +26,12 @@ impl State { } } - pub fn put_verified( + pub fn put_verifier( &mut self, store: &BS, verified_addr: &Address, verifier_cap: &Datacap, - ) -> Result<(), String> { + ) -> StateResult<()> { Self::put(&mut self.verifiers, store, verified_addr, verifier_cap) } @@ -38,7 +39,7 @@ impl State { &mut self, store: &BS, address_get: &Address, - ) -> Result, String> { + ) -> StateResult> { Self::get(&mut self.verifiers, store, address_get) } @@ -46,7 +47,7 @@ impl State { &mut self, store: &BS, address: &Address, - ) -> Result<(), String> { + ) -> StateResult<()> { Self::delete(&mut self.verifiers, store, address) } @@ -55,7 +56,7 @@ impl State { store: &BS, verified_addr: &Address, verifier_cap: &Datacap, - ) -> Result<(), String> { + ) -> StateResult<()> { Self::put( &mut self.verified_clients, store, @@ -64,19 +65,19 @@ impl State { ) } - pub fn get_verified_clients( + pub fn get_verified_client( &mut self, store: &BS, address: &Address, - ) -> Result, String> { + ) -> StateResult> { Self::get(&mut self.verified_clients, store, address) } - pub fn delete_verified_clients( + pub fn delete_verified_client( &mut self, store: &BS, address: &Address, - ) -> Result<(), String> { + ) -> StateResult<()> { Self::delete(&mut self.verified_clients, store, address) } @@ -86,7 +87,7 @@ impl State { store: &BS, verified_addr: &Address, verifier_cap: &Datacap, - ) -> Result<(), String> { + ) -> StateResult<()> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.set(verified_addr.to_bytes().into(), &verifier_cap)?; @@ -98,17 +99,16 @@ impl State { storage: &mut Cid, store: &BS, verified_addr: &Address, - ) -> Result, String> { + ) -> StateResult> { let map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; - map.get(&verified_addr.to_bytes()) - .map_err(|e| e.to_string()) + Ok(map.get(&verified_addr.to_bytes())?) } fn delete( storage: &mut Cid, store: &BS, verified_addr: &Address, - ) -> Result<(), String> { + ) -> StateResult<()> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.delete(&verified_addr.to_bytes())?; From 34c3064338fe356af8726ba73dc6774e2ca87833 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 08:55:36 -0400 Subject: [PATCH 08/42] fixes --- vm/actor/src/builtin/verifreg/mod.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 77ffed66b22b..388095d6b22d 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -1,5 +1,5 @@ -pub mod state; -pub mod types; +mod state; +mod types; pub use self::state::State; pub use self::types::*; use crate::{HAMT_BIT_WIDTH, SYSTEM_ACTOR_ADDR}; @@ -12,6 +12,7 @@ use num_derive::FromPrimitive; use num_traits::Zero; use runtime::Runtime; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; +use crate::builtin::singletons::STORAGE_MARKET_ACTOR_ADDR; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] From b39110f8c835c1063f482da27d99ff047dae4f9a Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 08:55:58 -0400 Subject: [PATCH 09/42] fmt changes --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 388095d6b22d..298c68ccc918 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -2,6 +2,7 @@ mod state; mod types; pub use self::state::State; pub use self::types::*; +use crate::builtin::singletons::STORAGE_MARKET_ACTOR_ADDR; use crate::{HAMT_BIT_WIDTH, SYSTEM_ACTOR_ADDR}; use address::Address; use ipld_blockstore::BlockStore; @@ -12,7 +13,6 @@ use num_derive::FromPrimitive; use num_traits::Zero; use runtime::Runtime; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; -use crate::builtin::singletons::STORAGE_MARKET_ACTOR_ADDR; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] From 3a6834ae636486eab6e1fcc2de676b8dea448503 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 09:08:09 -0400 Subject: [PATCH 10/42] added license --- vm/actor/src/builtin/verifreg/mod.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 298c68ccc918..adf87e424c58 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -1,3 +1,5 @@ +// Copyright 2020 ChainSafe Systems +// SPDX-License-Identifier: Apache-2.0, MIT mod state; mod types; pub use self::state::State; From 52a1b60855ee6aa9544116a0d8d43ffaf1260b7e Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 09:11:16 -0400 Subject: [PATCH 11/42] license headers --- vm/actor/src/builtin/verifreg/mod.rs | 1 + vm/actor/src/builtin/verifreg/state.rs | 3 +++ vm/actor/src/builtin/verifreg/types.rs | 3 +++ 3 files changed, 7 insertions(+) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index adf87e424c58..3786486a303b 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -1,5 +1,6 @@ // Copyright 2020 ChainSafe Systems // SPDX-License-Identifier: Apache-2.0, MIT + mod state; mod types; pub use self::state::State; diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 07cb3fe50e71..f0ac41b1d587 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -1,3 +1,6 @@ +// Copyright 2020 ChainSafe Systems +// SPDX-License-Identifier: Apache-2.0, MIT + use crate::HAMT_BIT_WIDTH; use address::Address; use cid::Cid; diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 92171ce11694..37e149fb58fe 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -14,6 +14,9 @@ pub struct VerifierParams { pub allowance: Datacap, } +// Copyright 2020 ChainSafe Systems +// SPDX-License-Identifier: Apache-2.0, MIT + pub type AddVerifierParams = VerifierParams; pub type AddVerifierClientParams = VerifierParams; From 6cccc57af19aadbfc1ea72d5295ca9735de0a09a Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 09:15:18 -0400 Subject: [PATCH 12/42] license headers --- vm/actor/src/builtin/verifreg/types.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 37e149fb58fe..aba70deb53e7 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -1,3 +1,6 @@ +// Copyright 2020 ChainSafe Systems +// SPDX-License-Identifier: Apache-2.0, MIT + use crate::StoragePower; use address::Address; use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; @@ -14,9 +17,6 @@ pub struct VerifierParams { pub allowance: Datacap, } -// Copyright 2020 ChainSafe Systems -// SPDX-License-Identifier: Apache-2.0, MIT - pub type AddVerifierParams = VerifierParams; pub type AddVerifierClientParams = VerifierParams; From 17004147242bc0341e1b830400ab365c717bb890 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 09:54:16 -0400 Subject: [PATCH 13/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 3786486a303b..5215c0f9ee08 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -37,7 +37,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*SYSTEM_ACTOR_ADDR))?; - let empty_root = Hamt::::new_with_bit_width(rt.store(), HAMT_BIT_WIDTH) + let empty_root = Hamt::::new_with_bit_width(rt.store(), HAMT_BIT_WIDTH) .flush() .map_err(|e| { ActorError::new( From d9ab9991e9482f1fd939f87e143b7eb700d55292 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 09:54:24 -0400 Subject: [PATCH 14/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 5215c0f9ee08..839d47f4007d 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -72,7 +72,7 @@ impl Actor { Ok(()) } - pub fn delete_verifier(rt: &mut RT, params: AddVerifierParams) -> Result<(), ActorError> + pub fn remove_verifier(rt: &mut RT, params: AddVerifierParams) -> Result<(), ActorError> where BS: BlockStore, RT: Runtime, From 867916c8dcdc55d30a33e4ab8a19e1d69cb410b7 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 09:54:51 -0400 Subject: [PATCH 15/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 839d47f4007d..45010c18c0d7 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -118,7 +118,7 @@ impl Actor { )); } - rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + rt.transaction(|st: &mut State, rt| { // Validate caller is one of the verifiers. let message: Box<&dyn Message> = Box::new(rt.message()); let verify_addr = message.from(); From c400111a5ef22f05275a1027e633c02f04b6de6d Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 10:48:31 -0400 Subject: [PATCH 16/42] removed datacap new type --- vm/actor/src/builtin/verifreg/mod.rs | 39 ++++++++------------ vm/actor/src/builtin/verifreg/state.rs | 8 +++- vm/actor/src/builtin/verifreg/types.rs | 51 +------------------------- 3 files changed, 23 insertions(+), 75 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 3786486a303b..5995c66f25e8 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -103,11 +103,9 @@ impl Actor { RT: Runtime, { if params.allowance - <= Datacap::new( - MINIMUM_VERIFIED_SIZE - .to_biguint() - .expect("Could not convert size to big int"), - ) + <= + MINIMUM_VERIFIED_SIZE.into() + { return Err(ActorError::new( ExitCode::ErrIllegalState, @@ -201,11 +199,10 @@ impl Actor { { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; if params.deal_size - < Datacap::new( + < MINIMUM_VERIFIED_SIZE - .to_biguint() - .expect("Could not convert size to big int"), - ) + .into() + { return Err(ActorError::new( ExitCode::ErrIllegalState, @@ -232,16 +229,15 @@ impl Actor { ) })?; - if verifier_cap >= Datacap::new(Zero::zero()) { + if verifier_cap >= Zero::zero() { panic!("new verifier cap should be greater than or equal to 0"); } let new_verifier_cap = verifier_cap - params.deal_size.clone(); if new_verifier_cap - < Datacap::new( + < MINIMUM_VERIFIED_SIZE - .to_biguint() - .expect("Could not convert size to big int"), - ) + .into() + { // Delete entry if remaining DataCap is less than MinVerifiedDealSize. // Will be restored later if the deal did not get activated with a ProvenSector. @@ -282,11 +278,10 @@ impl Actor { { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; if params.deal_size - < Datacap::new( + < MINIMUM_VERIFIED_SIZE - .to_biguint() - .expect("Could not convert size to big int"), - ) + .into() + { return Err(ActorError::new( ExitCode::ErrIllegalState, @@ -307,11 +302,9 @@ impl Actor { ) })? .unwrap_or_else(|| { - Datacap::new( - MINIMUM_VERIFIED_SIZE - .to_biguint() - .expect("Could not convert size to big int"), - ) + + MINIMUM_VERIFIED_SIZE.into() + }); let new_verifier_cap = verifier_cap + params.deal_size.clone(); diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index f0ac41b1d587..3365f262d5a1 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -6,6 +6,8 @@ use address::Address; use cid::Cid; use serde::{Deserialize, Deserializer, Serialize, Serializer}; +use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; +use num_bigint::BigUint; use encoding::Cbor; use ipld_blockstore::BlockStore; use ipld_hamt::{BytesKey, Hamt}; @@ -93,7 +95,7 @@ impl State { ) -> StateResult<()> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; - map.set(verified_addr.to_bytes().into(), &verifier_cap)?; + map.set(verified_addr.to_bytes().into(), BigUintSer(&verifier_cap))?; map.flush()?; Ok(()) } @@ -104,7 +106,9 @@ impl State { verified_addr: &Address, ) -> StateResult> { let map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; - Ok(map.get(&verified_addr.to_bytes())?) + Ok(map.get::<_,BigUintDe>(&verified_addr.to_bytes())?.map(|s|s.0)) + + } fn delete( diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index aba70deb53e7..74110152284f 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -3,7 +3,6 @@ use crate::StoragePower; use address::Address; -use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use std::{ @@ -22,14 +21,7 @@ pub type AddVerifierClientParams = VerifierParams; pub const MINIMUM_VERIFIED_SIZE: u32 = 1 << 20; -#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)] -pub struct Datacap(StoragePower); - -impl Datacap { - pub fn new(storage_power: StoragePower) -> Self { - Self(storage_power) - } -} +pub type Datacap = StoragePower; #[derive(Clone, Debug, PartialEq)] pub struct BytesParams { @@ -39,44 +31,3 @@ pub struct BytesParams { pub type UseBytesParams = BytesParams; pub type RestoreBytesParams = BytesParams; - -impl Add for Datacap { - type Output = Self; - - fn add(self, other: Self) -> Self { - Self(self.0 + other.0) - } -} - -impl Sub for Datacap { - type Output = Self; - - fn sub(self, other: Self) -> Self { - Self(self.0 - other.0) - } -} - -impl fmt::Display for Datacap { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{}", self.0) - } -} - -impl Serialize for Datacap { - fn serialize(&self, serializer: S) -> Result - where - S: Serializer, - { - (BigUintSer(&self.0)).serialize(serializer) - } -} - -impl<'de> Deserialize<'de> for Datacap { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let BigUintDe(datacap) = Deserialize::deserialize(deserializer)?; - Ok(Self(datacap)) - } -} From d5835a71a359ef7d1aee480a71e1e4758362f7f0 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 10:52:05 -0400 Subject: [PATCH 17/42] run cargo fmt --- vm/actor/src/builtin/verifreg/mod.rs | 34 ++++---------------------- vm/actor/src/builtin/verifreg/state.rs | 9 +++---- vm/actor/src/builtin/verifreg/types.rs | 6 ----- 3 files changed, 9 insertions(+), 40 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 5995c66f25e8..52a32da5c1f8 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -11,7 +11,6 @@ use address::Address; use ipld_blockstore::BlockStore; use ipld_hamt::Hamt; use message::Message; -use num_bigint::ToBigUint; use num_derive::FromPrimitive; use num_traits::Zero; use runtime::Runtime; @@ -102,11 +101,7 @@ impl Actor { BS: BlockStore, RT: Runtime, { - if params.allowance - <= - MINIMUM_VERIFIED_SIZE.into() - - { + if params.allowance <= MINIMUM_VERIFIED_SIZE.into() { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -198,12 +193,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; - if params.deal_size - < - MINIMUM_VERIFIED_SIZE - .into() - - { + if params.deal_size < MINIMUM_VERIFIED_SIZE.into() { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -233,12 +223,7 @@ impl Actor { panic!("new verifier cap should be greater than or equal to 0"); } let new_verifier_cap = verifier_cap - params.deal_size.clone(); - if new_verifier_cap - < - MINIMUM_VERIFIED_SIZE - .into() - - { + if new_verifier_cap < MINIMUM_VERIFIED_SIZE.into() { // Delete entry if remaining DataCap is less than MinVerifiedDealSize. // Will be restored later if the deal did not get activated with a ProvenSector. st.delete_verified_client(rt.store(), ¶ms.address) @@ -277,12 +262,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; - if params.deal_size - < - MINIMUM_VERIFIED_SIZE - .into() - - { + if params.deal_size < MINIMUM_VERIFIED_SIZE.into() { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -301,11 +281,7 @@ impl Actor { format!("Failed to get Verifier {:?}", params.address.clone()), ) })? - .unwrap_or_else(|| { - - MINIMUM_VERIFIED_SIZE.into() - - }); + .unwrap_or_else(|| MINIMUM_VERIFIED_SIZE.into()); let new_verifier_cap = verifier_cap + params.deal_size.clone(); st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 3365f262d5a1..cb1c9e60ea6d 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -6,11 +6,10 @@ use address::Address; use cid::Cid; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; -use num_bigint::BigUint; use encoding::Cbor; use ipld_blockstore::BlockStore; use ipld_hamt::{BytesKey, Hamt}; +use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; use crate::builtin::verifreg::types::Datacap; @@ -106,9 +105,9 @@ impl State { verified_addr: &Address, ) -> StateResult> { let map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; - Ok(map.get::<_,BigUintDe>(&verified_addr.to_bytes())?.map(|s|s.0)) - - + Ok(map + .get::<_, BigUintDe>(&verified_addr.to_bytes())? + .map(|s| s.0)) } fn delete( diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 74110152284f..374b0411a812 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -4,12 +4,6 @@ use crate::StoragePower; use address::Address; -use serde::{Deserialize, Deserializer, Serialize, Serializer}; -use std::{ - fmt, - ops::{Add, Sub}, -}; - #[derive(Clone, Debug, PartialEq, Eq)] pub struct VerifierParams { pub address: Address, From 896729cdf2afdee0b923dcdbd3655421563bc36c Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 10:54:35 -0400 Subject: [PATCH 18/42] imports fixed --- vm/actor/src/builtin/verifreg/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 38c0646d939a..4a78c2fc6f21 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -15,6 +15,7 @@ use num_derive::FromPrimitive; use num_traits::Zero; use runtime::Runtime; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; +use ipld_hamt::BytesKey; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] From ed39849ed8206910778194965668a3b0d8ad493c Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 11:00:12 -0400 Subject: [PATCH 19/42] fmt --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 4a78c2fc6f21..62e5766f0aa3 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -9,13 +9,13 @@ use crate::builtin::singletons::STORAGE_MARKET_ACTOR_ADDR; use crate::{HAMT_BIT_WIDTH, SYSTEM_ACTOR_ADDR}; use address::Address; use ipld_blockstore::BlockStore; +use ipld_hamt::BytesKey; use ipld_hamt::Hamt; use message::Message; use num_derive::FromPrimitive; use num_traits::Zero; use runtime::Runtime; use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; -use ipld_hamt::BytesKey; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] From 02c98ee3b6ae68b5295a856e836fd0c83bdc5dc1 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 11:47:40 -0400 Subject: [PATCH 20/42] Update vm/actor/src/builtin/verifreg/state.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/state.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index cb1c9e60ea6d..7fe0c564fb1a 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -13,7 +13,6 @@ use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; use crate::builtin::verifreg::types::Datacap; -#[derive(Default)] pub struct State { pub root_key: Address, pub verifiers: Cid, From c1faf45fc06a6d5bea912291f860abe48c6028cf Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 11:47:51 -0400 Subject: [PATCH 21/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 62e5766f0aa3..2ed00001115f 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -204,7 +204,7 @@ impl Actor { )); } - rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + rt.transaction(|st: &mut State, rt| { let verifier_cap = st .get_verifier(rt.store(), ¶ms.address) .map_err(|_| { From d49699c4d5487935127c57420218d446c42dfc87 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 11:50:57 -0400 Subject: [PATCH 22/42] fixes --- vm/actor/src/builtin/verifreg/mod.rs | 6 +++--- vm/actor/src/builtin/verifreg/types.rs | 4 +++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 62e5766f0aa3..6369748819c8 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -104,7 +104,7 @@ impl Actor { { if params.allowance <= MINIMUM_VERIFIED_SIZE.into() { return Err(ActorError::new( - ExitCode::ErrIllegalState, + ExitCode::ErrIllegalArgument, format!( "Allowance {:} below MinVerifiedDealSize for add verified client {:}", params.allowance, params.address @@ -142,7 +142,7 @@ impl Actor { ), )); } - let new_verifier_cap = verifier_cap - params.allowance.clone(); + let new_verifier_cap = verifier_cap - params.allowance; st.put_verifier(rt.store(), &*verify_addr, &new_verifier_cap) .map_err(|_| { ActorError::new( @@ -171,7 +171,7 @@ impl Actor { format!("Illegal Argument{:}", params.address), ) })?; - st.put_verifier(rt.store(), ¶ms.address, ¶ms.allowance) + st.put_verifier_client(rt.store(), ¶ms.address, ¶ms.allowance) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 374b0411a812..48b2be9e7a1f 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -4,6 +4,8 @@ use crate::StoragePower; use address::Address; +pub const MINIMUM_VERIFIED_SIZE: u32 = 1 << 20; + #[derive(Clone, Debug, PartialEq, Eq)] pub struct VerifierParams { pub address: Address, @@ -13,7 +15,7 @@ pub struct VerifierParams { pub type AddVerifierParams = VerifierParams; pub type AddVerifierClientParams = VerifierParams; -pub const MINIMUM_VERIFIED_SIZE: u32 = 1 << 20; + pub type Datacap = StoragePower; From 589fa18fdd914030afc412d503b1b6088e0a39ac Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 12:14:26 -0400 Subject: [PATCH 23/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 2ed00001115f..fab7d3508f2e 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -257,7 +257,7 @@ impl Actor { // Called by HandleInitTimeoutDeals from StorageMarketActor when a VerifiedDeal fails to init. // Restore allowable cap for the client, creating new entry if the client has been deleted. - pub fn restore_bytes(rt: &mut RT, params: UseBytesParams) -> Result<(), ActorError> + pub fn restore_bytes(rt: &mut RT, params: RestoreBytesParams) -> Result<(), ActorError> where BS: BlockStore, RT: Runtime, From dea79267533ca31891b29425b5c0f6feea29bfa9 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 12:16:10 -0400 Subject: [PATCH 24/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index fab7d3508f2e..37a6fdfc60dc 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -265,7 +265,7 @@ impl Actor { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; if params.deal_size < MINIMUM_VERIFIED_SIZE.into() { return Err(ActorError::new( - ExitCode::ErrIllegalState, + ExitCode::ErrIllegalArgument, format!( "Verified Dealsize {:} is below minimum in usedbytes", params.deal_size From e6630a90169c735776b42f725b28181937578b85 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 12:29:43 -0400 Subject: [PATCH 25/42] changes --- vm/actor/src/builtin/verifreg/mod.rs | 65 ++++++++++++++++++++++---- vm/actor/src/builtin/verifreg/types.rs | 42 ++++++++++++++++- 2 files changed, 96 insertions(+), 11 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index ff63b8270f7b..d7556cf2b7db 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -13,9 +13,9 @@ use ipld_hamt::BytesKey; use ipld_hamt::Hamt; use message::Message; use num_derive::FromPrimitive; -use num_traits::Zero; -use runtime::Runtime; -use vm::{ActorError, ExitCode, METHOD_CONSTRUCTOR}; +use num_traits::{FromPrimitive, Zero}; +use runtime::{ActorCode, Runtime}; +use vm::{ActorError, ExitCode, MethodNum, Serialized, METHOD_CONSTRUCTOR}; /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] @@ -142,7 +142,7 @@ impl Actor { ), )); } - let new_verifier_cap = verifier_cap - params.allowance; + let new_verifier_cap = verifier_cap - ¶ms.allowance; st.put_verifier(rt.store(), &*verify_addr, &new_verifier_cap) .map_err(|_| { ActorError::new( @@ -171,7 +171,7 @@ impl Actor { format!("Illegal Argument{:}", params.address), ) })?; - st.put_verifier_client(rt.store(), ¶ms.address, ¶ms.allowance) + st.put_verified_client(rt.store(), ¶ms.address, ¶ms.allowance) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, @@ -220,10 +220,16 @@ impl Actor { ) })?; - if verifier_cap >= Zero::zero() { - panic!("new verifier cap should be greater than or equal to 0"); - } - let new_verifier_cap = verifier_cap - params.deal_size.clone(); + if ¶ms.deal_size <= &verifier_cap { + return Err(ActorError::new( + ExitCode::ErrIllegalState, + format!( + "Deal size of {:} is greater than verifier_cap {:}", + params.deal_size, verifier_cap + ), + )); + }; + let new_verifier_cap = &verifier_cap - ¶ms.deal_size; if new_verifier_cap < MINIMUM_VERIFIED_SIZE.into() { // Delete entry if remaining DataCap is less than MinVerifiedDealSize. // Will be restored later if the deal did not get activated with a ProvenSector. @@ -300,3 +306,44 @@ impl Actor { Ok(()) } } + +impl ActorCode for Actor { + fn invoke_method( + &self, + rt: &mut RT, + method: MethodNum, + params: &Serialized, + ) -> Result + where + BS: BlockStore, + RT: Runtime, + { + match FromPrimitive::from_u64(method) { + Some(Method::Constructor) => { + Self::constructor(rt, params.deserialize()?)?; + Ok(Serialized::default()) + } + Some(Method::AddVerifier) => { + Self::add_verifier(rt, params.deserialize()?)?; + Ok(Serialized::default()) + } + Some(Method::RemoveVerifier) => { + Self::remove_verifier(rt, params.deserialize()?)?; + Ok(Serialized::default()) + } + Some(Method::AddVerifiedClient) => { + Self::add_verified_client(rt, params.deserialize()?)?; + Ok(Serialized::default()) + } + Some(Method::UseBytes) => { + Self::use_bytes(rt, params.deserialize()?)?; + Ok(Serialized::default()) + } + Some(Method::RestoreBytes) => { + Self::restore_bytes(rt, params.deserialize()?)?; + Ok(Serialized::default()) + } + _ => Err(rt.abort(ExitCode::SysErrInvalidMethod, "Invalid method".to_owned())), + } + } +} diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 48b2be9e7a1f..67ee692d55bf 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -3,6 +3,8 @@ use crate::StoragePower; use address::Address; +use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; +use serde::{Deserialize, Deserializer, Serialize, Serializer}; pub const MINIMUM_VERIFIED_SIZE: u32 = 1 << 20; @@ -15,8 +17,6 @@ pub struct VerifierParams { pub type AddVerifierParams = VerifierParams; pub type AddVerifierClientParams = VerifierParams; - - pub type Datacap = StoragePower; #[derive(Clone, Debug, PartialEq)] @@ -27,3 +27,41 @@ pub struct BytesParams { pub type UseBytesParams = BytesParams; pub type RestoreBytesParams = BytesParams; + +impl Serialize for VerifierParams { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + (&self.address, BigUintSer(&self.allowance)).serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for VerifierParams { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let (address, BigUintDe(allowance)) = Deserialize::deserialize(deserializer)?; + Ok(Self { address, allowance }) + } +} + +impl Serialize for BytesParams { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + (&self.address, BigUintSer(&self.deal_size)).serialize(serializer) + } +} + +impl<'de> Deserialize<'de> for BytesParams { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let (address, BigUintDe(deal_size)) = Deserialize::deserialize(deserializer)?; + Ok(Self { address, deal_size }) + } +} From dc3a40dadfe0b3375212fb801bcf2b1a902f848a Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 12:32:15 -0400 Subject: [PATCH 26/42] changed error return type --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index d95165f1077d..c5f0782089d0 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -174,7 +174,7 @@ impl Actor { st.put_verified_client(rt.store(), ¶ms.address, ¶ms.allowance) .map_err(|_| { ActorError::new( - ExitCode::ErrIllegalState, + ExitCode::ErrNotFound, format!( "Failed to add verified client {:?} with cap {:?}", params.address, params.allowance From edb3e8e0235873a221c4aa0d0b88cf0846803098 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 12:34:11 -0400 Subject: [PATCH 27/42] changed back --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index c5f0782089d0..d95165f1077d 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -174,7 +174,7 @@ impl Actor { st.put_verified_client(rt.store(), ¶ms.address, ¶ms.allowance) .map_err(|_| { ActorError::new( - ExitCode::ErrNotFound, + ExitCode::ErrIllegalState, format!( "Failed to add verified client {:?} with cap {:?}", params.address, params.allowance From e1a9d449a7aada42a0cc4537dbb5878701c795af Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 12:36:28 -0400 Subject: [PATCH 28/42] illegal argument type changed to --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index d95165f1077d..da1f358f7870 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -167,7 +167,7 @@ impl Actor { })? .ok_or_else(|| { ActorError::new( - ExitCode::ErrNotFound, + ExitCode::ErrIllegalArgument, format!("Illegal Argument{:}", params.address), ) })?; From 7ac9ae8a14976f00b5f35cb70db184f8e1f1ec8a Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 12:37:17 -0400 Subject: [PATCH 29/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index da1f358f7870..7a68881cfcce 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -215,7 +215,7 @@ impl Actor { })? .ok_or_else(|| { ActorError::new( - ExitCode::ErrNotFound, + ExitCode::ErrIllegalArgument, format!("Invalid Verifier {:}", params.address), ) })?; From 1099d2b237d2ec6f854089c90c8caf9920460bd8 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 12:37:37 -0400 Subject: [PATCH 30/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 7a68881cfcce..256179658fdb 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -279,7 +279,7 @@ impl Actor { )); } - rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { + rt.transaction(|st: &mut State, rt| { let verifier_cap = st .get_verifier(rt.store(), ¶ms.address) .map_err(|_| { From 9edc8032e3ec500438c35a4d11327f059285090e Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 12:38:54 -0400 Subject: [PATCH 31/42] changed get verified client --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index da1f358f7870..215fb02fa01f 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -281,7 +281,7 @@ impl Actor { rt.transaction::<_, Result<_, ActorError>, _>(|st: &mut State, rt| { let verifier_cap = st - .get_verifier(rt.store(), ¶ms.address) + .get_verifier_client(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, From ba0a252f01b8ce0aa1fa6e11093d8b54f759cea3 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 12:40:26 -0400 Subject: [PATCH 32/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 9260c828cac9..b5603423c88a 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -290,7 +290,7 @@ impl Actor { })? .unwrap_or_else(|| MINIMUM_VERIFIED_SIZE.into()); - let new_verifier_cap = verifier_cap + params.deal_size.clone(); + let new_verifier_cap = verifier_cap + ¶ms.deal_size; st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) .map_err(|_| { ActorError::new( From 29815e7fac4ddd65f67fb79232f05262dcbf7853 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 13:12:50 -0400 Subject: [PATCH 33/42] updated CIDs and other fixes --- vm/actor/src/builtin/verifreg/mod.rs | 15 +++++++------- vm/actor/src/builtin/verifreg/state.rs | 27 +++++++++++++++----------- vm/actor/src/builtin/verifreg/types.rs | 6 ++++-- 3 files changed, 27 insertions(+), 21 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 9260c828cac9..e18ed8e36ff8 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -102,7 +102,7 @@ impl Actor { BS: BlockStore, RT: Runtime, { - if params.allowance <= MINIMUM_VERIFIED_SIZE.into() { + if params.allowance <= *MINIMUM_VERIFIED_SIZE { return Err(ActorError::new( ExitCode::ErrIllegalArgument, format!( @@ -194,7 +194,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; - if params.deal_size < MINIMUM_VERIFIED_SIZE.into() { + if params.deal_size < *MINIMUM_VERIFIED_SIZE { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -230,7 +230,7 @@ impl Actor { )); }; let new_verifier_cap = &verifier_cap - ¶ms.deal_size; - if new_verifier_cap < MINIMUM_VERIFIED_SIZE.into() { + if new_verifier_cap < *MINIMUM_VERIFIED_SIZE { // Delete entry if remaining DataCap is less than MinVerifiedDealSize. // Will be restored later if the deal did not get activated with a ProvenSector. st.delete_verified_client(rt.store(), ¶ms.address) @@ -239,8 +239,7 @@ impl Actor { ExitCode::ErrIllegalState, format!( "Failed to delete verified client{:} with bytes {:?}", - params.clone().address, - params.deal_size + params.address, params.deal_size ), ) }) @@ -269,7 +268,7 @@ impl Actor { RT: Runtime, { rt.validate_immediate_caller_is(std::iter::once(&*STORAGE_MARKET_ACTOR_ADDR))?; - if params.deal_size < MINIMUM_VERIFIED_SIZE.into() { + if params.deal_size < *MINIMUM_VERIFIED_SIZE { return Err(ActorError::new( ExitCode::ErrIllegalArgument, format!( @@ -281,14 +280,14 @@ impl Actor { rt.transaction(|st: &mut State, rt| { let verifier_cap = st - .get_verifier_client(rt.store(), ¶ms.address) + .get_verified_client(rt.store(), ¶ms.address) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, format!("Failed to get Verifier {:?}", params.address.clone()), ) })? - .unwrap_or_else(|| MINIMUM_VERIFIED_SIZE.into()); + .unwrap_or_else(|| Zero::zero()); let new_verifier_cap = verifier_cap + params.deal_size.clone(); st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 7fe0c564fb1a..64e05f70061a 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -35,7 +35,8 @@ impl State { verified_addr: &Address, verifier_cap: &Datacap, ) -> StateResult<()> { - Self::put(&mut self.verifiers, store, verified_addr, verifier_cap) + self.verifiers = Self::put(&mut self.verifiers, store, verified_addr, verifier_cap)?; + Ok(()) } pub fn get_verifier( @@ -51,7 +52,8 @@ impl State { store: &BS, address: &Address, ) -> StateResult<()> { - Self::delete(&mut self.verifiers, store, address) + self.verifiers = Self::delete(&mut self.verifiers, store, address)?; + Ok(()) } pub fn put_verified_client( @@ -60,12 +62,14 @@ impl State { verified_addr: &Address, verifier_cap: &Datacap, ) -> StateResult<()> { - Self::put( + self.verified_clients = Self::put( &mut self.verified_clients, store, verified_addr, verifier_cap, - ) + )?; + + Ok(()) } pub fn get_verified_client( @@ -81,7 +85,8 @@ impl State { store: &BS, address: &Address, ) -> StateResult<()> { - Self::delete(&mut self.verified_clients, store, address) + self.verified_clients = Self::delete(&mut self.verified_clients, store, address)?; + Ok(()) } //private helper functions @@ -90,12 +95,12 @@ impl State { store: &BS, verified_addr: &Address, verifier_cap: &Datacap, - ) -> StateResult<()> { + ) -> StateResult { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.set(verified_addr.to_bytes().into(), BigUintSer(&verifier_cap))?; - map.flush()?; - Ok(()) + let root = map.flush()?; + Ok(root) } fn get( @@ -113,12 +118,12 @@ impl State { storage: &mut Cid, store: &BS, verified_addr: &Address, - ) -> StateResult<()> { + ) -> StateResult { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.delete(&verified_addr.to_bytes())?; - map.flush()?; - Ok(()) + let root = map.flush()?; + Ok(root) } } diff --git a/vm/actor/src/builtin/verifreg/types.rs b/vm/actor/src/builtin/verifreg/types.rs index 67ee692d55bf..cb4b69a124ee 100644 --- a/vm/actor/src/builtin/verifreg/types.rs +++ b/vm/actor/src/builtin/verifreg/types.rs @@ -4,10 +4,12 @@ use crate::StoragePower; use address::Address; use num_bigint::biguint_ser::{BigUintDe, BigUintSer}; +use num_traits::FromPrimitive; use serde::{Deserialize, Deserializer, Serialize, Serializer}; -pub const MINIMUM_VERIFIED_SIZE: u32 = 1 << 20; - +lazy_static! { + pub static ref MINIMUM_VERIFIED_SIZE: StoragePower = StoragePower::from_i32(1 << 20).unwrap();// placeholder +} #[derive(Clone, Debug, PartialEq, Eq)] pub struct VerifierParams { pub address: Address, From 5030a4555308ee9d8f4911b3ab5bfec909dbace1 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 13:14:24 -0400 Subject: [PATCH 34/42] clippy fixes --- vm/actor/src/builtin/verifreg/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index e18ed8e36ff8..f0238ed8b227 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -220,7 +220,7 @@ impl Actor { ) })?; - if ¶ms.deal_size <= &verifier_cap { + if params.deal_size <= verifier_cap { return Err(ActorError::new( ExitCode::ErrIllegalState, format!( @@ -287,7 +287,7 @@ impl Actor { format!("Failed to get Verifier {:?}", params.address.clone()), ) })? - .unwrap_or_else(|| Zero::zero()); + .unwrap_or_else(Zero::zero); let new_verifier_cap = verifier_cap + params.deal_size.clone(); st.put_verified_client(rt.store(), ¶ms.address, &new_verifier_cap) From ba777791af27c56eee86e72caa63419c0b57dda5 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 14:33:08 -0400 Subject: [PATCH 35/42] removed mutable reference --- vm/actor/src/builtin/verifreg/state.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 64e05f70061a..8cda8aedde3f 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -91,7 +91,7 @@ impl State { //private helper functions fn put( - storage: &mut Cid, + storage: &Cid, store: &BS, verified_addr: &Address, verifier_cap: &Datacap, @@ -104,7 +104,7 @@ impl State { } fn get( - storage: &mut Cid, + storage: &Cid, store: &BS, verified_addr: &Address, ) -> StateResult> { @@ -115,7 +115,7 @@ impl State { } fn delete( - storage: &mut Cid, + storage: &Cid, store: &BS, verified_addr: &Address, ) -> StateResult { From a5f2b0e76a7411b5676b0ffbfa9a196b4ca65b9b Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 14:39:14 -0400 Subject: [PATCH 36/42] line break --- vm/actor/src/builtin/verifreg/mod.rs | 1 + vm/actor/src/builtin/verifreg/state.rs | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index dd9960e9a639..08938114e8bc 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -16,6 +16,7 @@ use num_derive::FromPrimitive; use num_traits::{FromPrimitive, Zero}; use runtime::{ActorCode, Runtime}; use vm::{ActorError, ExitCode, MethodNum, Serialized, METHOD_CONSTRUCTOR}; + /// Account actor methods available #[derive(FromPrimitive)] #[repr(u64)] diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 8cda8aedde3f..3247dd91eef3 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -95,7 +95,7 @@ impl State { store: &BS, verified_addr: &Address, verifier_cap: &Datacap, - ) -> StateResult { + ) -> StateResult<()> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.set(verified_addr.to_bytes().into(), BigUintSer(&verifier_cap))?; @@ -118,7 +118,7 @@ impl State { storage: &Cid, store: &BS, verified_addr: &Address, - ) -> StateResult { + ) -> StateResult<()> { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.delete(&verified_addr.to_bytes())?; From f34c1633fffe2b9e0b5f86e593f383cddf7347b6 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 14:44:20 -0400 Subject: [PATCH 37/42] fixed type error --- vm/actor/src/builtin/verifreg/state.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index 3247dd91eef3..d40b00f35b61 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -73,11 +73,11 @@ impl State { } pub fn get_verified_client( - &mut self, + &self, store: &BS, address: &Address, ) -> StateResult> { - Self::get(&mut self.verified_clients, store, address) + Self::get(&self.verified_clients, store, address) } pub fn delete_verified_client( @@ -85,7 +85,7 @@ impl State { store: &BS, address: &Address, ) -> StateResult<()> { - self.verified_clients = Self::delete(&mut self.verified_clients, store, address)?; + self.verified_clients = Self::delete(&self.verified_clients, store, address)?; Ok(()) } @@ -95,7 +95,7 @@ impl State { store: &BS, verified_addr: &Address, verifier_cap: &Datacap, - ) -> StateResult<()> { + ) -> StateResult { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.set(verified_addr.to_bytes().into(), BigUintSer(&verifier_cap))?; @@ -118,7 +118,7 @@ impl State { storage: &Cid, store: &BS, verified_addr: &Address, - ) -> StateResult<()> { + ) -> StateResult { let mut map: Hamt = Hamt::load_with_bit_width(&storage, store, HAMT_BIT_WIDTH)?; map.delete(&verified_addr.to_bytes())?; From a94c8e78925a26db94071e400ec97e879e36efb9 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Wed, 13 May 2020 15:01:16 -0400 Subject: [PATCH 38/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 08938114e8bc..1e3c875efcb0 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -119,7 +119,7 @@ impl Actor { let verify_addr = message.from(); let verifier_cap = st - .get_verifier(rt.store(), &*verify_addr) + .get_verifier(rt.store(), &verify_addr) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, From 79940b75c23feb2e31e11af61d587a41dc656dc1 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 15:15:01 -0400 Subject: [PATCH 39/42] add none clause --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 08938114e8bc..7e08956cbb7c 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -343,7 +343,7 @@ impl ActorCode for Actor { Self::restore_bytes(rt, params.deserialize()?)?; Ok(Serialized::default()) } - _ => Err(rt.abort(ExitCode::SysErrInvalidMethod, "Invalid method".to_owned())), + None => Err(rt.abort(ExitCode::SysErrInvalidMethod, "Invalid method".to_owned())), } } } From 7e832fd6b4e3b58b751e70e4537cf46247dc14f7 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Wed, 13 May 2020 15:33:15 -0400 Subject: [PATCH 40/42] removed mutable refs --- vm/actor/src/builtin/verifreg/state.rs | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) diff --git a/vm/actor/src/builtin/verifreg/state.rs b/vm/actor/src/builtin/verifreg/state.rs index d40b00f35b61..5ff59085acf5 100644 --- a/vm/actor/src/builtin/verifreg/state.rs +++ b/vm/actor/src/builtin/verifreg/state.rs @@ -35,7 +35,7 @@ impl State { verified_addr: &Address, verifier_cap: &Datacap, ) -> StateResult<()> { - self.verifiers = Self::put(&mut self.verifiers, store, verified_addr, verifier_cap)?; + self.verifiers = Self::put(&self.verifiers, store, verified_addr, verifier_cap)?; Ok(()) } @@ -44,7 +44,7 @@ impl State { store: &BS, address_get: &Address, ) -> StateResult> { - Self::get(&mut self.verifiers, store, address_get) + Self::get(&self.verifiers, store, address_get) } pub fn delete_verifier( @@ -52,7 +52,7 @@ impl State { store: &BS, address: &Address, ) -> StateResult<()> { - self.verifiers = Self::delete(&mut self.verifiers, store, address)?; + self.verifiers = Self::delete(&self.verifiers, store, address)?; Ok(()) } @@ -62,12 +62,8 @@ impl State { verified_addr: &Address, verifier_cap: &Datacap, ) -> StateResult<()> { - self.verified_clients = Self::put( - &mut self.verified_clients, - store, - verified_addr, - verifier_cap, - )?; + self.verified_clients = + Self::put(&self.verified_clients, store, verified_addr, verifier_cap)?; Ok(()) } From 4eb31bafd46bdb26bc0f7d20ff5925f8d96f26d7 Mon Sep 17 00:00:00 2001 From: Purple Hair Rust Bard Date: Thu, 14 May 2020 07:11:10 -0400 Subject: [PATCH 41/42] Update vm/actor/src/builtin/verifreg/mod.rs Co-authored-by: Austin Abell --- vm/actor/src/builtin/verifreg/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 241745d5e3b0..9c5b7401b657 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -144,7 +144,7 @@ impl Actor { )); } let new_verifier_cap = verifier_cap - ¶ms.allowance; - st.put_verifier(rt.store(), &*verify_addr, &new_verifier_cap) + st.put_verifier(rt.store(), &verify_addr, &new_verifier_cap) .map_err(|_| { ActorError::new( ExitCode::ErrIllegalState, From b54dd7e45937702e291b43df7f2ffbb70aeb3db8 Mon Sep 17 00:00:00 2001 From: Ashanti Mutinta Date: Fri, 15 May 2020 10:13:02 -0400 Subject: [PATCH 42/42] implemented fix --- vm/actor/src/builtin/verifreg/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/vm/actor/src/builtin/verifreg/mod.rs b/vm/actor/src/builtin/verifreg/mod.rs index 241745d5e3b0..8dd251b99f12 100644 --- a/vm/actor/src/builtin/verifreg/mod.rs +++ b/vm/actor/src/builtin/verifreg/mod.rs @@ -113,6 +113,7 @@ impl Actor { )); } + rt.validate_immediate_caller_accept_any(); rt.transaction(|st: &mut State, rt| { // Validate caller is one of the verifiers. let message: Box<&dyn Message> = Box::new(rt.message());