본문으로 건너뛰기

Module sui::coin

Defines the 

Coin
type - platform wide representation of fungible tokens and coins. 
Coin
can be described as a secure wrapper around Balance type.

use std::address;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::type_name;
use std::vector;
use sui::accumulator;
use sui::accumulator_metadata;
use sui::accumulator_settlement;
use sui::address;
use sui::bag;
use sui::balance;
use sui::bcs;
use sui::config;
use sui::deny_list;
use sui::dynamic_field;
use sui::dynamic_object_field;
use sui::event;
use sui::funds_accumulator;
use sui::hash;
use sui::hex;
use sui::object;
use sui::party;
use sui::table;
use sui::transfer;
use sui::tx_context;
use sui::types;
use sui::url;
use sui::vec_map;
use sui::vec_set;

Struct Coin​

A coin of type T worth 

value
. Transferable and storable

public struct Coin<phantom T> has key, store
Click to open
Fields

Struct CoinMetadata​

Each Coin type T created through 

create_currency
function will have a unique instance of CoinMetadata that stores the metadata for this coin type.

public struct CoinMetadata<phantom T> has key, store
Click to open
Fields
id: sui::object::UID
decimals: u8
Number of decimal places the coin uses. A coin with 
value
N and decimals D should be shown as N / 10^D E.g., a coin with 
value
7002 and decimals 3 should be displayed as 7.002 This is metadata for display usage only. 
name: std::string::String
Name for the token 
symbol: std::ascii::String
Symbol for the token 
description: std::string::String
Description of the token 
icon_url: std::option::Option<sui::url::Url>
URL for the token logo

Struct RegulatedCoinMetadata​

Similar to CoinMetadata, but created only for regulated coins that use the DenyList. This object is always immutable.

public struct RegulatedCoinMetadata<phantom T> has key
Click to open
Fields
id: sui::object::UID
coin_metadata_object: sui::object::ID
The ID of the coin's CoinMetadata object. 
deny_cap_object: sui::object::ID
The ID of the coin's DenyCap object.

Struct TreasuryCap​

Capability allowing the bearer to mint and burn coins of type T. Transferable

public struct TreasuryCap<phantom T> has key, store
Click to open
Fields

Struct DenyCapV2​

Capability allowing the bearer to deny addresses from using the currency's coins-- immediately preventing those addresses from interacting with the coin as an input to a transaction and at the start of the next preventing them from receiving the coin. If 

allow_global_pause
is true, the bearer can enable a global pause that behaves as if all addresses were added to the deny list.

public struct DenyCapV2<phantom T> has key, store
Click to open
Fields

Struct CurrencyCreated​

public struct CurrencyCreated<phantom T> has copy, drop
Click to open
Fields
decimals: u8

Struct DenyCap​

Capability allowing the bearer to freeze addresses, preventing those addresses from interacting with the coin as an input to a transaction.

public struct DenyCap<phantom T> has key, store
Click to open
Fields

Constants​

A type passed to create_supply is not a one-time witness.

const EBadWitness: u64 = 0;

Invalid arguments are passed to a function.

const EInvalidArg: u64 = 1;

Trying to split a coin more times than its balance allows.

const ENotEnough: u64 = 2;

const EGlobalPauseNotAllowed: u64 = 3;

The index into the deny list vector for the 

sui::coin::Coin
type.

const DENY_LIST_COIN_INDEX: u64 = 0;

Function total_supply​

Return the total number of T's in circulation.

public fun total_supply<T>(cap: &sui::coin::TreasuryCap<T>): u64
Click to open
Implementation
public fun total_supply<T>(cap: &TreasuryCap<T>): u64 {
    balance::supply_value(&cap.total_supply)
}

Function treasury_into_supply​

Unwrap 

TreasuryCap
getting the Supply.

Operation is irreversible. Supply cannot be converted into a 

TreasuryCap
due to different security guarantees (TreasuryCap can be created only once for a type)

public fun treasury_into_supply<T>(treasury: sui::coin::TreasuryCap<T>): sui::balance::Supply<T>
Click to open
Implementation
public fun treasury_into_supply<T>(treasury: TreasuryCap<T>): Supply<T> {
    let TreasuryCap { id, total_supply } = treasury;
    id.delete();
    total_supply
}

