stable-layer-sdk 0.0.3 → 1.0.1

package/dist/generated/stable_vault_farm/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/generated/stable_vault_farm/deps/sui/vec_set.d.ts

@@ -0,0 +1,20 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { type BcsType } from '@mysten/sui/bcs';
+import { MoveStruct } from '../../../utils/index.js';
+/**
+ * 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<{
+    contents: BcsType<import("@mysten/bcs").InferBcsType<K>[], Iterable<import("@mysten/bcs").InferBcsInput<K>> & {
+        length: number;
+    }, string>;
+}, `0x2::vec_set::VecSet<${K["name"]}>`>;

package/dist/generated/stable_vault_farm/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])
+        } });
+}

package/dist/generated/stable_vault_farm/stable_vault_farm.d.ts

@@ -0,0 +1,242 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.js';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const Claim: MoveStruct<{
+    reward_type: import("@mysten/bcs").BcsType<string, string, "string">;
+    amount: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    claimer: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@local-pkg/stable_vault_farm.move::stable_vault_farm::Claim">;
+export declare const StableVaultFarmEntity: MoveStruct<{
+    dummy_field: import("@mysten/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/stable_vault_farm.move::stable_vault_farm::StableVaultFarmEntity">;
+export declare const StableVaultFarmWitness: MoveStruct<{
+    dummy_field: import("@mysten/bcs").BcsType<boolean, boolean, "bool">;
+}, "@local-pkg/stable_vault_farm.move::stable_vault_farm::StableVaultFarmWitness">;
+export declare const StableVaultFarm: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+    sheet: MoveStruct<{
+        credits: MoveStruct<{
+            contents: import("@mysten/bcs").BcsType<{
+                key: {
+                    name: string;
+                }[];
+                value: {
+                    value: string;
+                };
+            }[], Iterable<{
+                key: {
+                    name: string;
+                }[];
+                value: {
+                    value: string | number | bigint;
+                };
+            }> & {
+                length: number;
+            }, string>;
+        }, "0x2::vec_map::VecMap<bucket_v2_framework::sheet::Entity, bucket_v2_framework::liability::Credit>">;
+        debts: MoveStruct<{
+            contents: import("@mysten/bcs").BcsType<{
+                key: {
+                    name: string;
+                }[];
+                value: {
+                    value: string;
+                };
+            }[], Iterable<{
+                key: {
+                    name: string;
+                }[];
+                value: {
+                    value: string | number | bigint;
+                };
+            }> & {
+                length: number;
+            }, string>;
+        }, "0x2::vec_map::VecMap<bucket_v2_framework::sheet::Entity, bucket_v2_framework::liability::Debt>">;
+        blacklist: MoveStruct<{
+            contents: import("@mysten/bcs").BcsType<{
+                name: string;
+            }[][], Iterable<{
+                name: string;
+            }[]> & {
+                length: number;
+            }, string>;
+        }, "0x2::vec_set::VecSet<bucket_v2_framework::sheet::Entity>">;
+    }, "bucket_v2_framework::sheet::Sheet">;
+    yield_table: MoveStruct<{
+        id: MoveStruct<{
+            id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+        }, "0x2::object::UID">;
+        size: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::table::Table">;
+    u_surplus: MoveStruct<{
+        value: import("@mysten/bcs").BcsType<string, string | number | bigint, "u64">;
+    }, "0x2::balance::Balance">;
+}, "@local-pkg/stable_vault_farm.move::stable_vault_farm::StableVaultFarm">;
+export declare const AdminCap: MoveStruct<{
+    id: MoveStruct<{
+        id: import("@mysten/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    }, "0x2::object::UID">;
+}, "@local-pkg/stable_vault_farm.move::stable_vault_farm::AdminCap">;
+export interface NewArguments {
+    Cap: RawTransactionArgument<string>;
+    initUCoin: RawTransactionArgument<string>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        Cap: RawTransactionArgument<string>,
+        initUCoin: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface DefaultArguments {
+    cap: RawTransactionArgument<string>;
+    initUCoin: RawTransactionArgument<string>;
+}
+export interface DefaultOptions {
+    package?: string;
+    arguments: DefaultArguments | [
+        cap: RawTransactionArgument<string>,
+        initUCoin: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function _default(options: DefaultOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReceiveArguments {
+    farm: RawTransactionArgument<string>;
+    loan: RawTransactionArgument<string>;
+    stableVault: RawTransactionArgument<string>;
+    usdbTreasury: RawTransactionArgument<string>;
+    psmPool: RawTransactionArgument<string>;
+    savingPool: RawTransactionArgument<string>;
+    yieldVault: RawTransactionArgument<string>;
+    uPrice: RawTransactionArgument<string>;
+}
+export interface ReceiveOptions {
+    package?: string;
+    arguments: ReceiveArguments | [
+        farm: RawTransactionArgument<string>,
+        loan: RawTransactionArgument<string>,
+        stableVault: RawTransactionArgument<string>,
+        usdbTreasury: RawTransactionArgument<string>,
+        psmPool: RawTransactionArgument<string>,
+        savingPool: RawTransactionArgument<string>,
+        yieldVault: RawTransactionArgument<string>,
+        uPrice: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+}
+export declare function receive(options: ReceiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface PayArguments {
+    farm: RawTransactionArgument<string>;
+    request: RawTransactionArgument<string>;
+    stableVault: RawTransactionArgument<string>;
+    usdbTreasury: RawTransactionArgument<string>;
+    psmPool: RawTransactionArgument<string>;
+    savingPool: RawTransactionArgument<string>;
+    yieldVault: RawTransactionArgument<string>;
+    uPrice: RawTransactionArgument<string>;
+}
+export interface PayOptions {
+    package?: string;
+    arguments: PayArguments | [
+        farm: RawTransactionArgument<string>,
+        request: RawTransactionArgument<string>,
+        stableVault: RawTransactionArgument<string>,
+        usdbTreasury: RawTransactionArgument<string>,
+        psmPool: RawTransactionArgument<string>,
+        savingPool: RawTransactionArgument<string>,
+        yieldVault: RawTransactionArgument<string>,
+        uPrice: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+}
+export declare function pay(options: PayOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ClaimArguments {
+    farm: RawTransactionArgument<string>;
+    stableRegistry: RawTransactionArgument<string>;
+    stableVault: RawTransactionArgument<string>;
+    usdbTreasury: RawTransactionArgument<string>;
+    savingPool: RawTransactionArgument<string>;
+    yieldVault: RawTransactionArgument<string>;
+}
+export interface ClaimOptions {
+    package?: string;
+    arguments: ClaimArguments | [
+        farm: RawTransactionArgument<string>,
+        stableRegistry: RawTransactionArgument<string>,
+        stableVault: RawTransactionArgument<string>,
+        usdbTreasury: RawTransactionArgument<string>,
+        savingPool: RawTransactionArgument<string>,
+        yieldVault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+}
+export declare function claim(options: ClaimOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ClaimableAmountArguments {
+    farm: RawTransactionArgument<string>;
+    savingPool: RawTransactionArgument<string>;
+    yieldVault: RawTransactionArgument<string>;
+}
+export interface ClaimableAmountOptions {
+    package?: string;
+    arguments: ClaimableAmountArguments | [
+        farm: RawTransactionArgument<string>,
+        savingPool: RawTransactionArgument<string>,
+        yieldVault: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string,
+        string,
+        string,
+        string
+    ];
+}
+export declare function claimableAmount(options: ClaimableAmountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AddSurplusArguments {
+    farm: RawTransactionArgument<string>;
+    coin: RawTransactionArgument<string>;
+}
+export interface AddSurplusOptions {
+    package?: string;
+    arguments: AddSurplusArguments | [
+        farm: RawTransactionArgument<string>,
+        coin: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string,
+        string
+    ];
+}
+export declare function addSurplus(options: AddSurplusOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;

package/dist/generated/stable_vault_farm/stable_vault_farm.js

@@ -0,0 +1,163 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import * as object from './deps/sui/object.js';
+import * as sheet from './deps/bucket_v2_framework/sheet.js';
+import * as table from './deps/sui/table.js';
+import * as balance from './deps/sui/balance.js';
+const $moduleName = '@local-pkg/stable_vault_farm.move::stable_vault_farm';
+export const Claim = new MoveStruct({ name: `${$moduleName}::Claim`, fields: {
+        reward_type: bcs.string(),
+        amount: bcs.u64(),
+        claimer: bcs.Address
+    } });
+export const StableVaultFarmEntity = new MoveStruct({ name: `${$moduleName}::StableVaultFarmEntity`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const StableVaultFarmWitness = new MoveStruct({ name: `${$moduleName}::StableVaultFarmWitness`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const StableVaultFarm = new MoveStruct({ name: `${$moduleName}::StableVaultFarm`, fields: {
+        id: object.UID,
+        sheet: sheet.Sheet,
+        yield_table: table.Table,
+        u_surplus: balance.Balance
+    } });
+export const AdminCap = new MoveStruct({ name: `${$moduleName}::AdminCap`, fields: {
+        id: object.UID
+    } });
+export function _new(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::AdminCap`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`
+    ];
+    const parameterNames = ["Cap", "initUCoin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function _default(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::AdminCap`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`
+    ];
+    const parameterNames = ["cap", "initUCoin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'default',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function receive(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${packageAddress}::sheet::Loan<${options.typeArguments[1]}, ${packageAddress}::stable_layer::StableFactoryEntity<${options.typeArguments[2]}, ${options.typeArguments[1]}>, ${packageAddress}::stable_vault_farm::StableVaultFarmEntity<${options.typeArguments[0]}, ${options.typeArguments[1]}>>`,
+        `${packageAddress}::stable_vault::StableVault<${options.typeArguments[0]}, ${options.typeArguments[1]}, ${options.typeArguments[3]}>`,
+        `${packageAddress}::usdb::Treasury`,
+        `${packageAddress}::pool::Pool<${options.typeArguments[1]}>`,
+        `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+        `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+        `${packageAddress}::result::PriceResult<${options.typeArguments[1]}>`,
+        '0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock'
+    ];
+    const parameterNames = ["farm", "loan", "stableVault", "usdbTreasury", "psmPool", "savingPool", "yieldVault", "uPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'receive',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function pay(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${packageAddress}::sheet::Request<${options.typeArguments[1]}, ${packageAddress}::stable_layer::StableFactoryEntity<${options.typeArguments[2]}, ${options.typeArguments[1]}>>`,
+        `${packageAddress}::stable_vault::StableVault<${options.typeArguments[0]}, ${options.typeArguments[1]}, ${options.typeArguments[3]}>`,
+        `${packageAddress}::usdb::Treasury`,
+        `${packageAddress}::pool::Pool<${options.typeArguments[1]}>`,
+        `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+        `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+        `${packageAddress}::result::PriceResult<${options.typeArguments[1]}>`,
+        '0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock'
+    ];
+    const parameterNames = ["farm", "request", "stableVault", "usdbTreasury", "psmPool", "savingPool", "yieldVault", "uPrice"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'pay',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function claim(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${packageAddress}::stable_layer::StableRegistry`,
+        `${packageAddress}::stable_vault::StableVault<${options.typeArguments[0]}, ${options.typeArguments[1]}, ${options.typeArguments[3]}>`,
+        `${packageAddress}::usdb::Treasury`,
+        `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+        `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+        '0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock'
+    ];
+    const parameterNames = ["farm", "stableRegistry", "stableVault", "usdbTreasury", "savingPool", "yieldVault"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'claim',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function claimableAmount(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+        `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+        '0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock'
+    ];
+    const parameterNames = ["farm", "savingPool", "yieldVault"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'claimable_amount',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function addSurplus(options) {
+    var _a;
+    const packageAddress = (_a = options.package) !== null && _a !== void 0 ? _a : '@local-pkg/stable_vault_farm.move';
+    const argumentsTypes = [
+        `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+        `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`
+    ];
+    const parameterNames = ["farm", "coin"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'stable_vault_farm',
+        function: 'add_surplus',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}

package/dist/generated/utils/index.d.ts

@@ -0,0 +1,11 @@
+import { BcsType, TypeTag, BcsStruct, BcsEnum, BcsTuple } from '@mysten/sui/bcs';
+import { TransactionArgument } from '@mysten/sui/transactions';
+export type RawTransactionArgument<T> = T | TransactionArgument;
+export declare function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null;
+export declare function normalizeMoveArguments(args: unknown[] | object, argTypes: string[], parameterNames?: string[]): TransactionArgument[];
+export declare class MoveStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsStruct<T, Name> {
+}
+export declare class MoveEnum<T extends Record<string, BcsType<any> | null>, const Name extends string> extends BcsEnum<T, Name> {
+}
+export declare class MoveTuple<T extends readonly BcsType<any>[], const Name extends string> extends BcsTuple<T, Name> {
+}

package/dist/generated/utils/index.js

@@ -0,0 +1,131 @@
+import { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from '@mysten/sui/bcs';
+import { normalizeSuiAddress } from '@mysten/sui/utils';
+import { isArgument } from '@mysten/sui/transactions';
+const MOVE_STDLIB_ADDRESS = normalizeSuiAddress('0x1');
+const SUI_FRAMEWORK_ADDRESS = normalizeSuiAddress('0x2');
+const SUI_SYSTEM_ADDRESS = normalizeSuiAddress('0x3');
+export function getPureBcsSchema(typeTag) {
+    const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+    if ('u8' in parsedTag) {
+        return bcs.U8;
+    }
+    else if ('u16' in parsedTag) {
+        return bcs.U16;
+    }
+    else if ('u32' in parsedTag) {
+        return bcs.U32;
+    }
+    else if ('u64' in parsedTag) {
+        return bcs.U64;
+    }
+    else if ('u128' in parsedTag) {
+        return bcs.U128;
+    }
+    else if ('u256' in parsedTag) {
+        return bcs.U256;
+    }
+    else if ('address' in parsedTag) {
+        return bcs.Address;
+    }
+    else if ('bool' in parsedTag) {
+        return bcs.Bool;
+    }
+    else if ('vector' in parsedTag) {
+        const type = getPureBcsSchema(parsedTag.vector);
+        return type ? bcs.vector(type) : null;
+    }
+    else if ('struct' in parsedTag) {
+        const structTag = parsedTag.struct;
+        const pkg = normalizeSuiAddress(parsedTag.struct.address);
+        if (pkg === MOVE_STDLIB_ADDRESS) {
+            if ((structTag.module === 'ascii' || structTag.module === 'string') &&
+                structTag.name === 'String') {
+                return bcs.String;
+            }
+            if (structTag.module === 'option' && structTag.name === 'Option') {
+                const type = getPureBcsSchema(structTag.typeParams[0]);
+                return type ? bcs.option(type) : null;
+            }
+        }
+        if (pkg === SUI_FRAMEWORK_ADDRESS && structTag.module === 'Object' && structTag.name === 'ID') {
+            return bcs.Address;
+        }
+    }
+    return null;
+}
+export function normalizeMoveArguments(args, argTypes, parameterNames) {
+    const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+    if (parameterNames && argLen !== parameterNames.length) {
+        throw new Error(`Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`);
+    }
+    const normalizedArgs = [];
+    let index = 0;
+    for (const [i, argType] of argTypes.entries()) {
+        if (argType === `${SUI_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
+            normalizedArgs.push((tx) => tx.object.denyList());
+            continue;
+        }
+        if (argType === `${SUI_FRAMEWORK_ADDRESS}::random::Random`) {
+            normalizedArgs.push((tx) => tx.object.random());
+            continue;
+        }
+        if (argType === `${SUI_FRAMEWORK_ADDRESS}::clock::Clock`) {
+            normalizedArgs.push((tx) => tx.object.clock());
+            continue;
+        }
+        if (argType === `${SUI_SYSTEM_ADDRESS}::sui_system::SuiSystemState`) {
+            normalizedArgs.push((tx) => tx.object.system());
+            continue;
+        }
+        let arg;
+        if (Array.isArray(args)) {
+            if (index >= args.length) {
+                throw new Error(`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`);
+            }
+            arg = args[index];
+        }
+        else {
+            if (!parameterNames) {
+                throw new Error(`Expected arguments to be passed as an array`);
+            }
+            const name = parameterNames[index];
+            arg = args[name];
+            if (arg == null) {
+                throw new Error(`Parameter ${name} is required`);
+            }
+        }
+        index += 1;
+        if (typeof arg === 'function' || isArgument(arg)) {
+            normalizedArgs.push(arg);
+            continue;
+        }
+        const type = argTypes[i];
+        const bcsType = getPureBcsSchema(type);
+        if (bcsType) {
+            const bytes = bcsType.serialize(arg);
+            normalizedArgs.push((tx) => tx.pure(bytes));
+            continue;
+        }
+        else if (typeof arg === 'string') {
+            normalizedArgs.push((tx) => tx.object(arg));
+            continue;
+        }
+        throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+    }
+    return normalizedArgs;
+}
+export class MoveStruct extends BcsStruct {
+}
+export class MoveEnum extends BcsEnum {
+}
+export class MoveTuple extends BcsTuple {
+}
+function stringify(val) {
+    if (typeof val === 'object') {
+        return JSON.stringify(val, (val) => val);
+    }
+    if (typeof val === 'bigint') {
+        return val.toString();
+    }
+    return val;
+}