feat(interchain-token): update interchain token

Cargo.toml

@@ -12,6 +12,7 @@ rust-version = "1.81.0"
 
 [workspace.dependencies]
 soroban-sdk = { version = "22.0.0-rc.3" }
+soroban-token-sdk = { version = "22.0.0-rc.3" }
 axelar-soroban-std = { version = "^0.1.0", path = "packages/axelar-soroban-std" }
 axelar-gas-service = { version = "^0.1.0", path = "contracts/axelar-gas-service" }
 axelar-gateway = { version = "^0.1.0", path = "contracts/axelar-gateway" }

contracts/interchain-token/Cargo.toml

@@ -9,6 +9,7 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 axelar-soroban-std = { workspace = true }
 soroban-sdk = { workspace = true }
+soroban-token-sdk = { workspace = true }
 
 [dev-dependencies]
 axelar-soroban-std = { workspace = true, features = ["testutils"] }

contracts/interchain-token/src/contract.rs

@@ -1,16 +1,42 @@
 use axelar_soroban_std::ensure;
-use soroban_sdk::{contract, contractimpl, Address, Env};
+use soroban_sdk::token::{self, Interface as _};
+use soroban_sdk::{contract, contractimpl, Address, Bytes, Env, IntoVal, String};
+use soroban_token_sdk::metadata::TokenMetadata;
+use soroban_token_sdk::TokenUtils;
 
 use crate::error::ContractError;
 use crate::event;
 use crate::storage_types::DataKey;
