tempo_precompiles/tip403_registry/

dispatch.rs

//! ABI dispatch for the [`TIP403Registry`] precompile.

use crate::{
    Precompile, SelectorSchedule, charge_input_cost, dispatch_call, mutate, mutate_void,
    tip403_registry::{AuthRole, TIP403Registry},
    view,
};
use alloy::{
    primitives::Address,
    sol_types::{SolCall, SolInterface},
};
use revm::precompile::PrecompileResult;
use tempo_chainspec::hardfork::TempoHardfork;
use tempo_contracts::precompiles::ITIP403Registry::{self, ITIP403RegistryCalls};

const T2_ADDED: &[[u8; 4]] = &[
    ITIP403Registry::isAuthorizedSenderCall::SELECTOR,
    ITIP403Registry::isAuthorizedRecipientCall::SELECTOR,
    ITIP403Registry::isAuthorizedMintRecipientCall::SELECTOR,
    ITIP403Registry::compoundPolicyDataCall::SELECTOR,
    ITIP403Registry::createCompoundPolicyCall::SELECTOR,
];

const T6_ADDED: &[[u8; 4]] = &[
    ITIP403Registry::receivePolicyCall::SELECTOR,
    ITIP403Registry::validateReceivePolicyCall::SELECTOR,
    ITIP403Registry::setReceivePolicyCall::SELECTOR,
];

