stellar-axelar-operators 1.1.3

AxelarOperators contract, responsible for managing operators and enabling invoking functions with access control and upgradeability.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use stellar_axelar_std::events::Event;
use stellar_axelar_std::{
    contract, contractimpl, ensure, interfaces, only_owner, soroban_sdk, Address, Env, Ownable,
    Symbol, Upgradable, Val, Vec,
};

use crate::error::ContractError;
use crate::event::{OperatorAddedEvent, OperatorRemovedEvent};
use crate::interface::AxelarOperatorsInterface;
use crate::storage;

#[contract]
#[derive(Ownable, Upgradable)]
pub struct AxelarOperators;

#[contractimpl]
impl AxelarOperators {
    pub fn __constructor(env: Env, owner: Address) {
        interfaces::set_owner(&env, &owner);
    }
}

#[contractimpl]
impl AxelarOperatorsInterface for AxelarOperators {
    fn is_operator(env: Env, account: Address) -> bool {
        storage::is_operator(&env, account)
    }

    #[only_owner]
    fn add_operator(env: Env, account: Address) -> Result<(), ContractError> {
        ensure!(
            !storage::is_operator(&env, account.clone()),
            ContractError::OperatorAlreadyAdded
        );

        storage::set_operator_status(&env, account.clone());

        OperatorAddedEvent { operator: account }.emit(&env);

        Ok(())
    }

    #[only_owner]
    fn remove_operator(env: Env, account: Address) -> Result<(), ContractError> {
        ensure!(
            storage::is_operator(&env, account.clone()),
            ContractError::NotAnOperator
        );

        storage::remove_operator_status(&env, account.clone());

        OperatorRemovedEvent { operator: account }.emit(&env);

        Ok(())
    }

    fn execute(
        env: Env,
        operator: Address,
        contract: Address,
        func: Symbol,
        args: Vec<Val>,
    ) -> Result<Val, ContractError> {
        operator.require_auth();

        ensure!(
            storage::is_operator(&env, operator),
            ContractError::NotAnOperator
        );

        let res: Val = env.invoke_contract(&contract, &func, args);

        Ok(res)
    }
}