Skip to main content

Module bridge::treasury

use iota::address;
use iota::bag;
use iota::balance;
use iota::coin;
use iota::config;
use iota::deny_list;
use iota::dynamic_field;
use iota::dynamic_object_field;
use iota::event;
use iota::hex;
use iota::object;
use iota::object_bag;
use iota::package;
use iota::transfer;
use iota::tx_context;
use iota::types;
use iota::url;
use iota::vec_map;
use std::address;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::type_name;
use std::u64;
use std::vector;

Struct BridgeTreasury​

public struct BridgeTreasury has store
Fields

Struct BridgeTokenMetadata​

public struct BridgeTokenMetadata has copy, drop, store
Fields
id: u8
decimal_multiplier: u64
notional_value: u64
native_token: bool

Struct ForeignTokenRegistration​

public struct ForeignTokenRegistration has store
Fields

Struct UpdateTokenPriceEvent​

public struct UpdateTokenPriceEvent has copy, drop
Fields
token_id: u8
new_price: u64

Struct NewTokenEvent​

public struct NewTokenEvent has copy, drop
Fields
token_id: u8
type_name: std::type_name::TypeName
native_token: bool
decimal_multiplier: u64
notional_value: u64

Struct TokenRegistrationEvent​

public struct TokenRegistrationEvent has copy, drop
Fields
type_name: std::type_name::TypeName
decimal: u8
native_token: bool

Constants​

const EInvalidNotionalValue: u64 = 4;
const EInvalidUpgradeCap: u64 = 2;
const ETokenSupplyNonZero: u64 = 3;
const EUnsupportedTokenType: u64 = 1;

Function token_id​

public fun token_id<T>(self: &bridge::treasury::BridgeTreasury): u8
Implementation
public fun token_id<T>(self: &BridgeTreasury): u8 {
let metadata = self.get_token_metadata<T>();
metadata.id
}

Function decimal_multiplier​

public fun decimal_multiplier<T>(self: &bridge::treasury::BridgeTreasury): u64
Implementation
public fun decimal_multiplier<T>(self: &BridgeTreasury): u64 {
let metadata = self.get_token_metadata<T>();
metadata.decimal_multiplier
}

Function notional_value​

public fun notional_value<T>(self: &bridge::treasury::BridgeTreasury): u64
Implementation
public fun notional_value<T>(self: &BridgeTreasury): u64 {
let metadata = self.get_token_metadata<T>();
metadata.notional_value
}

Function register_foreign_token​

public(package) fun register_foreign_token<T>(self: &mut bridge::treasury::BridgeTreasury, tc: iota::coin::TreasuryCap<T>, uc: iota:📦:UpgradeCap, metadata: &iota::coin::CoinMetadata<T>)
Implementation
public(package) fun register_foreign_token<T>(
self: &mut BridgeTreasury,
tc: TreasuryCap<T>,
uc: UpgradeCap,
metadata: &CoinMetadata<T>,
) {
// Make sure TreasuryCap has not been minted before.
assert!(coin::total_supply(&tc) == 0, ETokenSupplyNonZero);
let type_name = type_name::get<T>();
let address_bytes = hex::decode(ascii::into_bytes(type_name::get_address(&type_name)));
let coin_address = address::from_bytes(address_bytes);
// Make sure upgrade cap is for the Coin package
// FIXME: add test
assert!(
object::id_to_address(&package::upgrade_package(&uc))
== coin_address,
EInvalidUpgradeCap,
);
let registration = ForeignTokenRegistration {
type_name,
uc,
decimal: coin::get_decimals(metadata),
};
self.waiting_room.add(type_name::into_string(type_name), registration);
self.treasuries.add(type_name, tc);
emit(TokenRegistrationEvent {
type_name,
decimal: coin::get_decimals(metadata),
native_token: false,
});
}

Function add_new_token​

public(package) fun add_new_token(self: &mut bridge::treasury::BridgeTreasury, token_name: std::ascii::String, token_id: u8, native_token: bool, notional_value: u64)
Implementation
public(package) fun add_new_token(
self: &mut BridgeTreasury,
token_name: String,
token_id: u8,
native_token: bool,
notional_value: u64,
) {
if (!native_token) {
assert!(notional_value > 0, EInvalidNotionalValue);
let ForeignTokenRegistration {
type_name,
uc,
decimal,
} = self.waiting_room.remove<String, ForeignTokenRegistration>(token_name);
let decimal_multiplier = 10u64.pow(decimal);
self
.supported_tokens
.insert(
type_name,
BridgeTokenMetadata {
id: token_id,
decimal_multiplier,
notional_value,
native_token,
},
);
self.id_token_type_map.insert(token_id, type_name);
// Freeze upgrade cap to prevent changes to the coin
transfer::public_freeze_object(uc);
emit(NewTokenEvent {
token_id,
type_name,
native_token,
decimal_multiplier,
notional_value,
})
} else {}
}

Function create​

public(package) fun create(ctx: &mut iota::tx_context::TxContext): bridge::treasury::BridgeTreasury
Implementation
public(package) fun create(ctx: &mut TxContext): BridgeTreasury {
BridgeTreasury {
treasuries: object_bag::new(ctx),
supported_tokens: vec_map::empty(),
id_token_type_map: vec_map::empty(),
waiting_room: bag::new(ctx),
}
}

Function burn​

public(package) fun burn<T>(self: &mut bridge::treasury::BridgeTreasury, token: iota::coin::Coin<T>)
Implementation
public(package) fun burn<T>(self: &mut BridgeTreasury, token: Coin<T>) {
let treasury = &mut self.treasuries[type_name::get<T>()];
coin::burn(treasury, token);
}

Function mint​

public(package) fun mint<T>(self: &mut bridge::treasury::BridgeTreasury, amount: u64, ctx: &mut iota::tx_context::TxContext): iota::coin::Coin<T>
Implementation
public(package) fun mint<T>(self: &mut BridgeTreasury, amount: u64, ctx: &mut TxContext): Coin<T> {
let treasury = &mut self.treasuries[type_name::get<T>()];
coin::mint(treasury, amount, ctx)
}

Function update_asset_notional_price​

public(package) fun update_asset_notional_price(self: &mut bridge::treasury::BridgeTreasury, token_id: u8, new_usd_price: u64)
Implementation
public(package) fun update_asset_notional_price(
self: &mut BridgeTreasury,
token_id: u8,
new_usd_price: u64,
) {
let type_name = self.id_token_type_map.try_get(&token_id);
assert!(type_name.is_some(), EUnsupportedTokenType);
assert!(new_usd_price > 0, EInvalidNotionalValue);
let type_name = type_name.destroy_some();
let metadata = self.supported_tokens.get_mut(&type_name);
metadata.notional_value = new_usd_price;
emit(UpdateTokenPriceEvent {
token_id,
new_price: new_usd_price,
})
}

Function get_token_metadata​

fun get_token_metadata<T>(self: &bridge::treasury::BridgeTreasury): bridge::treasury::BridgeTokenMetadata
Implementation
fun get_token_metadata<T>(self: &BridgeTreasury): BridgeTokenMetadata {
let coin_type = type_name::get<T>();
let metadata = self.supported_tokens.try_get(&coin_type);
assert!(metadata.is_some(), EUnsupportedTokenType);
metadata.destroy_some()
}