Skip to content
Aptos Docs

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::error;
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 = object::generate_signer(ref);
    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 = object::address_from_extend_ref(&mutator_ref.inner);
    if (exists<Royalty>(addr)) {
        move_from<Royalty>(addr);
    };


    let signer = object::generate_signer_for_extending(&mutator_ref.inner);
    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 = object::object_address(&maybe_royalty);
    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
}