tide
SUI$0.91384.40%USDC$0.99990.02%DEEP$0.01603.94%WAL$0.02965.50%CETUS$0.02043.64%NAVX$0.009142.62%IKA$0.001398.39%HAEDAL$0.029110.11%MMT$0.12183.71%BLUE$0.008383.43%NS$0.01031.55%USDT$0.99910.01%haSUI$0.99135.06%

Search by name, SuiNS, address, digest, object ID, coin type or checkpoint.

API

collection

Module0xa124…24ca
Move path
0xee47…c7fe::collection
Functions
170113 public, 11 entry
Structs
41
Friend modules
None
collection

Declarations

Rebuilt from the module interface. No verified source is published, and function bodies are only available as bytecode.

module collection;
struct AdminCap has key {
id: UID,
collection: ID,
}
struct AdminTransferred has copy, drop {
to: address,
}
struct Burned has copy, drop {
item: ID,
number: u64,
index: u64,
holder: address,
principal: u64,
staking_out: u64,
pot_a: u64,
pot_b: u64,
royalty: u64,
live: u64,
}
struct COLLECTION has drop {
dummy_field: bool,
}
struct Collected has copy, drop {
item: ID,
number: u64,
index: u64,
amount_a: u64,
amount_b: u64,
holder: address,
}
struct Collection has key {
id: UID,
config: ID,
version: u64,
name: String,
supply: u64,
minted: u64,
burned: u64,
price: u64,
stake_amount: u64,
lp_amount: u64,
fee_wallet: address,
royalty_wallet: address,
validator: address,
swap_pool: ID,
lp_pool: ID,
vault: ID,
policy: ID,
graveyard: ID,
graveyard_cap: KioskOwnerCap,
policy_cap: TransferPolicyCap<KingFizh>,
mint_open: bool,
holder_start_ms: u64,
public_start_ms: u64,
min_holder_balance: u64,
registry: Table<u64, ItemData>,
seeded: u64,
pool: vector<u16>,
drawn: u64,
reservations: Table<u64, address>,
reserved_total: u64,
moved: Table<u64, u64>,
items: Table<u64, ID>,
}
struct CollectionCreated has copy, drop {
collection: ID,
policy: ID,
graveyard: ID,
supply: u64,
price: u64,
}
struct Config has store, key {
id: UID,
collection: ID,
code_version: u64,
revision: u64,
upgrade_cap: Option<ID>,
values: Versioned,
}
struct ConfigCreated has copy, drop {
config: ID,
collection: ID,
version: u64,
}
struct ConfigKey has copy, drop, store {
dummy_field: bool,
}
struct ConfigUpdated has copy, drop {
config: ID,
revision: u64,
section: u8,
}
struct DisplayCapKey has copy, drop, store {
dummy_field: bool,
}
struct FeeWalletSet has copy, drop {
collection: ID,
from: address,
to: address,
}
struct Harvested has copy, drop {
item: ID,
number: u64,
index: u64,
reward: u64,
validator: address,
holder: address,
}
struct ItemData has store {
attributes: VecMap<String, String>,
filler: VecMap<String, String>,
pad: vector<u8>,
}
struct KingFizh has store, key {
id: UID,
number: u64,
index: u64,
attributes: VecMap<String, String>,
filler: VecMap<String, String>,
media: String,
vault: ID,
position: u64,
stake: Option<staking_pool::StakedSui>,
principal: u64,
validator: address,
status: String,
debt_a: u128,
debt_b: u128,
minted_epoch: u64,
burned_epoch: u64,
pad: vector<u8>,
}
struct LaunchReservationKey has copy, drop, store {
index: u64,
}
struct LegacyMigrated has copy, drop {
old: ID,
item: ID,
index: u64,
holder: address,
price: u64,
vip: bool,
}
struct LegacyStateKey has copy, drop, store {
dummy_field: bool,
}
struct Migrated has copy, drop {
object: ID,
from: u64,
to: u64,
}
struct MintOpenSet has copy, drop {
collection: ID,
open: bool,
}
struct Minted has copy, drop {
item: ID,
number: u64,
index: u64,
minter: address,
principal: u64,
validator: address,
position: u64,
reserved: bool,
}
struct PoolsSet has copy, drop {
collection: ID,
swap_from: ID,
swap_to: ID,
lp_from: ID,
lp_to: ID,
}
struct PositionLocked has copy, drop {
vault: ID,
position: u64,
ones: u64,
minter: address,
liquidity: u128,
swap_in: u64,
lp_sui: u64,
lp_a: u64,
fee: u64,
}
struct PositionPoolKey has copy, drop, store {
position: u64,
}
struct ProtocolUpgraded has copy, drop {
collection: ID,
vault: ID,
config: ID,
from: u64,
to: u64,
package: ID,
}
struct PublisherKey has copy, drop, store {
dummy_field: bool,
}
struct Reserved has copy, drop {
collection: ID,
index: u64,
minter: address,
}
struct RoyaltiesDistributed has copy, drop {
collection: ID,
policy: ID,
total: u64,
willie: u64,
king: u64,
}
struct RoyaltySet has copy, drop {
collection: ID,
bps: u16,
min: u64,
}
struct RoyaltyWalletSet has copy, drop {
collection: ID,
from: address,
to: address,
}
struct ScheduleSet has copy, drop {
collection: ID,
holder_start_ms: u64,
public_start_ms: u64,
min_holder_balance: u64,
}
struct SeedCap has key {
id: UID,
collection: ID,
}
struct SeedCapIssued has copy, drop {
collection: ID,
to: address,
}
struct Seeded has copy, drop {
collection: ID,
count: u64,
seeded: u64,
}
struct SettingsV1 has store {
public_mint: terms::Allocation,
migration: terms::Allocation,
vip_migration: terms::Allocation,
treasury_wallet: address,
hive_wallet: address,
subsidy_wallet: address,
willie_wallet: address,
royalty_willie_bps: u16,
royalty_bps: u16,
validator: address,
swap_pool: ID,
lp_pool: ID,
min_king_tokens: u64,
holder_start_ms: u64,
public_start_ms: u64,
early_access_ms: u64,
migration_duration_ms: u64,
max_per_tx: u64,
emergency_pauses: u64,
}
struct SweepSet has copy, drop {
vault: ID,
open: bool,
fee_bps: u64,
}
struct Swept has copy, drop {
vault: ID,
caller: address,
positions: u64,
amount_a: u64,
amount_b: u64,
caller_a: u64,
caller_b: u64,
live: u64,
}
struct ValidatorSet has copy, drop {
collection: ID,
from: address,
to: address,
}
struct Vault<phantom T0> has key {
id: UID,
version: u64,
collection: ID,
proofs: Table<u64, lp_burn::CetusLPBurnProof>,
positions: u64,
live: u64,
pot_a: Balance<T0>,
pot_b: Balance<SUI>,
acc_a: u128,
acc_b: u128,
sweep_fee_bps: u64,
sweep_open: bool,
swept_a: u64,
swept_b: u64,
paid_a: u64,
paid_b: u64,
}
struct VaultCreated has copy, drop {
collection: ID,
vault: ID,
}
public fun acc<T0>(&Vault<T0>): (u128, u128)
public fun activate_protocol_upgrade<T0>(&AdminCap,&mut Collection,&mut Vault<T0>,&UpgradeCap)
fun advance_protocol_internal<T0>(&mut Collection,&mut Vault<T0>,u64,ID)
public fun advance_protocol_version<T0>(&AdminCap,&mut Collection,&mut Vault<T0>,&UpgradeCap)
fun assert_action(&Collection,u8)
fun assert_admin(&AdminCap,&Collection)
fun assert_configured(&Collection)
fun assert_king<T0>()
fun assert_revision(&Collection,u64)
fun assert_v1_fields(&Display<KingFizh>)
public fun attributes(&KingFizh): VecMap<String, String>
public fun bind_legacy_batch(&AdminCap,&mut Collection,vector<ID>,vector<u64>)
fun build_attributes(&vector<vector<u8>>,&vector<vector<u8>>,u64,u64): (VecMap<String, String>, u64)
fun build_filler(u64): (VecMap<String, String>, u64)
public fun burn<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&mut TransferPolicy<KingFizh>,&mut Kiosk,&mut Kiosk,&KioskOwnerCap,ID)
public fun burned(&Collection): u64
fun check_burn<T0>(&Collection,&Vault<T0>,&TransferPolicy<KingFizh>,&Kiosk)
fun check_collection(&Collection)
fun check_public_inventory(&Collection,u64)
fun check_vault<T0>(&Vault<T0>)
fun check_window(&Collection,u64,Option<u64>)
public fun collect<T0>(&Collection,&mut Vault<T0>,&mut Kiosk,&KioskOwnerCap,ID)
fun config_changed(&mut Collection,u8)
public fun config_code_version(&Config): u64
public fun config_id(&Collection): ID
public fun config_revision(&Collection): u64
public fun config_schema_version(&Config): u64
public fun configuration(&Collection): &Config
fun configuration_mut(&mut Collection): &mut Config
public fun configure_legacy_layout(&AdminCap,&mut Collection,vector<u8>,u8,vector<u8>)
public fun configure_media(&AdminCap,&mut Collection,&mut Display<KingFizh>,String)
public fun configure_media_and_sync(&AdminCap,&mut Collection,&mut Display<KingFizh>,&mut Display<KingFizh>,String)
fun configure_media_internal(&mut Collection,&mut Display<KingFizh>,String)
public fun configured_allocation(&Collection,u8): (u64, u64, u64, u64, u64, u64)
fun copy_display_fields(&Display<KingFizh>,&mut Display<KingFizh>,&DisplayCap<KingFizh>)
public fun create_display_v2(&AdminCap,&mut Collection,&mut DisplayRegistry,&Display<KingFizh>,vector<String>,vector<String>)
public fun create_vault<T0>(&AdminCap,&mut Collection)
fun create_vault_internal<T0>(&mut Collection)
fun credit_slack<T0>(&mut Vault<T0>,Balance<SUI>)
fun deposit<T0>(&mut Vault<T0>,Balance<T0>,Balance<SUI>): (Coin<T0>, Coin<SUI>)
public fun destroy_seed_cap(SeedCap)
fun display_cover(&Display<KingFizh>): String
public fun display_v2_extras(&Collection,&Display<KingFizh>): (vector<String>, vector<String>)
public fun distribute(&Collection,&mut TransferPolicy<KingFizh>)
fun draw(&mut Collection,&mut RandomGenerator): u64
public fun drawn(&Collection): u64
public fun fee_wallet(&Collection): address
public fun filler_len(&KingFizh): u64
fun forge<T0>(&mut Collection,&mut Vault<T0>,staking_pool::StakedSui,u64,u64,bool): KingFizh
public fun full_range_ticks(u32): (u32, u32)
public fun graveyard_id(&Collection): ID
public fun harvest(&Collection,&mut sui_system::SuiSystemState,&mut Kiosk,&KioskOwnerCap,ID)
public fun has_display_v2(&Collection): bool
public fun has_proof<T0>(&Vault<T0>,u64): bool
public fun has_stake(&KingFizh): bool
public fun holder_start_ms(&Collection): u64
public fun index(&KingFizh): u64
fun init(COLLECTION)
public fun is_active(&KingFizh): bool
public fun is_minted(&Collection,u64): bool
public fun is_vip(&Collection,address): bool
public fun issue_seed_cap(&AdminCap,&Collection,address)
public fun item_id(&Collection,u64): ID
public fun item_validator(&KingFizh): address
public fun item_vault(&KingFizh): ID
public fun legacy_archive(&Collection): ID
public fun legacy_reserved_count(&Collection): u64
fun legacy_state(&Collection): &legacy::State
fun legacy_state_mut(&mut Collection): &mut legacy::State
public fun live<T0>(&Vault<T0>): u64
public fun lp_amount(&Collection): u64
public fun lp_pool(&Collection): ID
public fun max_per_tx(): u64
public fun media(&KingFizh): String
public fun migrate_collection(&AdminCap,&mut Collection)
public fun migrate_from_kiosk<T0: store + key, T1>(&mut Collection,&mut Vault<T1>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&mut legacy::Archive,&mut Kiosk,&KioskOwnerCap,&mut Kiosk,&KioskOwnerCap,&mut TransferPolicy<T0>,ID,Coin<SUI>,Coin<SUI>,u64,u64,&Clock)
public fun migrate_in_kiosk<T0: store + key, T1>(&mut Collection,&mut Vault<T1>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&mut legacy::Archive,&mut Kiosk,&KioskOwnerCap,&mut TransferPolicy<T0>,ID,Coin<SUI>,Coin<SUI>,u64,u64,&Clock)
public fun migrate_to_kiosk<T0: store + key, T1>(&mut Collection,&mut Vault<T1>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&mut legacy::Archive,&mut Kiosk,&KioskOwnerCap,T0,Coin<SUI>,u64,u64,&Clock)
public fun migrate_to_new_kiosk<T0: store + key, T1>(&mut Collection,&mut Vault<T1>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&mut legacy::Archive,T0,Coin<SUI>,u64,u64,&Clock)
public fun migrate_to_personal_kiosk<T0: store + key, T1>(&mut Collection,&mut Vault<T1>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&mut legacy::Archive,&mut Kiosk,&mut personal_kiosk::PersonalKioskCap,T0,Coin<SUI>,u64,u64,&Clock)
public fun migrate_vault<T0>(&AdminCap,&mut Vault<T0>)
public fun migrated_legacy(&Collection,ID): bool
public fun migration_end_ms(&Collection): u64
public fun migration_price_for_wallet(&Collection,address): u64
public fun migration_reserved(&Collection,u64): bool
public fun min_holder_balance(&Collection): u64
fun mint_drawn<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&KioskOwnerCap,Option<u64>,Coin<SUI>,u64,u64,u64,u128,&Clock,&mut RandomGenerator)
entry fun mint_holder_to_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&KioskOwnerCap,Coin<T0>,Coin<SUI>,u64,u64,u64,u128,u64,&Clock,&Random)
entry fun mint_holder_to_new_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,Coin<T0>,Coin<SUI>,u64,u64,u64,u128,u64,&Clock,&Random)
entry fun mint_holder_to_personal_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&mut personal_kiosk::PersonalKioskCap,Coin<T0>,Coin<SUI>,u64,u64,u64,u128,u64,&Clock,&Random)
public fun mint_launch_reserved<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&mut Kiosk,&KioskOwnerCap,Coin<SUI>,u64,u64,u64,&Clock)
public fun mint_open(&Collection): bool
fun mint_reserved<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&KioskOwnerCap,Coin<SUI>,u64,u64,u64,u128,&Clock)
entry fun mint_reserved_to_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&KioskOwnerCap,Coin<SUI>,u64,u64,u64,u128,u64,&Clock)
entry fun mint_reserved_to_new_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,Coin<SUI>,u64,u64,u64,u128,u64,&Clock)
entry fun mint_reserved_to_personal_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&mut personal_kiosk::PersonalKioskCap,Coin<SUI>,u64,u64,u64,u128,u64,&Clock)
entry fun mint_to_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&KioskOwnerCap,Coin<SUI>,u64,u64,u64,u128,u64,&Clock,&Random)
entry fun mint_to_new_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,Coin<SUI>,u64,u64,u64,u128,u64,&Clock,&Random)
entry fun mint_to_personal_kiosk<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,&mut Kiosk,&mut personal_kiosk::PersonalKioskCap,Coin<SUI>,u64,u64,u64,u128,u64,&Clock,&Random)
public fun minted(&Collection): u64
public fun number(&KingFizh): u64
fun pay_and_lock<T0>(&Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,&mut lp_burn::BurnManager,&TransferPolicy<KingFizh>,Coin<SUI>,u64,u64,u64,u128,&Clock): (vector<staking_pool::StakedSui>, u64, Coin<SUI>, Balance<SUI>)
fun pay_pot<T0>(&mut Vault<T0>,&mut KingFizh): (Coin<T0>, Coin<SUI>)
public fun pending<T0>(&Vault<T0>,&KingFizh): (u64, u64)
public fun policy_id(&Collection): ID
public fun position(&KingFizh): u64
public fun positions<T0>(&Vault<T0>): u64
public fun pot<T0>(&Vault<T0>): (u64, u64)
fun prepare_migration<T0: store + key, T1>(&mut Collection,&mut Vault<T1>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,&T0,Coin<SUI>,u64,u64,&Clock): (KingFizh, Coin<SUI>, u64)
fun prepare_migration_at_index<T0>(&mut Collection,&mut Vault<T0>,&mut sui_system::SuiSystemState,&TransferPolicy<KingFizh>,ID,u64,Coin<SUI>,u64,&Clock): (KingFizh, Coin<SUI>, u64)
public fun price(&Collection): u64
public fun principal(&KingFizh): u64
public fun public_remaining(&Collection): u64
public fun public_start_ms(&Collection): u64
public fun register_upgrade_cap(&AdminCap,&mut Collection,&UpgradeCap)
public fun release_expired_legacy(&mut Collection,vector<u64>,&Clock)
fun remove_available(&mut Collection,u64)
public fun reservation(&Collection,u64): Option<address>
public fun reserve(&AdminCap,&mut Collection,u64,address)
public fun reserve_after_launch(&AdminCap,&mut Collection,vector<u64>,vector<address>)
public fun reserve_legacy_batch(&AdminCap,&mut Collection,vector<u64>)
public fun reserved_total(&Collection): u64
fun route_allocation(&Collection,u8): terms::Allocation
fun route_payment(&Collection,Coin<SUI>,u8,u64,u64): (Coin<SUI>, Coin<SUI>)
public fun royalty_wallet(&Collection): address
public fun scale(): u128
public fun seal_legacy_inventory(&AdminCap,&mut Collection,u64)
public fun seed_batch(&SeedCap,&mut Collection,vector<u64>,vector<u64>,vector<vector<u8>>,vector<vector<u8>>)
public fun seeded(&Collection): u64
fun send<T0>(Coin<T0>, address)
fun send_sui(Coin<SUI>,address)
public fun set_access_limits(&AdminCap,&mut Collection,u64,u64)
public fun set_economics(&AdminCap,&mut Collection,vector<u64>,vector<u64>,vector<u64>)
public fun set_emergency_pauses(&AdminCap,&mut Collection,u64)
public fun set_fee_wallet(&AdminCap,&mut Collection,address)
public fun set_king_metadata<T0>(&AdminCap,&mut Collection,&CoinMetadata<T0>)
public fun set_launch_terms(&AdminCap,&mut Collection,u64,u64,u64)
public fun set_mint_open(&AdminCap,&mut Collection,bool)
public fun set_pools(&AdminCap,&mut Collection,ID,ID)
fun set_pools_internal(&mut Collection,ID,ID)
public fun set_recipients(&AdminCap,&mut Collection,address,address,address,address)
public fun set_royalty(&AdminCap,&mut Collection,&mut TransferPolicy<KingFizh>,u16,u64)
public fun set_royalty_split(&AdminCap,&mut Collection,u16)
public fun set_royalty_wallet(&AdminCap,&mut Collection,address)
public fun set_schedule(&AdminCap,&mut Collection,u64,u64,u64)
fun set_schedule_internal(&mut Collection,u64,u64,u64)
public fun set_sweep<T0>(&AdminCap,&Collection,&mut Vault<T0>,bool,u64)
public fun set_validator(&AdminCap,&mut Collection,address)
public fun set_vip_batch(&AdminCap,&mut Collection,vector<address>,bool)
fun settings(&Collection): &SettingsV1
fun settings_mut(&mut Collection): &mut SettingsV1
fun settle_burn<T0>(&mut Collection,&mut Vault<T0>,&mut TransferPolicy<KingFizh>,&mut Kiosk,KingFizh,TransferRequest<KingFizh>,Balance<SUI>)
public fun stake_amount(&Collection): u64
public fun status(&KingFizh): String
public fun supply(&Collection): u64
public fun swap_pool(&Collection): ID
public fun sweep<T0>(&Collection,&mut Vault<T0>,&lp_burn::BurnManager,&config::GlobalConfig,&mut pool::Pool<T0, SUI>,vector<u64>)
public fun sweep_fee_bps<T0>(&Vault<T0>): u64
public fun sweep_open<T0>(&Vault<T0>): bool
public fun sync_display_v2(&AdminCap,&Collection,&Display<KingFizh>,&mut Display<KingFizh>)
fun take_out(&mut Kiosk,&KioskOwnerCap,ID): (KingFizh, TransferRequest<KingFizh>)
public fun traits(&Collection,u64): VecMap<String, String>
entry fun transfer_admin(AdminCap,address)
entry fun transfer_seed_cap(SeedCap,address)
fun validate_migration<T0>(&Collection,&Vault<T0>,&TransferPolicy<KingFizh>,ID,u64,u64,address): u8
public fun validator(&Collection): address
public fun vault_id(&Collection): ID
public fun version(): u64
public fun withdraw_royalties(&Collection,&mut TransferPolicy<KingFizh>)
fun zeros(u64): vector<u8>