Function supply_immut​

Get immutable reference to the treasury's Supply.

public fun supply_immut<T>(treasury: &sui::coin::TreasuryCap<T>): &sui::balance::Supply<T>
Click to open
Implementation
public fun supply_immut<T>(treasury: &TreasuryCap<T>): &Supply<T> {
    &treasury.total_supply
}

Function supply_mut​

Get mutable reference to the treasury's Supply.

public fun supply_mut<T>(treasury: &mut sui::coin::TreasuryCap<T>): &mut sui::balance::Supply<T>
Click to open
Implementation
public fun supply_mut<T>(treasury: &mut TreasuryCap<T>): &mut Supply<T> {
    &mut treasury.total_supply
}

Function value​

Public getter for the coin's value

public fun value<T>(self: &sui::coin::Coin<T>): u64
Click to open
Implementation
public fun value<T>(self: &Coin<T>): u64 {
    self.balance.value()
}

Function balance​

Get immutable reference to the balance of a coin.

public fun balance<T>(coin: &sui::coin::Coin<T>): &sui::balance::Balance<T>
Click to open
Implementation
public fun balance<T>(coin: &Coin<T>): &Balance<T> {
    &coin.balance
}

Function balance_mut​

Get a mutable reference to the balance of a coin.

public fun balance_mut<T>(coin: &mut sui::coin::Coin<T>): &mut sui::balance::Balance<T>
Click to open
Implementation
public fun balance_mut<T>(coin: &mut Coin<T>): &mut Balance<T> {
    &mut coin.balance
}

Function from_balance​

Wrap a balance into a Coin to make it transferable.

public fun from_balance<T>(balance: sui::balance::Balance<T>, ctx: &mut sui::tx_context::TxContext): sui::coin::Coin<T>
Click to open
Implementation
public fun from_balance<T>(balance: Balance<T>, ctx: &mut TxContext): Coin<T> {
    Coin { id: object::new(ctx), balance }
}

Function into_balance​

Destruct a Coin wrapper and keep the balance.

public fun into_balance<T>(coin: sui::coin::Coin<T>): sui::balance::Balance<T>
Click to open
Implementation
public fun into_balance<T>(coin: Coin<T>): Balance<T> {
    let Coin { id, balance } = coin;
    id.delete();
    balance
}

Function take​

Take a 

Coin
worth of 
value
from Balance. Aborts if 
value > balance.value

public fun take<T>(balance: &mut sui::balance::Balance<T>, value: u64, ctx: &mut sui::tx_context::TxContext): sui::coin::Coin<T>
Click to open
Implementation
public fun take<T>(balance: &mut Balance<T>, value: u64, ctx: &mut TxContext): Coin<T> {
    Coin {
        id: object::new(ctx),
        balance: balance.split(value),
    }
}

Function put​

Put a 

Coin<T>
to the Balance<T>.

public fun put<T>(balance: &mut sui::balance::Balance<T>, coin: sui::coin::Coin<T>)
Click to open
Implementation
public fun put<T>(balance: &mut Balance<T>, coin: Coin<T>) {
    balance.join(into_balance(coin));
}

Function join​

Consume the coin c and add its value to self. Aborts if 

c.value + self.value > U64_MAX

public entry fun join<T>(self: &mut sui::coin::Coin<T>, c: sui::coin::Coin<T>)
Click to open
Implementation
public entry fun join<T>(self: &mut Coin<T>, c: Coin<T>) {
    let Coin { id, balance } = c;
    id.delete();
    self.balance.join(balance);
}

Function split​

Split coin self to two coins, one with balance split_amount, and the remaining balance is left is self.

public fun split<T>(self: &mut sui::coin::Coin<T>, split_amount: u64, ctx: &mut sui::tx_context::TxContext): sui::coin::Coin<T>
Click to open
Implementation
public fun split<T>(self: &mut Coin<T>, split_amount: u64, ctx: &mut TxContext): Coin<T> {
    take(&mut self.balance, split_amount, ctx)
}

Function divide_into_n​

Split coin self into n - 1 coins with equal balances. The remainder is left in self. Return newly created coins.

