Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Module 0x4::royalty

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;

Resource 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.

Struct MutatorRef

This enables creating or overwriting a MutatorRef.

struct MutatorRef has drop, store
Fields
inner: object::ExtendRef

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;

Function 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);
}

Function 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);
}

Function 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 }
}

Function 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 }
}

Function exists_at 

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

Function 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);
}

Function 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()
    }
}

Function denominator 

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

Function numerator 

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

Function payee_address 

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