royalty - [mainnet]

此内容尚不支持你的语言。

This defines an object-based Royalty. The royalty can be applied to either a collection or a token. Applications should read the royalty from the token, as it will read the appropriate royalty.

use 0x1::object;
use 0x1::option;

Constants

The royalty denominator cannot be 0

const EROYALTY_DENOMINATOR_IS_ZERO: u64 = 3;

Royalty does not exist

const EROYALTY_DOES_NOT_EXIST: u64 = 1;

The royalty cannot be greater than 100%

const EROYALTY_EXCEEDS_MAXIMUM: u64 = 2;

Structs

MutatorRef

This enables creating or overwriting a MutatorRef.

struct MutatorRef has drop, store

Fields

inner: object::ExtendRef

Resources

Royalty

The royalty of a token within this collection

Royalties are optional for a collection. Royalty percentage is calculated by (numerator / denominator) * 100%

#[resource_group_member(#[group = 0x1::object::ObjectGroup])]
struct Royalty has copy, drop, key

Fields

numerator: u64

denominator: u64

payee_address: address

The recipient of royalty payments. See the shared_account for how to handle multiple creators.

Functions

init

Add a royalty, given a ConstructorRef.

public fun init(ref: &object::ConstructorRef, royalty: royalty::Royalty)

Implementation

public fun init(ref: &ConstructorRef, royalty: Royalty) {
    let signer = ref.generate_signer();
    move_to(&signer, royalty);
}

update

Set the royalty if it does not exist, replace it otherwise.

public fun update(mutator_ref: &royalty::MutatorRef, royalty: royalty::Royalty)

Implementation

public fun update(mutator_ref: &MutatorRef, royalty: Royalty) acquires Royalty {
    let addr = mutator_ref.inner.address_from_extend_ref();
    if (exists<Royalty>(addr)) {
        move_from<Royalty>(addr);
    };

    let signer = mutator_ref.inner.generate_signer_for_extending();
    move_to(&signer, royalty);
}

create

Creates a new royalty, verifying that it is a valid percentage

public fun create(numerator: u64, denominator: u64, payee_address: address): royalty::Royalty

Implementation

public fun create(numerator: u64, denominator: u64, payee_address: address): Royalty {
    assert!(denominator != 0, error::out_of_range(EROYALTY_DENOMINATOR_IS_ZERO));
    assert!(numerator <= denominator, error::out_of_range(EROYALTY_EXCEEDS_MAXIMUM));

    Royalty { numerator, denominator, payee_address }
}

generate_mutator_ref

public fun generate_mutator_ref(ref: object::ExtendRef): royalty::MutatorRef

Implementation

public fun generate_mutator_ref(ref: ExtendRef): MutatorRef {
    MutatorRef { inner: ref }
}

exists_at

public fun exists_at(addr: address): bool

Implementation

public fun exists_at(addr: address): bool {
    exists<Royalty>(addr)
}

delete

public(friend) fun delete(addr: address)

Implementation

friend fun delete(addr: address) acquires Royalty {
    assert!(exists<Royalty>(addr), error::not_found(EROYALTY_DOES_NOT_EXIST));
    move_from<Royalty>(addr);
}

get

public fun get<T: key>(maybe_royalty: object::Object<T>): option::Option<royalty::Royalty>

Implementation

public fun get<T: key>(maybe_royalty: Object<T>): Option<Royalty> acquires Royalty {
    let obj_addr = maybe_royalty.object_address();
    if (exists<Royalty>(obj_addr)) {
        option::some(Royalty[obj_addr])
    } else {
        option::none()
    }
}

denominator

public fun denominator(royalty: &royalty::Royalty): u64

Implementation

public fun denominator(royalty: &Royalty): u64 {
    royalty.denominator
}

numerator

public fun numerator(royalty: &royalty::Royalty): u64

Implementation

public fun numerator(royalty: &Royalty): u64 {
    royalty.numerator
}

payee_address

public fun payee_address(royalty: &royalty::Royalty): address

Implementation

public fun payee_address(royalty: &Royalty): address {
    royalty.payee_address
}