Contract reference

// Canonical coins: register a coin whose home chain is Sui.
public fun register_coin_from_metadata<T>(
    self: &mut InterchainTokenService,
    metadata: &CoinMetadata<T>,
    coin_management: CoinManagement<T>,
): TokenId;

// Same, with values you supply. ITS doesn't check them against the coin.
public fun register_coin_from_info<T>(
    self: &mut InterchainTokenService,
    name: std::string::String,
    symbol: String,
    decimals: u8,
    coin_management: CoinManagement<T>,
): TokenId;

// Deploys an interchain token, with no minter, for a canonical coin. Aborts for custom coins.
public fun deploy_remote_interchain_token<T>(
    self: &InterchainTokenService,
    token_id: TokenId,
    destination_chain: String,
): MessageTicket;

// Sends the coin's type and decimals to the ITS Hub.
public fun register_coin_metadata<T>(self: &InterchainTokenService, coin_metadata: &CoinMetadata<T>): MessageTicket;

// Registers a custom coin under a token ID derived from `deployer` and `salt`.
// Returns a reclaimer if `coin_management` has the TreasuryCap.
public fun register_custom_coin<T>(
    self: &mut InterchainTokenService,
    deployer: &Channel,
    salt: Bytes32,
    coin_metadata: &CoinMetadata<T>,
    coin_management: CoinManagement<T>,
    ctx: &mut TxContext,
): (TokenId, Option<TreasuryCapReclaimer<T>>);

// Links the custom coin registered by `deployer` with `salt` to a token on `destination_chain`.
public fun link_coin(
    self: &InterchainTokenService,
    deployer: &Channel,
    salt: Bytes32,
    destination_chain: String,
    destination_token_address: vector<u8>,
    token_manager_type: TokenManagerType, // token_manager_type::lock_unlock() or mint_burn()
    link_params: vector<u8>, // the destination operator, or empty
): MessageTicket;

// Holds a coin for a link from another chain, under that chain's token ID.
// With a TreasuryCap, returns a reclaimer and a distributor channel.
public fun give_unlinked_coin<T>(
    self: &mut InterchainTokenService,
    token_id: TokenId,
    coin_metadata: &CoinMetadata<T>,
    treasury_cap: Option<TreasuryCap<T>>,
    ctx: &mut TxContext,
): (Option<TreasuryCapReclaimer<T>>, Option<Channel>);

// Returns the TreasuryCap of a coin given with give_unlinked_coin that was never linked.
public fun remove_unlinked_coin<T>(
    self: &mut InterchainTokenService,
    treasury_cap_reclaimer: TreasuryCapReclaimer<T>,
): TreasuryCap<T>;

// Puts the whole coin in a ticket. `source_channel` is the sender.
public fun prepare_interchain_transfer<T>(
    token_id: TokenId,
    coin: Coin<T>,
    destination_chain: String,
    destination_address: vector<u8>,
    metadata: vector<u8>,
    source_channel: &Channel,
): InterchainTransferTicket<T>;

// Locks or burns the coins, and applies the flow limit.
public fun send_interchain_transfer<T>(
    self: &mut InterchainTokenService,
    ticket: InterchainTransferTicket<T>,
    clock: &Clock,
): MessageTicket;

// Called by relayers: unlocks or mints the coins, and sends them to the destination address.
public fun receive_interchain_transfer<T>(
    self: &mut InterchainTokenService,
    approved_message: ApprovedMessage,
    clock: &Clock,
    ctx: &mut TxContext,
);

// For transfers with data: called by the package that holds `channel`, the destination.
// Returns (source_chain, source_address, data, coins).
public fun receive_interchain_transfer_with_data<T>(
    self: &mut InterchainTokenService,
    approved_message: ApprovedMessage,
    channel: &Channel,
    clock: &Clock,
    ctx: &mut TxContext,
): (String, vector<u8>, vector<u8>, Coin<T>);

// No abilities: send it in the transaction that prepares it
public struct InterchainTransferTicket<phantom T> {
    token_id: TokenId,
    balance: Balance<T>,
    source_address: address, // the source channel's ID
    destination_chain: String,
    destination_address: vector<u8>, // e.g. an EVM address's 20 bytes, or a Sui address's 32
    metadata: vector<u8>,
    version: u64,
}

public fun registered_coin_type(self: &InterchainTokenService, token_id: TokenId): &TypeName;
public fun registered_coin_data<T>(self: &InterchainTokenService, token_id: TokenId): &CoinData<T>;
public fun channel_address(self: &InterchainTokenService): address; // ITS's own channel

// Mint and burn: ITS holds the TreasuryCap.
public fun new_with_cap<T>(treasury_cap: TreasuryCap<T>): CoinManagement<T>;

// Lock and unlock: ITS holds the locked coins.
public fun new_locked<T>(): CoinManagement<T>;

// Before registering only. Aborts without a TreasuryCap.
public fun add_distributor<T>(self: &mut CoinManagement<T>, distributor: address);

// Before registering only.
public fun add_operator<T>(self: &mut CoinManagement<T>, operator: address);

module its_receiver::receiver;

use axelar_gateway::channel::{Self, ApprovedMessage, Channel};
use interchain_token_service::discovery as its_discovery;
use interchain_token_service::interchain_token_service::InterchainTokenService;
use relayer_discovery::discovery::RelayerDiscovery;
use relayer_discovery::transaction::{Self, Transaction};
use std::ascii::{Self, String};
use sui::clock::Clock;
use sui::table::{Self, Table};

