@suilend/springsui-cli 1.0.0

package/sdk/src/_generated/liquid_staking/storage/structs.js

@@ -0,0 +1,365 @@
+"use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidatorInfo = exports.Storage = void 0;
+exports.isStorage = isStorage;
+exports.isValidatorInfo = isValidatorInfo;
+const reified = __importStar(require("../../_framework/reified"));
+const structs_1 = require("../../_dependencies/source/0x1/option/structs");
+const structs_2 = require("../../_dependencies/source/0x2/bag/structs");
+const structs_3 = require("../../_dependencies/source/0x2/balance/structs");
+const structs_4 = require("../../_dependencies/source/0x2/object/structs");
+const structs_5 = require("../../_dependencies/source/0x2/sui/structs");
+const structs_6 = require("../../_dependencies/source/0x3/staking-pool/structs");
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const index_1 = require("../index");
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+/* ============================== Storage =============================== */
+function isStorage(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::storage::Storage`;
+}
+class Storage {
+    constructor(typeArgs, fields) {
+        this.__StructClass = true;
+        this.$typeName = Storage.$typeName;
+        this.$isPhantom = Storage.$isPhantom;
+        this.$fullTypeName = (0, util_1.composeSuiType)(Storage.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.suiPool = fields.suiPool;
+        this.validatorInfos = fields.validatorInfos;
+        this.totalSuiSupply = fields.totalSuiSupply;
+        this.lastRefreshEpoch = fields.lastRefreshEpoch;
+        this.extraFields = fields.extraFields;
+    }
+    static reified() {
+        return {
+            typeName: Storage.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(Storage.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: Storage.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => Storage.fromFields(fields),
+            fromFieldsWithTypes: (item) => Storage.fromFieldsWithTypes(item),
+            fromBcs: (data) => Storage.fromBcs(data),
+            bcs: Storage.bcs,
+            fromJSONField: (field) => Storage.fromJSONField(field),
+            fromJSON: (json) => Storage.fromJSON(json),
+            fromSuiParsedData: (content) => Storage.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => Storage.fromSuiObjectData(content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Storage.fetch(client, id); }),
+            new: (fields) => {
+                return new Storage([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return Storage.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(Storage.reified());
+    }
+    static get p() {
+        return Storage.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("Storage", {
+            sui_pool: structs_3.Balance.bcs,
+            validator_infos: bcs_1.bcs.vector(ValidatorInfo.bcs),
+            total_sui_supply: bcs_1.bcs.u64(),
+            last_refresh_epoch: bcs_1.bcs.u64(),
+            extra_fields: structs_2.Bag.bcs,
+        });
+    }
+    static fromFields(fields) {
+        return Storage.reified().new({
+            suiPool: (0, reified_1.decodeFromFields)(structs_3.Balance.reified(reified.phantom(structs_5.SUI.reified())), fields.sui_pool),
+            validatorInfos: (0, reified_1.decodeFromFields)(reified.vector(ValidatorInfo.reified()), fields.validator_infos),
+            totalSuiSupply: (0, reified_1.decodeFromFields)("u64", fields.total_sui_supply),
+            lastRefreshEpoch: (0, reified_1.decodeFromFields)("u64", fields.last_refresh_epoch),
+            extraFields: (0, reified_1.decodeFromFields)(structs_2.Bag.reified(), fields.extra_fields),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isStorage(item.type)) {
+            throw new Error("not a Storage type");
+        }
+        return Storage.reified().new({
+            suiPool: (0, reified_1.decodeFromFieldsWithTypes)(structs_3.Balance.reified(reified.phantom(structs_5.SUI.reified())), item.fields.sui_pool),
+            validatorInfos: (0, reified_1.decodeFromFieldsWithTypes)(reified.vector(ValidatorInfo.reified()), item.fields.validator_infos),
+            totalSuiSupply: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.total_sui_supply),
+            lastRefreshEpoch: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.last_refresh_epoch),
+            extraFields: (0, reified_1.decodeFromFieldsWithTypes)(structs_2.Bag.reified(), item.fields.extra_fields),
+        });
+    }
+    static fromBcs(data) {
+        return Storage.fromFields(Storage.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            suiPool: this.suiPool.toJSONField(),
+            validatorInfos: (0, reified_1.fieldToJSON)(`vector<${ValidatorInfo.$typeName}>`, this.validatorInfos),
+            totalSuiSupply: this.totalSuiSupply.toString(),
+            lastRefreshEpoch: this.lastRefreshEpoch.toString(),
+            extraFields: this.extraFields.toJSONField(),
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(field) {
+        return Storage.reified().new({
+            suiPool: (0, reified_1.decodeFromJSONField)(structs_3.Balance.reified(reified.phantom(structs_5.SUI.reified())), field.suiPool),
+            validatorInfos: (0, reified_1.decodeFromJSONField)(reified.vector(ValidatorInfo.reified()), field.validatorInfos),
+            totalSuiSupply: (0, reified_1.decodeFromJSONField)("u64", field.totalSuiSupply),
+            lastRefreshEpoch: (0, reified_1.decodeFromJSONField)("u64", field.lastRefreshEpoch),
+            extraFields: (0, reified_1.decodeFromJSONField)(structs_2.Bag.reified(), field.extraFields),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== Storage.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return Storage.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isStorage(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a Storage object`);
+        }
+        return Storage.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isStorage(data.bcs.type)) {
+                throw new Error(`object at is not a Storage object`);
+            }
+            return Storage.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return Storage.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static fetch(client, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const res = yield client.getObject({ id, options: { showBcs: true } });
+            if (res.error) {
+                throw new Error(`error fetching Storage object at id ${id}: ${res.error.code}`);
+            }
+            if (((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.bcs) === null || _b === void 0 ? void 0 : _b.dataType) !== "moveObject" ||
+                !isStorage(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a Storage object`);
+            }
+            return Storage.fromSuiObjectData(res.data);
+        });
+    }
+}
+exports.Storage = Storage;
+Storage.$typeName = `${index_1.PKG_V1}::storage::Storage`;
+Storage.$numTypeParams = 0;
+Storage.$isPhantom = [];
+/* ============================== ValidatorInfo =============================== */
+function isValidatorInfo(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::storage::ValidatorInfo`;
+}
+class ValidatorInfo {
+    constructor(typeArgs, fields) {
+        this.__StructClass = true;
+        this.$typeName = ValidatorInfo.$typeName;
+        this.$isPhantom = ValidatorInfo.$isPhantom;
+        this.$fullTypeName = (0, util_1.composeSuiType)(ValidatorInfo.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.stakingPoolId = fields.stakingPoolId;
+        this.validatorAddress = fields.validatorAddress;
+        this.activeStake = fields.activeStake;
+        this.inactiveStake = fields.inactiveStake;
+        this.exchangeRate = fields.exchangeRate;
+        this.totalSuiAmount = fields.totalSuiAmount;
+        this.extraFields = fields.extraFields;
+    }
+    static reified() {
+        return {
+            typeName: ValidatorInfo.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(ValidatorInfo.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: ValidatorInfo.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ValidatorInfo.fromFields(fields),
+            fromFieldsWithTypes: (item) => ValidatorInfo.fromFieldsWithTypes(item),
+            fromBcs: (data) => ValidatorInfo.fromBcs(data),
+            bcs: ValidatorInfo.bcs,
+            fromJSONField: (field) => ValidatorInfo.fromJSONField(field),
+            fromJSON: (json) => ValidatorInfo.fromJSON(json),
+            fromSuiParsedData: (content) => ValidatorInfo.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => ValidatorInfo.fromSuiObjectData(content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return ValidatorInfo.fetch(client, id); }),
+            new: (fields) => {
+                return new ValidatorInfo([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return ValidatorInfo.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(ValidatorInfo.reified());
+    }
+    static get p() {
+        return ValidatorInfo.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("ValidatorInfo", {
+            staking_pool_id: structs_4.ID.bcs,
+            validator_address: bcs_1.bcs
+                .bytes(32)
+                .transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }),
+            active_stake: structs_1.Option.bcs(structs_6.FungibleStakedSui.bcs),
+            inactive_stake: structs_1.Option.bcs(structs_6.StakedSui.bcs),
+            exchange_rate: structs_6.PoolTokenExchangeRate.bcs,
+            total_sui_amount: bcs_1.bcs.u64(),
+            extra_fields: structs_2.Bag.bcs,
+        });
+    }
+    static fromFields(fields) {
+        return ValidatorInfo.reified().new({
+            stakingPoolId: (0, reified_1.decodeFromFields)(structs_4.ID.reified(), fields.staking_pool_id),
+            validatorAddress: (0, reified_1.decodeFromFields)("address", fields.validator_address),
+            activeStake: (0, reified_1.decodeFromFields)(structs_1.Option.reified(structs_6.FungibleStakedSui.reified()), fields.active_stake),
+            inactiveStake: (0, reified_1.decodeFromFields)(structs_1.Option.reified(structs_6.StakedSui.reified()), fields.inactive_stake),
+            exchangeRate: (0, reified_1.decodeFromFields)(structs_6.PoolTokenExchangeRate.reified(), fields.exchange_rate),
+            totalSuiAmount: (0, reified_1.decodeFromFields)("u64", fields.total_sui_amount),
+            extraFields: (0, reified_1.decodeFromFields)(structs_2.Bag.reified(), fields.extra_fields),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isValidatorInfo(item.type)) {
+            throw new Error("not a ValidatorInfo type");
+        }
+        return ValidatorInfo.reified().new({
+            stakingPoolId: (0, reified_1.decodeFromFieldsWithTypes)(structs_4.ID.reified(), item.fields.staking_pool_id),
+            validatorAddress: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.validator_address),
+            activeStake: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Option.reified(structs_6.FungibleStakedSui.reified()), item.fields.active_stake),
+            inactiveStake: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Option.reified(structs_6.StakedSui.reified()), item.fields.inactive_stake),
+            exchangeRate: (0, reified_1.decodeFromFieldsWithTypes)(structs_6.PoolTokenExchangeRate.reified(), item.fields.exchange_rate),
+            totalSuiAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.total_sui_amount),
+            extraFields: (0, reified_1.decodeFromFieldsWithTypes)(structs_2.Bag.reified(), item.fields.extra_fields),
+        });
+    }
+    static fromBcs(data) {
+        return ValidatorInfo.fromFields(ValidatorInfo.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            stakingPoolId: this.stakingPoolId,
+            validatorAddress: this.validatorAddress,
+            activeStake: (0, reified_1.fieldToJSON)(`${structs_1.Option.$typeName}<${structs_6.FungibleStakedSui.$typeName}>`, this.activeStake),
+            inactiveStake: (0, reified_1.fieldToJSON)(`${structs_1.Option.$typeName}<${structs_6.StakedSui.$typeName}>`, this.inactiveStake),
+            exchangeRate: this.exchangeRate.toJSONField(),
+            totalSuiAmount: this.totalSuiAmount.toString(),
+            extraFields: this.extraFields.toJSONField(),
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(field) {
+        return ValidatorInfo.reified().new({
+            stakingPoolId: (0, reified_1.decodeFromJSONField)(structs_4.ID.reified(), field.stakingPoolId),
+            validatorAddress: (0, reified_1.decodeFromJSONField)("address", field.validatorAddress),
+            activeStake: (0, reified_1.decodeFromJSONField)(structs_1.Option.reified(structs_6.FungibleStakedSui.reified()), field.activeStake),
+            inactiveStake: (0, reified_1.decodeFromJSONField)(structs_1.Option.reified(structs_6.StakedSui.reified()), field.inactiveStake),
+            exchangeRate: (0, reified_1.decodeFromJSONField)(structs_6.PoolTokenExchangeRate.reified(), field.exchangeRate),
+            totalSuiAmount: (0, reified_1.decodeFromJSONField)("u64", field.totalSuiAmount),
+            extraFields: (0, reified_1.decodeFromJSONField)(structs_2.Bag.reified(), field.extraFields),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== ValidatorInfo.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return ValidatorInfo.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isValidatorInfo(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a ValidatorInfo object`);
+        }
+        return ValidatorInfo.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" ||
+                !isValidatorInfo(data.bcs.type)) {
+                throw new Error(`object at is not a ValidatorInfo object`);
+            }
+            return ValidatorInfo.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return ValidatorInfo.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static fetch(client, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const res = yield client.getObject({ id, options: { showBcs: true } });
+            if (res.error) {
+                throw new Error(`error fetching ValidatorInfo object at id ${id}: ${res.error.code}`);
+            }
+            if (((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.bcs) === null || _b === void 0 ? void 0 : _b.dataType) !== "moveObject" ||
+                !isValidatorInfo(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a ValidatorInfo object`);
+            }
+            return ValidatorInfo.fromSuiObjectData(res.data);
+        });
+    }
+}
+exports.ValidatorInfo = ValidatorInfo;
+ValidatorInfo.$typeName = `${index_1.PKG_V1}::storage::ValidatorInfo`;
+ValidatorInfo.$numTypeParams = 0;
+ValidatorInfo.$isPhantom = [];

package/sdk/src/_generated/liquid_staking/version/structs.d.ts

@@ -0,0 +1,46 @@
+import { PhantomReified, Reified, StructClass, ToField, ToTypeStr } from "../../_framework/reified";
+import { FieldsWithTypes } from "../../_framework/util";
+import { PKG_V1 } from "../index";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+export declare function isVersion(type: string): boolean;
+export interface VersionFields {
+    pos0: ToField<"u16">;
+}
+export type VersionReified = Reified<Version, VersionFields>;
+export declare class Version implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::version::Version";
+    static readonly $numTypeParams = 0;
+    static readonly $isPhantom: readonly [];
+    readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::version::Version";
+    readonly $fullTypeName: `${typeof PKG_V1}::version::Version`;
+    readonly $typeArgs: [];
+    readonly $isPhantom: readonly [];
+    readonly pos0: ToField<"u16">;
+    private constructor();
+    static reified(): VersionReified;
+    static get r(): import("../../_framework/reified").StructClassReified<Version, VersionFields>;
+    static phantom(): PhantomReified<ToTypeStr<Version>>;
+    static get p(): PhantomReified<"0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::version::Version">;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        pos0: number;
+    }, {
+        pos0: number;
+    }>;
+    static fromFields(fields: Record<string, any>): Version;
+    static fromFieldsWithTypes(item: FieldsWithTypes): Version;
+    static fromBcs(data: Uint8Array): Version;
+    toJSONField(): {
+        pos0: number;
+    };
+    toJSON(): {
+        pos0: number;
+        $typeName: string;
+        $typeArgs: [];
+    };
+    static fromJSONField(field: any): Version;
+    static fromJSON(json: Record<string, any>): Version;
+    static fromSuiParsedData(content: SuiParsedData): Version;
+    static fromSuiObjectData(data: SuiObjectData): Version;
+    static fetch(client: SuiClient, id: string): Promise<Version>;
+}

package/sdk/src/_generated/liquid_staking/version/structs.js

@@ -0,0 +1,143 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Version = void 0;
+exports.isVersion = isVersion;
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const index_1 = require("../index");
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+/* ============================== Version =============================== */
+function isVersion(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::version::Version`;
+}
+class Version {
+    constructor(typeArgs, fields) {
+        this.__StructClass = true;
+        this.$typeName = Version.$typeName;
+        this.$isPhantom = Version.$isPhantom;
+        this.$fullTypeName = (0, util_1.composeSuiType)(Version.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.pos0 = fields.pos0;
+    }
+    static reified() {
+        return {
+            typeName: Version.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(Version.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: Version.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => Version.fromFields(fields),
+            fromFieldsWithTypes: (item) => Version.fromFieldsWithTypes(item),
+            fromBcs: (data) => Version.fromBcs(data),
+            bcs: Version.bcs,
+            fromJSONField: (field) => Version.fromJSONField(field),
+            fromJSON: (json) => Version.fromJSON(json),
+            fromSuiParsedData: (content) => Version.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => Version.fromSuiObjectData(content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return Version.fetch(client, id); }),
+            new: (fields) => {
+                return new Version([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return Version.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(Version.reified());
+    }
+    static get p() {
+        return Version.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("Version", {
+            pos0: bcs_1.bcs.u16(),
+        });
+    }
+    static fromFields(fields) {
+        return Version.reified().new({
+            pos0: (0, reified_1.decodeFromFields)("u16", fields.pos0),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isVersion(item.type)) {
+            throw new Error("not a Version type");
+        }
+        return Version.reified().new({
+            pos0: (0, reified_1.decodeFromFieldsWithTypes)("u16", item.fields.pos0),
+        });
+    }
+    static fromBcs(data) {
+        return Version.fromFields(Version.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            pos0: this.pos0,
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(field) {
+        return Version.reified().new({
+            pos0: (0, reified_1.decodeFromJSONField)("u16", field.pos0),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== Version.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return Version.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isVersion(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a Version object`);
+        }
+        return Version.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isVersion(data.bcs.type)) {
+                throw new Error(`object at is not a Version object`);
+            }
+            return Version.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return Version.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static fetch(client, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const res = yield client.getObject({ id, options: { showBcs: true } });
+            if (res.error) {
+                throw new Error(`error fetching Version object at id ${id}: ${res.error.code}`);
+            }
+            if (((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.bcs) === null || _b === void 0 ? void 0 : _b.dataType) !== "moveObject" ||
+                !isVersion(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a Version object`);
+            }
+            return Version.fromSuiObjectData(res.data);
+        });
+    }
+}
+exports.Version = Version;
+Version.$typeName = `${index_1.PKG_V1}::version::Version`;
+Version.$numTypeParams = 0;
+Version.$isPhantom = [];

package/sdk/src/_generated/liquid_staking/weight/functions.d.ts

@@ -0,0 +1,19 @@
+import { Transaction, TransactionObjectInput } from "@mysten/sui/transactions";
+export declare function new_(tx: Transaction, typeArg: string, adminCap: TransactionObjectInput): import("@mysten/sui/transactions").TransactionResult;
+export interface EjectArgs {
+    self: TransactionObjectInput;
+    adminCap: TransactionObjectInput;
+}
+export declare function eject(tx: Transaction, typeArg: string, args: EjectArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface RebalanceArgs {
+    self: TransactionObjectInput;
+    systemState: TransactionObjectInput;
+    liquidStakingInfo: TransactionObjectInput;
+}
+export declare function rebalance(tx: Transaction, typeArg: string, args: RebalanceArgs): import("@mysten/sui/transactions").TransactionResult;
+export interface SetValidatorAddressesAndWeightsArgs {
+    self: TransactionObjectInput;
+    weightHookAdminCap: TransactionObjectInput;
+    validatorAddressesAndWeights: TransactionObjectInput;
+}
+export declare function setValidatorAddressesAndWeights(tx: Transaction, typeArg: string, args: SetValidatorAddressesAndWeightsArgs): import("@mysten/sui/transactions").TransactionResult;

package/sdk/src/_generated/liquid_staking/weight/functions.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.new_ = new_;
+exports.eject = eject;
+exports.rebalance = rebalance;
+exports.setValidatorAddressesAndWeights = setValidatorAddressesAndWeights;
+const __1 = require("..");
+const util_1 = require("../../_framework/util");
+function new_(tx, typeArg, adminCap) {
+    return tx.moveCall({
+        target: `${__1.PUBLISHED_AT}::weight::new`,
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, adminCap)],
+    });
+}
+function eject(tx, typeArg, args) {
+    return tx.moveCall({
+        target: `${__1.PUBLISHED_AT}::weight::eject`,
+        typeArguments: [typeArg],
+        arguments: [(0, util_1.obj)(tx, args.self), (0, util_1.obj)(tx, args.adminCap)],
+    });
+}
+function rebalance(tx, typeArg, args) {
+    return tx.moveCall({
+        target: `${__1.PUBLISHED_AT}::weight::rebalance`,
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.self),
+            (0, util_1.obj)(tx, args.systemState),
+            (0, util_1.obj)(tx, args.liquidStakingInfo),
+        ],
+    });
+}
+function setValidatorAddressesAndWeights(tx, typeArg, args) {
+    return tx.moveCall({
+        target: `${__1.PUBLISHED_AT}::weight::set_validator_addresses_and_weights`,
+        typeArguments: [typeArg],
+        arguments: [
+            (0, util_1.obj)(tx, args.self),
+            (0, util_1.obj)(tx, args.weightHookAdminCap),
+            (0, util_1.obj)(tx, args.validatorAddressesAndWeights),
+        ],
+    });
+}