public fun divide_into_n<T>(self: &mut sui::coin::Coin<T>, n: u64, ctx: &mut sui::tx_context::TxContext): vector<sui::coin::Coin<T>>
Click to open
Implementation
public fun divide_into_n<T>(self: &mut Coin<T>, n: u64, ctx: &mut TxContext): vector<Coin<T>> {
    assert!(n > 0, EInvalidArg);
    assert!(n <= self.value(), ENotEnough);
    let split_amount = self.value() / n;
    vector::tabulate!(n - 1, |_| self.split(split_amount, ctx))
}

Function zero​

Make any Coin with a zero value. Useful for placeholding bids/payments or preemptively making empty balances.

public fun zero<T>(ctx: &mut sui::tx_context::TxContext): sui::coin::Coin<T>
Click to open
Implementation
public fun zero<T>(ctx: &mut TxContext): Coin<T> {
    Coin { id: object::new(ctx), balance: balance::zero() }
}

Function destroy_zero​

Destroy a coin with value zero

public fun destroy_zero<T>(c: sui::coin::Coin<T>)
Click to open
Implementation
public fun destroy_zero<T>(c: Coin<T>) {
    let Coin { id, balance } = c;
    id.delete();
    balance.destroy_zero()
}

Function create_currency​

Create a new currency type T as and return the 

TreasuryCap
for T to the caller. Can only be called with a one-time-witness type, ensuring that there's only one 
TreasuryCap
per T.

public fun create_currency<T: drop>(witness: T, decimals: u8, symbol: vector<u8>, name: vector<u8>, description: vector<u8>, icon_url: std::option::Option<sui::url::Url>, ctx: &mut sui::tx_context::TxContext): (sui::coin::TreasuryCap<T>, sui::coin::CoinMetadata<T>)
Click to open
Implementation
public fun create_currency<T: drop>(
    witness: T,
    decimals: u8,
    symbol: vector<u8>,
    name: vector<u8>,
    description: vector<u8>,
    icon_url: Option<Url>,
    ctx: &mut TxContext,
): (TreasuryCap<T>, CoinMetadata<T>) {
    // Make sure there's only one instance of the type T
    assert!(sui::types::is_one_time_witness(&witness), EBadWitness);
    (
        TreasuryCap {
            id: object::new(ctx),
            total_supply: balance::create_supply(witness),
        },
        CoinMetadata {
            id: object::new(ctx),
            decimals,
            name: name.to_string(),
            symbol: symbol.to_ascii_string(),
            description: description.to_string(),
            icon_url,
        },
    )
}

Function create_regulated_currency_v2​

This creates a new currency, via 

create_currency
, but with an extra capability that allows for specific addresses to have their coins frozen. When an address is added to the deny list, it is immediately unable to interact with the currency's coin as input objects. Additionally at the start of the next epoch, they will be unable to receive the currency's coin. The 
allow_global_pause
flag enables an additional API that will cause all addresses to be denied. Note however, that this doesn't affect per-address entries of the deny list and will not change the result of the "contains" APIs.

public fun create_regulated_currency_v2<T: drop>(witness: T, decimals: u8, symbol: vector<u8>, name: vector<u8>, description: vector<u8>, icon_url: std::option::Option<sui::url::Url>, allow_global_pause: bool, ctx: &mut sui::tx_context::TxContext): (sui::coin::TreasuryCap<T>, sui::coin::DenyCapV2<T>, sui::coin::CoinMetadata<T>)
Click to open
Implementation
public fun create_regulated_currency_v2<T: drop>(
    witness: T,
    decimals: u8,
    symbol: vector<u8>,
    name: vector<u8>,
    description: vector<u8>,
    icon_url: Option<Url>,
    allow_global_pause: bool,
    ctx: &mut TxContext,
): (TreasuryCap<T>, DenyCapV2<T>, CoinMetadata<T>) {
    let (treasury_cap, metadata) = create_currency(
        witness,
        decimals,
        symbol,
        name,
        description,
        icon_url,
        ctx,
    );
    let deny_cap = DenyCapV2 {
        id: object::new(ctx),
        allow_global_pause,
    };
    transfer::freeze_object(RegulatedCoinMetadata<T> {
        id: object::new(ctx),
        coin_metadata_object: object::id(&metadata),
        deny_cap_object: object::id(&deny_cap),
    });
    (treasury_cap, deny_cap, metadata)
}

Function migrate_regulated_currency_to_v2​

