Verifreg: Export AddVerifiedClient and GetClaims (#873)

* Verifreg: Rename AddVerifierClientParams to AddVerifiedClientParams

* Verifreg: Export AddVerifiedClient and GetClaims

actors/verifreg/src/lib.rs

@@ -61,7 +61,9 @@ pub enum Method {
     ExtendClaimTerms = 11,
     RemoveExpiredClaims = 12,
     // Method numbers derived from FRC-0042 standards
+    AddVerifiedClientExported = frc42_dispatch::method_hash!("AddVerifiedClient"),
     RemoveExpiredAllocationsExported = frc42_dispatch::method_hash!("RemoveExpiredAllocations"),
+    GetClaimsExported = frc42_dispatch::method_hash!("GetClaims"),
     ExtendClaimTermsExported = frc42_dispatch::method_hash!("ExtendClaimTerms"),
     RemoveExpiredClaimsExported = frc42_dispatch::method_hash!("RemoveExpiredClaims"),
     UniversalReceiverHook = frc42_dispatch::method_hash!("Receive"),
@@ -145,7 +147,7 @@ impl Actor {
 
     pub fn add_verified_client(
         rt: &mut impl Runtime,
-        params: AddVerifierClientParams,
+        params: AddVerifiedClientParams,
     ) -> Result<(), ActorError> {
         // The caller will be verified by checking table below
         rt.validate_immediate_caller_accept_any()?;
@@ -1085,7 +1087,7 @@ impl ActorCode for Actor {
                 Self::remove_verifier(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
-            Some(Method::AddVerifiedClient) => {
+            Some(Method::AddVerifiedClient) | Some(Method::AddVerifiedClientExported) => {
                 Self::add_verified_client(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::default())
             }
@@ -1107,7 +1109,7 @@ impl ActorCode for Actor {
                 let res = Self::extend_claim_terms(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::serialize(res)?)
             }
-            Some(Method::GetClaims) => {
+            Some(Method::GetClaims) | Some(Method::GetClaimsExported) => {
                 let res = Self::get_claims(rt, cbor::deserialize_params(params)?)?;
                 Ok(RawBytes::serialize(res)?)
             }

actors/verifreg/src/types.rs

@@ -30,7 +30,7 @@ impl Cbor for VerifierParams {}
 
 pub type AddVerifierParams = VerifierParams;
 
-pub type AddVerifierClientParams = VerifierParams;
+pub type AddVerifiedClientParams = VerifierParams;
 
 /// DataCap is an integer number of bytes.
 /// We can introduce policy changes and replace this in the future.

actors/verifreg/tests/harness/mod.rs

@@ -14,7 +14,7 @@ use num_traits::{ToPrimitive, Zero};
 
 use fil_actor_verifreg::testing::check_state_invariants;
 use fil_actor_verifreg::{
-    ext, Actor as VerifregActor, AddVerifierClientParams, AddVerifierParams, Allocation,
+    ext, Actor as VerifregActor, AddVerifiedClientParams, AddVerifierParams, Allocation,
     AllocationID, AllocationRequest, AllocationRequests, AllocationsResponse, Claim,
     ClaimAllocationsParams, ClaimAllocationsReturn, ClaimExtensionRequest, ClaimID, DataCap,
     ExtendClaimTermsParams, ExtendClaimTermsReturn, GetClaimsParams, GetClaimsReturn, Method,
@@ -187,7 +187,7 @@ impl Harness {
             ExitCode::OK,
         );
 
-        let params = AddVerifierClientParams { address: *client, allowance: allowance.clone() };
+        let params = AddVerifiedClientParams { address: *client, allowance: allowance.clone() };
         let ret = rt.call::<VerifregActor>(
             Method::AddVerifiedClient as MethodNum,
             &RawBytes::serialize(params).unwrap(),

actors/verifreg/tests/verifreg_actor_test.rs

@@ -238,9 +238,14 @@ mod clients {
     use fvm_shared::{MethodNum, METHOD_SEND};
     use num_traits::Zero;
 
-    use fil_actor_verifreg::{Actor as VerifregActor, AddVerifierClientParams, DataCap, Method};
+    use fil_actor_verifreg::{
+        ext, Actor as VerifregActor, AddVerifiedClientParams, DataCap, Method,
+    };
     use fil_actors_runtime::test_utils::*;
+    use fil_actors_runtime::{DATACAP_TOKEN_ACTOR_ADDR, STORAGE_MARKET_ACTOR_ADDR};
+
     use harness::*;
+    use num_traits::ToPrimitive;
     use util::*;
 
     use crate::*;
@@ -363,7 +368,7 @@ mod clients {
         let caller = Address::new_id(209);
         rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, caller);
         rt.expect_validate_caller_any();
-        let params = AddVerifierClientParams { address: *CLIENT, allowance: allowance_client };
+        let params = AddVerifiedClientParams { address: *CLIENT, allowance: allowance_client };
         expect_abort(
             ExitCode::USR_NOT_FOUND,
             rt.call::<VerifregActor>(
@@ -374,6 +379,59 @@ mod clients {
         h.check_state(&rt);
     }
 
+    #[test]
+    fn add_verified_client_restricted_correctly() {
+        let (h, mut rt) = new_harness();
+        let allowance_verifier = verifier_allowance(&rt);
+        let allowance_client = client_allowance(&rt);
+        h.add_verifier(&mut rt, &VERIFIER, &allowance_verifier).unwrap();
+
+        let params =
+            AddVerifiedClientParams { address: *CLIENT, allowance: allowance_client.clone() };
+
+        // set caller to not-builtin
+        rt.set_caller(make_identity_cid(b"1234"), *VERIFIER);
+
+        // cannot call the unexported method num
+        expect_abort_contains_message(
+            ExitCode::USR_FORBIDDEN,
+            "must be built-in",
+            rt.call::<VerifregActor>(
+                Method::AddVerifiedClient as MethodNum,
+                &RawBytes::serialize(params.clone()).unwrap(),
+            ),
+        );
+
+        rt.verify();
+
+        // can call the exported method num
+
+        let mint_params = ext::datacap::MintParams {
+            to: *CLIENT,
+            amount: TokenAmount::from_whole(allowance_client.to_i64().unwrap()),
+            operators: vec![STORAGE_MARKET_ACTOR_ADDR],
+        };
+        rt.expect_send(
+            DATACAP_TOKEN_ACTOR_ADDR,
+            ext::datacap::Method::Mint as MethodNum,
+            RawBytes::serialize(&mint_params).unwrap(),
+            TokenAmount::zero(),
+            RawBytes::default(),
+            ExitCode::OK,
+        );
+
+        rt.expect_validate_caller_any();
+        rt.call::<VerifregActor>(
+            Method::AddVerifiedClientExported as MethodNum,
+            &RawBytes::serialize(params).unwrap(),
+        )
+        .unwrap();
+
+        rt.verify();
+
+        h.check_state(&rt);
+    }
+
     #[test]
     fn rejects_allowance_greater_than_verifier_cap() {
         let (h, mut rt) = new_harness();
@@ -432,7 +490,8 @@ mod allocs_claims {
     use std::str::FromStr;
 
     use fil_actor_verifreg::{
-        Actor, AllocationID, ClaimTerm, DataCap, ExtendClaimTermsParams, Method, State,
+        Actor, AllocationID, ClaimTerm, DataCap, ExtendClaimTermsParams, GetClaimsParams,
+        GetClaimsReturn, Method, State,
     };
     use fil_actor_verifreg::{Claim, ExtendClaimTermsReturn};
     use fil_actors_runtime::cbor::serialize;
@@ -896,7 +955,7 @@ mod allocs_claims {
     }
 
     #[test]
-    fn extend_claims_restricted_correctly() {
+    fn claims_restricted_correctly() {
         let (h, mut rt) = new_harness();
         let size = MINIMUM_VERIFIED_ALLOCATION_SIZE as u64;
         let sector = 0;
@@ -908,15 +967,16 @@ mod allocs_claims {
 
         let id1 = h.create_claim(&mut rt, &claim1).unwrap();
 
-        // Extend claim terms and verify return value.
+        // First, let's extend some claims
+
         let params = ExtendClaimTermsParams {
             terms: vec![ClaimTerm { provider: PROVIDER1, claim_id: id1, term_max: max_term + 1 }],
         };
 
         // set caller to not-builtin
         rt.set_caller(make_identity_cid(b"1234"), Address::new_id(CLIENT1));
 
-        // cannot call the unexported method num
+        // cannot call the unexported extend method num
         expect_abort_contains_message(
             ExitCode::USR_FORBIDDEN,
             "must be built-in",
@@ -939,8 +999,38 @@ mod allocs_claims {
 
         assert_eq!(ret.codes(), vec![ExitCode::OK]);
 
-        // Verify state directly.
-        assert_claim(&rt, PROVIDER1, id1, &Claim { term_max: max_term + 1, ..claim1 });
+        // Now let's Get those Claims, and check them
+
+        let params = GetClaimsParams { claim_ids: vec![id1], provider: PROVIDER1 };
+
+        // cannot call the unexported extend method num
+        expect_abort_contains_message(
+            ExitCode::USR_FORBIDDEN,
+            "must be built-in",
+            rt.call::<Actor>(
+                Method::GetClaims as MethodNum,
+                &serialize(&params, "get claims params").unwrap(),
+            ),
+        );
+
+        rt.verify();
+
+        // can call the exported method num
+        rt.expect_validate_caller_any();
+        let ret: GetClaimsReturn = rt
+            .call::<Actor>(
+                Method::GetClaimsExported as MethodNum,
+                &serialize(&params, "get claims params").unwrap(),
+            )
+            .unwrap()
+            .deserialize()
+            .expect("failed to deserialize get claims return");
+
+        rt.verify();
+
+        assert_eq!(ret.batch_info.codes(), vec![ExitCode::OK]);
+        assert_eq!(ret.claims, vec![Claim { term_max: max_term + 1, ..claim1 }]);
+
         h.check_state(&rt);
     }
 }

test_vm/src/util.rs

@@ -42,7 +42,7 @@ use fil_actor_power::{
 };
 use fil_actor_reward::Method as RewardMethod;
 use fil_actor_verifreg::{
-    AddVerifierClientParams, AllocationID, ClaimID, ClaimTerm, ExtendClaimTermsParams,
+    AddVerifiedClientParams, AllocationID, ClaimID, ClaimTerm, ExtendClaimTermsParams,
     GetClaimsParams, Method as VerifregMethod, RemoveExpiredAllocationsParams, VerifierParams,
 };
 use fil_actors_runtime::cbor::deserialize;
@@ -868,7 +868,7 @@ pub fn verifreg_add_verifier(v: &VM, verifier: Address, data_cap: StoragePower)
 
 pub fn verifreg_add_client(v: &VM, verifier: Address, client: Address, allowance: StoragePower) {
     let add_client_params =
-        AddVerifierClientParams { address: client, allowance: allowance.clone() };
+        AddVerifiedClientParams { address: client, allowance: allowance.clone() };
     apply_ok(
         v,
         verifier,

test_vm/tests/publish_deals_test.rs

@@ -11,7 +11,7 @@ use fil_actor_miner::Method as MinerMethod;
 use fil_actor_power::Method as PowerMethod;
 use fil_actor_reward::Method as RewardMethod;
 
-use fil_actor_verifreg::{AddVerifierClientParams, Method as VerifregMethod};
+use fil_actor_verifreg::{AddVerifiedClientParams, Method as VerifregMethod};
 use fil_actors_runtime::cbor::serialize;
 use fil_actors_runtime::network::EPOCHS_IN_DAY;
 use fil_actors_runtime::runtime::Policy;
@@ -74,7 +74,7 @@ fn setup(store: &'_ MemoryBlockstore) -> (VM<'_>, Addrs, ChainEpoch) {
 
     // setup verified client
     verifreg_add_verifier(&v, verifier, StoragePower::from((32_u64 << 40) as u128));
-    let add_client_params = AddVerifierClientParams {
+    let add_client_params = AddVerifiedClientParams {
         address: verified_client,
         allowance: StoragePower::from((1_u64 << 32) as u64),
     };

test_vm/tests/verifreg_remove_datacap_test.rs

@@ -15,7 +15,7 @@ use fil_actor_datacap::{
     DestroyParams, Method as DataCapMethod, MintParams, State as DataCapState,
 };
 use fil_actor_verifreg::{
-    AddVerifierClientParams, DataCap, RemoveDataCapParams, RemoveDataCapRequest,
+    AddVerifiedClientParams, DataCap, RemoveDataCapParams, RemoveDataCapRequest,
     RemoveDataCapReturn, SIGNATURE_DOMAIN_SEPARATION_REMOVE_DATA_CAP,
 };
 use fil_actor_verifreg::{AddrPairKey, Method as VerifregMethod};
@@ -47,7 +47,7 @@ fn remove_datacap_simple_successful_path() {
 
     // register the verified client
     let add_verified_client_params =
-        AddVerifierClientParams { address: verified_client, allowance: verifier_allowance.clone() };
+        AddVerifiedClientParams { address: verified_client, allowance: verifier_allowance.clone() };
     let mint_params = MintParams {
         to: verified_client,
         amount: TokenAmount::from_whole(verifier_allowance.to_i64().unwrap()),