Module sui::borrow

A simple library that enables hot-potato-locked borrow mechanics.

With Programmable transactions, it is possible to borrow a value within a transaction, use it and put back in the end. Hot-potato Borrow makes sure the object is returned and was not swapped for another one.

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

Struct Referent

An object wrapping a T and providing the borrow API.

public struct Referent<T: key, store> has store

Click to open

Fields

id: address

value: std::option::Option<T>

Struct Borrow

A hot potato making sure the object is put back once borrowed.

public struct Borrow

Click to open

Fields

ref: address

obj: sui::object::ID

Constants

The Borrow does not match the Referent.

const EWrongBorrow: u64 = 0;

An attempt to swap the Referent.value with another object of the same type.

const EWrongValue: u64 = 1;

Function new

Create a new Referent struct

public fun new<T: key, store>(value: T, ctx: &mut sui::tx_context::TxContext): sui::borrow::Referent<T>

Function borrow

Borrow the T from the Referent, receiving the T and a Borrow hot potato.

public fun borrow<T: key, store>(self: &mut sui::borrow::Referent<T>): (T, sui::borrow::Borrow)

Function put_back

Put an object and the Borrow hot potato back.

public fun put_back<T: key, store>(self: &mut sui::borrow::Referent<T>, value: T, borrow: sui::borrow::Borrow)

Function destroy

Unpack the Referent struct and return the value.

public fun destroy<T: key, store>(self: sui::borrow::Referent<T>): T