@waterx/sdk 2.1.0

package/dist/src/generated/waterx_oracle/aggregator.js

@@ -0,0 +1,213 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Per-ticker price aggregator. Stored as a DOF child on `Oracle`. */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as type_name from "./deps/std/type_name.js";
+import * as float from "./deps/bucket_v2_framework/float.js";
+import * as float_1 from "./deps/bucket_v2_framework/float.js";
+const $moduleName = '@waterx/oracle::aggregator';
+export const NewPriceAggregator = new MoveStruct({ name: `${$moduleName}::NewPriceAggregator`, fields: {
+        aggregator_id: bcs.Address,
+        symbol: bcs.string(),
+        weight_threshold: bcs.u64(),
+        outlier_tolerance_bps: bcs.u64()
+    } });
+export const WeightUpdated = new MoveStruct({ name: `${$moduleName}::WeightUpdated`, fields: {
+        aggregator_id: bcs.Address,
+        symbol: bcs.string(),
+        rule_type: bcs.string(),
+        weight: bcs.u8()
+    } });
+export const ThresholdUpdated = new MoveStruct({ name: `${$moduleName}::ThresholdUpdated`, fields: {
+        aggregator_id: bcs.Address,
+        symbol: bcs.string(),
+        weight_threshold: bcs.u64()
+    } });
+export const OutlierToleranceUpdated = new MoveStruct({ name: `${$moduleName}::OutlierToleranceUpdated`, fields: {
+        aggregator_id: bcs.Address,
+        symbol: bcs.string(),
+        outlier_tolerance_bps: bcs.u64()
+    } });
+export const PriceAggregated = new MoveStruct({ name: `${$moduleName}::PriceAggregated`, fields: {
+        aggregator_id: bcs.Address,
+        symbol: bcs.string(),
+        sources: bcs.vector(bcs.string()),
+        prices: bcs.vector(bcs.u128()),
+        weights: bcs.vector(bcs.u8()),
+        current_threshold: bcs.u64(),
+        result: bcs.u128(),
+        timestamp_ms: bcs.u64()
+    } });
+export const HistoricalPriceRegistered = new MoveStruct({ name: `${$moduleName}::HistoricalPriceRegistered`, fields: {
+        aggregator_id: bcs.Address,
+        symbol: bcs.string(),
+        sources: bcs.vector(bcs.string()),
+        prices: bcs.vector(bcs.u128()),
+        weights: bcs.vector(bcs.u8()),
+        current_threshold: bcs.u64(),
+        result: bcs.u128(),
+        timestamp_ms: bcs.u64()
+    } });
+export const PriceAggregator = new MoveStruct({ name: `${$moduleName}::PriceAggregator`, fields: {
+        id: bcs.Address,
+        /** Ticker, e.g., `b"BTC_USD".to_string()`. */
+        symbol: bcs.string(),
+        /** Rule type -> weight. Entries with weight=0 are removed. */
+        weights: vec_map.VecMap(type_name.TypeName, bcs.u8()),
+        /** Minimum total weight of contributing rules required to aggregate. */
+        weight_threshold: bcs.u64(),
+        /** Maximum allowed deviation from the weighted-average price. */
+        outlier_tolerance: float.Float,
+        /** Latest aggregated price. */
+        latest_price: float_1.Float,
+        /** `clock.timestamp_ms()` at the time `aggregate` ran. */
+        last_update_ms: bcs.u64(),
+        /** Number of exact timestamp snapshots stored as dynamic fields on this aggregator. */
+        history_count: bcs.u64()
+    } });
+export function symbol(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'symbol',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function weights(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'weights',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function weightThreshold(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'weight_threshold',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function outlierTolerance(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'outlier_tolerance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function latestPrice(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'latest_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function lastUpdateMs(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'last_update_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function historyCount(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["self"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'history_count',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Returns the latest price when `timestamp_ms` is `none`, otherwise the exact
+ * historical price written at `timestamp_ms`.
+ */
+export function priceAtTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::option::Option<u64>'
+    ];
+    const parameterNames = ["self", "timestampMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'price_at_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function hasPriceAtTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["self", "timestampMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'has_price_at_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Removes the exact historical price snapshot at `timestamp_ms`.
+ *
+ * This only deletes history dynamic fields. It never changes `latest_price` or
+ * `last_update_ms`, so consumers can still read the latest oracle value.
+ */
+export function removePriceAtTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        'u64'
+    ];
+    const parameterNames = ["self", "timestampMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'aggregator',
+        function: 'remove_price_at_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/src/generated/waterx_oracle/collector.d.ts

@@ -0,0 +1,119 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Hot-potato collector for oracle rules feeding prices for a single ticker. */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type BcsType } from '@mysten/sui/bcs';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const PriceObservation: MoveStruct<{
+    price: MoveStruct<{
+        value: BcsType<string, string | number | bigint, "u128">;
+    }, "bucket_v2_framework::float::Float">;
+    timestamp_ms: BcsType<string | null, string | number | bigint | null | undefined, "Option<u64>">;
+}, "@waterx/oracle::collector::PriceObservation">;
+export declare const PriceCollector: MoveStruct<{
+    symbol: BcsType<string, string, "string">;
+    contents: MoveStruct<{
+        contents: BcsType<{
+            key: {
+                name: string;
+            };
+            value: {
+                price: {
+                    value: string;
+                };
+                timestamp_ms: string | null;
+            } | null;
+        }[], Iterable<{
+            key: {
+                name: string;
+            };
+            value: {
+                price: {
+                    value: string | number | bigint;
+                };
+                timestamp_ms: string | number | bigint | null | undefined;
+            } | null | undefined;
+        }> & {
+            length: number;
+        }, string>;
+    }, "0x2::vec_map::VecMap<std::type_name::TypeName, Option<@waterx/oracle::collector::PriceObservation>>">;
+}, "@waterx/oracle::collector::PriceCollector">;
+export interface SymbolArguments {
+    c: RawTransactionArgument<string>;
+}
+export interface SymbolOptions {
+    package?: string;
+    arguments: SymbolArguments | [
+        c: RawTransactionArgument<string>
+    ];
+}
+export declare function symbol(options: SymbolOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ContentsArguments {
+    c: RawTransactionArgument<string>;
+}
+export interface ContentsOptions {
+    package?: string;
+    arguments: ContentsArguments | [
+        c: RawTransactionArgument<string>
+    ];
+}
+export declare function contents(options: ContentsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CollectArguments<R extends BcsType<any>> {
+    c: RawTransactionArgument<string>;
+    W: RawTransactionArgument<R>;
+    price: RawTransactionArgument<string | null>;
+}
+export interface CollectOptions<R extends BcsType<any>> {
+    package?: string;
+    arguments: CollectArguments<R> | [
+        c: RawTransactionArgument<string>,
+        W: RawTransactionArgument<R>,
+        price: RawTransactionArgument<string | null>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** A rule reports its observed price (or `none` if stale / unavailable). */
+export declare function collect<R extends BcsType<any>>(options: CollectOptions<R>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CollectAtArguments<R extends BcsType<any>> {
+    c: RawTransactionArgument<string>;
+    W: RawTransactionArgument<R>;
+    price: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+}
+export interface CollectAtOptions<R extends BcsType<any>> {
+    package?: string;
+    arguments: CollectAtArguments<R> | [
+        c: RawTransactionArgument<string>,
+        W: RawTransactionArgument<R>,
+        price: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+/** A rule reports a price that is bound to an exact source timestamp. */
+export declare function collectAt<R extends BcsType<any>>(options: CollectAtOptions<R>): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ObservationPriceArguments {
+    o: RawTransactionArgument<string>;
+}
+export interface ObservationPriceOptions {
+    package?: string;
+    arguments: ObservationPriceArguments | [
+        o: RawTransactionArgument<string>
+    ];
+}
+export declare function observationPrice(options: ObservationPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ObservationTimestampMsArguments {
+    o: RawTransactionArgument<string>;
+}
+export interface ObservationTimestampMsOptions {
+    package?: string;
+    arguments: ObservationTimestampMsArguments | [
+        o: RawTransactionArgument<string>
+    ];
+}
+export declare function observationTimestampMs(options: ObservationTimestampMsOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/src/generated/waterx_oracle/collector.js

@@ -0,0 +1,105 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Hot-potato collector for oracle rules feeding prices for a single ticker. */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as float from "./deps/bucket_v2_framework/float.js";
+import * as vec_map from "./deps/sui/vec_map.js";
+import * as type_name from "./deps/std/type_name.js";
+const $moduleName = '@waterx/oracle::collector';
+export const PriceObservation = new MoveStruct({ name: `${$moduleName}::PriceObservation`, fields: {
+        price: float.Float,
+        timestamp_ms: bcs.option(bcs.u64())
+    } });
+export const PriceCollector = new MoveStruct({ name: `${$moduleName}::PriceCollector`, fields: {
+        symbol: bcs.string(),
+        contents: vec_map.VecMap(type_name.TypeName, bcs.option(PriceObservation))
+    } });
+export function symbol(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["c"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'collector',
+        function: 'symbol',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function contents(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["c"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'collector',
+        function: 'contents',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** A rule reports its observed price (or `none` if stale / unavailable). */
+export function collect(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        '0x1::option::Option<null>'
+    ];
+    const parameterNames = ["c", "W", "price"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'collector',
+        function: 'collect',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+/** A rule reports a price that is bound to an exact source timestamp. */
+export function collectAt(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        `${options.typeArguments[0]}`,
+        null,
+        'u64'
+    ];
+    const parameterNames = ["c", "W", "price", "timestampMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'collector',
+        function: 'collect_at',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function observationPrice(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'collector',
+        function: 'observation_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function observationTimestampMs(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["o"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'collector',
+        function: 'observation_timestamp_ms',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

package/dist/src/generated/waterx_oracle/deps/bucket_v2_framework/float.d.ts

@@ -0,0 +1,8 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for floating points */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const Float: MoveStruct<{
+    value: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+}, "bucket_v2_framework::float::Float">;

package/dist/src/generated/waterx_oracle/deps/bucket_v2_framework/float.js

@@ -0,0 +1,10 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for floating points */
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'bucket_v2_framework::float';
+export const Float = new MoveStruct({ name: `${$moduleName}::Float`, fields: {
+        value: bcs.u128()
+    } });

package/dist/src/generated/waterx_oracle/deps/std/type_name.d.ts

@@ -0,0 +1,17 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Functionality for converting Move types into values. Use with care! */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const TypeName: MoveStruct<{
+    /**
+       * String representation of the type. All types are represented using their source
+       * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+       * Struct types are represented as fully qualified type names; e.g.
+       * `00000000000000000000000000000001::string::String` or
+       * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+       * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+       * 32 depending on the Move platform)
+       */
+    name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+}, "std::type_name::TypeName">;

package/dist/src/generated/waterx_oracle/deps/std/type_name.js

@@ -0,0 +1,19 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Functionality for converting Move types into values. Use with care! */
+import { MoveStruct } from "../../../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = 'std::type_name';
+export const TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
+        /**
+           * String representation of the type. All types are represented using their source
+           * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+           * Struct types are represented as fully qualified type names; e.g.
+           * `00000000000000000000000000000001::string::String` or
+           * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+           * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+           * 32 depending on the Move platform)
+           */
+        name: bcs.string()
+    } });

package/dist/src/generated/waterx_oracle/deps/sui/vec_map.d.ts

@@ -0,0 +1,36 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+/** An entry in the map */
+export declare function Entry<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    key: K;
+    value: V;
+}, `0x2::vec_map::Entry<${K["name"]}, ${V["name"]}>`>;
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export declare function VecMap<K extends BcsType<any>, V extends BcsType<any>>(...typeParameters: [
+    K,
+    V
+]): MoveStruct<{
+    contents: BcsType<{
+        key: K extends BcsType<infer U, any, string> ? U : never;
+        value: V extends BcsType<infer U, any, string> ? U : never;
+    }[], Iterable<{
+        key: K extends BcsType<any, infer U_1, string> ? U_1 : never;
+        value: V extends BcsType<any, infer U_1, string> ? U_1 : never;
+    }> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_map::VecMap<${K["name"]}, ${V["name"]}>`>;

package/dist/src/generated/waterx_oracle/deps/sui/vec_map.js

@@ -0,0 +1,27 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = '0x2::vec_map';
+/** An entry in the map */
+export function Entry(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            key: typeParameters[0],
+            value: typeParameters[1]
+        } });
+}
+/**
+ * A map data structure backed by a vector. The map is guaranteed not to contain
+ * duplicate keys, but entries are _not_ sorted by key--entries are included in
+ * insertion order. All operations are O(N) in the size of the map--the intention
+ * of this data structure is only to provide the convenience of programming against
+ * a map API. Large maps should use handwritten parent/child relationships instead.
+ * Maps that need sorted iteration rather than insertion order iteration should
+ * also be handwritten.
+ */
+export function VecMap(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+            contents: bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+        } });
+}

package/dist/src/generated/waterx_oracle/deps/sui/vec_set.d.ts

@@ -0,0 +1,16 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.ts';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export declare function VecSet<K extends BcsType<any>>(...typeParameters: [
+    K
+]): MoveStruct<any, any>;

package/dist/src/generated/waterx_oracle/deps/sui/vec_set.js

@@ -0,0 +1,19 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { bcs } from '@mysten/sui/bcs';
+import { MoveStruct } from "../../../utils/index.js";
+const $moduleName = '0x2::vec_set';
+/**
+ * A set data structure backed by a vector. The set is guaranteed not to contain
+ * duplicate keys. All operations are O(N) in the size of the set
+ *
+ * - the intention of this data structure is only to provide the convenience of
+ *   programming against a set API. Sets that need sorted iteration rather than
+ *   insertion order iteration should be handwritten.
+ */
+export function VecSet(...typeParameters) {
+    return new MoveStruct({ name: `${$moduleName}::VecSet<${typeParameters[0].name}>`, fields: {
+            contents: bcs.vector(typeParameters[0])
+        } });
+}