Given the 

DenyCap
for a regulated currency, migrate it to the new 
DenyCapV2
type. All entries in the deny list will be migrated to the new format. See 
create_regulated_currency_v2
for details on the new v2 of the deny list.

public fun migrate_regulated_currency_to_v2<T>(deny_list: &mut sui::deny_list::DenyList, cap: sui::coin::DenyCap<T>, allow_global_pause: bool, ctx: &mut sui::tx_context::TxContext): sui::coin::DenyCapV2<T>
Click to open
Implementation
public fun migrate_regulated_currency_to_v2<T>(
    deny_list: &mut DenyList,
    cap: DenyCap<T>,
    allow_global_pause: bool,
    ctx: &mut TxContext,
): DenyCapV2<T> {
    let DenyCap { id } = cap;
    id.delete();
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.migrate_v1_to_v2(DENY_LIST_COIN_INDEX, ty, ctx);
    DenyCapV2 {
        id: object::new(ctx),
        allow_global_pause,
    }
}

Function mint​

Create a coin worth 

value
and increase the total supply in cap accordingly.

public fun mint<T>(cap: &mut sui::coin::TreasuryCap<T>, value: u64, ctx: &mut sui::tx_context::TxContext): sui::coin::Coin<T>
Click to open
Implementation
public fun mint<T>(cap: &mut TreasuryCap<T>, value: u64, ctx: &mut TxContext): Coin<T> {
    Coin {
        id: object::new(ctx),
        balance: cap.total_supply.increase_supply(value),
    }
}

Function mint_balance​

Mint some amount of T as a Balance and increase the total supply in cap accordingly. Aborts if 

value
+ 
cap.total_supply
>= U64_MAX

public fun mint_balance<T>(cap: &mut sui::coin::TreasuryCap<T>, value: u64): sui::balance::Balance<T>
Click to open
Implementation
public fun mint_balance<T>(cap: &mut TreasuryCap<T>, value: u64): Balance<T> {
    cap.total_supply.increase_supply(value)
}

Function burn​

Destroy the coin c and decrease the total supply in cap accordingly.

public entry fun burn<T>(cap: &mut sui::coin::TreasuryCap<T>, c: sui::coin::Coin<T>): u64
Click to open
Implementation
public entry fun burn<T>(cap: &mut TreasuryCap<T>, c: Coin<T>): u64 {
    let Coin { id, balance } = c;
    id.delete();
    cap.total_supply.decrease_supply(balance)
}

Function deny_list_v2_add​

Adds the given address to the deny list, preventing it from interacting with the specified coin type as an input to a transaction. Additionally at the start of the next epoch, the address will be unable to receive objects of this coin type.

