@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/message-libs/simple-message-lib/src/simple_message_lib.rs

@@ -0,0 +1,136 @@
+use crate::{errors::SimpleMessageLibError, storage::SmlStorage};
+use common_macros::ttl_configurable;
+use endpoint_v2::{
+    FeeRecipient, FeesAndPacket, IMessageLib, ISendLib, LayerZeroEndpointV2Client, MessageLibType, MessageLibVersion,
+    MessagingFee, Origin, OutboundPacket, SetConfigParam,
+};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    address_payload::AddressPayload, assert_with_error, contract, contractimpl, panic_with_error, vec, Address, Bytes,
+    BytesN, Env, Vec,
+};
+use utils::ownable::Ownable;
+
+#[contract]
+#[ttl_configurable]
+pub struct SimpleMessageLib;
+
+#[contractimpl]
+impl SimpleMessageLib {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, fee_recipient: &Address) {
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, endpoint);
+        let local_eid = endpoint_client.eid();
+
+        SmlStorage::set_endpoint(env, endpoint);
+        SmlStorage::set_local_eid(env, &local_eid);
+        SmlStorage::set_zro_fee(env, &99_i128);
+        SmlStorage::set_native_fee(env, &100_i128);
+        SmlStorage::set_fee_recipient(env, fee_recipient);
+        SmlStorage::set_whitelisted_caller(env, owner);
+        Self::__init_owner(env, owner);
+    }
+
+    pub fn validate_packet(env: Env, caller: Address, header_bytes: Bytes, payload_hash: BytesN<32>) {
+        caller.require_auth();
+        assert_with_error!(
+            env,
+            Some(caller) == SmlStorage::whitelisted_caller(&env),
+            SimpleMessageLibError::OnlyWhitelistedCaller
+        );
+
+        let header = packet_codec_v1::decode_packet_header(&env, &header_bytes);
+        let origin = Origin { src_eid: header.src_eid, sender: header.sender, nonce: header.nonce };
+
+        let receiver = Address::from_payload(&env, AddressPayload::ContractIdHash(header.receiver)); // Enforce receiver is a contract address
+        Self::endpoint_client(&env).verify(&env.current_contract_address(), &origin, &receiver, &payload_hash);
+    }
+
+    // === View Functions ===
+
+    pub fn fee_recipient(env: &Env) -> Address {
+        SmlStorage::fee_recipient(env).unwrap()
+    }
+
+    pub fn native_fee(env: &Env) -> i128 {
+        SmlStorage::native_fee(env).unwrap()
+    }
+
+    pub fn zro_fee(env: &Env) -> i128 {
+        SmlStorage::zro_fee(env).unwrap()
+    }
+
+    pub fn whitelisted_caller(env: &Env) -> Address {
+        SmlStorage::whitelisted_caller(env).unwrap()
+    }
+
+    pub fn endpoint(env: &Env) -> Address {
+        SmlStorage::endpoint(env).unwrap()
+    }
+
+    pub fn eid(env: &Env) -> u32 {
+        SmlStorage::local_eid(env).unwrap()
+    }
+
+    pub fn treasury(env: &Env) -> Address {
+        SmlStorage::treasury(env).unwrap()
+    }
+
+    // ==== Internal helpers ====
+
+    fn require_endpoint_auth(env: &Env) {
+        Self::endpoint(env).require_auth();
+    }
+
+    fn endpoint_client(env: &Env) -> LayerZeroEndpointV2Client<'_> {
+        LayerZeroEndpointV2Client::new(env, &Self::endpoint(env))
+    }
+}
+
+#[contractimpl]
+impl IMessageLib for SimpleMessageLib {
+    fn get_config(env: &Env, _eid: u32, _oapp: &Address, _config_type: u32) -> Bytes {
+        panic_with_error!(env, SimpleMessageLibError::NotImplemented);
+    }
+
+    fn is_supported_eid(_env: &Env, _eid: u32) -> bool {
+        true
+    }
+
+    fn message_lib_type(_env: &Env) -> MessageLibType {
+        MessageLibType::SendAndReceive
+    }
+
+    fn set_config(env: &Env, _oapp: &Address, _param: &Vec<SetConfigParam>) {
+        panic_with_error!(env, SimpleMessageLibError::NotImplemented);
+    }
+
+    fn version(_env: &Env) -> MessageLibVersion {
+        MessageLibVersion { major: 0, minor: 0, endpoint_version: 2 }
+    }
+}
+
+#[contractimpl]
+impl ISendLib for SimpleMessageLib {
+    fn quote(env: &Env, _packet: &OutboundPacket, _options: &Bytes, pay_in_zro: bool) -> MessagingFee {
+        MessagingFee { native_fee: Self::native_fee(env), zro_fee: if pay_in_zro { Self::zro_fee(env) } else { 0 } }
+    }
+
+    fn send(env: &Env, packet: &OutboundPacket, _options: &Bytes, pay_in_zro: bool) -> FeesAndPacket {
+        Self::require_endpoint_auth(env);
+
+        let native_fee_recipients =
+            vec![env, FeeRecipient { address: Self::fee_recipient(env), amount: Self::native_fee(env) }];
+
+        let mut zro_fee_recipients = vec![env];
+        if pay_in_zro {
+            zro_fee_recipients
+                .push_back(FeeRecipient { address: Self::fee_recipient(env), amount: Self::zro_fee(env) });
+        }
+
+        FeesAndPacket {
+            native_fee_recipients,
+            zro_fee_recipients,
+            encoded_packet: packet_codec_v1::encode_packet(env, packet),
+        }
+    }
+}

