Module sui::accumulator

• Struct AccumulatorRoot
• Struct U128
• Struct Key
• Constants
• Function create
• Function root_id
• Function root_id_mut
• Function create_u128
• Function destroy_u128
• Function update_u128
• Function is_zero_u128
• Function accumulator_key
• Function accumulator_address
• Function root_has_accumulator
• Function root_add_accumulator
• Function root_borrow_accumulator_mut
• Function root_remove_accumulator
• Function emit_deposit_event
• Function emit_withdraw_event

use std::ascii;
use std::bcs;
use std::option;
use std::string;
use std::vector;
use sui::address;
use sui::dynamic_field;
use sui::hex;
use sui::object;
use sui::party;
use sui::transfer;
use sui::tx_context;
use sui::vec_map;

Struct `AccumulatorRoot`

public struct AccumulatorRoot has key

Fields

id: sui::object::UID

Struct `U128`

Storage for 128-bit accumulator values.

Currently only used to represent the sum of 64 bit values (such as Balance<T>). The additional bits are necessary to prevent overflow, as it would take 2^64 deposits of U64_MAX to cause an overflow.

public struct U128 has store

Fields

value: u128

Struct `Key`

Key is used only for computing the field id of accumulator objects. T is the type of the accumulated value, e.g. Balance<SUI>

public struct Key<phantom T> has copy, drop, store

Fields

address: address

Constants

const ENotSystemAddress: u64 = 0;

Function `create`

fun create(ctx: &sui::tx_context::TxContext)

Implementation

fun create(ctx: &TxContext) {
    assert!(ctx.sender() == @0x0, ENotSystemAddress);
    transfer::share_object(AccumulatorRoot {
        id: object::sui_accumulator_root_object_id(),
    })
}

Function `root_id`

public(package) fun root_id(accumulator_root: &sui::accumulator::AccumulatorRoot): &sui::object::UID

Implementation

public(package) fun root_id(accumulator_root: &AccumulatorRoot): &UID {
    &accumulator_root.id
}

Function `root_id_mut`

public(package) fun root_id_mut(accumulator_root: &mut sui::accumulator::AccumulatorRoot): &mut sui::object::UID

Implementation

public(package) fun root_id_mut(accumulator_root: &mut AccumulatorRoot): &mut UID {
    &mut accumulator_root.id
}

Function `create_u128`

public(package) fun create_u128(value: u128): sui::accumulator::U128

Implementation

public(package) fun create_u128(value: u128): U128 {
    U128 { value }
}

Function `destroy_u128`

public(package) fun destroy_u128(u128: sui::accumulator::U128)

Implementation

public(package) fun destroy_u128(u128: U128) {
    let U128 { value: _ } = u128;
}

Function `update_u128`

public(package) fun update_u128(u128: &mut sui::accumulator::U128, merge: u128, split: u128)

Implementation

public(package) fun update_u128(u128: &mut U128, merge: u128, split: u128) {
    u128.value = u128.value + merge - split;
}

Function `is_zero_u128`

public(package) fun is_zero_u128(u128: &sui::accumulator::U128): bool

Implementation

public(package) fun is_zero_u128(u128: &U128): bool {
    u128.value == 0
}

Function `accumulator_key`

public(package) fun accumulator_key<T>(address: address): sui::accumulator::Key<T>

Implementation

public(package) fun accumulator_key<T>(address: address): Key<T> {
    Key { address }
}

Function `accumulator_address`

public(package) fun accumulator_address<T>(address: address): address

Implementation

public(package) fun accumulator_address<T>(address: address): address {
    let key = Key<T> { address };
    dynamic_field::hash_type_and_key(sui_accumulator_root_address(), key)
}

Function `root_has_accumulator`

Balance object methods

public(package) fun root_has_accumulator<K, V: store>(accumulator_root: &sui::accumulator::AccumulatorRoot, name: sui::accumulator::Key<K>): bool

Implementation

public(package) fun root_has_accumulator<K, V: store>(
    accumulator_root: &AccumulatorRoot,
    name: Key<K>,
): bool {
    dynamic_field::exists_with_type<Key<K>, V>(&accumulator_root.id, name)
}

Function `root_add_accumulator`

public(package) fun root_add_accumulator<K, V: store>(accumulator_root: &mut sui::accumulator::AccumulatorRoot, name: sui::accumulator::Key<K>, value: V)

Implementation

public(package) fun root_add_accumulator<K, V: store>(
    accumulator_root: &mut AccumulatorRoot,
    name: Key<K>,
    value: V,
) {
    dynamic_field::add(&mut accumulator_root.id, name, value);
}

Function `root_borrow_accumulator_mut`

public(package) fun root_borrow_accumulator_mut<K, V: store>(accumulator_root: &mut sui::accumulator::AccumulatorRoot, name: sui::accumulator::Key<K>): &mut V

Implementation

public(package) fun root_borrow_accumulator_mut<K, V: store>(
    accumulator_root: &mut AccumulatorRoot,
    name: Key<K>,
): &mut V {
    dynamic_field::borrow_mut<Key<K>, V>(&mut accumulator_root.id, name)
}

Function `root_remove_accumulator`

public(package) fun root_remove_accumulator<K, V: store>(accumulator_root: &mut sui::accumulator::AccumulatorRoot, name: sui::accumulator::Key<K>): V

Implementation

public(package) fun root_remove_accumulator<K, V: store>(
    accumulator_root: &mut AccumulatorRoot,
    name: Key<K>,
): V {
    dynamic_field::remove<Key<K>, V>(&mut accumulator_root.id, name)
}

Function `emit_deposit_event`

public(package) fun emit_deposit_event<T>(accumulator: address, recipient: address, amount: u64)

Implementation

public(package) native fun emit_deposit_event<T>(
    accumulator: address,
    recipient: address,
    amount: u64,
);

Function `emit_withdraw_event`

public(package) fun emit_withdraw_event<T>(accumulator: address, owner: address, amount: u64)

Implementation

public(package) native fun emit_withdraw_event<T>(
    accumulator: address,
    owner: address,
    amount: u64,
);