+use crate::utils::{
+    admin, check_nonnegative_amount, extend_instance_ttl, read_allowance, read_balance,
+    read_decimal, read_name, read_symbol, receive_balance, spend_allowance, spend_balance,
+    write_allowance, write_metadata,
+};
 
 #[contract]
 pub struct InterchainToken;
 
 #[contractimpl]
 impl InterchainToken {
-    pub fn initialize(env: Env, owner: Address) -> Result<(), ContractError> {
+    pub fn initialize_interchain_token(
+        env: Env,
+        interchain_token_service: Address,
+        admin: Address,
+        minter: Address,
+        token_id: Bytes,
+        token_meta_data: TokenMetadata,
+    ) -> Result<(), ContractError> {
+        ensure!(!token_id.is_empty(), ContractError::TokenIdZero);
+        ensure!(token_meta_data.decimal <= 18, ContractError::InvalidDecimal);
+        ensure!(
+            !token_meta_data.name.is_empty(),
+            ContractError::TokenNameEmpty
+        );
+        ensure!(
+            !token_meta_data.symbol.is_empty(),
+            ContractError::TokenSymbolEmpty
+        );
+
         ensure!(
             env.storage()
                 .instance()
@@ -20,27 +46,171 @@ impl InterchainToken {
         );
 
         env.storage().instance().set(&DataKey::Initialized, &true);
+        env.storage().instance().set(&DataKey::TokenId, &token_id);
+        write_metadata(&env, token_meta_data);
 
-        env.storage().instance().set(&DataKey::Owner, &owner);
+        env.storage().instance().set(&DataKey::Admin, &admin);
+        env.storage()
+            .persistent()
+            .set(&DataKey::Minter(minter), &true);
+        env.storage()
+            .persistent()
+            .set(&DataKey::Minter(interchain_token_service.clone()), &true);
+
+        env.storage().instance().set(
+            &DataKey::InterchainTokenServiceAddress,
+            &interchain_token_service,
+        );
 
         Ok(())
     }
 
-    pub fn owner(env: &Env) -> Result<Address, ContractError> {
+    pub fn token_id(env: &Env) -> Address {
+        env.storage().instance().get(&DataKey::TokenId).unwrap()
+    }
+
+    pub fn interchain_token_service(env: &Env) -> Address {
         env.storage()
             .instance()
-            .get(&DataKey::Owner)
-            .ok_or(ContractError::NotInitialized)
+            .get(&DataKey::InterchainTokenServiceAddress)
+            .unwrap()
     }
 
-    pub fn transfer_ownership(env: Env, new_owner: Address) -> Result<(), ContractError> {
-        let owner: Address = Self::owner(&env)?;
-        owner.require_auth();
+    pub fn mint(env: Env, minter: Address, to: Address, amount: i128) -> Result<(), ContractError> {
+        minter.require_auth_for_args((&to, amount).into_val(&env));
+
+        check_nonnegative_amount(amount);
 
-        env.storage().instance().set(&DataKey::Owner, &new_owner);
+        let admin = admin(&env);
+        if admin != minter {
+            let is_authorized = env
+                .storage()
+                .persistent()
+                .get::<_, bool>(&DataKey::Minter(minter))
+                .unwrap_or(false);
 
-        event::transfer_ownership(&env, owner, new_owner);
+            if !is_authorized {
+                return Err(ContractError::NotAuthorizedMinter);
+            }
+        }
+
+        extend_instance_ttl(&env);
+
+        receive_balance(&env, to.clone(), amount);
+        TokenUtils::new(&env).events().mint(admin, to, amount);
 
         Ok(())
     }
+
+    pub fn set_admin(env: Env, new_admin: Address) {
+        let admin = admin(&env);
+        admin.require_auth();
+
+        extend_instance_ttl(&env);
+
+        env.storage().instance().set(&DataKey::Admin, &admin);
+        TokenUtils::new(&env)
+            .events()
+            .set_admin(admin.clone(), new_admin.clone());
+
+        event::set_admin(&env, admin, new_admin);
+    }
+
+    pub fn add_minter(env: &Env, minter: Address) {
+        admin(env).require_auth();
+
+        env.storage()
+            .persistent()
+            .set(&DataKey::Minter(minter.clone()), &true);
+
+        event::add_minter(env, minter);
+    }
+}
+
+#[contractimpl]
+impl token::Interface for InterchainToken {
+    fn allowance(env: Env, from: Address, spender: Address) -> i128 {
+        extend_instance_ttl(&env);
+        read_allowance(&env, from, spender).amount
+    }
+
+    fn approve(env: Env, from: Address, spender: Address, amount: i128, expiration_ledger: u32) {
+        from.require_auth();
+
+        check_nonnegative_amount(amount);
+        extend_instance_ttl(&env);
+
+        write_allowance(
+            &env,
+            from.clone(),
+            spender.clone(),
+            amount,
+            expiration_ledger,
+        );
+
+        TokenUtils::new(&env)
+            .events()
+            .approve(from, spender, amount, expiration_ledger);
+    }
+
+    fn balance(env: Env, id: Address) -> i128 {
+        extend_instance_ttl(&env);
+        read_balance(&env, id)
+    }
+
+    fn transfer(env: Env, from: Address, to: Address, amount: i128) {
+        from.require_auth();
+
+        check_nonnegative_amount(amount);
+        extend_instance_ttl(&env);
+
+        spend_balance(&env, from.clone(), amount);
+        receive_balance(&env, to.clone(), amount);
+        TokenUtils::new(&env).events().transfer(from, to, amount);
+    }
+
+    fn transfer_from(env: Env, spender: Address, from: Address, to: Address, amount: i128) {
+        spender.require_auth();
+
+        check_nonnegative_amount(amount);
+        extend_instance_ttl(&env);
+
+        spend_allowance(&env, from.clone(), spender, amount);
+        spend_balance(&env, from.clone(), amount);
+        receive_balance(&env, to.clone(), amount);
+        TokenUtils::new(&env).events().transfer(from, to, amount)
+    }
+
+    fn burn(env: Env, from: Address, amount: i128) {
+        from.require_auth();
+
+        check_nonnegative_amount(amount);
+        extend_instance_ttl(&env);
+
+        spend_balance(&env, from.clone(), amount);
+        TokenUtils::new(&env).events().burn(from, amount);
+    }
+
+    fn burn_from(env: Env, spender: Address, from: Address, amount: i128) {
+        spender.require_auth();
+
+        check_nonnegative_amount(amount);
+        extend_instance_ttl(&env);
+
+        spend_allowance(&env, from.clone(), spender, amount);
+        spend_balance(&env, from.clone(), amount);
+        TokenUtils::new(&env).events().burn(from, amount)
+    }
+
+    fn decimals(env: Env) -> u32 {
+        read_decimal(&env)
+    }
+
+    fn name(env: Env) -> String {
+        read_name(&env)
+    }
+
+    fn symbol(env: Env) -> String {
+        read_symbol(&env)
+    }
 }

contracts/interchain-token/src/error.rs

@@ -4,6 +4,10 @@ use soroban_sdk::contracterror;
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 #[repr(u32)]
 pub enum ContractError {
-    NotInitialized = 1,
-    AlreadyInitialized = 2,
+    AlreadyInitialized = 1,
+    InvalidDecimal = 2,
+    TokenIdZero = 3,
+    TokenNameEmpty = 4,
+    TokenSymbolEmpty = 5,
+    NotAuthorizedMinter = 6,
 }

contracts/interchain-token/src/event.rs

@@ -1,10 +1,11 @@
 use soroban_sdk::{Address, Env, Symbol};
 
-pub fn transfer_ownership(env: &Env, previous_owner: Address, new_owner: Address) {
-    let topics = (
-        Symbol::new(env, "ownership_transferred"),
-        previous_owner,
-        new_owner,
-    );
+pub fn set_admin(env: &Env, previous_admin: Address, new_admin: Address) {
+    let topics = (Symbol::new(env, "set_admin"), previous_admin, new_admin);
+    env.events().publish(topics, ());
+}
+
+pub fn add_minter(env: &Env, minter: Address) {
+    let topics = (Symbol::new(env, "add_minter"), minter);
     env.events().publish(topics, ());
 }

contracts/interchain-token/src/lib.rs

@@ -1,9 +1,14 @@
 #![no_std]
 
+pub mod contract;
 pub mod error;
 mod event;
 mod storage_types;
+mod utils;
 
-pub mod contract;
+// Allows using std (and its macros) in test modules
+#[cfg(test)]
+#[macro_use]
+extern crate std;
 
-pub use contract::InterchainTokenClient;
+pub use crate::contract::InterchainTokenClient;

contracts/interchain-token/src/storage_types.rs

@@ -1,8 +1,34 @@
-use soroban_sdk::contracttype;
+use soroban_sdk::{contracttype, Address};
+
+pub const DAY_IN_LEDGERS: u32 = 17280;
+pub const INSTANCE_BUMP_AMOUNT: u32 = 7 * DAY_IN_LEDGERS;
+pub const INSTANCE_LIFETIME_THRESHOLD: u32 = INSTANCE_BUMP_AMOUNT - DAY_IN_LEDGERS;
+
+pub const BALANCE_BUMP_AMOUNT: u32 = 30 * DAY_IN_LEDGERS;
+pub const BALANCE_LIFETIME_THRESHOLD: u32 = BALANCE_BUMP_AMOUNT - DAY_IN_LEDGERS;
+
+#[derive(Clone)]
+#[contracttype]
+pub struct AllowanceDataKey {
+    pub from: Address,
+    pub spender: Address,
+}
+
+#[contracttype]
+pub struct AllowanceValue {
+    pub amount: i128,
+    pub expiration_ledger: u32,
+}
 
 #[contracttype]
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum DataKey {
     Initialized,
-    Owner,
+    Allowance(AllowanceDataKey),
+    Balance(Address),
+    State(Address),
+    Admin,
+    Minter(Address),
+    TokenId,
+    InterchainTokenServiceAddress,
 }