#[error]
const EUntrustedSender: vector<u8> = b"the sender is not trusted";

public struct Receiver has key {
    id: UID,
    channel: Channel,
    // Source chain name -> sender address on that chain, as bytes
    trusted_senders: Table<String, vector<u8>>,
}

public struct OwnerCap has key, store {
    id: UID,
}

fun init(ctx: &mut TxContext) {
    transfer::share_object(Receiver {
        id: object::new(ctx),
        channel: channel::new(ctx),
        trusted_senders: table::new(ctx),
    });
    transfer::transfer(OwnerCap { id: object::new(ctx) }, ctx.sender());
}

public fun set_trusted_sender(
    self: &mut Receiver,
    _: &OwnerCap,
    source_chain: String,
    source_address: vector<u8>,
) {
    if (self.trusted_senders.contains(source_chain)) {
        self.trusted_senders.remove(source_chain);
    };
    self.trusted_senders.add(source_chain, source_address);
}

// Tells relayers to call `get_final_transaction` with the message payload.
public fun register_transaction(
    self: &Receiver,
    _: &OwnerCap,
    discovery: &mut RelayerDiscovery,
    its: &InterchainTokenService,
) {
    let arguments = vector[object_arg(object::id_address(self)), object_arg(object::id_address(its)), vector[3]];
    let tx = transaction::new_transaction(
        false,
        vector[
            transaction::new_move_call(
                transaction::new_function(
                    transaction::package_id<Receiver>(),
                    ascii::string(b"receiver"),
                    ascii::string(b"get_final_transaction"),
                ),
                arguments,
                vector[],
            ),
        ],
    );
    discovery.register_transaction(&self.channel, tx);
}

// Relayers simulate this to learn the coin type, then call `receive<T>`.
public fun get_final_transaction(self: &Receiver, its: &InterchainTokenService, payload: vector<u8>): Transaction {
    let (token_id, _, _, _) = its_discovery::interchain_transfer_info(payload);
    let coin_type = (*its.registered_coin_type(token_id)).into_string();
    let arguments = vector[
        vector[2],
        object_arg(object::id_address(self)),
        object_arg(object::id_address(its)),
        object_arg(@0x6),
    ];
    transaction::new_transaction(
        true,
        vector[
            transaction::new_move_call(
                transaction::new_function(
                    transaction::package_id<Receiver>(),
                    ascii::string(b"receiver"),
                    ascii::string(b"receive"),
                ),
                arguments,
                vector[coin_type],
            ),
        ],
    )
}

public fun receive<T>(
    approved_message: ApprovedMessage,
    self: &Receiver,
    its: &mut InterchainTokenService,
    clock: &Clock,
    ctx: &mut TxContext,
) {
    let (source_chain, source_address, data, coin) = its.receive_interchain_transfer_with_data<T>(
        approved_message,
        &self.channel,
        clock,
        ctx,
    );
    assert!(
        self.trusted_senders.contains(source_chain) && self.trusted_senders[source_chain] == source_address,
        EUntrustedSender,
    );

    // Your logic. Here, `data` is the Sui address to send the coins to.
    transfer::public_transfer(coin, sui::address::from_bytes(data));
}

public fun channel_address(self: &Receiver): address {
    self.channel.to_address()
}

fun object_arg(id: address): vector<u8> {
    let mut arg = vector[0];
    arg.append(id.to_bytes());
    arg
}

public fun mint_as_distributor<T>(self: &mut InterchainTokenService, channel: &Channel, token_id: TokenId, amount: u64, ctx: &mut TxContext): Coin<T>;
public fun mint_to_as_distributor<T>(self: &mut InterchainTokenService, channel: &Channel, token_id: TokenId, to: address, amount: u64, ctx: &mut TxContext);
public fun burn_as_distributor<T>(self: &mut InterchainTokenService, channel: &Channel, token_id: TokenId, coin: Coin<T>);

public fun set_flow_limit_as_token_operator<T>(self: &mut InterchainTokenService, channel: &Channel, token_id: TokenId, limit: Option<u64>);

// Pass the role on. `option::none()` removes it for good.
public fun transfer_distributorship<T>(self: &mut InterchainTokenService, channel: &Channel, token_id: TokenId, new_distributor: Option<address>);
public fun transfer_operatorship<T>(self: &mut InterchainTokenService, channel: &Channel, token_id: TokenId, new_operator: Option<address>);

sui client ptb \
  --move-call $ITS_PKG::token_id::from_address @$TOKEN_ID --assign token_id \
  --move-call 0x1::option::some "<u64>" 1000000 --assign limit \
  --move-call $ITS_PKG::interchain_token_service::set_flow_limit_as_token_operator "<$COIN>" \
    @$ITS @$OPERATOR_CHANNEL token_id limit

// Returns the TreasuryCap. ITS can then no longer send or receive the coin.
public fun remove_treasury_cap<T>(self: &mut InterchainTokenService, treasury_cap_reclaimer: TreasuryCapReclaimer<T>): TreasuryCap<T>;

// Gives the TreasuryCap back to ITS, and returns a new reclaimer.
public fun restore_treasury_cap<T>(self: &mut InterchainTokenService, treasury_cap: TreasuryCap<T>, token_id: TokenId, ctx: &mut TxContext): TreasuryCapReclaimer<T>;