@waterx/sdk 2.1.0

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

@@ -0,0 +1,298 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Shared `Oracle` registry. Holds one `PriceAggregator` per ticker as a DOF child.
+ *
+ * PTB flow:
+ *
+ * ```text
+ * let collector = oracle::new_collector(b"BTC_USD".to_string());
+ * waterx_rule::feed(&mut collector, &waterx_config, &clock, ...);
+ * oracle::aggregate(&mut oracle, collector, &clock);
+ * // ... later in the same tx:
+ * let price = oracle::get_price(&oracle, b"BTC_USD".to_string(), &clock);
+ * let historical = oracle::get_price_at_timestamp(&oracle, b"BTC_USD".to_string(), option::some(ts));
+ * ```
+ */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const VersionAllowed: MoveStruct<{
+    version: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+}, "@waterx/oracle::oracle::VersionAllowed">;
+export declare const VersionDisallowed: MoveStruct<{
+    version: import("@mysten/sui/bcs").BcsType<number, number, "u16">;
+}, "@waterx/oracle::oracle::VersionDisallowed">;
+export declare const Oracle: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    /**
+     * Allowed package versions. `assert_version` aborts unless the current
+     * `version::package_version()` is in this set.
+     */
+    allowed_versions: MoveStruct<any, any>;
+}, "@waterx/oracle::oracle::Oracle">;
+export declare const ListingCap: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@waterx/oracle::oracle::ListingCap">;
+export interface AssertVersionArguments {
+    oracle: RawTransactionArgument<string>;
+}
+export interface AssertVersionOptions {
+    package?: string;
+    arguments: AssertVersionArguments | [
+        oracle: RawTransactionArgument<string>
+    ];
+}
+export declare function assertVersion(options: AssertVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsVersionAllowedArguments {
+    oracle: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface IsVersionAllowedOptions {
+    package?: string;
+    arguments: IsVersionAllowedArguments | [
+        oracle: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+}
+export declare function isVersionAllowed(options: IsVersionAllowedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AllowVersionArguments {
+    oracle: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface AllowVersionOptions {
+    package?: string;
+    arguments: AllowVersionArguments | [
+        oracle: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+}
+export declare function allowVersion(options: AllowVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DisallowVersionArguments {
+    oracle: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    v: RawTransactionArgument<number>;
+}
+export interface DisallowVersionOptions {
+    package?: string;
+    arguments: DisallowVersionArguments | [
+        oracle: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        v: RawTransactionArgument<number>
+    ];
+}
+export declare function disallowVersion(options: DisallowVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddAggregatorArguments {
+    oracle: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    weightThreshold: RawTransactionArgument<number | bigint>;
+    outlierToleranceBps: RawTransactionArgument<number | bigint>;
+}
+export interface AddAggregatorOptions {
+    package?: string;
+    arguments: AddAggregatorArguments | [
+        oracle: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        weightThreshold: RawTransactionArgument<number | bigint>,
+        outlierToleranceBps: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function addAggregator(options: AddAggregatorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetRuleWeightArguments {
+    oracle: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    weight: RawTransactionArgument<number>;
+}
+export interface SetRuleWeightOptions {
+    package?: string;
+    arguments: SetRuleWeightArguments | [
+        oracle: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        weight: RawTransactionArgument<number>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function setRuleWeight(options: SetRuleWeightOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetWeightThresholdArguments {
+    oracle: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    weightThreshold: RawTransactionArgument<number | bigint>;
+}
+export interface SetWeightThresholdOptions {
+    package?: string;
+    arguments: SetWeightThresholdArguments | [
+        oracle: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        weightThreshold: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function setWeightThreshold(options: SetWeightThresholdOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface SetOutlierToleranceArguments {
+    oracle: RawTransactionArgument<string>;
+    Cap: RawTransactionArgument<string>;
+    symbol: RawTransactionArgument<string>;
+    outlierToleranceBps: RawTransactionArgument<number | bigint>;
+}
+export interface SetOutlierToleranceOptions {
+    package?: string;
+    arguments: SetOutlierToleranceArguments | [
+        oracle: RawTransactionArgument<string>,
+        Cap: RawTransactionArgument<string>,
+        symbol: RawTransactionArgument<string>,
+        outlierToleranceBps: RawTransactionArgument<number | bigint>
+    ];
+}
+export declare function setOutlierTolerance(options: SetOutlierToleranceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface NewCollectorArguments {
+    symbol: RawTransactionArgument<string>;
+}
+export interface NewCollectorOptions {
+    package?: string;
+    arguments: NewCollectorArguments | [
+        symbol: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Creates a hot-potato collector for a given ticker. The ticker must already be
+ * listed (or `aggregate` will abort), but the membership check happens at
+ * `aggregate` time so no mutable borrow on the oracle is taken here.
+ */
+export declare function newCollector(options: NewCollectorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AggregateArguments {
+    oracle: RawTransactionArgument<string>;
+    collector: RawTransactionArgument<string>;
+}
+export interface AggregateOptions {
+    package?: string;
+    arguments: AggregateArguments | [
+        oracle: RawTransactionArgument<string>,
+        collector: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Consumes the collector and writes the aggregated price into the matching
+ * aggregator with `last_update_ms = clock.timestamp_ms()`.
+ */
+export declare function aggregate(options: AggregateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RegisterPriceAtTimestampArguments {
+    oracle: RawTransactionArgument<string>;
+    collector: RawTransactionArgument<string>;
+}
+export interface RegisterPriceAtTimestampOptions {
+    package?: string;
+    arguments: RegisterPriceAtTimestampArguments | [
+        oracle: RawTransactionArgument<string>,
+        collector: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Consumes a verified historical collector and stores an exact historical snapshot
+ * at the collector's verified timestamp without touching the latest price.
+ */
+export declare function registerPriceAtTimestamp(options: RegisterPriceAtTimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetPriceArguments {
+    oracle: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface GetPriceOptions {
+    package?: string;
+    arguments: GetPriceArguments | [
+        oracle: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Reads the latest aggregated price for `ticker`.
+ *
+ * This is intentionally strict: the latest price must have been written in the
+ * same PTB, using this same `Clock` timestamp.
+ */
+export declare function getPrice(options: GetPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface GetPriceAtTimestampArguments {
+    oracle: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint | null>;
+}
+export interface GetPriceAtTimestampOptions {
+    package?: string;
+    arguments: GetPriceAtTimestampArguments | [
+        oracle: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint | null>
+    ];
+}
+/**
+ * Reads the exact historical price written at `timestamp_ms`.
+ *
+ * Passing `none` returns the raw latest value without a freshness check. Use
+ * `get_price` for current-price consumer paths that require same-PTB freshness.
+ */
+export declare function getPriceAtTimestamp(options: GetPriceAtTimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RemovePriceAtTimestampArguments {
+    oracle: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+    timestampMs: RawTransactionArgument<number | bigint>;
+}
+export interface RemovePriceAtTimestampOptions {
+    package?: string;
+    arguments: RemovePriceAtTimestampArguments | [
+        oracle: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>,
+        timestampMs: RawTransactionArgument<number | bigint>
+    ];
+}
+/**
+ * Removes the exact historical price snapshot at `timestamp_ms` so the caller can
+ * reclaim the dynamic-field storage rebate. Latest price is unchanged.
+ */
+export declare function removePriceAtTimestamp(options: RemovePriceAtTimestampOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UnsafeGetLatestPriceArguments {
+    oracle: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface UnsafeGetLatestPriceOptions {
+    package?: string;
+    arguments: UnsafeGetLatestPriceArguments | [
+        oracle: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+}
+/**
+ * Reads the latest aggregated price without the freshness check. For
+ * view/off-chain pricing - never call from a path that updates state.
+ */
+export declare function unsafeGetLatestPrice(options: UnsafeGetLatestPriceOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface IsListedArguments {
+    oracle: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface IsListedOptions {
+    package?: string;
+    arguments: IsListedArguments | [
+        oracle: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+}
+export declare function isListed(options: IsListedOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AggregatorArguments {
+    oracle: RawTransactionArgument<string>;
+    ticker: RawTransactionArgument<string>;
+}
+export interface AggregatorOptions {
+    package?: string;
+    arguments: AggregatorArguments | [
+        oracle: RawTransactionArgument<string>,
+        ticker: RawTransactionArgument<string>
+    ];
+}
+export declare function aggregator(options: AggregatorOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

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

@@ -0,0 +1,323 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Shared `Oracle` registry. Holds one `PriceAggregator` per ticker as a DOF child.
+ *
+ * PTB flow:
+ *
+ * ```text
+ * let collector = oracle::new_collector(b"BTC_USD".to_string());
+ * waterx_rule::feed(&mut collector, &waterx_config, &clock, ...);
+ * oracle::aggregate(&mut oracle, collector, &clock);
+ * // ... later in the same tx:
+ * let price = oracle::get_price(&oracle, b"BTC_USD".to_string(), &clock);
+ * let historical = oracle::get_price_at_timestamp(&oracle, b"BTC_USD".to_string(), option::some(ts));
+ * ```
+ */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+import * as vec_set from "./deps/sui/vec_set.js";
+const $moduleName = '@waterx/oracle::oracle';
+export const VersionAllowed = new MoveStruct({ name: `${$moduleName}::VersionAllowed`, fields: {
+        version: bcs.u16()
+    } });
+export const VersionDisallowed = new MoveStruct({ name: `${$moduleName}::VersionDisallowed`, fields: {
+        version: bcs.u16()
+    } });
+export const Oracle = new MoveStruct({ name: `${$moduleName}::Oracle`, fields: {
+        id: bcs.Address,
+        /**
+         * Allowed package versions. `assert_version` aborts unless the current
+         * `version::package_version()` is in this set.
+         */
+        allowed_versions: vec_set.VecSet(bcs.u16())
+    } });
+export const ListingCap = new MoveStruct({ name: `${$moduleName}::ListingCap`, fields: {
+        id: bcs.Address
+    } });
+export function assertVersion(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["oracle"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'assert_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isVersionAllowed(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        'u16'
+    ];
+    const parameterNames = ["oracle", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'is_version_allowed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function allowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["oracle", "Cap", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'allow_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function disallowVersion(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        'u16'
+    ];
+    const parameterNames = ["oracle", "Cap", "v"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'disallow_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function addAggregator(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["oracle", "Cap", "symbol", "weightThreshold", "outlierToleranceBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'add_aggregator',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function setRuleWeight(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        'u8'
+    ];
+    const parameterNames = ["oracle", "Cap", "symbol", "weight"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'set_rule_weight',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function setWeightThreshold(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        'u64'
+    ];
+    const parameterNames = ["oracle", "Cap", "symbol", "weightThreshold"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'set_weight_threshold',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function setOutlierTolerance(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x1::string::String',
+        'u64'
+    ];
+    const parameterNames = ["oracle", "Cap", "symbol", "outlierToleranceBps"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'set_outlier_tolerance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Creates a hot-potato collector for a given ticker. The ticker must already be
+ * listed (or `aggregate` will abort), but the membership check happens at
+ * `aggregate` time so no mutable borrow on the oracle is taken here.
+ */
+export function newCollector(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        '0x1::string::String'
+    ];
+    const parameterNames = ["symbol"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'new_collector',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Consumes the collector and writes the aggregated price into the matching
+ * aggregator with `last_update_ms = clock.timestamp_ms()`.
+ */
+export function aggregate(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null,
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["oracle", "collector"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'aggregate',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Consumes a verified historical collector and stores an exact historical snapshot
+ * at the collector's verified timestamp without touching the latest price.
+ */
+export function registerPriceAtTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["oracle", "collector"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'register_price_at_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Reads the latest aggregated price for `ticker`.
+ *
+ * This is intentionally strict: the latest price must have been written in the
+ * same PTB, using this same `Clock` timestamp.
+ */
+export function getPrice(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String',
+        '0x2::clock::Clock'
+    ];
+    const parameterNames = ["oracle", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'get_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Reads the exact historical price written at `timestamp_ms`.
+ *
+ * Passing `none` returns the raw latest value without a freshness check. Use
+ * `get_price` for current-price consumer paths that require same-PTB freshness.
+ */
+export function getPriceAtTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String',
+        '0x1::option::Option<u64>'
+    ];
+    const parameterNames = ["oracle", "ticker", "timestampMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'get_price_at_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Removes the exact historical price snapshot at `timestamp_ms` so the caller can
+ * reclaim the dynamic-field storage rebate. Latest price is unchanged.
+ */
+export function removePriceAtTimestamp(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String',
+        'u64'
+    ];
+    const parameterNames = ["oracle", "ticker", "timestampMs"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'remove_price_at_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Reads the latest aggregated price without the freshness check. For
+ * view/off-chain pricing - never call from a path that updates state.
+ */
+export function unsafeGetLatestPrice(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["oracle", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'unsafe_get_latest_price',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function isListed(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["oracle", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'is_listed',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function aggregator(options) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["oracle", "ticker"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'oracle',
+        function: 'aggregator',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}

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

@@ -0,0 +1,10 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type Transaction } from '@mysten/sui/transactions';
+export interface PackageVersionOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function packageVersion(options?: PackageVersionOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

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

@@ -0,0 +1,8 @@
+export function packageVersion(options = {}) {
+    const packageAddress = options.package ?? '@waterx/oracle';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'version',
+        function: 'package_version',
+    });
+}