stellar-interchain-token-service 0.2.0

Contract related to Interchain Token Service.
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

mod utils;

use soroban_sdk::testutils::Address as _;
use soroban_sdk::xdr::ToXdr;
use soroban_sdk::{Address, BytesN};
use stellar_axelar_std::address::AddressExt;
use stellar_axelar_std::{assert_contract_err, events};
use stellar_interchain_token_service::error::ContractError;
use stellar_interchain_token_service::event::InterchainTokenIdClaimedEvent;
use stellar_interchain_token_service::types::TokenManagerType;
use utils::setup_env;

#[test]
fn register_canonical_token_succeeds() {
    let (env, client, _, _, _) = setup_env();
    let token_address = Address::generate(&env);
    let expected_deploy_salt = client.canonical_token_deploy_salt(&token_address);
    let expected_id = client.interchain_token_id(&Address::zero(&env), &expected_deploy_salt);

    assert_eq!(client.register_canonical_token(&token_address), expected_id);
    goldie::assert!(events::fmt_last_emitted_event::<
        InterchainTokenIdClaimedEvent,
    >(&env));

    assert_eq!(client.token_address(&expected_id), token_address);
    assert_eq!(
        client.token_manager_type(&expected_id),
        TokenManagerType::LockUnlock
    );
}

#[test]
fn register_canonical_token_fails_when_paused() {
    let (env, client, _, _, _) = setup_env();

    client.mock_all_auths().set_pause_status(&true);

    assert_contract_err!(
        client.try_register_canonical_token(&Address::generate(&env)),
        ContractError::ContractPaused
    );
}

#[test]
fn register_canonical_token_fails_if_already_registered() {
    let (env, client, _, _, _) = setup_env();
    let token_address = Address::generate(&env);

    client.register_canonical_token(&token_address);

    assert_contract_err!(
        client.try_register_canonical_token(&token_address),
        ContractError::TokenAlreadyRegistered
    );
}

#[test]
fn canonical_token_id_derivation() {
    let (env, client, _, _, _) = setup_env();
    let token_address = Address::generate(&env);

    let chain_name = client.chain_name();
    let chain_name_hash: BytesN<32> = env.crypto().keccak256(&(chain_name).to_xdr(&env)).into();
    let deploy_salt = client.canonical_token_deploy_salt(&token_address);

    let token_id = client.interchain_token_id(&Address::zero(&env), &deploy_salt);

    goldie::assert_json!(vec![
        hex::encode(chain_name_hash.to_array()),
        hex::encode(deploy_salt.to_array()),
        hex::encode(token_id.to_array())
    ]);
}