package/contracts/message-libs/simple-message-lib/src/storage.rs

@@ -0,0 +1,27 @@
+use common_macros::storage;
+use soroban_sdk::Address;
+use utils::ttl::DefaultTtlConfigProvider;
+
+#[storage(DefaultTtlConfigProvider)]
+pub enum SmlStorage {
+    #[instance(Address)]
+    Endpoint,
+
+    #[instance(Address)]
+    Treasury,
+
+    #[instance(u32)]
+    LocalEID,
+
+    #[instance(i128)]
+    NativeFee,
+
+    #[instance(i128)]
+    ZROFee,
+
+    #[instance(Address)]
+    FeeRecipient,
+
+    #[instance(Address)]
+    WhitelistedCaller,
+}

package/contracts/message-libs/simple-message-lib/src/test.rs

@@ -0,0 +1,280 @@
+use endpoint_v2::{LayerZeroEndpointV2Client, OutboundPacket};
+use message_lib_common::packet_codec_v1;
+use soroban_sdk::{
+    contract, contractimpl, symbol_short,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, Env, IntoVal,
+};
+
+use crate::simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
+
+#[contract]
+pub struct MockEndpoint;
+
+#[contractimpl]
+impl MockEndpoint {
+    pub fn __constructor(env: Env, native_token: Address) {
+        env.storage().instance().set(&symbol_short!("ntk"), &native_token);
+    }
+
+    pub fn eid(_env: Env) -> u32 {
+        1
+    }
+
+    pub fn native_token(env: Env) -> Address {
+        env.storage().instance().get(&symbol_short!("ntk")).unwrap()
+    }
+
+    pub fn zro(env: Env) -> Option<Address> {
+        env.storage().instance().get(&symbol_short!("zro")).unwrap_or(None)
+    }
+
+    pub fn set_zro(env: Env, zro: Address) {
+        env.storage().instance().set(&symbol_short!("zro"), &zro);
+    }
+}
+
+struct TestSetup<'a> {
+    env: Env,
+    owner: Address,
+    fee_recipient: Address,
+    endpoint: LayerZeroEndpointV2Client<'a>,
+    sml: SimpleMessageLibClient<'a>,
+}
+
+fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let fee_recipient = Address::generate(&env);
+
+    let native_token = env.register_stellar_asset_contract_v2(owner.clone());
+
+    let endpoint = env.register(MockEndpoint, (&native_token.address(),));
+    let endpoint_client = LayerZeroEndpointV2Client::new(&env, &endpoint);
+    let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint, &fee_recipient));
+    let sml = SimpleMessageLibClient::new(&env, &sml_address);
+    TestSetup { env, owner, fee_recipient, endpoint: endpoint_client, sml }
+}
+
+fn create_packet(env: &Env) -> OutboundPacket {
+    OutboundPacket {
+        nonce: 1,
+        src_eid: 2,
+        sender: Address::generate(env),
+        dst_eid: 3,
+        receiver: soroban_sdk::BytesN::from_array(env, &[0u8; 32]),
+        guid: soroban_sdk::BytesN::from_array(env, &[0u8; 32]),
+        message: soroban_sdk::Bytes::from_array(env, b"test"),
+    }
+}
+
+#[test]
+fn test_quote() {
+    let TestSetup { env, sml, endpoint, .. } = setup();
+
+    let packet = OutboundPacket {
+        nonce: 1,
+        src_eid: 2,
+        sender: Address::generate(&env),
+        dst_eid: 3,
+        receiver: soroban_sdk::BytesN::from_array(&env, &[0u8; 32]),
+        guid: soroban_sdk::BytesN::from_array(&env, &[0u8; 32]),
+        message: soroban_sdk::Bytes::from_array(&env, b"test"),
+    };
+    let options = soroban_sdk::Bytes::new(&env);
+    let pay_in_zro = false;
+
+    env.mock_auths(&[MockAuth {
+        address: &endpoint.address,
+        invoke: &MockAuthInvoke {
+            contract: &sml.address,
+            fn_name: "quote",
+            args: (&packet, &options, &pay_in_zro).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let fee = sml.quote(&packet, &options, &pay_in_zro);
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 0);
+}
+
+#[test]
+fn test_send() {
+    let TestSetup { env, sml, endpoint, .. } = setup();
+
+    let packet = OutboundPacket {
+        nonce: 1,
+        src_eid: 2,
+        sender: Address::generate(&env),
+        dst_eid: 3,
+        receiver: soroban_sdk::BytesN::from_array(&env, &[0u8; 32]),
+        guid: soroban_sdk::BytesN::from_array(&env, &[0u8; 32]),
+        message: soroban_sdk::Bytes::from_array(&env, b"test"),
+    };
+    let options = soroban_sdk::Bytes::new(&env);
+    let pay_in_zro = false;
+
+    env.mock_auths(&[MockAuth {
+        address: &endpoint.address,
+        invoke: &MockAuthInvoke {
+            contract: &sml.address,
+            fn_name: "send",
+            args: (&packet, &options, &pay_in_zro).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let send_result = sml.send(&packet, &options, &pay_in_zro);
+    assert_eq!(send_result.native_fee_recipients.len(), 1);
+    assert_eq!(send_result.native_fee_recipients.get(0).unwrap().amount, 100);
+    assert_eq!(send_result.zro_fee_recipients.len(), 0);
+    assert_eq!(send_result.encoded_packet, packet_codec_v1::encode_packet(&env, &packet));
+}
+
+#[test]
+fn test_fee_recipient() {
+    let TestSetup { sml, fee_recipient, .. } = setup();
+
+    // Verify fee recipient is set correctly from constructor
+    let recipient = sml.fee_recipient();
+    assert_eq!(recipient, fee_recipient);
+}
+
+#[test]
+fn test_send_returns_native_fee_recipient() {
+    let TestSetup { env, sml, endpoint, fee_recipient, .. } = setup();
+
+    let packet = create_packet(&env);
+    let options = Bytes::new(&env);
+    let pay_in_zro = false;
+
+    env.mock_auths(&[MockAuth {
+        address: &endpoint.address,
+        invoke: &MockAuthInvoke {
+            contract: &sml.address,
+            fn_name: "send",
+            args: (&packet, &options, &pay_in_zro).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let send_result = sml.send(&packet, &options, &pay_in_zro);
+
+    // Should only have native fee recipient
+    assert_eq!(send_result.native_fee_recipients.len(), 1);
+    assert_eq!(send_result.zro_fee_recipients.len(), 0);
+
+    let native_recipient = send_result.native_fee_recipients.get(0).unwrap();
+    assert_eq!(native_recipient.address, fee_recipient);
+    assert_eq!(native_recipient.amount, 100); // native_fee from setup
+}
+
+#[test]
+fn test_send_returns_both_fee_recipients_with_zro() {
+    let TestSetup { env, sml, endpoint, owner, fee_recipient } = setup();
+
+    // Set up ZRO token
+    let zro = env.register_stellar_asset_contract_v2(owner.clone());
+    let zro_address = zro.address();
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint.address,
+            fn_name: "set_zro",
+            args: (&zro_address,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint.set_zro(&zro_address);
+
+    let packet = create_packet(&env);
+    let options = Bytes::new(&env);
+    let pay_in_zro = true;
+
+    env.mock_auths(&[MockAuth {
+        address: &endpoint.address,
+        invoke: &MockAuthInvoke {
+            contract: &sml.address,
+            fn_name: "send",
+            args: (&packet, &options, &pay_in_zro).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let send_result = sml.send(&packet, &options, &pay_in_zro);
+
+    // Should have both native and ZRO fee recipients
+    assert_eq!(send_result.native_fee_recipients.len(), 1);
+    assert_eq!(send_result.zro_fee_recipients.len(), 1);
+
+    let native_recipient = send_result.native_fee_recipients.get(0).unwrap();
+    assert_eq!(native_recipient.address, fee_recipient);
+    assert_eq!(native_recipient.amount, 100); // native_fee
+
+    let zro_recipient = send_result.zro_fee_recipients.get(0).unwrap();
+    assert_eq!(zro_recipient.address, fee_recipient);
+    assert_eq!(zro_recipient.amount, 99); // zro_fee from setup
+}
+
+#[test]
+fn test_native_fee() {
+    let TestSetup { sml, .. } = setup();
+
+    let native_fee = sml.native_fee();
+    assert_eq!(native_fee, 100);
+}
+
+#[test]
+fn test_zro_fee() {
+    let TestSetup { sml, .. } = setup();
+
+    let zro_fee = sml.zro_fee();
+    assert_eq!(zro_fee, 99);
+}
+
+#[test]
+fn test_quote_with_native_fee_only() {
+    let TestSetup { env, sml, endpoint, .. } = setup();
+
+    let packet = create_packet(&env);
+    let options = Bytes::new(&env);
+    let pay_in_zro = false;
+
+    env.mock_auths(&[MockAuth {
+        address: &endpoint.address,
+        invoke: &MockAuthInvoke {
+            contract: &sml.address,
+            fn_name: "quote",
+            args: (&packet, &options, &pay_in_zro).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let fee = sml.quote(&packet, &options, &pay_in_zro);
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 0);
+}
+
+#[test]
+fn test_quote_with_zro_fee() {
+    let TestSetup { env, sml, endpoint, .. } = setup();
+
+    let packet = create_packet(&env);
+    let options = Bytes::new(&env);
+    let pay_in_zro = true;
+
+    env.mock_auths(&[MockAuth {
+        address: &endpoint.address,
+        invoke: &MockAuthInvoke {
+            contract: &sml.address,
+            fn_name: "quote",
+            args: (&packet, &options, &pay_in_zro).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let fee = sml.quote(&packet, &options, &pay_in_zro);
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 99);
+}

package/contracts/message-libs/treasury/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "treasury"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+doctest = false
+
+[features]
+library = []
+testutils = []
+
+[dependencies]
+cfg-if = { workspace = true }
+soroban-sdk = { workspace = true }
+common-macros = { workspace = true }
+utils = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+message-lib-common = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
+insta = { workspace = true }

package/contracts/message-libs/treasury/src/errors.rs

@@ -0,0 +1,10 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum TreasuryError {
+    InvalidNativeFeeBp,
+    InvalidTotalNativeFee,
+    InvalidZROFee,
+    InvalidZROFeeLib,
+    ZROFeeLibNotSet,
+}

package/contracts/message-libs/treasury/src/events.rs

@@ -0,0 +1,28 @@
+use common_macros::event;
+use soroban_sdk::Address;
+
+/// Emitted when the native fee basis points is updated.
+#[event]
+pub struct NativeFeeBpSet {
+    pub native_fee_bp: u32,
+}
+
+/// Emitted when fee collection is enabled or disabled.
+#[event]
+pub struct FeeEnabledSet {
+    pub fee_enabled: bool,
+}
+
+/// Emitted when the ZRO fee library is set or removed.
+#[event]
+pub struct ZROFeeLibSet {
+    pub zro_fee_lib: Option<Address>,
+}
+
+/// Emitted when a token (including native XLM) is withdrawn from the contract.
+#[event]
+pub struct TokenWithdrawn {
+    pub token: Address,
+    pub to: Address,
+    pub amount: i128,
+}

package/contracts/message-libs/treasury/src/interfaces/mod.rs

@@ -0,0 +1,3 @@
+mod zro_fee_lib;
+
+pub use zro_fee_lib::*;

package/contracts/message-libs/treasury/src/interfaces/zro_fee_lib.rs

@@ -0,0 +1,20 @@
+use soroban_sdk::{contractclient, Address, Env};
+
+/// Interface for ZRO token fee library.
+///
+/// The ZRO token fee library calculates treasury fees when paying in ZRO tokens.
+/// This allows for custom fee calculation logic when users opt to pay fees in ZRO.
+#[contractclient(name = "ZROFeeLibClient")]
+pub trait IZROFeeLib {
+    /// Get the treasury fee in ZRO tokens based on the worker fee.
+    ///
+    /// # Arguments
+    /// * `sender` - The sender OApp address
+    /// * `dst_eid` - The destination endpoint ID
+    /// * `worker_fee` - The worker fee
+    /// * `native_treasury_fee` - The treasury fee in native tokens
+    ///
+    /// # Returns
+    /// The amount of ZRO tokens to be paid
+    fn get_fee(env: &Env, sender: &Address, dst_eid: u32, worker_fee: i128, native_treasury_fee: i128) -> i128;
+}

package/contracts/message-libs/treasury/src/lib.rs

@@ -0,0 +1,20 @@
+#![no_std]
+
+mod interfaces;
+
+pub use interfaces::*;
+
+cfg_if::cfg_if! {
+    // Include implementation when NOT in library mode, OR when testutils is enabled (for tests)
+    if #[cfg(any(not(feature = "library"), feature = "testutils"))] {
+        mod errors;
+        mod events;
+        mod storage;
+        mod treasury;
+
+        pub use treasury::{Treasury, TreasuryClient};
+    }
+}
+
+#[cfg(test)]
+mod tests;

package/contracts/message-libs/treasury/src/storage.rs

@@ -0,0 +1,18 @@
+use common_macros::storage;
+use soroban_sdk::Address;
+use utils::ttl::DefaultTtlConfigProvider;
+
+#[storage(DefaultTtlConfigProvider)]
+pub enum TreasuryStorage {
+    /// Native fee in basis points (0-10000, where 10000 = 100%)
+    #[instance(u32)]
+    NativeFeeBp,
+
+    /// Global toggle for all fee collection
+    #[instance(bool)]
+    FeeEnabled,
+
+    /// Address of the ZRO token fee library contract for custom fee calculations
+    #[instance(Address)]
+    ZROFeeLib,
+}

package/contracts/message-libs/treasury/src/tests/mod.rs

@@ -0,0 +1,2 @@
+mod setup;
+mod treasury_tests;

package/contracts/message-libs/treasury/src/tests/setup.rs

@@ -0,0 +1,112 @@
+use soroban_sdk::{
+    contract, contractimpl,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token, Address, Env, IntoVal, Val, Vec,
+};
+
+use crate::treasury::{Treasury, TreasuryClient};
+
+// === Test Constants ===
+
+pub const BPS_DENOMINATOR: u32 = 10000;
+
+// === Dummy Contract for creating valid addresses ===
+
+/// A minimal dummy contract used to create valid contract addresses in tests.
+/// This is needed because `Address::generate()` creates addresses that don't
+/// pass the `.exists()` check in Soroban.
+#[contract]
+pub struct DummyContract;
+
+#[contractimpl]
+impl DummyContract {
+    pub fn __constructor(_env: &Env) {}
+}
+
+/// Test setup struct following the pattern from endpoint-v2 and uln-302
+pub struct TestSetup<'a> {
+    pub env: Env,
+    pub owner: Address,
+    pub treasury: TreasuryClient<'a>,
+}
+
+/// Creates a new test setup with a deployed treasury contract
+pub fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+
+    let treasury = env.register(Treasury, (&owner,));
+    let treasury_client = TreasuryClient::new(&env, &treasury);
+
+    TestSetup { env, owner, treasury: treasury_client }
+}
+
+impl<'a> TestSetup<'a> {
+    /// Helper to mock owner auth for treasury operations
+    pub fn mock_owner_auth<T: IntoVal<Env, Vec<Val>>>(&self, fn_name: &str, args: T) {
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: &self.treasury.address,
+                fn_name,
+                args: args.into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    /// Helper to mock auth for any address (for testing unauthorized access)
+    pub fn mock_auth<T: IntoVal<Env, Vec<Val>>>(&self, address: &Address, fn_name: &str, args: T) {
+        self.env.mock_auths(&[MockAuth {
+            address,
+            invoke: &MockAuthInvoke {
+                contract: &self.treasury.address,
+                fn_name,
+                args: args.into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+    }
+
+    /// Creates a valid contract address by registering a dummy contract.
+    /// Use this instead of `Address::generate()` when the address needs to pass `.exists()` check.
+    pub fn create_contract_address(&self) -> Address {
+        self.env.register(DummyContract, ())
+    }
+
+    /// Configure treasury with native fee basis points and enable fees
+    pub fn configure_treasury(&self, native_fee_bp: u32) {
+        self.mock_owner_auth("set_native_fee_bp", (&native_fee_bp,));
+        self.treasury.set_native_fee_bp(&native_fee_bp);
+
+        self.mock_owner_auth("set_fee_enabled", (&true,));
+        self.treasury.set_fee_enabled(&true);
+    }
+
+    /// Deploys a test token contract and returns its address
+    pub fn deploy_test_token(&self) -> Address {
+        self.env.register_stellar_asset_contract_v2(self.owner.clone()).address()
+    }
+
+    /// Mints tokens to a specified address
+    pub fn mint_tokens(&self, token: &Address, to: &Address, amount: i128) {
+        let token_admin = token::StellarAssetClient::new(&self.env, token);
+        // Mock authorization for the mint operation
+        self.env.mock_auths(&[MockAuth {
+            address: &self.owner,
+            invoke: &MockAuthInvoke {
+                contract: token,
+                fn_name: "mint",
+                args: (to, &amount).into_val(&self.env),
+                sub_invokes: &[],
+            },
+        }]);
+        token_admin.mint(to, &amount);
+    }
+
+    /// Gets the token balance of an address
+    pub fn get_token_balance(&self, token: &Address, address: &Address) -> i128 {
+        let token_client = token::Client::new(&self.env, token);
+        token_client.balance(address)
+    }
+}