@waterx/sdk 3.0.1 → 3.1.0

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

@@ -0,0 +1,626 @@
+"use strict";
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyedBigVector = void 0;
+exports.Element = Element;
+exports.Slice = Slice;
+exports.duplicateKey = duplicateKey;
+exports.indexOutOfBounds = indexOutOfBounds;
+exports.invalidSliceSize = invalidSliceSize;
+exports.keyNotFound = keyNotFound;
+exports.maxSliceAmountReached = maxSliceAmountReached;
+exports.notEmpty = notEmpty;
+exports._new = _new;
+exports.sliceIdx = sliceIdx;
+exports.sliceSize = sliceSize;
+exports.length = length;
+exports.isEmpty = isEmpty;
+exports.contains = contains;
+exports.getSliceIdx = getSliceIdx;
+exports.getSliceLength = getSliceLength;
+exports.pushBack = pushBack;
+exports.popBack = popBack;
+exports.borrowSlice = borrowSlice;
+exports.borrowSlice_ = borrowSlice_;
+exports.borrowSliceMut = borrowSliceMut;
+exports.borrowSliceMut_ = borrowSliceMut_;
+exports.borrow = borrow;
+exports.borrow_ = borrow_;
+exports.borrowMut = borrowMut;
+exports.borrowMut_ = borrowMut_;
+exports.borrowByKey = borrowByKey;
+exports.borrowByKeyMut = borrowByKeyMut;
+exports.borrowFromSlice = borrowFromSlice;
+exports.borrowFromSliceMut = borrowFromSliceMut;
+exports.swapRemove = swapRemove;
+exports.swapRemove_ = swapRemove_;
+exports.swapRemoveByKey = swapRemoveByKey;
+exports.destroyEmpty = destroyEmpty;
+exports.drop = drop;
+exports.completelyDrop = completelyDrop;
+exports.trimSlice = trimSlice;
+/**
+ * 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`.
+ */
+const index_ts_1 = require("../utils/index.js");
+const bcs_1 = require("@mysten/sui/bcs");
+const type_name = __importStar(require("./deps/std/type_name.js"));
+const $moduleName = '@waterx/perp::keyed_big_vector';
+exports.KeyedBigVector = new index_ts_1.MoveStruct({ name: `${$moduleName}::KeyedBigVector`, fields: {
+        /** The unique identifier of the KeyedBigVector object. */
+        id: bcs_1.bcs.Address,
+        /** The type name of the keys. */
+        key_type: type_name.TypeName,
+        /** The type name of the values. */
+        value_type: type_name.TypeName,
+        /** The index of the latest slice. */
+        slice_idx: bcs_1.bcs.u16(),
+        /** The maximum size of each slice. */
+        slice_size: bcs_1.bcs.u32(),
+        /** The total number of elements in the KeyedBigVector. */
+        length: bcs_1.bcs.u64()
+    } });
+/** An element in the KeyedBigVector, containing a key-value pair. */
+function Element(...typeParameters) {
+    return new index_ts_1.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. */
+function Slice(...typeParameters) {
+    return new index_ts_1.MoveStruct({ name: `${$moduleName}::Slice<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            /** The index of the slice. */
+            idx: bcs_1.bcs.u16(),
+            /** The vector that stores the elements. */
+            vector: bcs_1.bcs.vector(Element(typeParameters[0], typeParameters[1]))
+        } });
+}
+/** Error for a duplicate key. */
+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. */
+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. */
+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. */
+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. */
+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. */
+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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the index of the latest slice in the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns the maximum size of each slice in the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns the total number of elements in the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Returns `true` if the KeyedBigVector is empty. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns `true` if there is a value associated with the key `key` in the
+ * KeyedBigVector.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the index of the slice. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Returns the number of elements in the slice. */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.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.
+ */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a slice from the KeyedBigVector at `slice_idx`. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable slice from the KeyedBigVector at `slice_idx`. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an element at index `i` from the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable element at index `i` from the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an element by its key from the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable element by its key from the KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows an element at index `i` from a slice. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Borrows a mutable element at index `i` from a slice. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Swaps the element at index `i` with the last element and removes it. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Swaps the element with the given key with the last element and removes it. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Destroys an empty KeyedBigVector. Aborts if the KeyedBigVector is not empty. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Destroys a KeyedBigVector. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Destroys a KeyedBigVector and its elements completely. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** Removes an empty slice after an element has been removed from it. */
+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: (0, index_ts_1.normalizeMoveArguments)(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}