stellar-axelar-std 2.0.0

Standard libraries for Axelar contracts.
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

// this is only needed in this crate itself, any crate that imports this one doesn't have to do this manual import resolution
use stellar_axelar_std::{
    contract, contracterror, contractimpl, contracttype, Address, Env, String,
};
use stellar_axelar_std_derive::{Ownable, Upgradable};

use crate as stellar_axelar_std;
use crate::interfaces::testdata::contract_trivial_migration::DataKey;
use crate::interfaces::{operatable, ownable, CustomMigratableInterface};

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

#[contracttype]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct MigrationData {
    pub data1: String,
    pub data2: bool,
    pub data3: u32,
}

#[contractimpl]
impl ContractNonTrivial {
    pub fn __constructor(env: Env, owner: Option<Address>, operator: Option<Address>) {
        if let Some(owner) = owner {
            ownable::set_owner(&env, &owner);
        }

        if let Some(operator) = operator {
            operatable::set_operator(&env, &operator);
        }
    }

    pub fn migration_data(env: &Env) -> Option<String> {
        env.storage().instance().get(&DataKey::Data)
    }
}

impl CustomMigratableInterface for ContractNonTrivial {
    type MigrationData = MigrationData;
    type Error = ContractError;

    fn __migrate(env: &Env, migration_data: MigrationData) -> Result<(), Self::Error> {
        env.storage()
            .instance()
            .set(&DataKey::Data, &migration_data.data1);

        Ok(())
    }
}

#[contracterror]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum ContractError {
    MigrationNotAllowed = 1,
    MigrationInProgress = 2,
}