Skip to main content

Module iota::transfer

use iota::address;
use iota::hex;
use iota::object;
use iota::tx_context;
use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::vector;

Module Functions​

pub freeze_object​

Freeze obj. After freezing obj becomes immutable and can no longer be transferred or mutated. This function has custom rules performed by the IOTA Move bytecode verifier that ensures that T is an object defined in the module where freeze_object is invoked. Use public_freeze_object to freeze an object with store outside of its module.

public fun freeze_object<T: key>(obj: T)
Implementation
public fun freeze_object<T: key>(obj: T) {
    freeze_object_impl(obj)
}

pub public_freeze_object​

Freeze obj. After freezing obj becomes immutable and can no longer be transferred or mutated. The object must have store to be frozen outside of its module.

public fun public_freeze_object<T: key, store>(obj: T)
Implementation
public fun public_freeze_object<T: key + store>(obj: T) {
    freeze_object_impl(obj)
}

pub public_receive​

Given mutable (i.e., locked) access to the parent and a Receiving argument referencing an object of type T owned by parent use the to_receive argument to receive and return the referenced owned object of type T. The object must have store to be received outside of its defining module.

public fun public_receive<T: key, store>(parent: &mut iota::object::UID, to_receive: iota::transfer::Receiving<T>): T
Implementation
public fun public_receive<T: key + store>(parent: &mut UID, to_receive: Receiving<T>): T {
    let Receiving {
        id,
        version,
    } = to_receive;
    receive_impl(parent.to_address(), id, version)
}

pub public_share_object​

Turn the given object into a mutable shared object that everyone can access and mutate. This is irreversible, i.e. once an object is shared, it will stay shared forever. Aborts with ESharedNonNewObject of the object being shared was not created in this transaction. This restriction may be relaxed in the future. The object must have store to be shared outside of its module.

public fun public_share_object<T: key, store>(obj: T)
Implementation
public fun public_share_object<T: key + store>(obj: T) {
    share_object_impl(obj)
}

pub public_transfer​

Transfer ownership of obj to recipient. obj must have the key attribute, which (in turn) ensures that obj has a globally unique ID. Note that if the recipient address represents an object ID, the obj sent will be inaccessible after the transfer (though they will be retrievable at a future date once new features are added). The object must have store to be transferred outside of its module.

public fun public_transfer<T: key, store>(obj: T, recipient: address)
Implementation
public fun public_transfer<T: key + store>(obj: T, recipient: address) {
    transfer_impl(obj, recipient)
}

pub receive​

Given mutable (i.e., locked) access to the parent and a Receiving argument referencing an object of type T owned by parent use the to_receive argument to receive and return the referenced owned object of type T. This function has custom rules performed by the IOTA Move bytecode verifier that ensures that T is an object defined in the module where receive is invoked. Use public_receive to receivne an object with store outside of its module.

public fun receive<T: key>(parent: &mut iota::object::UID, to_receive: iota::transfer::Receiving<T>): T
Implementation
public fun receive<T: key>(parent: &mut UID, to_receive: Receiving<T>): T {
    let Receiving {
        id,
        version,
    } = to_receive;
    receive_impl(parent.to_address(), id, version)
}

pub share_object​

Turn the given object into a mutable shared object that everyone can access and mutate. This is irreversible, i.e. once an object is shared, it will stay shared forever. Aborts with ESharedNonNewObject of the object being shared was not created in this transaction. This restriction may be relaxed in the future. This function has custom rules performed by the IOTA Move bytecode verifier that ensures that T is an object defined in the module where share_object is invoked. Use public_share_object to share an object with store outside of its module.

public fun share_object<T: key>(obj: T)
Implementation
public fun share_object<T: key>(obj: T) {
    share_object_impl(obj)
}

pub transfer​

Transfer ownership of obj to recipient. obj must have the key attribute, which (in turn) ensures that obj has a globally unique ID. Note that if the recipient address represents an object ID, the obj sent will be inaccessible after the transfer (though they will be retrievable at a future date once new features are added). This function has custom rules performed by the IOTA Move bytecode verifier that ensures that T is an object defined in the module where transfer is invoked. Use public_transfer to transfer an object with store outside of its module.

public fun transfer<T: key>(obj: T, recipient: address)
Implementation
public fun transfer<T: key>(obj: T, recipient: address) {
    transfer_impl(obj, recipient)
}

pub(pkg) freeze_object_impl​

public(package) fun freeze_object_impl<T: key>(obj: T)
Implementation
public(package) native fun freeze_object_impl<T: key>(obj: T);

pub(pkg) share_object_impl​

public(package) fun share_object_impl<T: key>(obj: T)
Implementation
public(package) native fun share_object_impl<T: key>(obj: T);

pub(pkg) transfer_impl​

public(package) fun transfer_impl<T: key>(obj: T, recipient: address)
Implementation
public(package) native fun transfer_impl<T: key>(obj: T, recipient: address);

prv receive_impl​

fun receive_impl<T: key>(parent: address, to_receive: iota::object::ID, version: u64): T
Implementation
native fun receive_impl<T: key>(parent: address, to_receive: ID, version: u64): T;

Structs​

struct Receiving​

This represents the ability to receive an object of type T. This type is ephemeral per-transaction and cannot be stored on-chain. This does not represent the obligation to receive the object that it references, but simply the ability to receive the object with object ID id at version version if you can prove mutable access to the parent object during the transaction. Internals of this struct are opaque outside this module.

public struct Receiving<phantom T: key> has drop
Fields
id: iota::object::ID
version: u64

pub receiving_object_id​

Return the object ID that the given Receiving argument references.

public fun receiving_object_id<T: key>(receiving: &iota::transfer::Receiving<T>): iota::object::ID
Implementation
public fun receiving_object_id<T: key>(receiving: &Receiving<T>): ID {
    receiving.id
}

Constants​

err ESharedNonNewObject​

Shared an object that was previously created. Shared objects must currently be constructed in the transaction they are created.

const ESharedNonNewObject: u64 = 0;

err EBCSSerializationFailure​

Serialization of the object failed.

const EBCSSerializationFailure: u64 = 1;

err EReceivingObjectTypeMismatch​

The object being received is not of the expected type.

const EReceivingObjectTypeMismatch: u64 = 2;

err EUnableToReceiveObject​

Represents both the case where the object does not exist and the case where the object is not able to be accessed through the parent that is passed-in.

const EUnableToReceiveObject: u64 = 3;

err ESharedObjectOperationNotSupported​

Shared object operations such as wrapping, freezing, and converting to owned are not allowed.

const ESharedObjectOperationNotSupported: u64 = 4;

err EAccountCannotReceiveObject​

const EAccountCannotReceiveObject: u64 = 5;