impl Precompile for TIP403Registry {
    fn call(&mut self, calldata: &[u8], msg_sender: Address) -> PrecompileResult {
        if let Some(err) = charge_input_cost(&mut self.storage, calldata) {
            return err;
        }

        dispatch_call(
            calldata,
            &[
                SelectorSchedule::new(TempoHardfork::T2).with_added(T2_ADDED),
                SelectorSchedule::new(TempoHardfork::T6).with_added(T6_ADDED),
            ],
            ITIP403RegistryCalls::abi_decode,
            |call| match call {
                ITIP403RegistryCalls::policyIdCounter(call) => {
                    view(call, |_| self.policy_id_counter())
                }
                ITIP403RegistryCalls::policyExists(call) => view(call, |c| self.policy_exists(c)),
                ITIP403RegistryCalls::policyData(call) => view(call, |c| self.policy_data(c)),
                ITIP403RegistryCalls::isAuthorized(call) => view(call, |c| {
                    self.is_authorized_as(c.policyId, c.user, AuthRole::Transfer)
                }),
                // TIP-1015: T2+ only (gated via T2_ADDED_SELECTORS)
                ITIP403RegistryCalls::isAuthorizedSender(call) => view(call, |c| {
                    self.is_authorized_as(c.policyId, c.user, AuthRole::Sender)
                }),
                ITIP403RegistryCalls::isAuthorizedRecipient(call) => view(call, |c| {
                    self.is_authorized_as(c.policyId, c.user, AuthRole::Recipient)
                }),
                ITIP403RegistryCalls::isAuthorizedMintRecipient(call) => view(call, |c| {
                    self.is_authorized_as(c.policyId, c.user, AuthRole::MintRecipient)
                }),
                ITIP403RegistryCalls::compoundPolicyData(call) => {
                    view(call, |c| self.compound_policy_data(c))
                }
                ITIP403RegistryCalls::receivePolicy(call) => {
                    view(call, |c| self.receive_policy(c.account))
                }
                ITIP403RegistryCalls::validateReceivePolicy(call) => view(call, |c| {
                    let blocked_reason = self
                        .validate_receive_policy(c.token, c.sender, c.receiver)?
                        .unwrap_or(ITIP403Registry::BlockedReason::NONE);
                    Ok(ITIP403Registry::validateReceivePolicyReturn {
                        authorized: blocked_reason == ITIP403Registry::BlockedReason::NONE,
                        blockedReason: blocked_reason,
                    })
                }),
                ITIP403RegistryCalls::setReceivePolicy(call) => {
                    mutate_void(call, msg_sender, |s, c| self.set_receive_policy(s, c))
                }
                ITIP403RegistryCalls::createPolicy(call) => {
                    mutate(call, msg_sender, |s, c| self.create_policy(s, c))
                }
                ITIP403RegistryCalls::createPolicyWithAccounts(call) => {
                    mutate(call, msg_sender, |s, c| {
                        self.create_policy_with_accounts(s, c)
                    })
                }
                ITIP403RegistryCalls::setPolicyAdmin(call) => {
                    mutate_void(call, msg_sender, |s, c| self.set_policy_admin(s, c))
                }
                ITIP403RegistryCalls::modifyPolicyWhitelist(call) => {
                    mutate_void(call, msg_sender, |s, c| self.modify_policy_whitelist(s, c))
                }
                ITIP403RegistryCalls::modifyPolicyBlacklist(call) => {
                    mutate_void(call, msg_sender, |s, c| self.modify_policy_blacklist(s, c))
                }
                // TIP-1015: T2+ only (gated via T2_ADDED_SELECTORS)
                ITIP403RegistryCalls::createCompoundPolicy(call) => {
                    mutate(call, msg_sender, |s, c| self.create_compound_policy(s, c))
                }
            },
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        storage::{StorageCtx, hashmap::HashMapStorageProvider},
        test_util::{assert_full_coverage, check_selector_coverage},
        tip403_registry::ITIP403Registry,
    };
    use alloy::sol_types::{SolCall, SolError, SolValue};
    use tempo_chainspec::hardfork::TempoHardfork;
    use tempo_contracts::precompiles::{
        ITIP403Registry::ITIP403RegistryCalls, UnknownFunctionSelector,
    };

    #[test]
    fn test_is_authorized_precompile() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let user = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Test policy 1 (always allow)
            let call = ITIP403Registry::isAuthorizedCall { policyId: 1, user };
            let calldata = call.abi_encode();
            let result = registry.call(&calldata, Address::ZERO);

            assert!(result.is_ok());
            let output = result.unwrap();
            let decoded: bool =
                ITIP403Registry::isAuthorizedCall::abi_decode_returns(&output.bytes).unwrap();
            assert!(decoded);

            Ok(())
        })
    }

    #[test]
    fn test_create_policy_precompile() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let admin = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            let call = ITIP403Registry::createPolicyCall {
                admin,
                policyType: ITIP403Registry::PolicyType::WHITELIST,
            };
            let calldata = call.abi_encode();
            let result = registry.call(&calldata, admin);

            assert!(result.is_ok());
            let output = result.unwrap();
            let decoded: u64 =
                ITIP403Registry::createPolicyCall::abi_decode_returns(&output.bytes).unwrap();
            assert_eq!(decoded, 2); // First created policy ID

            Ok(())
        })
    }

    #[test]
    fn test_policy_id_counter_initialization() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let sender = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Get initial counter
            let counter_call = ITIP403Registry::policyIdCounterCall {};
            let calldata = counter_call.abi_encode();
            let result = registry.call(&calldata, sender).unwrap();
            let counter = u64::abi_decode(&result.bytes).unwrap();
            assert_eq!(counter, 2); // Counter starts at 2 (policies 0 and 1 are reserved)

            Ok(())
        })
    }

    #[test]
    fn test_create_policy_with_accounts() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let admin = Address::random();
        let account1 = Address::random();
        let account2 = Address::random();
        let other_account = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            let accounts = vec![account1, account2];
            let call = ITIP403Registry::createPolicyWithAccountsCall {
                admin,
                policyType: ITIP403Registry::PolicyType::WHITELIST,
                accounts,
            };
            let calldata = call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();

            let policy_id: u64 =
                ITIP403Registry::createPolicyWithAccountsCall::abi_decode_returns(&result.bytes)
                    .unwrap();
            assert_eq!(policy_id, 2);

            // Check that accounts are authorized
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: account1,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: account2,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            // Check that other accounts are not authorized
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: other_account,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(!is_authorized);

            Ok(())
        })
    }

    #[test]
    fn test_blacklist_policy() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let admin = Address::random();
        let blocked_account = Address::random();
        let allowed_account = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Create blacklist policy
            let call = ITIP403Registry::createPolicyCall {
                admin,
                policyType: ITIP403Registry::PolicyType::BLACKLIST,
            };
            let calldata = call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let policy_id: u64 =
                ITIP403Registry::createPolicyCall::abi_decode_returns(&result.bytes).unwrap();

            // Initially, all accounts should be authorized (empty blacklist)
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: blocked_account,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            // Add account to blacklist
            let modify_call = ITIP403Registry::modifyPolicyBlacklistCall {
                policyId: policy_id,
                account: blocked_account,
                restricted: true,
            };
            let calldata = modify_call.abi_encode();
            registry.call(&calldata, admin).unwrap();

            // Now blocked account should not be authorized
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: blocked_account,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(!is_authorized);

            // Other accounts should still be authorized
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: allowed_account,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            // Remove account from blacklist
            let modify_call = ITIP403Registry::modifyPolicyBlacklistCall {
                policyId: policy_id,
                account: blocked_account,
                restricted: false,
            };
            let calldata = modify_call.abi_encode();
            registry.call(&calldata, admin).unwrap();

            // Account should be authorized again
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: blocked_account,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            Ok(())
        })
    }

    #[test]
    fn test_modify_policy_whitelist() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let admin = Address::random();
        let account1 = Address::random();
        let account2 = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Create whitelist policy
            let call = ITIP403Registry::createPolicyCall {
                admin,
                policyType: ITIP403Registry::PolicyType::WHITELIST,
            };
            let calldata = call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let policy_id: u64 =
                ITIP403Registry::createPolicyCall::abi_decode_returns(&result.bytes).unwrap();

            // Add multiple accounts to whitelist
            let modify_call1 = ITIP403Registry::modifyPolicyWhitelistCall {
                policyId: policy_id,
                account: account1,
                allowed: true,
            };
            let calldata = modify_call1.abi_encode();
            registry.call(&calldata, admin).unwrap();

            let modify_call2 = ITIP403Registry::modifyPolicyWhitelistCall {
                policyId: policy_id,
                account: account2,
                allowed: true,
            };
            let calldata = modify_call2.abi_encode();
            registry.call(&calldata, admin).unwrap();

            // Both accounts should be authorized
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: account1,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: account2,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            // Remove one account from whitelist
            let modify_call = ITIP403Registry::modifyPolicyWhitelistCall {
                policyId: policy_id,
                account: account1,
                allowed: false,
            };
            let calldata = modify_call.abi_encode();
            registry.call(&calldata, admin).unwrap();

            // Account1 should not be authorized, account2 should still be
            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: account1,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(!is_authorized);

            let is_auth_call = ITIP403Registry::isAuthorizedCall {
                policyId: policy_id,
                user: account2,
            };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            Ok(())
        })
    }

    #[test]
    fn test_set_policy_admin() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let admin = Address::random();
        let new_admin = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Create a policy
            let call = ITIP403Registry::createPolicyCall {
                admin,
                policyType: ITIP403Registry::PolicyType::WHITELIST,
            };
            let calldata = call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let policy_id: u64 =
                ITIP403Registry::createPolicyCall::abi_decode_returns(&result.bytes).unwrap();

            // Get initial policy data
            let policy_data_call = ITIP403Registry::policyDataCall {
                policyId: policy_id,
            };
            let calldata = policy_data_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let policy_data =
                ITIP403Registry::policyDataCall::abi_decode_returns(&result.bytes).unwrap();
            assert_eq!(policy_data.admin, admin);

            // Change policy admin
            let set_admin_call = ITIP403Registry::setPolicyAdminCall {
                policyId: policy_id,
                admin: new_admin,
            };
            let calldata = set_admin_call.abi_encode();
            registry.call(&calldata, admin).unwrap();

            // Verify policy admin was changed
            let policy_data_call = ITIP403Registry::policyDataCall {
                policyId: policy_id,
            };
            let calldata = policy_data_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let policy_data =
                ITIP403Registry::policyDataCall::abi_decode_returns(&result.bytes).unwrap();
            assert_eq!(policy_data.admin, new_admin);

            Ok(())
        })
    }

    #[test]
    fn test_special_policy_ids() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let user = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Test policy 0 (always deny)
            let is_auth_call = ITIP403Registry::isAuthorizedCall { policyId: 0, user };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, Address::ZERO).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(!is_authorized);

            // Test policy 1 (always allow)
            let is_auth_call = ITIP403Registry::isAuthorizedCall { policyId: 1, user };
            let calldata = is_auth_call.abi_encode();
            let result = registry.call(&calldata, Address::ZERO).unwrap();
            let is_authorized = bool::abi_decode(&result.bytes).unwrap();
            assert!(is_authorized);

            Ok(())
        })
    }

    #[test]
    fn test_invalid_selector() -> eyre::Result<()> {
        let sender = Address::random();

        // T1: invalid selector returns reverted output
        let mut storage = HashMapStorageProvider::new_with_spec(1, TempoHardfork::T1);
        StorageCtx::enter(&mut storage, || -> eyre::Result<()> {
            let mut registry = TIP403Registry::new();

            let invalid_data = vec![0x12, 0x34, 0x56, 0x78];
            let result = registry.call(&invalid_data, sender)?;
            assert!(result.is_revert());

            // T1: insufficient data also returns reverted output
            let short_data = vec![0x12, 0x34];
            let result = registry.call(&short_data, sender)?;
            assert!(result.is_revert());

            Ok(())
        })?;

        // Pre-T1 (T0): insufficient data returns halted output
        let mut storage = HashMapStorageProvider::new_with_spec(1, TempoHardfork::T0);
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            let short_data = vec![0x12, 0x34];
            let result = registry.call(&short_data, sender);
            let output = result.expect("expected Ok(halt) for short calldata");
            assert!(output.is_halt());

            Ok(())
        })
    }

    #[test]
    fn test_create_multiple_policies() -> eyre::Result<()> {
        let mut storage = HashMapStorageProvider::new(1);
        let admin = Address::random();
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            // Create multiple policies with different types
            let whitelist_call = ITIP403Registry::createPolicyCall {
                admin,
                policyType: ITIP403Registry::PolicyType::WHITELIST,
            };
            let calldata = whitelist_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let whitelist_id: u64 =
                ITIP403Registry::createPolicyCall::abi_decode_returns(&result.bytes).unwrap();

            let blacklist_call = ITIP403Registry::createPolicyCall {
                admin,
                policyType: ITIP403Registry::PolicyType::BLACKLIST,
            };
            let calldata = blacklist_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let blacklist_id: u64 =
                ITIP403Registry::createPolicyCall::abi_decode_returns(&result.bytes).unwrap();

            // Verify IDs are sequential
            assert_eq!(whitelist_id, 2);
            assert_eq!(blacklist_id, 3);

            // Verify counter has been updated
            let counter_call = ITIP403Registry::policyIdCounterCall {};
            let calldata = counter_call.abi_encode();
            let result = registry.call(&calldata, admin).unwrap();
            let counter = u64::abi_decode(&result.bytes).unwrap();
            assert_eq!(counter, 4);

            Ok(())
        })
    }

    #[test]
    fn test_selector_coverage() -> eyre::Result<()> {
        // Use T6 to test all selectors including TIP-1015 compound policy functions and
        // TIP-1028 receive-policy functions added in T6.
        let mut storage = HashMapStorageProvider::new_with_spec(1, TempoHardfork::T6);
        StorageCtx::enter(&mut storage, || {
            let mut registry = TIP403Registry::new();

            let unsupported = check_selector_coverage(
                &mut registry,
                ITIP403RegistryCalls::SELECTORS,
                "ITIP403Registry",
                ITIP403RegistryCalls::name_by_selector,
            );

            assert_full_coverage([unsupported]);

            Ok(())
        })
    }

    #[test]
    fn test_receive_policy_selectors_are_t6_gated() -> eyre::Result<()> {
        let account = Address::random();
        let receive_policy = ITIP403Registry::receivePolicyCall { account }.abi_encode();
        let validate_receive_policy = ITIP403Registry::validateReceivePolicyCall {
            token: Address::random(),
            sender: Address::random(),
            receiver: account,
        }
        .abi_encode();
        let set_receive_policy = ITIP403Registry::setReceivePolicyCall {
            senderPolicyId: 1,
            tokenFilterId: 1,
            recoveryAuthority: Address::ZERO,
        }
        .abi_encode();

        for calldata in [
            receive_policy.as_slice(),
            validate_receive_policy.as_slice(),
            set_receive_policy.as_slice(),
        ] {
            let mut storage = HashMapStorageProvider::new_with_spec(1, TempoHardfork::T5);
            StorageCtx::enter(&mut storage, || -> eyre::Result<()> {
                let mut registry = TIP403Registry::new();
                let result = registry
                    .call(calldata, account)
                    .map_err(|err| eyre::eyre!("{err:?}"))?;
                assert!(result.is_revert());
                assert!(UnknownFunctionSelector::abi_decode(&result.bytes).is_ok());
                Ok(())
            })?;
        }

        let mut storage = HashMapStorageProvider::new_with_spec(1, TempoHardfork::T6);
        StorageCtx::enter(&mut storage, || -> eyre::Result<()> {
            let mut registry = TIP403Registry::new();
            for calldata in [
                receive_policy.as_slice(),
                validate_receive_policy.as_slice(),
                set_receive_policy.as_slice(),
            ] {
                let result = registry
                    .call(calldata, account)
                    .map_err(|err| eyre::eyre!("{err:?}"))?;
                assert!(!result.is_revert());
            }
            Ok(())
        })
    }
}