paych actor tests

vm/actor/Cargo.toml

@@ -26,6 +26,7 @@ integer-encoding = "1.1.5"
 crypto = { package = "forest_crypto", path = "../../crypto" }
 bitfield = { path = "../../utils/bitfield" }
 fil_types = { path = "../../types" }
+derive_builder = "0.9"
 byteorder = "1.3.4"
 ahash = "0.4"
 

vm/actor/src/builtin/paych/mod.rs

@@ -93,12 +93,11 @@ impl Actor {
             st.from
         };
 
-        let mut sv = params.sv;
-
+        let sv = params.sv;
         // Pull signature from signed voucher
         let sig = sv
             .signature
-            .take()
+            .as_ref()
             .ok_or_else(|| rt.abort(ExitCode::ErrIllegalArgument, "voucher has no signature"))?;
 
         // Generate unsigned bytes
@@ -211,7 +210,7 @@ impl Actor {
             // 2. To prevent double counting, remove already redeemed amounts (from
             // voucher or other lanes) from the voucher amount
             st.lane_states[idx].nonce = sv.nonce;
-            let balance_delta = &sv.amount - redeemed + &st.lane_states[idx].redeemed;
+            let balance_delta = &sv.amount - (redeemed + &st.lane_states[idx].redeemed);
 
             // 3. set new redeemed value for merged-into lane
             st.lane_states[idx].redeemed = sv.amount;
@@ -349,6 +348,10 @@ impl ActorCode for Actor {
                 Self::collect(rt)?;
                 Ok(Serialized::default())
             }
+            Some(Method::UpdateChannelState) => {
+                Self::update_channel_state(rt, params.deserialize()?)?;
+                Ok(Serialized::default())
+            }
             _ => Err(rt.abort(ExitCode::SysErrInvalidMethod, "Invalid method")),
         }
     }

vm/actor/src/builtin/paych/state.rs

