@waterx/sdk 2.1.0

package/dist/src/generated/waterx_perp/keyed_big_vector.js

@@ -0,0 +1,554 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * This module implements a `KeyedBigVector`, a data structure that combines the
+ * features of a `BigVector` and a `Table`. It allows for both indexed and keyed
+ * access to a large number of elements by storing them in slices, while
+ * maintaining a mapping from keys to indices in a `Table`.
+ */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as type_name from "./deps/std/type_name.js";
+import * as type_name_1 from "./deps/std/type_name.js";
+const $moduleName = '@waterx/perp::keyed_big_vector';
+export const KeyedBigVector = new MoveStruct({ name: `${$moduleName}::KeyedBigVector`, fields: {
+        /** The unique identifier of the KeyedBigVector object. */
+        id: bcs.Address,
+        /** The type name of the keys. */
+        key_type: type_name.TypeName,
+        /** The type name of the values. */
+        value_type: type_name_1.TypeName,
+        /** The index of the latest slice. */
+        slice_idx: bcs.u16(),
+        /** The maximum size of each slice. */
+        slice_size: bcs.u32(),
+        /** The total number of elements in the KeyedBigVector. */
+        length: bcs.u64()
+    } });
+/** An element in the KeyedBigVector, containing a key-value pair. */
+export function Element(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Element<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            /** The key of the element. */
+            key: typeParameters[0],
+            /** The value of the element. */
+            value: typeParameters[1]
+        } });
+}
+/** A slice of the KeyedBigVector, containing a vector of elements. */
+export function Slice(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Slice<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            /** The index of the slice. */
+            idx: bcs.u16(),
+            /** The vector that stores the elements. */
+            vector: bcs.vector(Element(typeParameters[0], typeParameters[1]))
+        } });
+}
+/** Error for a duplicate key. */
+export function duplicateKey(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'duplicate_key',
+    });
+}
+/** Error for an out-of-bounds index. */
+export function indexOutOfBounds(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'index_out_of_bounds',
+    });
+}
+/** Error for an invalid slice size. */
+export function invalidSliceSize(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'invalid_slice_size',
+    });
+}
+/** Error when a key is not found. */
+export function keyNotFound(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'key_not_found',
+    });
+}
+/** Error when the maximum number of slices is reached. */
+export function maxSliceAmountReached(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'max_slice_amount_reached',
+    });
+}
+/** Error when trying to destroy a non-empty KeyedBigVector. */
+export function notEmpty(options = {}) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'not_empty',
+    });
+}
+/**
+ * Creates a new `KeyedBigVector`. The `slice_size` determines the maximum number
+ * of elements in each slice.
+ */
+export function _new(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        'u32'
+    ];
+    const parameterNames = ["sliceSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the index of the latest slice in the KeyedBigVector. */
+export function sliceIdx(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'slice_idx',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns the maximum size of each slice in the KeyedBigVector. */
+export function sliceSize(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'slice_size',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns the total number of elements in the KeyedBigVector. */
+export function length(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'length',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns `true` if the KeyedBigVector is empty. */
+export function isEmpty(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'is_empty',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns `true` if there is a value associated with the key `key` in the
+ * KeyedBigVector.
+ */
+export function contains(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["kbv", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'contains',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the index of the slice. */
+export function getSliceIdx(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["slice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'get_slice_idx',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the number of elements in the slice. */
+export function getSliceLength(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["slice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'get_slice_length',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Pushes a new element to the end of the KeyedBigVector. Aborts if the key already
+ * exists or if the maximum number of slices is reached.
+ */
+export function pushBack(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        `${options.typeArguments[1]}`
+    ];
+    const parameterNames = ["kbv", "key", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'push_back',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/**
+ * Pops an element from the end of the KeyedBigVector and returns its key and
+ * value. Aborts if the KeyedBigVector is empty.
+ */
+export function popBack(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'pop_back',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a slice from the KeyedBigVector at `slice_idx`. */
+export function borrowSlice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["kbv", "sliceIdx"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_slice',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function borrowSlice_(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        '0x2::object::ID',
+        'u16'
+    ];
+    const parameterNames = ["id", "sliceIdx"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_slice_',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable slice from the KeyedBigVector at `slice_idx`. */
+export function borrowSliceMut(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["kbv", "sliceIdx"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_slice_mut',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function borrowSliceMut_(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        '0x2::object::ID',
+        'u16'
+    ];
+    const parameterNames = ["id", "sliceIdx"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_slice_mut_',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an element at index `i` from the KeyedBigVector. */
+export function borrow(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["kbv", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function borrow_(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["kbv", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable element at index `i` from the KeyedBigVector. */
+export function borrowMut(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["kbv", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_mut',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function borrowMut_(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["kbv", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_mut_',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an element by its key from the KeyedBigVector. */
+export function borrowByKey(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["kbv", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_by_key',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable element by its key from the KeyedBigVector. */
+export function borrowByKeyMut(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["kbv", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_by_key_mut',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an element at index `i` from a slice. */
+export function borrowFromSlice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["slice", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_from_slice',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable element at index `i` from a slice. */
+export function borrowFromSliceMut(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["slice", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'borrow_from_slice_mut',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Swaps the element at index `i` with the last element and removes it. */
+export function swapRemove(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["kbv", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'swap_remove',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function swapRemove_(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["kbv", "i"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'swap_remove_',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Swaps the element with the given key with the last element and removes it. */
+export function swapRemoveByKey(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`
+    ];
+    const parameterNames = ["kbv", "key"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'swap_remove_by_key',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Destroys an empty KeyedBigVector. Aborts if the KeyedBigVector is not empty. */
+export function destroyEmpty(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'destroy_empty',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Destroys a KeyedBigVector. */
+export function drop(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'drop',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Destroys a KeyedBigVector and its elements completely. */
+export function completelyDrop(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'completely_drop',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Removes an empty slice after an element has been removed from it. */
+export function trimSlice(options) {
+    const packageAddress = options.package ?? '@waterx/perp';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["kbv"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'keyed_big_vector',
+        function: 'trim_slice',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}