axelar-cgp-sui

Module 0x0::registry

Registry holds all created pools.

use 0x0::constants;
use 0x1::type_name;
use 0x2::bag;
use 0x2::object;
use 0x2::transfer;
use 0x2::tx_context;
use 0x2::vec_set;
use 0x2::versioned;

Struct REGISTRY

struct REGISTRY has drop
Fields
dummy_field: bool

Resource DeepbookAdminCap

DeepbookAdminCap is used to call admin functions.

struct DeepbookAdminCap has store, key
Fields
id: object::UID

Resource Registry

struct Registry has key
Fields
id: object::UID
inner: versioned::Versioned

Struct RegistryInner

struct RegistryInner has store
Fields
allowed_versions: vec_set::VecSet<u64>
pools: bag::Bag
treasury_address: address

Struct PoolKey

struct PoolKey has copy, drop, store
Fields
base: type_name::TypeName
quote: type_name::TypeName

Constants

const ECannotDisableCurrentVersion: u64 = 6;


const EPackageVersionNotEnabled: u64 = 3;


const EPoolAlreadyExists: u64 = 1;


const EPoolDoesNotExist: u64 = 2;


const EVersionAlreadyEnabled: u64 = 5;


const EVersionNotEnabled: u64 = 4;

Function init

fun init(_: registry::REGISTRY, ctx: &mut tx_context::TxContext)
Implementation 
fun init(_: REGISTRY, ctx: &mut TxContext) {
    let registry_inner = RegistryInner {
        allowed_versions: vec_set::singleton(constants::current_version()),
        pools: bag::new(ctx),
        treasury_address: ctx.sender(),
    };
    let registry = Registry {
        id: object::new(ctx),
        inner: versioned::create(
            constants::current_version(),
            registry_inner,
            ctx,
        ),
    };
    transfer::share_object(registry);
    let admin = DeepbookAdminCap { id: object::new(ctx) };
    transfer::public_transfer(admin, ctx.sender());
}

Function set_treasury_address

Sets the treasury address where the pool creation fees are sent By default, the treasury address is the publisher of the deepbook package

public fun set_treasury_address(self: &mut registry::Registry, treasury_address: address, _cap: &registry::DeepbookAdminCap)
Implementation 
public fun set_treasury_address(
    self: &mut Registry,
    treasury_address: address,
    _cap: &DeepbookAdminCap,
) {
    let self = self.load_inner_mut();
    self.treasury_address = treasury_address;
}

Function enable_version

Enables a package version Only Admin can enable a package version This function does not have version restrictions

public fun enable_version(self: &mut registry::Registry, version: u64, _cap: &registry::DeepbookAdminCap)
Implementation 
public fun enable_version(
    self: &mut Registry,
    version: u64,
    _cap: &DeepbookAdminCap,
) {
    let self: &mut RegistryInner = self.inner.load_value_mut();
    assert!(!self.allowed_versions.contains(&version), EVersionAlreadyEnabled);
    self.allowed_versions.insert(version);
}

Function disable_version

Disables a package version Only Admin can disable a package version This function does not have version restrictions

public fun disable_version(self: &mut registry::Registry, version: u64, _cap: &registry::DeepbookAdminCap)
Implementation 
public fun disable_version(
    self: &mut Registry,
    version: u64,
    _cap: &DeepbookAdminCap,
) {
    let self: &mut RegistryInner = self.inner.load_value_mut();
    assert!(
        version != constants::current_version(),
        ECannotDisableCurrentVersion,
    );
    assert!(self.allowed_versions.contains(&version), EVersionNotEnabled);
    self.allowed_versions.remove(&version);
}

Function load_inner_mut

public(friend) fun load_inner_mut(self: &mut registry::Registry): &mut registry::RegistryInner
Implementation 
public(package) fun load_inner_mut(self: &mut Registry): &mut RegistryInner {
    let inner: &mut RegistryInner = self.inner.load_value_mut();
    let package_version = constants::current_version();
    assert!(
        inner.allowed_versions.contains(&package_version),
        EPackageVersionNotEnabled,
    );

    inner
}

Function register_pool

Register a new pool in the registry. Asserts if (Base, Quote) pool already exists or (Quote, Base) pool already exists.

public(friend) fun register_pool<BaseAsset, QuoteAsset>(self: &mut registry::Registry, pool_id: object::ID)
Implementation 
public(package) fun register_pool<BaseAsset, QuoteAsset>(
    self: &mut Registry,
    pool_id: ID,
) {
    let self = self.load_inner_mut();
    let key = PoolKey {
        base: type_name::get<QuoteAsset>(),
        quote: type_name::get<BaseAsset>(),
    };
    assert!(!self.pools.contains(key), EPoolAlreadyExists);

    let key = PoolKey {
        base: type_name::get<BaseAsset>(),
        quote: type_name::get<QuoteAsset>(),
    };
    assert!(!self.pools.contains(key), EPoolAlreadyExists);

    self.pools.add(key, pool_id);
}

Function unregister_pool

Only admin can call this function

public(friend) fun unregister_pool<BaseAsset, QuoteAsset>(self: &mut registry::Registry)
Implementation 
public(package) fun unregister_pool<BaseAsset, QuoteAsset>(
    self: &mut Registry,
) {
    let self = self.load_inner_mut();
    let key = PoolKey {
        base: type_name::get<BaseAsset>(),
        quote: type_name::get<QuoteAsset>(),
    };
    assert!(self.pools.contains(key), EPoolDoesNotExist);
    self.pools.remove<PoolKey, ID>(key);
}

Function load_inner

public(friend) fun load_inner(self: &registry::Registry): &registry::RegistryInner
Implementation 
public(package) fun load_inner(self: &Registry): &RegistryInner {
    let inner: &RegistryInner = self.inner.load_value();
    let package_version = constants::current_version();
    assert!(
        inner.allowed_versions.contains(&package_version),
        EPackageVersionNotEnabled,
    );

    inner
}

Function get_pool_id

Get the pool id for the given base and quote assets.

public(friend) fun get_pool_id<BaseAsset, QuoteAsset>(self: &registry::Registry): object::ID
Implementation 
public(package) fun get_pool_id<BaseAsset, QuoteAsset>(self: &Registry): ID {
    let self = self.load_inner();
    let key = PoolKey {
        base: type_name::get<BaseAsset>(),
        quote: type_name::get<QuoteAsset>(),
    };
    assert!(self.pools.contains(key), EPoolDoesNotExist);

    *self.pools.borrow<PoolKey, ID>(key)
}

Function treasury_address

Get the treasury address

public(friend) fun treasury_address(self: &registry::Registry): address
Implementation 
public(package) fun treasury_address(self: &Registry): address {
    let self = self.load_inner();
    self.treasury_address
}

Function allowed_versions

public(friend) fun allowed_versions(self: &registry::Registry): vec_set::VecSet<u64>
Implementation 
public(package) fun allowed_versions(self: &Registry): VecSet<u64> {
    let self = self.load_inner();

    self.allowed_versions
}