FIP-0118: Additional FIL+ removal & datacap freeze

actors/datacap/src/lib.rs

@@ -140,8 +140,6 @@ impl Actor {
 
     pub fn mint(rt: &impl Runtime, _params: MintParams) -> Result<MintReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        // FIP-0118: datacap is deprecated. No new datacap can be minted, and
-        // existing balances are frozen in place.
         Err(actor_error!(
             forbidden,
             "FIP-0118: datacap is deprecated, minting is no longer supported"
@@ -152,27 +150,19 @@ impl Actor {
     /// Only the governor can call this method.
     /// This method is not part of the fungible token standard, and is named distinctly from
     /// "burn" to reflect that distinction.
-    pub fn destroy(rt: &impl Runtime, params: DestroyParams) -> Result<BurnReturn, ActorError> {
-        rt.transaction(|st: &mut State, rt| {
-            // Only the governor can destroy datacap tokens on behalf of a holder.
-            rt.validate_immediate_caller_is(std::iter::once(&st.governor))?;
-
-            let syscalls = SyscallProvider { rt };
-            let runtime = ActorRuntime::new(&syscalls, syscalls.rt.store());
-            let mut token = as_token(st, &runtime);
-            // Burn tokens as if the holder had invoked burn() themselves.
-            // The governor doesn't need an allowance.
-            token.burn(&params.owner, &params.amount).actor_result()
-        })
-        .context("state transaction failed")
+    pub fn destroy(rt: &impl Runtime, _params: DestroyParams) -> Result<BurnReturn, ActorError> {
+        rt.validate_immediate_caller_accept_any()?;
+        Err(actor_error!(
+            forbidden,
+            "FIP-0118: datacap is deprecated, destroying datacap is no longer supported"
+        ))
     }
 
     pub fn transfer(
         rt: &impl Runtime,
         _params: TransferParams,
     ) -> Result<TransferReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        // FIP-0118: datacap is deprecated, existing balances are frozen in place.
         Err(actor_error!(
             forbidden,
             "FIP-0118: datacap is deprecated, transfer is no longer supported"
@@ -184,7 +174,6 @@ impl Actor {
         _params: TransferFromParams,
     ) -> Result<TransferFromReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        // FIP-0118: datacap is deprecated, existing balances are frozen in place.
         Err(actor_error!(
             forbidden,
             "FIP-0118: datacap is deprecated, transfer is no longer supported"
@@ -193,67 +182,39 @@ impl Actor {
 
     pub fn increase_allowance(
         rt: &impl Runtime,
-        params: IncreaseAllowanceParams,
+        _params: IncreaseAllowanceParams,
     ) -> Result<IncreaseAllowanceReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        let owner = rt.message().caller();
-        let operator = params.operator;
-
-        rt.transaction(|st: &mut State, rt| {
-            let syscalls = SyscallProvider { rt };
-            let runtime = ActorRuntime::new(&syscalls, syscalls.rt.store());
-            let mut token = as_token(st, &runtime);
-            token
-                .increase_allowance(&owner, &operator, &params.increase)
-                .map(|new_allowance| IncreaseAllowanceReturn { new_allowance })
-                .actor_result()
-        })
-        .context("state transaction failed")
+        Err(actor_error!(
+            forbidden,
+            "FIP-0118: datacap is deprecated, increasing allowance is no longer supported"
+        ))
     }
 
     pub fn decrease_allowance(
         rt: &impl Runtime,
-        params: DecreaseAllowanceParams,
+        _params: DecreaseAllowanceParams,
     ) -> Result<DecreaseAllowanceReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        let owner = &rt.message().caller();
-        let operator = &params.operator;
-
-        rt.transaction(|st: &mut State, rt| {
-            let syscalls = SyscallProvider { rt };
-            let runtime = ActorRuntime::new(&syscalls, syscalls.rt.store());
-            let mut token = as_token(st, &runtime);
-            token
-                .decrease_allowance(owner, operator, &params.decrease)
-                .map(|new_allowance| DecreaseAllowanceReturn { new_allowance })
-                .actor_result()
-        })
-        .context("state transaction failed")
+        Err(actor_error!(
+            forbidden,
+            "FIP-0118: datacap is deprecated, decreasing allowance is no longer supported"
+        ))
     }
 
     pub fn revoke_allowance(
         rt: &impl Runtime,
-        params: RevokeAllowanceParams,
+        _params: RevokeAllowanceParams,
     ) -> Result<RevokeAllowanceReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        let owner = &rt.message().caller();
-        let operator = &params.operator;
-
-        rt.transaction(|st: &mut State, rt| {
-            let syscalls = SyscallProvider { rt };
-            let runtime = ActorRuntime::new(&syscalls, syscalls.rt.store());
-            let mut token = as_token(st, &runtime);
-            token
-                .revoke_allowance(owner, operator)
-                .map(|old_allowance| RevokeAllowanceReturn { old_allowance })
-                .actor_result()
-        })
-        .context("state transaction failed")
+        Err(actor_error!(
+            forbidden,
+            "FIP-0118: datacap is deprecated, revoking allowance is no longer supported"
+        ))
     }
 
     pub fn burn(rt: &impl Runtime, _params: BurnParams) -> Result<BurnReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        // FIP-0118: datacap is deprecated, existing balances are frozen in place.
         Err(actor_error!(forbidden, "FIP-0118: datacap is deprecated, burn is no longer supported"))
     }
 
@@ -262,7 +223,6 @@ impl Actor {
         _params: BurnFromParams,
     ) -> Result<BurnFromReturn, ActorError> {
         rt.validate_immediate_caller_accept_any()?;
-        // FIP-0118: datacap is deprecated, existing balances are frozen in place.
         Err(actor_error!(forbidden, "FIP-0118: datacap is deprecated, burn is no longer supported"))
     }
 }

actors/datacap/tests/datacap_actor_test.rs

@@ -232,7 +232,6 @@ mod burn {
 mod destroy {
     use crate::{ALICE, BOB, make_harness};
     use fil_actor_datacap::DestroyParams;
-    use fil_actors_runtime::VERIFIED_REGISTRY_ACTOR_ADDR;
     use fil_actors_runtime::test_utils::{ACCOUNT_ACTOR_CODE_ID, expect_abort_contains_message};
     use fvm_shared::MethodNum;
     use fvm_shared::econ::TokenAmount;
@@ -241,31 +240,29 @@ mod destroy {
     use fvm_ipld_encoding::ipld_block::IpldBlock;
     use fvm_shared::error::ExitCode;
 
+    // Datacap balances are frozen, so destroying is rejected for every caller, the governor
+    // included.
     #[test]
-    fn only_governor_allowed() {
+    fn rejected_for_all_callers() {
         let (rt, h) = make_harness();
 
         let amt = TokenAmount::from_whole(1);
         h.mint_directly(&rt, &ALICE, &(2 * amt.clone()));
-
-        // destroying from operator does not work
         let params = DestroyParams { owner: *ALICE, amount: amt.clone() };
 
-        rt.expect_validate_caller_addr(vec![VERIFIED_REGISTRY_ACTOR_ADDR]);
-        rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, *BOB);
-        expect_abort_contains_message(
-            ExitCode::USR_FORBIDDEN,
-            "caller address",
-            rt.call::<Actor>(
-                Method::DestroyExported as MethodNum,
-                IpldBlock::serialize_cbor(&params).unwrap(),
-            ),
-        );
+        for caller in [*BOB, h.governor] {
+            rt.expect_validate_caller_any();
+            rt.set_caller(*ACCOUNT_ACTOR_CODE_ID, caller);
+            expect_abort_contains_message(
+                ExitCode::USR_FORBIDDEN,
+                "datacap is deprecated",
+                rt.call::<Actor>(
+                    Method::DestroyExported as MethodNum,
+                    IpldBlock::serialize_cbor(&params).unwrap(),
+                ),
+            );
+        }
 
-        // Destroying from 0 allowance having governor works
-        assert!(h.get_allowance_between(&rt, &ALICE, &h.governor).is_zero());
-        let ret = h.destroy(&rt, &ALICE, &amt).unwrap();
-        assert_eq!(ret.balance, amt); // burned 2 amt - amt = amt
         h.check_state(&rt)
     }
 }

actors/datacap/tests/harness/mod.rs

@@ -1,16 +1,15 @@
 use std::cell::RefCell;
 
-use frc46_token::token::types::BurnReturn;
 use fvm_shared::MethodNum;
 use fvm_shared::address::Address;
 use fvm_shared::econ::TokenAmount;
 
 use fil_actor_datacap::testing::check_state_invariants;
-use fil_actor_datacap::{Actor as DataCapActor, DestroyParams, Method, State};
+use fil_actor_datacap::{Actor as DataCapActor, Method, State};
 use fil_actors_runtime::runtime::Runtime;
 use fil_actors_runtime::test_utils::*;
 use fil_actors_runtime::{
-    ActorError, DATACAP_TOKEN_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR,
+    DATACAP_TOKEN_ACTOR_ADDR, SYSTEM_ACTOR_ADDR, VERIFIED_REGISTRY_ACTOR_ADDR,
 };
 use fvm_ipld_encoding::ipld_block::IpldBlock;
 
@@ -78,26 +77,6 @@ impl Harness {
         rt.replace_state(&st);
     }
 
-    pub fn destroy(
-        &self,
-        rt: &MockRuntime,
-        owner: &Address,
-        amount: &TokenAmount,
-    ) -> Result<BurnReturn, ActorError> {
-        rt.expect_validate_caller_addr(vec![VERIFIED_REGISTRY_ACTOR_ADDR]);
-
-        let params = DestroyParams { owner: *owner, amount: amount.clone() };
-
-        rt.set_caller(*VERIFREG_ACTOR_CODE_ID, VERIFIED_REGISTRY_ACTOR_ADDR);
-        let ret = rt.call::<DataCapActor>(
-            Method::DestroyExported as MethodNum,
-            IpldBlock::serialize_cbor(&params).unwrap(),
-        )?;
-
-        rt.verify();
-        Ok(ret.unwrap().deserialize().unwrap())
-    }
-
     // Reads a balance from state directly.
     pub fn get_balance(&self, rt: &MockRuntime, address: &Address) -> TokenAmount {
         rt.expect_validate_caller_any();
@@ -114,19 +93,6 @@ impl Harness {
         ret
     }
 
-    // Reads allowance from state directly
-    pub fn get_allowance_between(
-        &self,
-        rt: &MockRuntime,
-        owner: &Address,
-        operator: &Address,
-    ) -> TokenAmount {
-        rt.get_state::<State>()
-            .token
-            .get_allowance_between(rt.store(), owner.id().unwrap(), operator.id().unwrap())
-            .unwrap()
-    }
-
     pub fn check_state(&self, rt: &MockRuntime) {
         let (_, acc) = check_state_invariants(&rt.get_state(), rt.store());
         acc.assert_empty();

actors/market/Cargo.toml

@@ -38,7 +38,6 @@ multihash-codetable = { workspace = true }
 fil_actors_runtime = { workspace = true, features = ["test_utils", "sector-default"] }
 fil_actor_power = { workspace = true }
 fil_actor_reward = { workspace = true }
-fil_actor_verifreg = { workspace = true }
 fvm_ipld_amt = { workspace = true }
 regex = { workspace = true }
 itertools = { workspace = true }

actors/market/src/ext.rs

@@ -95,10 +95,6 @@ pub mod miner {
     }
 }
 
-pub mod verifreg {
-    pub type AllocationID = u64;
-}
-
 pub mod reward {
     pub const THIS_EPOCH_REWARD_METHOD: u64 = 3;
 }