@@ -43,7 +43,7 @@ impl State {
 
 /// The Lane state tracks the latest (highest) voucher nonce used to merge the lane
 /// as well as the amount it has already redeemed.
-#[derive(Default, Debug, Serialize_tuple, Deserialize_tuple)]
+#[derive(Default, PartialEq, Debug, Serialize_tuple, Deserialize_tuple)]
 pub struct LaneState {
     /// Identifier unique to this channel
     pub id: u64,
@@ -54,7 +54,7 @@ pub struct LaneState {
 }
 
 /// Specifies which `lane`s to be merged with what `nonce` on `channel_update`
-#[derive(Default, Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
+#[derive(Default, Clone, Copy, Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
 pub struct Merge {
     pub lane: u64,
     pub nonce: u64,

vm/actor/src/builtin/paych/types.rs

@@ -24,7 +24,7 @@ pub struct ConstructorParams {
 
 /// A voucher is sent by `from` to `to` off-chain in order to enable
 /// `to` to redeem payments on-chain in the future
-#[derive(Default, Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
+#[derive(Default, Debug, Clone, PartialEq, Serialize_tuple, Deserialize_tuple)]
 pub struct SignedVoucher {
     /// Min epoch before which the voucher cannot be redeemed
     pub time_lock_min: ChainEpoch,
@@ -55,7 +55,7 @@ pub struct SignedVoucher {
 }
 
 /// Modular Verification method
-#[derive(Debug, PartialEq, Serialize_tuple, Deserialize_tuple)]
+#[derive(Debug, Clone, PartialEq, Serialize_tuple, Deserialize_tuple)]
 pub struct ModVerifyParams {
     pub actor: Address,
     pub method: MethodNum,
@@ -80,6 +80,16 @@ pub struct UpdateChannelStateParams {
     pub proof: Vec<u8>,
 }
 
+impl From<SignedVoucher> for UpdateChannelStateParams {
+    fn from(sv: SignedVoucher) -> Self {
+        UpdateChannelStateParams {
+            proof: vec![],
+            secret: vec![],
+            sv,
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

vm/actor/tests/common/mod.rs

@@ -9,13 +9,15 @@ use actor::{
 use address::Address;
 use cid::{multihash::Blake2b256, Cid};
 use clock::ChainEpoch;
-use crypto::DomainSeparationTag;
-use encoding::{de::DeserializeOwned, Cbor};
+use crypto::{DomainSeparationTag, Signature};
+use encoding::{blake2b_256, de::DeserializeOwned, Cbor};
+use fil_types::{PieceInfo, RegisteredSealProof, SealVerifyInfo, WindowPoStVerifyInfo};
 use ipld_blockstore::BlockStore;
 use message::{Message, UnsignedMessage};
-use runtime::{ActorCode, Runtime, Syscalls};
+use runtime::{ActorCode, ConsensusFault, Runtime, Syscalls};
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
+use std::error::Error as StdError;
 use vm::{ActorError, ExitCode, MethodNum, Randomness, Serialized, TokenAmount};
 
 pub struct MockRuntime<'a, BS: BlockStore> {
@@ -33,6 +35,7 @@ pub struct MockRuntime<'a, BS: BlockStore> {
     // Actor State
     pub state: Option<Cid>,
     pub balance: TokenAmount,
+    pub received: TokenAmount,
 
     // VM Impl
     pub in_call: bool,
@@ -45,6 +48,7 @@ pub struct MockRuntime<'a, BS: BlockStore> {
     pub expect_validate_caller_type: RefCell<Option<Vec<Cid>>>,
     pub expect_sends: VecDeque<ExpectedMessage>,
     pub expect_create_actor: Option<ExpectCreateActor>,
+    pub expect_verify_sig: RefCell<Option<ExpectedVerifySig>>,
 }
 
 #[derive(Clone, Debug)]
@@ -64,9 +68,20 @@ pub struct ExpectedMessage {
     pub exit_code: ExitCode,
 }
 
-impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
+#[derive(Clone, Debug)]
+pub struct ExpectedVerifySig {
+    pub sig: Signature,
+    pub signer: Address,
+    pub plaintext: Vec<u8>,
+    pub result: ExitCode,
+}
+
+impl<'a, BS> MockRuntime<'a, BS>
+where
+    BS: BlockStore,
+{
     pub fn new(bs: &'a BS, message: UnsignedMessage) -> Self {
-        Self {
+        MockRuntime {
             epoch: 0,
             caller_type: Cid::default(),
 
@@ -79,6 +94,7 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
             message: message,
             state: None,
             balance: 0u8.into(),
+            received: 0u8.into(),
 
             // VM Impl
             in_call: false,
@@ -91,6 +107,7 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
             expect_validate_caller_type: RefCell::new(None),
             expect_sends: VecDeque::new(),
             expect_create_actor: None,
+            expect_verify_sig: RefCell::new(None),
         }
     }
     fn require_in_call(&self) {
@@ -126,6 +143,11 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
         *self.expect_validate_caller_addr.borrow_mut() = Some(addr.to_vec());
     }
 
+    #[allow(dead_code)]
+    pub fn expect_verify_signature(&self, exp: ExpectedVerifySig) {
+        *self.expect_verify_sig.borrow_mut() = Some(exp);
+    }
+
     #[allow(dead_code)]
     pub fn expect_validate_caller_type(&self, types: &[Cid]) {
         assert!(types.len() > 0, "addrs must be non-empty");
@@ -225,6 +247,7 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
         *self.expect_validate_caller_addr.borrow_mut() = None;
         *self.expect_validate_caller_type.borrow_mut() = None;
         self.expect_create_actor = None;
+        *self.expect_verify_sig.borrow_mut() = None;
     }
 
     #[allow(dead_code)]
@@ -276,7 +299,10 @@ impl<'a, BS: BlockStore> MockRuntime<'a, BS> {
     }
 }
 
-impl<BS: BlockStore> Runtime<BS> for MockRuntime<'_, BS> {
+impl<BS> Runtime<BS> for MockRuntime<'_, BS>
+where
+    BS: BlockStore,
+{
     fn message(&self) -> &UnsignedMessage {
         self.require_in_call();
         &self.message
@@ -381,14 +407,26 @@ impl<BS: BlockStore> Runtime<BS> for MockRuntime<'_, BS> {
         if address.protocol() == address::Protocol::ID {
             return Ok(address.clone());
         }
-        let resolved = self.id_addresses.get(&address).unwrap();
-        return Ok(resolved.clone());
+
+        self.id_addresses
+            .get(&address)
+            .cloned()
+            .ok_or(ActorError::new(
+                ExitCode::ErrIllegalArgument,
+                "Address not found".to_string(),
+            ))
     }
 
     fn get_actor_code_cid(&self, addr: &Address) -> Result<Cid, ActorError> {
         self.require_in_call();
-        let ret = self.actor_code_cids.get(&addr).unwrap();
-        Ok(ret.clone())
+
+        self.actor_code_cids
+            .get(&addr)
+            .cloned()
+            .ok_or(ActorError::new(
+                ExitCode::ErrIllegalArgument,
+                "Actor address is not found".to_string(),
+            ))
     }
 
     fn get_randomness(
@@ -528,11 +566,73 @@ impl<BS: BlockStore> Runtime<BS> for MockRuntime<'_, BS> {
         todo!("implement me???")
     }
 
+    fn total_fil_circ_supply(&self) -> Result<TokenAmount, ActorError> {
+        unimplemented!();
+    }
+
     fn syscalls(&self) -> &dyn Syscalls {
-        unimplemented!()
+        self
+    }
+}
+
+impl<BS> Syscalls for MockRuntime<'_, BS>
+where
+    BS: BlockStore,
+{
+    fn verify_signature(
+        &self,
+        signature: &Signature,
+        signer: &Address,
+        plaintext: &[u8],
+    ) -> Result<(), Box<dyn StdError>> {
+        let op_exp = self.expect_verify_sig.replace(Option::None);
+
+        if let Some(exp) = op_exp {
+            if exp.sig == *signature && exp.signer == *signer && &exp.plaintext[..] == plaintext {
+                if exp.result == ExitCode::Ok {
+                    return Ok(());
+                } else {
+                    return Err(Box::new(ActorError::new(
+                        exp.result,
+                        "Expected failure".to_string(),
+                    )));
+                }
+            } else {
+                return Err(Box::new(ActorError::new(
+                    ExitCode::ErrIllegalState,
+                    "Signatures did not match".to_string(),
+                )));
+            }
+        } else {
+            return Err(Box::new(ActorError::new(
+                ExitCode::ErrPlaceholder,
+                "Expected verify sig not there ".to_string(),
+            )));
+        }
     }
 
-    fn total_fil_circ_supply(&self) -> Result<TokenAmount, ActorError> {
-        unimplemented!()
+    fn hash_blake2b(&self, data: &[u8]) -> Result<[u8; 32], Box<dyn StdError>> {
+        Ok(blake2b_256(&data))
+    }
+    fn compute_unsealed_sector_cid(
+        &self,
+        _reg: RegisteredSealProof,
+        _pieces: &[PieceInfo],
+    ) -> Result<Cid, Box<dyn StdError>> {
+        unimplemented!();
+    }
+    fn verify_seal(&self, _vi: &SealVerifyInfo) -> Result<(), Box<dyn StdError>> {
+        unimplemented!();
+    }
+    fn verify_post(&self, _vi: &WindowPoStVerifyInfo) -> Result<(), Box<dyn StdError>> {
+        unimplemented!();
+    }
+    fn verify_consensus_fault(
+        &self,
+        _h1: &[u8],
+        _h2: &[u8],
+        _extra: &[u8],
+    ) -> Result<Option<ConsensusFault>, Box<dyn StdError>> {
+        unimplemented!();
     }
 }

vm/actor/tests/cron_actor_test.rs

@@ -13,7 +13,7 @@ use ipld_blockstore::BlockStore;
 use message::UnsignedMessage;
 use vm::{ExitCode, Serialized};
 
-fn construct_runtime<BS: BlockStore>(bs: &BS) -> MockRuntime<'_, BS> {
+fn construct_runtime<'a, BS: BlockStore>(bs: &'a BS) -> MockRuntime<'a, BS> {
     let receiver = Address::new_id(100);
 
     let message = UnsignedMessage::builder()
@@ -28,6 +28,7 @@ fn construct_runtime<BS: BlockStore>(bs: &BS) -> MockRuntime<'_, BS> {
 #[test]
 fn construct_with_empty_entries() {
     let bs = MemoryDB::default();
+
     let mut rt = construct_runtime(&bs);
 
     construct_and_verify(&mut rt, &ConstructorParams { entries: vec![] });
@@ -39,6 +40,7 @@ fn construct_with_empty_entries() {
 #[test]
 fn construct_with_entries() {
     let bs = MemoryDB::default();
+
     let mut rt = construct_runtime(&bs);
 
     let entry1 = Entry {

vm/actor/tests/init_actor_test.rs

@@ -18,7 +18,7 @@ use message::{Message, UnsignedMessage};
 use serde::Serialize;
 use vm::{ActorError, ExitCode, Serialized, TokenAmount, METHOD_CONSTRUCTOR};
 
-fn construct_runtime<BS: BlockStore>(bs: &BS) -> MockRuntime<'_, BS> {
+fn construct_runtime<'a, BS: BlockStore>(bs: &'a BS) -> MockRuntime<'a, BS> {
     let receiver = Address::new_id(1000);
     let message = UnsignedMessage::builder()
         .to(receiver.clone())
@@ -48,7 +48,7 @@ fn abort_cant_call_exec() {
 #[test]
 fn create_2_payment_channels() {
     let bs = MemoryDB::default();
-    let mut rt: MockRuntime<MemoryDB> = construct_runtime(&bs);
+    let mut rt = construct_runtime(&bs);
     construct_and_verify(&mut rt);
     let anne = Address::new_id(1001);
 
@@ -112,7 +112,7 @@ fn create_2_payment_channels() {
 #[test]
 fn create_storage_miner() {
     let bs = MemoryDB::default();
-    let mut rt: MockRuntime<MemoryDB> = construct_runtime(&bs);
+    let mut rt = construct_runtime(&bs);
     construct_and_verify(&mut rt);
 
     // only the storage power actor can create a miner
@@ -259,7 +259,7 @@ fn sending_constructor_failure() {
     );
 }
 
-fn construct_and_verify<BS: BlockStore>(rt: &mut MockRuntime<'_, BS>) {
+fn construct_and_verify<'a, BS: BlockStore>(rt: &mut MockRuntime<'a, BS>) {
     rt.expect_validate_caller_addr(&[SYSTEM_ACTOR_ADDR.clone()]);
     let params = ConstructorParams {
         network_name: "mock".to_string(),
@@ -287,8 +287,8 @@ fn construct_and_verify<BS: BlockStore>(rt: &mut MockRuntime<'_, BS>) {
     assert_eq!("mock".to_string(), state_data.network_name);
 }
 
-fn exec_and_verify<BS: BlockStore, S: Serialize>(
-    rt: &mut MockRuntime<'_, BS>,
+fn exec_and_verify<'a, BS: BlockStore, S: Serialize>(
+    rt: &mut MockRuntime<'a, BS>,
     code_id: Cid,
     params: &S,
 ) -> Result<Serialized, ActorError>