@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/workers/base/test_worker_base.cairo

@@ -0,0 +1,1097 @@
+//! Base worker tests
+
+use layerzero::common::constants::ZERO_ADDRESS;
+use layerzero::workers::access_control::{ADMIN_ROLE, DEFAULT_ADMIN_ROLE, MESSAGE_LIB_ROLE};
+use layerzero::workers::base::base::WorkerBaseComponent;
+use layerzero::workers::base::errors;
+use layerzero::workers::base::events::{
+    DefaultMultiplierBpsSet, FeeWithdrawn, SupportedOptionTypeSet, WorkerFeeLibSet,
+};
+use layerzero::workers::base::interface::{
+    IWorkerBaseDispatcherTrait, IWorkerBaseSafeDispatcherTrait,
+};
+use openzeppelin::access::accesscontrol::AccessControlComponent;
+use openzeppelin::access::accesscontrol::interface::{
+    IAccessControlDispatcherTrait, IAccessControlSafeDispatcherTrait,
+};
+use openzeppelin::security::interface::{IPausableDispatcher, IPausableDispatcherTrait};
+use openzeppelin::security::pausable::PausableComponent;
+use openzeppelin::token::erc20::ERC20Component::{
+    Errors as ERC20Errors, Event as ERC20Event, Transfer,
+};
+use openzeppelin::token::erc20::interface::IERC20DispatcherTrait;
+use snforge_std::fuzzable::{FuzzableU16, FuzzableU256};
+use snforge_std::{
+    EventSpyAssertionsTrait, spy_events, start_cheat_caller_address, stop_cheat_caller_address,
+};
+use starknet::ContractAddress;
+use starkware_utils_testing::test_utils::{assert_panic_with_error, assert_panic_with_felt_error};
+use crate::fuzzable::contract_address::{
+    ContractAddressArrayList, FuzzableContractAddress, FuzzableContractAddresses,
+};
+use crate::fuzzable::eid::{Eid, FuzzableEid};
+use crate::fuzzable::role_admin::{FuzzableRoleAdmin, RoleAdmin};
+use crate::workers::base::utils::{
+    ERC20Mock, WorkerBaseMock, deploy_mock_erc20, deploy_worker_base,
+    deploy_worker_base_with_additional_roles,
+};
+
+//////////////////////////
+// Initialization tests //
+//////////////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn sets_initial_roles(
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    message_libs: ContractAddressArrayList,
+    admins: ContractAddressArrayList,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        access_control, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            message_libs.arr.span(), price_feed, role_admin, admins.arr.span(),
+        );
+
+    // Check that role_admin is only the role admin
+    assert(access_control.has_role(DEFAULT_ADMIN_ROLE, role_admin), 'Role admin should be set');
+    assert(!access_control.has_role(ADMIN_ROLE, role_admin), 'Role admin should not be admin');
+    assert!(
+        !access_control.has_role(MESSAGE_LIB_ROLE, role_admin), "Role admin should not be msg lib",
+    );
+
+    // Check that message libs are only message libs
+    for message_lib in message_libs.arr {
+        assert(access_control.has_role(MESSAGE_LIB_ROLE, message_lib), 'Msg lib should be set');
+        assert(!access_control.has_role(ADMIN_ROLE, message_lib), 'Msg lib should not be admin');
+        assert!(
+            !access_control.has_role(DEFAULT_ADMIN_ROLE, message_lib),
+            "Msg lib should not be role admin",
+        );
+    }
+
+    // Check that admins are only admins
+    for admin in admins.arr {
+        assert(access_control.has_role(ADMIN_ROLE, admin), 'Admin should be set');
+        assert(!access_control.has_role(MESSAGE_LIB_ROLE, admin), 'Admin should not be msg lib');
+        assert(
+            !access_control.has_role(DEFAULT_ADMIN_ROLE, admin), 'Admin should not be role admin',
+        );
+    }
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn does_not_set_zero_admin(
+    price_feed: ContractAddress,
+    message_libs: ContractAddressArrayList,
+    admins: ContractAddressArrayList,
+) {
+    let WorkerBaseMock {
+        access_control, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            message_libs.arr.span(), price_feed, ZERO_ADDRESS, admins.arr.span(),
+        );
+
+    // Check that zero address is not set as any role
+    assert!(
+        !access_control.has_role(DEFAULT_ADMIN_ROLE, ZERO_ADDRESS),
+        "Zero address should not be role admin",
+    );
+    assert!(!access_control.has_role(ADMIN_ROLE, ZERO_ADDRESS), "Zero address should not be admin");
+    assert!(
+        !access_control.has_role(MESSAGE_LIB_ROLE, ZERO_ADDRESS),
+        "Zero address should not be msg lib",
+    );
+
+    // Check that message libs are only message libs
+    for message_lib in message_libs.arr {
+        assert(access_control.has_role(MESSAGE_LIB_ROLE, message_lib), 'Msg lib should be set');
+        assert(!access_control.has_role(ADMIN_ROLE, message_lib), 'Msg lib should not be admin');
+        assert!(
+            !access_control.has_role(DEFAULT_ADMIN_ROLE, message_lib),
+            "Msg lib should not be role admin",
+        );
+    }
+
+    // Check that admins are only admins
+    for admin in admins.arr {
+        assert(access_control.has_role(ADMIN_ROLE, admin), 'Admin should be set');
+        assert(!access_control.has_role(MESSAGE_LIB_ROLE, admin), 'Admin should not be msg lib');
+        assert(
+            !access_control.has_role(DEFAULT_ADMIN_ROLE, admin), 'Admin should not be role admin',
+        );
+    }
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn set_initial_price_feed_succeeds(role_admin: ContractAddress, price_feed: ContractAddress) {
+    let WorkerBaseMock { dispatcher, .. } = deploy_worker_base(price_feed, role_admin);
+    assert(dispatcher.get_price_feed() == price_feed, 'Price feed should be set');
+}
+
+//////////////////////
+// Price feed tests //
+//////////////////////
+
+#[test]
+#[fuzzer(runs: 10)]
+fn set_price_feed_succeeds_when_admin(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    new_price_feed: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    // Set price feed
+    // Caller has admin role
+    start_cheat_caller_address(worker, admin);
+    dispatcher.set_price_feed(new_price_feed);
+    stop_cheat_caller_address(worker);
+
+    // Check that price feed is set
+    assert(dispatcher.get_price_feed() == new_price_feed, 'Price feed should be set');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn set_price_feed_fails_when_not_admin(
+    role_admin: RoleAdmin, not_admin: ContractAddress, price_feed: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, safe_dispatcher, access_control, ..,
+    } = deploy_worker_base(price_feed, role_admin);
+
+    // Check that not_admin does not have the admin role
+    assert(!access_control.has_role(ADMIN_ROLE, not_admin), 'Should not have admin role');
+
+    // Attempt to set price feed
+    // Caller does not have admin role
+    start_cheat_caller_address(worker, role_admin);
+    let res = safe_dispatcher.set_price_feed(price_feed);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because role_admin does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+
+    // Attempt to set price feed
+    // Caller does not have admin role
+    start_cheat_caller_address(worker, not_admin);
+    let res = safe_dispatcher.set_price_feed(price_feed);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_admin does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn set_price_feed_fails_when_msg_lib(
+    role_admin: RoleAdmin, msg_lib: ContractAddress, price_feed: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, safe_dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![msg_lib].span(), price_feed, role_admin, array![].span(),
+        );
+
+    // Attempt to set price feed
+    // Caller has msg lib role
+    start_cheat_caller_address(worker, msg_lib);
+    let res = safe_dispatcher.set_price_feed(price_feed);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because msg_lib does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn set_multiple_price_feeds_succeeds(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    first_new_price_feed: ContractAddress,
+    second_new_price_feed: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    // Caller has admin role
+    start_cheat_caller_address(worker, admin);
+
+    // First price feed update
+    dispatcher.set_price_feed(first_new_price_feed);
+    let price_feed = dispatcher.get_price_feed();
+    assert(price_feed == first_new_price_feed, 'First update should succeed');
+
+    // Second price feed update
+    dispatcher.set_price_feed(second_new_price_feed);
+    let price_feed = dispatcher.get_price_feed();
+    assert(price_feed == second_new_price_feed, 'Second update should succeed');
+
+    stop_cheat_caller_address(worker);
+}
+
+/////////////////////////////////
+// Supported option type tests //
+/////////////////////////////////
+
+/// An admin can set the supported option type for an EID - corresponding event is emitted
+#[test]
+#[fuzzer(runs: 10)]
+fn set_supported_option_type_succeeds_when_admin(
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    admin: ContractAddress,
+    eid: Eid,
+    option_type: ByteArray,
+) {
+    let eid = eid.eid;
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    let mut spy = spy_events();
+
+    // Caller has admin role
+    start_cheat_caller_address(worker, admin);
+    dispatcher.set_supported_option_type(eid, option_type.clone());
+    stop_cheat_caller_address(worker);
+
+    // Check that supported option type is set
+    assert!(
+        dispatcher.get_supported_option_type(eid) == option_type,
+        "Supported option type should be set",
+    );
+
+    // Verify SupportedOptionTypeSet event was emitted
+    let expected_event = WorkerBaseComponent::Event::SupportedOptionTypeSet(
+        SupportedOptionTypeSet { eid, option_type },
+    );
+    spy.assert_emitted(@array![(worker, expected_event)]);
+}
+
+/// A non-admin cannot set the supported option type for an EID - no event is emitted
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn set_supported_option_type_fails_when_not_admin(
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    not_admin: ContractAddress,
+    eid: Eid,
+    option_type: ByteArray,
+) {
+    let eid = eid.eid;
+    let role_admin = role_admin.address;
+    let WorkerBaseMock { worker, safe_dispatcher, .. } = deploy_worker_base(price_feed, role_admin);
+
+    let mut spy = spy_events();
+
+    // Caller does not have admin role
+    start_cheat_caller_address(worker, not_admin);
+    let res = safe_dispatcher.set_supported_option_type(eid, option_type.clone());
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_admin does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+
+    // Check that supported option type is not set
+    assert!(
+        safe_dispatcher.get_supported_option_type(eid).unwrap() == Default::default(),
+        "Supported option type should not be set",
+    );
+
+    // Verify SupportedOptionTypeSet event was not emitted
+    let event = WorkerBaseComponent::Event::SupportedOptionTypeSet(
+        SupportedOptionTypeSet { eid, option_type },
+    );
+    spy.assert_not_emitted(@array![(worker, event)]);
+}
+
+//////////////////////////
+// Access control tests //
+//////////////////////////
+
+/// The role admin can grant all roles
+#[test]
+#[fuzzer(runs: 10)]
+fn access_control_grant_all_roles_succeed_when_role_admin(
+    role_admin: RoleAdmin,
+    new_role_admin: ContractAddress,
+    admin: ContractAddress,
+    msg_lib: ContractAddress,
+    price_feed: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock { worker, access_control, .. } = deploy_worker_base(price_feed, role_admin);
+
+    // Role admin grants new role admin
+    // Caller is the role admin
+    start_cheat_caller_address(worker, role_admin);
+    access_control.grant_role(DEFAULT_ADMIN_ROLE, new_role_admin);
+    stop_cheat_caller_address(worker);
+
+    // Check that new role admin is a role admin
+    assert(
+        access_control.has_role(DEFAULT_ADMIN_ROLE, new_role_admin), 'New role admin should be set',
+    );
+    assert!(
+        !access_control.has_role(ADMIN_ROLE, new_role_admin), "New role admin should not be admin",
+    );
+    assert!(
+        !access_control.has_role(MESSAGE_LIB_ROLE, new_role_admin),
+        "New role admin should not be msg lib",
+    );
+
+    // Role admin grants admin role
+    // Caller is the new role admin
+    start_cheat_caller_address(worker, role_admin);
+    access_control.grant_role(ADMIN_ROLE, admin);
+    stop_cheat_caller_address(worker);
+
+    // Check that admin only has the admin role
+    assert(access_control.has_role(ADMIN_ROLE, admin), 'Admin role should be set');
+    assert(!access_control.has_role(DEFAULT_ADMIN_ROLE, admin), 'Admin should not be role admin');
+    assert(!access_control.has_role(MESSAGE_LIB_ROLE, admin), 'Admin should not be msg lib');
+
+    // Role admin grants msg lib role
+    // Caller is the role admin
+    start_cheat_caller_address(worker, new_role_admin);
+    access_control.grant_role(MESSAGE_LIB_ROLE, msg_lib);
+    stop_cheat_caller_address(worker);
+
+    // Check that msg_lib has only the message lib role
+    assert!(access_control.has_role(MESSAGE_LIB_ROLE, msg_lib), "Msg lib role should be set");
+    assert!(!access_control.has_role(ADMIN_ROLE, msg_lib), "Msg lib should not be admin");
+    assert!(
+        !access_control.has_role(DEFAULT_ADMIN_ROLE, msg_lib), "Msg lib should not be role admin",
+    );
+}
+
+/// Only the role admin can grant roles
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn access_control_grant_roles_fail_when_not_role_admin(
+    role_admin: ContractAddress,
+    not_role_admin: ContractAddress,
+    price_feed: ContractAddress,
+    grantee: ContractAddress,
+    message_libs: ContractAddressArrayList,
+    admins: ContractAddressArrayList,
+) {
+    // Ensure role_admin and not_role_admin are different
+    if role_admin == not_role_admin {
+        return;
+    }
+
+    let WorkerBaseMock {
+        worker, access_control, safe_access_control, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            message_libs.arr.span(), price_feed, role_admin, admins.arr.span(),
+        );
+
+    // Attempt to grant admin role
+    // Caller is not the role admin
+    start_cheat_caller_address(worker, not_role_admin);
+    let res = safe_access_control.grant_role(ADMIN_ROLE, grantee);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_role_admin is not a role admin
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+    assert(!access_control.has_role(ADMIN_ROLE, grantee), 'Admin role should not be set');
+
+    // Attempt to grant message lib role
+    // Caller is not the role admin
+    start_cheat_caller_address(worker, not_role_admin);
+    let res = safe_access_control.grant_role(MESSAGE_LIB_ROLE, grantee);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_role_admin is not a role admin
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+    assert(!access_control.has_role(MESSAGE_LIB_ROLE, grantee), 'Msg lib role should not be set');
+}
+
+/// Admins cannot grant roles
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn access_control_grant_roles_fail_when_admin(
+    role_admin: ContractAddress,
+    price_feed: ContractAddress,
+    grantee: ContractAddress,
+    admins: ContractAddressArrayList,
+) {
+    let WorkerBaseMock {
+        worker, access_control, safe_access_control, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, admins.arr.span(),
+        );
+
+    for admin in admins.arr {
+        // Ensure that admin and role_admin are different
+        if admin == role_admin {
+            continue;
+        }
+
+        // Attempt to grant admin role
+        // Caller has admin role
+        start_cheat_caller_address(worker, admin);
+        let res = safe_access_control.grant_role(ADMIN_ROLE, grantee);
+
+        // Should panic with missing role error because admin is not a role admin
+        assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+        assert(!access_control.has_role(ADMIN_ROLE, grantee), 'Admin role should not be set');
+
+        // Attempt to grant message lib role
+        let res = safe_access_control.grant_role(MESSAGE_LIB_ROLE, grantee);
+        stop_cheat_caller_address(worker);
+
+        // Should panic with missing role error because admin is not a role admin
+        assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+        assert(
+            !access_control.has_role(MESSAGE_LIB_ROLE, grantee), 'Msg lib role should not be set',
+        );
+    }
+}
+
+/// Message libs cannot grant roles
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn access_control_grant_roles_fail_when_message_lib(
+    role_admin: ContractAddress,
+    price_feed: ContractAddress,
+    grantee: ContractAddress,
+    message_libs: ContractAddressArrayList,
+) {
+    let WorkerBaseMock {
+        worker, access_control, safe_access_control, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            message_libs.arr.span(), price_feed, role_admin, array![].span(),
+        );
+
+    for msg_lib in message_libs.arr {
+        // Ensure that msg_lib and role_admin are different
+        if msg_lib == role_admin {
+            continue;
+        }
+
+        // Attempt to grant admin role
+        // Caller has msg lib role
+        start_cheat_caller_address(worker, msg_lib);
+        let res = safe_access_control.grant_role(ADMIN_ROLE, grantee);
+
+        // Should panic with missing role error because msg_lib is not a role admin
+        assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+        assert(!access_control.has_role(ADMIN_ROLE, grantee), 'Admin role should not be set');
+
+        // Attempt to grant message lib role
+        let res = safe_access_control.grant_role(MESSAGE_LIB_ROLE, grantee);
+        stop_cheat_caller_address(worker);
+
+        // Should panic with missing role error because msg_lib is not a role admin
+        assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+        assert(
+            !access_control.has_role(MESSAGE_LIB_ROLE, grantee), 'Msg lib role should not be set',
+        );
+    }
+}
+
+/// A role admin can grant a new role admin which can then grant admin roles
+#[test]
+#[fuzzer(runs: 10)]
+fn access_control_grant_role_chain_succeeds(
+    role_admin: ContractAddress,
+    new_role_admin: ContractAddress,
+    admin: ContractAddress,
+    msg_lib: ContractAddress,
+    price_feed: ContractAddress,
+) {
+    let WorkerBaseMock { worker, access_control, .. } = deploy_worker_base(price_feed, role_admin);
+
+    // Role admin grants admin role
+    // Caller is the role admin
+    start_cheat_caller_address(worker, role_admin);
+    access_control.grant_role(DEFAULT_ADMIN_ROLE, new_role_admin);
+    stop_cheat_caller_address(worker);
+
+    // Check that new_role_admin is the new role admin
+    assert(
+        access_control.has_role(DEFAULT_ADMIN_ROLE, new_role_admin), 'New role admin should be set',
+    );
+
+    // New role admin grants admin role
+    // Caller is a role admin
+    start_cheat_caller_address(worker, new_role_admin);
+    access_control.grant_role(ADMIN_ROLE, admin);
+    stop_cheat_caller_address(worker);
+
+    // Check that admin has the admin role
+    assert(access_control.has_role(ADMIN_ROLE, admin), 'Admin role should be set');
+
+    // New role admin grants message lib role
+    // Caller is a role admin
+    start_cheat_caller_address(worker, new_role_admin);
+    access_control.grant_role(MESSAGE_LIB_ROLE, msg_lib);
+    stop_cheat_caller_address(worker);
+
+    // Check that msg_lib has the message lib role
+    assert(access_control.has_role(MESSAGE_LIB_ROLE, msg_lib), 'Msg lib role should be set');
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn access_control_role_admin_is_default(role_admin: RoleAdmin, price_feed: ContractAddress) {
+    let WorkerBaseMock { access_control, .. } = deploy_worker_base(price_feed, role_admin.address);
+    assert!(
+        access_control.get_role_admin(DEFAULT_ADMIN_ROLE) == DEFAULT_ADMIN_ROLE,
+        "Role admin is self admin",
+    );
+    assert!(
+        access_control.get_role_admin(ADMIN_ROLE) == DEFAULT_ADMIN_ROLE,
+        "Role admin is admin admin",
+    );
+    assert!(
+        access_control.get_role_admin(MESSAGE_LIB_ROLE) == DEFAULT_ADMIN_ROLE,
+        "Role admin is msg lib admin",
+    );
+}
+
+#[test]
+#[fuzzer(runs: 10)]
+fn access_control_revoking_roles_succeeds(
+    role_admin: RoleAdmin, admin: ContractAddress, msg_lib: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, access_control, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![msg_lib].span(), ZERO_ADDRESS, role_admin, array![admin].span(),
+        );
+
+    // Role admin revokes admin role
+    start_cheat_caller_address(worker, role_admin);
+    access_control.revoke_role(ADMIN_ROLE, admin);
+    stop_cheat_caller_address(worker);
+
+    // Check that admin does not have the admin role
+    assert(!access_control.has_role(ADMIN_ROLE, admin), 'Admin role should not be set');
+
+    // Role admin revokes message lib role
+    start_cheat_caller_address(worker, role_admin);
+    access_control.revoke_role(MESSAGE_LIB_ROLE, msg_lib);
+    stop_cheat_caller_address(worker);
+
+    // Check that msg_lib does not have the message lib role
+    assert(!access_control.has_role(MESSAGE_LIB_ROLE, msg_lib), 'Msg lib role should not be set');
+}
+
+////////////////////////////////
+// Set default multiplier bps //
+////////////////////////////////
+
+/// An admin can set the default multiplier basis points - corresponding event is emitted
+#[test]
+#[fuzzer(runs: 10)]
+fn set_default_multiplier_bps_succeeds_when_admin(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    default_multiplier_bps: u16,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    let mut spy = spy_events();
+
+    // Caller has admin role
+    start_cheat_caller_address(worker, admin);
+    dispatcher.set_default_multiplier_bps(default_multiplier_bps);
+    stop_cheat_caller_address(worker);
+
+    // Check that default multiplier bps is set
+    assert!(
+        dispatcher.get_default_multiplier_bps() == default_multiplier_bps,
+        "Default multiplier bps should be set",
+    );
+
+    // Verify DefaultMultiplierBpsSet event was emitted
+    let expected_event = WorkerBaseComponent::Event::DefaultMultiplierBpsSet(
+        DefaultMultiplierBpsSet { default_multiplier_bps },
+    );
+    spy.assert_emitted(@array![(worker, expected_event)]);
+}
+
+/// A non-admin cannot set the default multiplier basis points - no event is emitted
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn set_default_multiplier_bps_fails_when_not_admin(
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    not_admin: ContractAddress,
+    default_multiplier_bps: u16,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock { worker, safe_dispatcher, .. } = deploy_worker_base(price_feed, role_admin);
+
+    let mut spy = spy_events();
+
+    // Caller does not have admin role
+    start_cheat_caller_address(worker, not_admin);
+    let res = safe_dispatcher.set_default_multiplier_bps(default_multiplier_bps);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_admin does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+
+    // Verify DefaultMultiplierBpsSet event was not emitted
+    let event = WorkerBaseComponent::Event::DefaultMultiplierBpsSet(
+        DefaultMultiplierBpsSet { default_multiplier_bps },
+    );
+    spy.assert_not_emitted(@array![(worker, event)]);
+}
+
+////////////////////////
+// Withdraw fee tests //
+////////////////////////
+
+/// Admin can withdraw fee
+#[test]
+#[fuzzer(runs: 10)]
+fn withdraw_fee_succeeds_when_correct(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_holder: ContractAddress,
+    recipient: ContractAddress,
+    amount: u256,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    // Give token_holder ERC20 tokens
+    const MIN_AMOUNT: u256 = 1_000;
+    const MAX_AMOUNT: u256 = 9_000;
+    let amount = MIN_AMOUNT + amount % MAX_AMOUNT;
+    let ERC20Mock { token, token_dispatcher } = deploy_mock_erc20(amount, token_holder);
+
+    // Holder transfers tokens to worker
+    // Caller has tokens
+    start_cheat_caller_address(token, token_holder);
+    token_dispatcher.transfer(worker, amount);
+    stop_cheat_caller_address(token);
+
+    // Check that worker received tokens
+    assert(token_dispatcher.balance_of(worker) == amount, 'Worker balance should be amount');
+
+    let mut spy = spy_events();
+
+    // Admin withdraws fee
+    // Caller has admin role
+    let withdraw_amount = amount / 2;
+    start_cheat_caller_address(worker, admin);
+    dispatcher.withdraw_fee(token, recipient, withdraw_amount);
+    stop_cheat_caller_address(worker);
+
+    // Verify balances
+    assert!(
+        token_dispatcher.balance_of(recipient) == withdraw_amount,
+        "Recipient balance should be withdraw amount",
+    );
+    assert!(
+        token_dispatcher.balance_of(worker) == amount - withdraw_amount,
+        "Worker balance should be remaining",
+    );
+
+    // Verify WithdrawFee event was emitted
+    let expected_event = WorkerBaseComponent::Event::FeeWithdrawn(
+        FeeWithdrawn { to: recipient, amount: withdraw_amount },
+    );
+    spy.assert_emitted(@array![(worker, expected_event)]);
+
+    // Verify ERC20 transfer event was emitted
+    let erc20_event = ERC20Event::Transfer(
+        Transfer { from: worker, to: recipient, value: withdraw_amount },
+    );
+    spy.assert_emitted(@array![(token, erc20_event)]);
+}
+
+/// Fees cannot be withdrawn if
+/// - caller is not admin
+/// - caller is admin but trying to withdraw more than worker balance
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn withdraw_fee_fails_when_incorrect(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    not_admin: ContractAddress,
+    price_feed: ContractAddress,
+    token_holder: ContractAddress,
+    recipient: ContractAddress,
+    amount: u256,
+) {
+    // Ensure that admin and not_admin are different
+    if admin == not_admin {
+        return;
+    }
+
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, safe_dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    // Give token_holder ERC20 tokens
+    const MIN_AMOUNT: u256 = 1_000;
+    const MAX_AMOUNT: u256 = 9_000;
+    let amount = MIN_AMOUNT + amount % MAX_AMOUNT;
+    let ERC20Mock { token, token_dispatcher } = deploy_mock_erc20(amount, token_holder);
+
+    // Holder transfers tokens to worker
+    // Caller has tokens
+    start_cheat_caller_address(token, token_holder);
+    token_dispatcher.transfer(worker, amount);
+    stop_cheat_caller_address(token);
+
+    // Check that worker received tokens
+    assert(token_dispatcher.balance_of(worker) == amount, 'Worker balance should be amount');
+
+    ///////////////////////////////////
+    // Non-admin cannot withdraw fee //
+    ///////////////////////////////////
+
+    // Non-admin attempts to withdraw fee
+    // Caller does not have admin role
+    let withdraw_amount = amount / 2;
+    start_cheat_caller_address(worker, not_admin);
+    let res = safe_dispatcher.withdraw_fee(token, recipient, withdraw_amount);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_admin does not have the admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+
+    // Verify balances are unchanged
+    assert(token_dispatcher.balance_of(recipient) == 0, 'Recipient balance should be 0');
+    assert(token_dispatcher.balance_of(worker) == amount, 'Worker balance should be amount');
+
+    //////////////////////////////////////////////
+    // Cannot withdraw more than worker balance //
+    //////////////////////////////////////////////
+
+    // Admin attempts to withdraw more than worker balance
+    let withdraw_amount = amount + 1;
+    start_cheat_caller_address(worker, admin);
+    let res = safe_dispatcher.withdraw_fee(token, recipient, withdraw_amount);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with insufficient balance error because admin is trying to withdraw more than
+    // worker balance
+    assert_panic_with_felt_error(res, ERC20Errors::INSUFFICIENT_BALANCE);
+
+    // Verify balances are unchanged
+    assert(token_dispatcher.balance_of(recipient) == 0, 'Recipient balance should be 0');
+    assert(token_dispatcher.balance_of(worker) == amount, 'Worker balance should be amount');
+}
+
+////////////////////////////
+// Worker fee_lib tests    //
+////////////////////////////
+
+/// An admin can set the worker fee_lib address - corresponding event is emitted
+#[test]
+#[fuzzer(runs: 10)]
+fn set_worker_fee_lib_succeeds_when_admin(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    initial_worker_fee_lib: ContractAddress,
+    new_worker_fee_lib: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    // Set initial worker fee_lib
+    start_cheat_caller_address(worker, admin);
+    dispatcher.set_worker_fee_lib(initial_worker_fee_lib);
+    stop_cheat_caller_address(worker);
+
+    let mut spy = spy_events();
+
+    // Set new worker fee_lib
+    start_cheat_caller_address(worker, admin);
+    dispatcher.set_worker_fee_lib(new_worker_fee_lib);
+    stop_cheat_caller_address(worker);
+
+    // Check that worker fee_lib is set
+    assert!(dispatcher.get_worker_fee_lib() == new_worker_fee_lib, "Worker fee_lib should be set");
+
+    // Verify WorkerFeeLibSet event was emitted
+    let expected_event = WorkerBaseComponent::Event::WorkerFeeLibSet(
+        WorkerFeeLibSet {
+            old_worker_fee_lib: initial_worker_fee_lib, new_worker_fee_lib: new_worker_fee_lib,
+        },
+    );
+    spy.assert_emitted(@array![(worker, expected_event)]);
+}
+
+/// A non-admin cannot set the worker fee_lib address - no event is emitted
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn set_worker_fee_lib_fails_when_not_admin(
+    role_admin: RoleAdmin,
+    price_feed: ContractAddress,
+    not_admin: ContractAddress,
+    worker_fee_lib: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock { worker, safe_dispatcher, .. } = deploy_worker_base(price_feed, role_admin);
+
+    let mut spy = spy_events();
+
+    // Caller does not have admin role
+    start_cheat_caller_address(worker, not_admin);
+    let res = safe_dispatcher.set_worker_fee_lib(worker_fee_lib);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because not_admin does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+
+    // Check that worker fee_lib is not set (should be zero address by default)
+    assert!(
+        safe_dispatcher.get_worker_fee_lib().unwrap() == ZERO_ADDRESS,
+        "Worker fee_lib should not be set",
+    );
+
+    // Verify WorkerFeeLibSet event was not emitted
+    let event = WorkerBaseComponent::Event::WorkerFeeLibSet(
+        WorkerFeeLibSet { old_worker_fee_lib: ZERO_ADDRESS, new_worker_fee_lib: worker_fee_lib },
+    );
+    spy.assert_not_emitted(@array![(worker, event)]);
+}
+
+/// A message lib cannot set the worker fee_lib address
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn set_worker_fee_lib_fails_when_msg_lib(
+    role_admin: RoleAdmin,
+    msg_lib: ContractAddress,
+    price_feed: ContractAddress,
+    worker_fee_lib: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, safe_dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![msg_lib].span(), price_feed, role_admin, array![].span(),
+        );
+
+    // Attempt to set worker fee_lib
+    // Caller has msg lib role
+    start_cheat_caller_address(worker, msg_lib);
+    let res = safe_dispatcher.set_worker_fee_lib(worker_fee_lib);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with missing role error because msg_lib does not have admin role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+}
+
+/// Admin can set multiple worker fee_lib addresses successfully
+#[test]
+#[fuzzer(runs: 10)]
+fn set_multiple_worker_fee_lib_succeeds(
+    role_admin: RoleAdmin,
+    admin: ContractAddress,
+    price_feed: ContractAddress,
+    first_worker_fee_lib: ContractAddress,
+    second_worker_fee_lib: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, ..,
+    } =
+        deploy_worker_base_with_additional_roles(
+            array![].span(), price_feed, role_admin, array![admin].span(),
+        );
+
+    // Caller has admin role
+    start_cheat_caller_address(worker, admin);
+
+    // First worker fee_lib update
+    dispatcher.set_worker_fee_lib(first_worker_fee_lib);
+    let fee_lib = dispatcher.get_worker_fee_lib();
+    assert(fee_lib == first_worker_fee_lib, 'First update should succeed');
+
+    // Second worker fee_lib update
+    dispatcher.set_worker_fee_lib(second_worker_fee_lib);
+    let fee_lib = dispatcher.get_worker_fee_lib();
+    assert(fee_lib == second_worker_fee_lib, 'Second update should succeed');
+
+    stop_cheat_caller_address(worker);
+}
+
+/// Get worker fee_lib returns zero address by default
+#[test]
+#[fuzzer(runs: 10)]
+fn get_worker_fee_lib_returns_zero_by_default(role_admin: RoleAdmin, price_feed: ContractAddress) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock { dispatcher, .. } = deploy_worker_base(price_feed, role_admin);
+
+    // Should return zero address by default
+    assert!(
+        dispatcher.get_worker_fee_lib() == ZERO_ADDRESS,
+        "Worker fee_lib should be zero address by default",
+    );
+}
+
+////////////////////////////
+// Renouncing roles tests //
+////////////////////////////
+
+/// Renouncing roles is disabled
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn renounce_roles_disabled(
+    role_admin: RoleAdmin, admin: ContractAddress, price_feed: ContractAddress,
+) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, access_control, safe_access_control, ..,
+    } = deploy_worker_base(price_feed, role_admin);
+
+    // Caller is the role admin
+    start_cheat_caller_address(worker, role_admin);
+    let res = safe_access_control.renounce_role(DEFAULT_ADMIN_ROLE, role_admin);
+    stop_cheat_caller_address(worker);
+
+    // Should panic with renouncing role error because role admin cannot renounce role
+    assert_panic_with_error(res, errors::err_role_renouncing_disabled());
+
+    // Check that admin does not have the admin role
+    assert(access_control.has_role(DEFAULT_ADMIN_ROLE, role_admin), 'Role should not be renounced');
+}
+
+////////////////////
+// Pausable tests //
+////////////////////
+
+/// Default admin can pause the contract
+#[test]
+#[fuzzer(runs: 10)]
+fn pause_succeeds_when_default_admin(role_admin: RoleAdmin, price_feed: ContractAddress) {
+    let role_admin = role_admin.address;
+    let WorkerBaseMock {
+        worker, dispatcher, access_control, ..,
+    } = deploy_worker_base(price_feed, role_admin);
+
+    let mut spy = spy_events();
+
+    // Caller has default admin role
+    assert!(
+        access_control.has_role(DEFAULT_ADMIN_ROLE, role_admin),
+        "Role admin should have default admin role",
+    );
+    start_cheat_caller_address(worker, role_admin);
+    dispatcher.pause();
+    stop_cheat_caller_address(worker);
+
+    // Check that contract is paused
+    let pausable_dispatcher = IPausableDispatcher { contract_address: worker };
+    assert(pausable_dispatcher.is_paused(), 'Contract should be paused');
+
+    // Verify Paused event was emitted
+    let expected_event = PausableComponent::Event::Paused(
+        PausableComponent::Paused { account: role_admin },
+    );
+    spy.assert_emitted(@array![(worker, expected_event)]);
+}
+
+/// Non-default admin cannot pause the contract
+#[test]
+#[fuzzer(runs: 10)]
+#[feature("safe_dispatcher")]
+fn pause_fails_when_not_default_admin(
+    role_admin: RoleAdmin, price_feed: ContractAddress, not_default_admin: ContractAddress,
+) {
+    // Ensure that role_admin and not_default_admin are different
+    let role_admin = role_admin.address;
+    if role_admin == not_default_admin {
+        return;
+    }
+
+    let WorkerBaseMock {
+        worker, safe_dispatcher, access_control, ..,
+    } = deploy_worker_base(price_feed, role_admin);
+
+    // Caller does not have default admin role
+    assert!(
+        !access_control.has_role(DEFAULT_ADMIN_ROLE, not_default_admin),
+        "Caller should not have default admin role",
+    );
+    start_cheat_caller_address(worker, not_default_admin);
+    let res = safe_dispatcher.pause();
+    stop_cheat_caller_address(worker);
+
+    // Check that contract is not paused
+    let pausable_dispatcher = IPausableDispatcher { contract_address: worker };
+    assert(!pausable_dispatcher.is_paused(), 'Contract should not be paused');
+
+    // Should panic with missing role error because not_default_admin does not have default admin
+    // role
+    assert_panic_with_felt_error(res, AccessControlComponent::Errors::MISSING_ROLE);
+}