public fun deny_list_v2_add<T>(deny_list: &mut sui::deny_list::DenyList, _deny_cap: &mut sui::coin::DenyCapV2<T>, addr: address, ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public fun deny_list_v2_add<T>(
    deny_list: &mut DenyList,
    _deny_cap: &mut DenyCapV2<T>,
    addr: address,
    ctx: &mut TxContext,
) {
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_add(DENY_LIST_COIN_INDEX, ty, addr, ctx)
}

Function deny_list_v2_remove​

Removes an address from the deny list. Similar to 

deny_list_v2_add
, the effect for input objects will be immediate, but the effect for receiving objects will be delayed until the next epoch.

public fun deny_list_v2_remove<T>(deny_list: &mut sui::deny_list::DenyList, _deny_cap: &mut sui::coin::DenyCapV2<T>, addr: address, ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public fun deny_list_v2_remove<T>(
    deny_list: &mut DenyList,
    _deny_cap: &mut DenyCapV2<T>,
    addr: address,
    ctx: &mut TxContext,
) {
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_remove(DENY_LIST_COIN_INDEX, ty, addr, ctx)
}

Function deny_list_v2_contains_current_epoch​

Check if the deny list contains the given address for the current epoch. Denied addresses in the current epoch will be unable to receive objects of this coin type.

public fun deny_list_v2_contains_current_epoch<T>(deny_list: &sui::deny_list::DenyList, addr: address, ctx: &sui::tx_context::TxContext): bool
Click to open
Implementation
public fun deny_list_v2_contains_current_epoch<T>(
    deny_list: &DenyList,
    addr: address,
    ctx: &TxContext,
): bool {
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_contains_current_epoch(DENY_LIST_COIN_INDEX, ty, addr, ctx)
}

Function deny_list_v2_contains_next_epoch​

Check if the deny list contains the given address for the next epoch. Denied addresses in the next epoch will immediately be unable to use objects of this coin type as inputs. At the start of the next epoch, the address will be unable to receive objects of this coin type.

public fun deny_list_v2_contains_next_epoch<T>(deny_list: &sui::deny_list::DenyList, addr: address): bool
Click to open
Implementation
public fun deny_list_v2_contains_next_epoch<T>(deny_list: &DenyList, addr: address): bool {
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_contains_next_epoch(DENY_LIST_COIN_INDEX, ty, addr)
}

Function deny_list_v2_enable_global_pause​

Enable the global pause for the given coin type. This will immediately prevent all addresses from using objects of this coin type as inputs. At the start of the next epoch, all addresses will be unable to receive objects of this coin type.

public fun deny_list_v2_enable_global_pause<T>(deny_list: &mut sui::deny_list::DenyList, deny_cap: &mut sui::coin::DenyCapV2<T>, ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public fun deny_list_v2_enable_global_pause<T>(
    deny_list: &mut DenyList,
    deny_cap: &mut DenyCapV2<T>,
    ctx: &mut TxContext,
) {
    assert!(deny_cap.allow_global_pause, EGlobalPauseNotAllowed);
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_enable_global_pause(DENY_LIST_COIN_INDEX, ty, ctx)
}

Function deny_list_v2_disable_global_pause​

Disable the global pause for the given coin type. This will immediately allow all addresses to resume using objects of this coin type as inputs. However, receiving objects of this coin type will still be paused until the start of the next epoch.

public fun deny_list_v2_disable_global_pause<T>(deny_list: &mut sui::deny_list::DenyList, deny_cap: &mut sui::coin::DenyCapV2<T>, ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public fun deny_list_v2_disable_global_pause<T>(
    deny_list: &mut DenyList,
    deny_cap: &mut DenyCapV2<T>,
    ctx: &mut TxContext,
) {
    assert!(deny_cap.allow_global_pause, EGlobalPauseNotAllowed);
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_disable_global_pause(DENY_LIST_COIN_INDEX, ty, ctx)
}

Function deny_list_v2_is_global_pause_enabled_current_epoch​

Check if the global pause is enabled for the given coin type in the current epoch.

public fun deny_list_v2_is_global_pause_enabled_current_epoch<T>(deny_list: &sui::deny_list::DenyList, ctx: &sui::tx_context::TxContext): bool
Click to open
Implementation
public fun deny_list_v2_is_global_pause_enabled_current_epoch<T>(
    deny_list: &DenyList,
    ctx: &TxContext,
): bool {
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_is_global_pause_enabled_current_epoch(DENY_LIST_COIN_INDEX, ty, ctx)
}

Function deny_list_v2_is_global_pause_enabled_next_epoch​

Check if the global pause is enabled for the given coin type in the next epoch.

public fun deny_list_v2_is_global_pause_enabled_next_epoch<T>(deny_list: &sui::deny_list::DenyList): bool
Click to open
Implementation
public fun deny_list_v2_is_global_pause_enabled_next_epoch<T>(deny_list: &DenyList): bool {
    let ty = type_name::with_original_ids<T>().into_string().into_bytes();
    deny_list.v2_is_global_pause_enabled_next_epoch(DENY_LIST_COIN_INDEX, ty)
}

Function mint_and_transfer​

Mint amount of 

Coin
and send it to recipient. Invokes 
mint()
.

public entry fun mint_and_transfer<T>(c: &mut sui::coin::TreasuryCap<T>, amount: u64, recipient: address, ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public entry fun mint_and_transfer<T>(
    c: &mut TreasuryCap<T>,
    amount: u64,
    recipient: address,
    ctx: &mut TxContext,
) {
    transfer::public_transfer(c.mint(amount, ctx), recipient)
}

Function update_name​

Update name of the coin in 

CoinMetadata

public entry fun update_name<T>(_treasury: &sui::coin::TreasuryCap<T>, metadata: &mut sui::coin::CoinMetadata<T>, name: std::string::String)
Click to open
Implementation
public entry fun update_name<T>(
    _treasury: &TreasuryCap<T>,
    metadata: &mut CoinMetadata<T>,
    name: string::String,
) {
    metadata.name = name;
}

Function update_symbol​

Update the symbol of the coin in 

CoinMetadata

public entry fun update_symbol<T>(_treasury: &sui::coin::TreasuryCap<T>, metadata: &mut sui::coin::CoinMetadata<T>, symbol: std::ascii::String)
Click to open
Implementation
public entry fun update_symbol<T>(
    _treasury: &TreasuryCap<T>,
    metadata: &mut CoinMetadata<T>,
    symbol: ascii::String,
) {
    metadata.symbol = symbol;
}

Function update_description​

Update the description of the coin in 

CoinMetadata

public entry fun update_description<T>(_treasury: &sui::coin::TreasuryCap<T>, metadata: &mut sui::coin::CoinMetadata<T>, description: std::string::String)
Click to open
Implementation
public entry fun update_description<T>(
    _treasury: &TreasuryCap<T>,
    metadata: &mut CoinMetadata<T>,
    description: string::String,
) {
    metadata.description = description;
}

Function update_icon_url​

Update the url of the coin in 

CoinMetadata

public entry fun update_icon_url<T>(_treasury: &sui::coin::TreasuryCap<T>, metadata: &mut sui::coin::CoinMetadata<T>, url: std::ascii::String)
Click to open
Implementation
public entry fun update_icon_url<T>(
    _treasury: &TreasuryCap<T>,
    metadata: &mut CoinMetadata<T>,
    url: ascii::String,
) {
    metadata.icon_url = option::some(url::new_unsafe(url));
}

Function get_decimals​

public fun get_decimals<T>(metadata: &sui::coin::CoinMetadata<T>): u8
Click to open
Implementation
public fun get_decimals<T>(metadata: &CoinMetadata<T>): u8 {
    metadata.decimals
}

Function get_name​

public fun get_name<T>(metadata: &sui::coin::CoinMetadata<T>): std::string::String
Click to open
Implementation
public fun get_name<T>(metadata: &CoinMetadata<T>): string::String {
    metadata.name
}

Function get_symbol​

public fun get_symbol<T>(metadata: &sui::coin::CoinMetadata<T>): std::ascii::String
Click to open
Implementation
public fun get_symbol<T>(metadata: &CoinMetadata<T>): ascii::String {
    metadata.symbol
}

Function get_description​

public fun get_description<T>(metadata: &sui::coin::CoinMetadata<T>): std::string::String
Click to open
Implementation
public fun get_description<T>(metadata: &CoinMetadata<T>): string::String {
    metadata.description
}

Function get_icon_url​

public fun get_icon_url<T>(metadata: &sui::coin::CoinMetadata<T>): std::option::Option<sui::url::Url>
Click to open
Implementation
public fun get_icon_url<T>(metadata: &CoinMetadata<T>): Option<Url> {
    metadata.icon_url
}

Function destroy_metadata​

Destroy legacy 

CoinMetadata
object

public(package) fun destroy_metadata<T>(metadata: sui::coin::CoinMetadata<T>)
Click to open
Implementation
public(package) fun destroy_metadata<T>(metadata: CoinMetadata<T>) {
    let CoinMetadata { id, .. } = metadata;
    id.delete()
}

Function deny_cap_id​

public(package) fun deny_cap_id<T>(metadata: &sui::coin::RegulatedCoinMetadata<T>): sui::object::ID
Click to open
Implementation
public(package) fun deny_cap_id<T>(metadata: &RegulatedCoinMetadata<T>): ID {
    metadata.deny_cap_object
}

Function new_deny_cap_v2​

public(package) fun new_deny_cap_v2<T>(allow_global_pause: bool, ctx: &mut sui::tx_context::TxContext): sui::coin::DenyCapV2<T>
Click to open
Implementation
public(package) fun new_deny_cap_v2<T>(
    allow_global_pause: bool,
    ctx: &mut TxContext,
): DenyCapV2<T> {
    DenyCapV2 {
        id: object::new(ctx),
        allow_global_pause,
    }
}

Function new_treasury_cap​

public(package) fun new_treasury_cap<T>(ctx: &mut sui::tx_context::TxContext): sui::coin::TreasuryCap<T>
Click to open
Implementation
public(package) fun new_treasury_cap<T>(ctx: &mut TxContext): TreasuryCap<T> {
    TreasuryCap {
        id: object::new(ctx),
        total_supply: balance::create_supply_internal(),
    }
}

Function allow_global_pause​

public(package) fun allow_global_pause<T>(cap: &sui::coin::DenyCapV2<T>): bool
Click to open
Implementation
public(package) fun allow_global_pause<T>(cap: &DenyCapV2<T>): bool {
    cap.allow_global_pause
}

Function supply​

public fun supply<T>(treasury: &mut sui::coin::TreasuryCap<T>): &sui::balance::Supply<T>
Click to open
Implementation
public fun supply<T>(treasury: &mut TreasuryCap<T>): &Supply<T> {
    &treasury.total_supply
}

Function create_regulated_currency​

This creates a new currency, via 

create_currency
, but with an extra capability that allows for specific addresses to have their coins frozen. Those addresses cannot interact with the coin as input objects.

public fun create_regulated_currency<T: drop>(witness: T, decimals: u8, symbol: vector<u8>, name: vector<u8>, description: vector<u8>, icon_url: std::option::Option<sui::url::Url>, ctx: &mut sui::tx_context::TxContext): (sui::coin::TreasuryCap<T>, sui::coin::DenyCap<T>, sui::coin::CoinMetadata<T>)
Click to open
Implementation
public fun create_regulated_currency<T: drop>(
    witness: T,
    decimals: u8,
    symbol: vector<u8>,
    name: vector<u8>,
    description: vector<u8>,
    icon_url: Option<Url>,
    ctx: &mut TxContext,
): (TreasuryCap<T>, DenyCap<T>, CoinMetadata<T>) {
    let (treasury_cap, metadata) = create_currency(
        witness,
        decimals,
        symbol,
        name,
        description,
        icon_url,
        ctx,
    );
    let deny_cap = DenyCap {
        id: object::new(ctx),
    };
    transfer::freeze_object(RegulatedCoinMetadata<T> {
        id: object::new(ctx),
        coin_metadata_object: object::id(&metadata),
        deny_cap_object: object::id(&deny_cap),
    });
    (treasury_cap, deny_cap, metadata)
}

Function deny_list_add​

Adds the given address to the deny list, preventing it from interacting with the specified coin type as an input to a transaction.

public fun deny_list_add<T>(deny_list: &mut sui::deny_list::DenyList, _deny_cap: &mut sui::coin::DenyCap<T>, addr: address, _ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public fun deny_list_add<T>(
    deny_list: &mut DenyList,
    _deny_cap: &mut DenyCap<T>,
    addr: address,
    _ctx: &mut TxContext,
) {
    let type = type_name::into_string(type_name::get_with_original_ids<T>()).into_bytes();
    deny_list.v1_add(DENY_LIST_COIN_INDEX, type, addr)
}

Function deny_list_remove​

Removes an address from the deny list. Aborts with ENotFrozen if the address is not already in the list.

public fun deny_list_remove<T>(deny_list: &mut sui::deny_list::DenyList, _deny_cap: &mut sui::coin::DenyCap<T>, addr: address, _ctx: &mut sui::tx_context::TxContext)
Click to open
Implementation
public fun deny_list_remove<T>(
    deny_list: &mut DenyList,
    _deny_cap: &mut DenyCap<T>,
    addr: address,
    _ctx: &mut TxContext,
) {
    let type = type_name::into_string(type_name::get_with_original_ids<T>()).into_bytes();
    deny_list.v1_remove(DENY_LIST_COIN_INDEX, type, addr)
}

Function deny_list_contains​

Returns true iff the given address is denied for the given coin type. It will return false if given a non-coin type.

public fun deny_list_contains<T>(deny_list: &sui::deny_list::DenyList, addr: address): bool
Click to open
Implementation
public fun deny_list_contains<T>(deny_list: &DenyList, addr: address): bool {
    let name = type_name::get_with_original_ids<T>();
    if (type_name::is_primitive(&name)) return false;
    let type = type_name::into_string(name).into_bytes();
    deny_list.v1_contains(DENY_LIST_COIN_INDEX, type, addr)
}