Contract reference

// Deploys an interchain token on Stellar, and mints `initial_supply` to `caller`.
// The token ID comes from `caller` and `salt`. `minter` is an optional extra minter;
// with none, `initial_supply` must be more than 0. `caller` must authorize.
fn deploy_interchain_token(
    env: Env,
    caller: Address,
    salt: BytesN<32>,
    token_metadata: TokenMetadata, // { decimal, name, symbol }
    initial_supply: i128,
    minter: Option<Address>,
) -> Result<BytesN<32>, ContractError>;

// Deploys the interchain token of `caller` and `salt` on another chain, with no minter.
// `caller` must authorize.
fn deploy_remote_interchain_token(
    env: Env,
    caller: Address,
    salt: BytesN<32>,
    destination_chain: String,
    gas_token: Option<Token>,
) -> Result<BytesN<32>, ContractError>;

// Registers an existing Stellar token as a canonical token, with a LockUnlock token manager.
// Anyone can call it.
fn register_canonical_token(env: Env, token_address: Address) -> Result<BytesN<32>, ContractError>;

// Deploys a canonical token on another chain, with no minter. `spender` pays the gas.
fn deploy_remote_canonical_token(
    env: Env,
    token_address: Address,
    destination_chain: String,
    spender: Address,
    gas_token: Option<Token>,
) -> Result<BytesN<32>, ContractError>;

// Sends a token's address and decimals to the ITS Hub, before linking it. `spender` pays the gas.
fn register_token_metadata(
    env: Env,
    token_address: Address,
    spender: Address,
    gas_token: Option<Token>,
) -> Result<(), ContractError>;

// Registers a custom token on Stellar, with a token manager of the given type
// (not NativeInterchainToken). The token ID comes from `deployer` and `salt`.
// `deployer` must authorize.
fn register_custom_token(
    env: Env,
    deployer: Address,
    salt: BytesN<32>,
    token_address: Address,
    token_manager_type: TokenManagerType,
) -> Result<BytesN<32>, ContractError>;

// Links a token on another chain to the custom token of `deployer` and `salt`.
// `token_manager_type` and `link_params` are for the destination chain.
// `deployer` must authorize, and pays the gas.
fn link_token(
    env: Env,
    deployer: Address,
    salt: BytesN<32>,
    destination_chain: String,
    destination_token_address: Bytes,
    token_manager_type: TokenManagerType,
    link_params: Option<Bytes>,
    gas_token: Option<Token>,
) -> Result<BytesN<32>, ContractError>;

// Burns or locks `amount` of `caller`'s tokens and sends them to `destination_address`.
// With `data`, ITS on the destination chain then calls the recipient contract with it.
// `caller` must authorize, and pays the gas.
fn interchain_transfer(
    env: Env,
    caller: Address,
    token_id: BytesN<32>,
    destination_chain: String,
    destination_address: Bytes,
    amount: i128,
    data: Option<Bytes>,
    gas_token: Option<Token>,
) -> Result<(), ContractError>;

fn interchain_token_id(env: Env, deployer: Address, salt: BytesN<32>) -> BytesN<32>;
fn canonical_interchain_token_id(env: Env, token_address: Address) -> BytesN<32>;
fn linked_token_id(env: Env, deployer: Address, salt: BytesN<32>) -> BytesN<32>;

fn registered_token_address(env: Env, token_id: BytesN<32>) -> Address;
fn deployed_token_manager(env: Env, token_id: BytesN<32>) -> Address;
fn token_manager_type(env: Env, token_id: BytesN<32>) -> TokenManagerType;

fn is_trusted_chain(env: Env, chain: String) -> bool;
fn chain_name(env: Env) -> String;
fn native_token_address(env: Env) -> Address; // XLM
fn gas_service(env: Env) -> Address;

fn flow_limit(env: Env, token_id: BytesN<32>) -> Option<i128>;
fn flow_out_amount(env: Env, token_id: BytesN<32>) -> i128; // sent out in the current window
fn flow_in_amount(env: Env, token_id: BytesN<32>) -> i128; // received in the current window
fn is_flow_limiter(env: Env, token_id: BytesN<32>, flow_limiter: Address) -> bool;

// `caller` must be ITS's operator or an approved flow limiter of the token, and authorize.
fn set_flow_limit(
    env: Env,
    caller: Address,
    token_id: BytesN<32>,
    flow_limit: Option<i128>,
) -> Result<(), ContractError>;

pub trait CustomInterchainTokenExecutable {
    type Error: Into<stellar_axelar_std::Error>;

    // Returns the ITS address
    fn __interchain_token_service(env: &Env) -> Address;

    // Your logic, called after ITS has given the tokens to your contract
    fn __authorized_execute_with_token(
        env: &Env,
        source_chain: String,
        message_id: String,
        source_address: Bytes,
        payload: Bytes,
        token_id: BytesN<32>,
        token_address: Address,
        amount: i128,
    ) -> Result<(), Self::Error>;
}