stellar-interchain-token-service 2.0.0

InterchainTokenService contract, responsible for allowing users/developers to easily create their own token bridge.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use stellar_axelar_gas_service::testutils::setup_gas_token;
use stellar_axelar_std::testutils::Address as _;
use stellar_axelar_std::token::StellarAssetClient;
use stellar_axelar_std::{
    assert_auth, assert_auth_err, assert_contract_err, Address, Bytes, BytesN, String,
};

use super::utils::setup_env;
use crate::error::ContractError;
use crate::testutils::setup_its_token;
use crate::types::TokenManagerType;

#[test]
fn transfer_token_admin_succeeds_with_mint_burn_token_manager_type() {
    let (env, client, _gateway, _gas_service, _signers) = setup_env();
    let owner = client.owner();
    let deployer = Address::generate(&env);
    let new_admin = Address::generate(&env);
    let token_owner = Address::generate(&env);
    let token = env.register_stellar_asset_contract_v2(token_owner.clone());
    let salt = BytesN::<32>::from_array(&env, &[1; 32]);
    let destination_chain = String::from_str(&env, "ethereum");
    let destination_token_address = Bytes::from_array(&env, &[2; 32]);
    let token_manager_type = TokenManagerType::MintBurn;
    let gas_token = setup_gas_token(&env, &deployer);

    client.mock_all_auths().register_custom_token(
        &deployer,
        &salt,
        &token.address(),
        &token_manager_type,
    );

    client
        .mock_all_auths()
        .set_trusted_chain(&destination_chain);

    let token_id = client.mock_all_auths().link_token(
        &deployer,
        &salt,
        &destination_chain,
        &destination_token_address,
        &token_manager_type,
        &None::<Bytes>,
        &Some(gas_token),
    );

    let token_address = client.registered_token_address(&token_id);
    let token_client = StellarAssetClient::new(&env, &token_address);
    assert_eq!(token_client.admin(), token_owner);

    let token_manager = client.deployed_token_manager(&token_id);
    assert_auth!(token_owner, token_client.set_admin(&token_manager));
    assert_eq!(token_client.admin(), token_manager);

    assert_auth!(owner, client.transfer_token_admin(&token_id, &new_admin));
    assert_eq!(token_client.admin(), new_admin);
}

#[test]
fn transfer_token_admin_fails_with_invalid_token_manager_types() {
    let (env, client, _gateway, _gas_service, _signers) = setup_env();
    let new_admin = Address::generate(&env);
    let deployer = Address::generate(&env);

    for token_manager_type in [
        TokenManagerType::MintBurnFrom,
        TokenManagerType::LockUnlock,
        TokenManagerType::NativeInterchainToken,
    ]
    .into_iter()
    {
        let token_id = if token_manager_type == TokenManagerType::NativeInterchainToken {
            setup_its_token(&env, &client, &deployer, 1000).0
        } else {
            let salt = BytesN::<32>::from_array(&env, &[token_manager_type as u8; 32]);
            client.mock_all_auths().register_custom_token(
                &deployer,
                &salt,
                &env.register_stellar_asset_contract_v2(deployer.clone())
                    .address(),
                &token_manager_type,
            )
        };

        assert_contract_err!(
            client
                .mock_all_auths()
                .try_transfer_token_admin(&token_id, &new_admin),
            ContractError::InvalidTokenManagerType
        );
    }
}

#[test]
fn transfer_token_admin_fails_with_invalid_token_id() {
    let (env, client, _gateway, _gas_service, _signers) = setup_env();
    let new_admin = Address::generate(&env);

    let invalid_token_id = BytesN::<32>::from_array(&env, &[0u8; 32]);

    assert_contract_err!(
        client
            .mock_all_auths()
            .try_transfer_token_admin(&invalid_token_id, &new_admin),
        ContractError::InvalidTokenId
    );
}

#[test]
fn transfer_token_admin_fails_with_non_owner() {
    let (env, client, _gateway, _gas_service, _signers) = setup_env();
    let deployer = Address::generate(&env);
    let non_owner = Address::generate(&env);
    let new_admin = Address::generate(&env);

    let (token_id, _) = setup_its_token(&env, &client, &deployer, 1000);

    assert_auth_err!(
        non_owner,
        client.transfer_token_admin(&token_id, &new_admin)
    );
}