@suilend/springsui-cli 1.0.0

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

@@ -0,0 +1,205 @@
+import { Bag } from "../../_dependencies/source/0x2/bag/structs";
+import { UID } from "../../_dependencies/source/0x2/object/structs";
+import { VecMap } from "../../_dependencies/source/0x2/vec-map/structs";
+import { PhantomReified, PhantomToTypeStr, PhantomTypeArgument, Reified, StructClass, ToField, ToPhantomTypeArgument, ToTypeStr } from "../../_framework/reified";
+import { FieldsWithTypes } from "../../_framework/util";
+import { PKG_V1 } from "../index";
+import { AdminCap } from "../liquid-staking/structs";
+import { Version } from "../version/structs";
+import { SuiClient, SuiObjectData, SuiParsedData } from "@mysten/sui/client";
+export declare function isWeightHook(type: string): boolean;
+export interface WeightHookFields<P extends PhantomTypeArgument> {
+    id: ToField<UID>;
+    validatorAddressesAndWeights: ToField<VecMap<"address", "u64">>;
+    totalWeight: ToField<"u64">;
+    adminCap: ToField<AdminCap<P>>;
+    version: ToField<Version>;
+    extraFields: ToField<Bag>;
+}
+export type WeightHookReified<P extends PhantomTypeArgument> = Reified<WeightHook<P>, WeightHookFields<P>>;
+export declare class WeightHook<P extends PhantomTypeArgument> implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::weight::WeightHook";
+    static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [true];
+    readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::weight::WeightHook";
+    readonly $fullTypeName: `${typeof PKG_V1}::weight::WeightHook<${PhantomToTypeStr<P>}>`;
+    readonly $typeArgs: [PhantomToTypeStr<P>];
+    readonly $isPhantom: readonly [true];
+    readonly id: ToField<UID>;
+    readonly validatorAddressesAndWeights: ToField<VecMap<"address", "u64">>;
+    readonly totalWeight: ToField<"u64">;
+    readonly adminCap: ToField<AdminCap<P>>;
+    readonly version: ToField<Version>;
+    readonly extraFields: ToField<Bag>;
+    private constructor();
+    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): WeightHookReified<ToPhantomTypeArgument<P>>;
+    static get r(): typeof WeightHook.reified;
+    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<WeightHook<ToPhantomTypeArgument<P>>>>;
+    static get p(): typeof WeightHook.phantom;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        validator_addresses_and_weights: {
+            contents: {
+                key: string;
+                value: string;
+            }[];
+        };
+        total_weight: string;
+        admin_cap: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+        };
+        version: {
+            pos0: number;
+        };
+        extra_fields: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string;
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+        validator_addresses_and_weights: {
+            contents: Iterable<{
+                key: string;
+                value: string | number | bigint;
+            }> & {
+                length: number;
+            };
+        };
+        total_weight: string | number | bigint;
+        admin_cap: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+        };
+        version: {
+            pos0: number;
+        };
+        extra_fields: {
+            id: {
+                id: {
+                    bytes: string;
+                };
+            };
+            size: string | number | bigint;
+        };
+    }>;
+    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): WeightHook<ToPhantomTypeArgument<P>>;
+    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): WeightHook<ToPhantomTypeArgument<P>>;
+    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): WeightHook<ToPhantomTypeArgument<P>>;
+    toJSONField(): {
+        id: string;
+        validatorAddressesAndWeights: {
+            contents: {
+                key: string;
+                value: string;
+            }[];
+        };
+        totalWeight: string;
+        adminCap: {
+            id: string;
+        };
+        version: {
+            pos0: number;
+        };
+        extraFields: {
+            id: string;
+            size: string;
+        };
+    };
+    toJSON(): {
+        id: string;
+        validatorAddressesAndWeights: {
+            contents: {
+                key: string;
+                value: string;
+            }[];
+        };
+        totalWeight: string;
+        adminCap: {
+            id: string;
+        };
+        version: {
+            pos0: number;
+        };
+        extraFields: {
+            id: string;
+            size: string;
+        };
+        $typeName: string;
+        $typeArgs: [PhantomToTypeStr<P>];
+    };
+    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): WeightHook<ToPhantomTypeArgument<P>>;
+    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): WeightHook<ToPhantomTypeArgument<P>>;
+    static fromSuiParsedData<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, content: SuiParsedData): WeightHook<ToPhantomTypeArgument<P>>;
+    static fromSuiObjectData<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: SuiObjectData): WeightHook<ToPhantomTypeArgument<P>>;
+    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: SuiClient, typeArg: P, id: string): Promise<WeightHook<ToPhantomTypeArgument<P>>>;
+}
+export declare function isWeightHookAdminCap(type: string): boolean;
+export interface WeightHookAdminCapFields<P extends PhantomTypeArgument> {
+    id: ToField<UID>;
+}
+export type WeightHookAdminCapReified<P extends PhantomTypeArgument> = Reified<WeightHookAdminCap<P>, WeightHookAdminCapFields<P>>;
+export declare class WeightHookAdminCap<P extends PhantomTypeArgument> implements StructClass {
+    __StructClass: true;
+    static readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::weight::WeightHookAdminCap";
+    static readonly $numTypeParams = 1;
+    static readonly $isPhantom: readonly [true];
+    readonly $typeName = "0xcfbcad8e0444ca85ad7ee28054585d12a7487bdbd83569ded988ca13441bf16e::weight::WeightHookAdminCap";
+    readonly $fullTypeName: `${typeof PKG_V1}::weight::WeightHookAdminCap<${PhantomToTypeStr<P>}>`;
+    readonly $typeArgs: [PhantomToTypeStr<P>];
+    readonly $isPhantom: readonly [true];
+    readonly id: ToField<UID>;
+    private constructor();
+    static reified<P extends PhantomReified<PhantomTypeArgument>>(P: P): WeightHookAdminCapReified<ToPhantomTypeArgument<P>>;
+    static get r(): typeof WeightHookAdminCap.reified;
+    static phantom<P extends PhantomReified<PhantomTypeArgument>>(P: P): PhantomReified<ToTypeStr<WeightHookAdminCap<ToPhantomTypeArgument<P>>>>;
+    static get p(): typeof WeightHookAdminCap.phantom;
+    static get bcs(): import("@mysten/sui/bcs").BcsType<{
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+    }, {
+        id: {
+            id: {
+                bytes: string;
+            };
+        };
+    }>;
+    static fromFields<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, fields: Record<string, any>): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    static fromFieldsWithTypes<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, item: FieldsWithTypes): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    static fromBcs<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: Uint8Array): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    toJSONField(): {
+        id: string;
+    };
+    toJSON(): {
+        id: string;
+        $typeName: string;
+        $typeArgs: [PhantomToTypeStr<P>];
+    };
+    static fromJSONField<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, field: any): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    static fromJSON<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, json: Record<string, any>): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    static fromSuiParsedData<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, content: SuiParsedData): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    static fromSuiObjectData<P extends PhantomReified<PhantomTypeArgument>>(typeArg: P, data: SuiObjectData): WeightHookAdminCap<ToPhantomTypeArgument<P>>;
+    static fetch<P extends PhantomReified<PhantomTypeArgument>>(client: SuiClient, typeArg: P, id: string): Promise<WeightHookAdminCap<ToPhantomTypeArgument<P>>>;
+}

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

@@ -0,0 +1,332 @@
+"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.WeightHookAdminCap = exports.WeightHook = void 0;
+exports.isWeightHook = isWeightHook;
+exports.isWeightHookAdminCap = isWeightHookAdminCap;
+const structs_1 = require("../../_dependencies/source/0x2/bag/structs");
+const structs_2 = require("../../_dependencies/source/0x2/object/structs");
+const structs_3 = require("../../_dependencies/source/0x2/vec-map/structs");
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const index_1 = require("../index");
+const structs_4 = require("../liquid-staking/structs");
+const structs_5 = require("../version/structs");
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+/* ============================== WeightHook =============================== */
+function isWeightHook(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type.startsWith(`${index_1.PKG_V1}::weight::WeightHook` + "<");
+}
+class WeightHook {
+    constructor(typeArgs, fields) {
+        this.__StructClass = true;
+        this.$typeName = WeightHook.$typeName;
+        this.$isPhantom = WeightHook.$isPhantom;
+        this.$fullTypeName = (0, util_1.composeSuiType)(WeightHook.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+        this.validatorAddressesAndWeights = fields.validatorAddressesAndWeights;
+        this.totalWeight = fields.totalWeight;
+        this.adminCap = fields.adminCap;
+        this.version = fields.version;
+        this.extraFields = fields.extraFields;
+    }
+    static reified(P) {
+        return {
+            typeName: WeightHook.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(WeightHook.$typeName, ...[(0, reified_1.extractType)(P)]),
+            typeArgs: [(0, reified_1.extractType)(P)],
+            isPhantom: WeightHook.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => WeightHook.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => WeightHook.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => WeightHook.fromBcs(P, data),
+            bcs: WeightHook.bcs,
+            fromJSONField: (field) => WeightHook.fromJSONField(P, field),
+            fromJSON: (json) => WeightHook.fromJSON(P, json),
+            fromSuiParsedData: (content) => WeightHook.fromSuiParsedData(P, content),
+            fromSuiObjectData: (content) => WeightHook.fromSuiObjectData(P, content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return WeightHook.fetch(client, P, id); }),
+            new: (fields) => {
+                return new WeightHook([(0, reified_1.extractType)(P)], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return WeightHook.reified;
+    }
+    static phantom(P) {
+        return (0, reified_1.phantom)(WeightHook.reified(P));
+    }
+    static get p() {
+        return WeightHook.phantom;
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("WeightHook", {
+            id: structs_2.UID.bcs,
+            validator_addresses_and_weights: structs_3.VecMap.bcs(bcs_1.bcs
+                .bytes(32)
+                .transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }), bcs_1.bcs.u64()),
+            total_weight: bcs_1.bcs.u64(),
+            admin_cap: structs_4.AdminCap.bcs,
+            version: structs_5.Version.bcs,
+            extra_fields: structs_1.Bag.bcs,
+        });
+    }
+    static fromFields(typeArg, fields) {
+        return WeightHook.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFields)(structs_2.UID.reified(), fields.id),
+            validatorAddressesAndWeights: (0, reified_1.decodeFromFields)(structs_3.VecMap.reified("address", "u64"), fields.validator_addresses_and_weights),
+            totalWeight: (0, reified_1.decodeFromFields)("u64", fields.total_weight),
+            adminCap: (0, reified_1.decodeFromFields)(structs_4.AdminCap.reified(typeArg), fields.admin_cap),
+            version: (0, reified_1.decodeFromFields)(structs_5.Version.reified(), fields.version),
+            extraFields: (0, reified_1.decodeFromFields)(structs_1.Bag.reified(), fields.extra_fields),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isWeightHook(item.type)) {
+            throw new Error("not a WeightHook type");
+        }
+        (0, reified_1.assertFieldsWithTypesArgsMatch)(item, [typeArg]);
+        return WeightHook.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFieldsWithTypes)(structs_2.UID.reified(), item.fields.id),
+            validatorAddressesAndWeights: (0, reified_1.decodeFromFieldsWithTypes)(structs_3.VecMap.reified("address", "u64"), item.fields.validator_addresses_and_weights),
+            totalWeight: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.total_weight),
+            adminCap: (0, reified_1.decodeFromFieldsWithTypes)(structs_4.AdminCap.reified(typeArg), item.fields.admin_cap),
+            version: (0, reified_1.decodeFromFieldsWithTypes)(structs_5.Version.reified(), item.fields.version),
+            extraFields: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.Bag.reified(), item.fields.extra_fields),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return WeightHook.fromFields(typeArg, WeightHook.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+            validatorAddressesAndWeights: this.validatorAddressesAndWeights.toJSONField(),
+            totalWeight: this.totalWeight.toString(),
+            adminCap: this.adminCap.toJSONField(),
+            version: this.version.toJSONField(),
+            extraFields: this.extraFields.toJSONField(),
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(typeArg, field) {
+        return WeightHook.reified(typeArg).new({
+            id: (0, reified_1.decodeFromJSONField)(structs_2.UID.reified(), field.id),
+            validatorAddressesAndWeights: (0, reified_1.decodeFromJSONField)(structs_3.VecMap.reified("address", "u64"), field.validatorAddressesAndWeights),
+            totalWeight: (0, reified_1.decodeFromJSONField)("u64", field.totalWeight),
+            adminCap: (0, reified_1.decodeFromJSONField)(structs_4.AdminCap.reified(typeArg), field.adminCap),
+            version: (0, reified_1.decodeFromJSONField)(structs_5.Version.reified(), field.version),
+            extraFields: (0, reified_1.decodeFromJSONField)(structs_1.Bag.reified(), field.extraFields),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== WeightHook.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        (0, reified_1.assertReifiedTypeArgsMatch)((0, util_1.composeSuiType)(WeightHook.$typeName, (0, reified_1.extractType)(typeArg)), json.$typeArgs, [typeArg]);
+        return WeightHook.fromJSONField(typeArg, json);
+    }
+    static fromSuiParsedData(typeArg, content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isWeightHook(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a WeightHook object`);
+        }
+        return WeightHook.fromFieldsWithTypes(typeArg, content);
+    }
+    static fromSuiObjectData(typeArg, data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isWeightHook(data.bcs.type)) {
+                throw new Error(`object at is not a WeightHook object`);
+            }
+            const gotTypeArgs = (0, util_1.parseTypeName)(data.bcs.type).typeArgs;
+            if (gotTypeArgs.length !== 1) {
+                throw new Error(`type argument mismatch: expected 1 type argument but got '${gotTypeArgs.length}'`);
+            }
+            const gotTypeArg = (0, util_1.compressSuiType)(gotTypeArgs[0]);
+            const expectedTypeArg = (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg));
+            if (gotTypeArg !== (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg))) {
+                throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+            return WeightHook.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return WeightHook.fromSuiParsedData(typeArg, 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, typeArg, 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 WeightHook 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" ||
+                !isWeightHook(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a WeightHook object`);
+            }
+            return WeightHook.fromSuiObjectData(typeArg, res.data);
+        });
+    }
+}
+exports.WeightHook = WeightHook;
+WeightHook.$typeName = `${index_1.PKG_V1}::weight::WeightHook`;
+WeightHook.$numTypeParams = 1;
+WeightHook.$isPhantom = [true];
+/* ============================== WeightHookAdminCap =============================== */
+function isWeightHookAdminCap(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type.startsWith(`${index_1.PKG_V1}::weight::WeightHookAdminCap` + "<");
+}
+class WeightHookAdminCap {
+    constructor(typeArgs, fields) {
+        this.__StructClass = true;
+        this.$typeName = WeightHookAdminCap.$typeName;
+        this.$isPhantom = WeightHookAdminCap.$isPhantom;
+        this.$fullTypeName = (0, util_1.composeSuiType)(WeightHookAdminCap.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.id = fields.id;
+    }
+    static reified(P) {
+        return {
+            typeName: WeightHookAdminCap.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(WeightHookAdminCap.$typeName, ...[(0, reified_1.extractType)(P)]),
+            typeArgs: [(0, reified_1.extractType)(P)],
+            isPhantom: WeightHookAdminCap.$isPhantom,
+            reifiedTypeArgs: [P],
+            fromFields: (fields) => WeightHookAdminCap.fromFields(P, fields),
+            fromFieldsWithTypes: (item) => WeightHookAdminCap.fromFieldsWithTypes(P, item),
+            fromBcs: (data) => WeightHookAdminCap.fromBcs(P, data),
+            bcs: WeightHookAdminCap.bcs,
+            fromJSONField: (field) => WeightHookAdminCap.fromJSONField(P, field),
+            fromJSON: (json) => WeightHookAdminCap.fromJSON(P, json),
+            fromSuiParsedData: (content) => WeightHookAdminCap.fromSuiParsedData(P, content),
+            fromSuiObjectData: (content) => WeightHookAdminCap.fromSuiObjectData(P, content),
+            fetch: (client, id) => __awaiter(this, void 0, void 0, function* () { return WeightHookAdminCap.fetch(client, P, id); }),
+            new: (fields) => {
+                return new WeightHookAdminCap([(0, reified_1.extractType)(P)], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return WeightHookAdminCap.reified;
+    }
+    static phantom(P) {
+        return (0, reified_1.phantom)(WeightHookAdminCap.reified(P));
+    }
+    static get p() {
+        return WeightHookAdminCap.phantom;
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("WeightHookAdminCap", {
+            id: structs_2.UID.bcs,
+        });
+    }
+    static fromFields(typeArg, fields) {
+        return WeightHookAdminCap.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFields)(structs_2.UID.reified(), fields.id),
+        });
+    }
+    static fromFieldsWithTypes(typeArg, item) {
+        if (!isWeightHookAdminCap(item.type)) {
+            throw new Error("not a WeightHookAdminCap type");
+        }
+        (0, reified_1.assertFieldsWithTypesArgsMatch)(item, [typeArg]);
+        return WeightHookAdminCap.reified(typeArg).new({
+            id: (0, reified_1.decodeFromFieldsWithTypes)(structs_2.UID.reified(), item.fields.id),
+        });
+    }
+    static fromBcs(typeArg, data) {
+        return WeightHookAdminCap.fromFields(typeArg, WeightHookAdminCap.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            id: this.id,
+        };
+    }
+    toJSON() {
+        return Object.assign({ $typeName: this.$typeName, $typeArgs: this.$typeArgs }, this.toJSONField());
+    }
+    static fromJSONField(typeArg, field) {
+        return WeightHookAdminCap.reified(typeArg).new({
+            id: (0, reified_1.decodeFromJSONField)(structs_2.UID.reified(), field.id),
+        });
+    }
+    static fromJSON(typeArg, json) {
+        if (json.$typeName !== WeightHookAdminCap.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        (0, reified_1.assertReifiedTypeArgsMatch)((0, util_1.composeSuiType)(WeightHookAdminCap.$typeName, (0, reified_1.extractType)(typeArg)), json.$typeArgs, [typeArg]);
+        return WeightHookAdminCap.fromJSONField(typeArg, json);
+    }
+    static fromSuiParsedData(typeArg, content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isWeightHookAdminCap(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a WeightHookAdminCap object`);
+        }
+        return WeightHookAdminCap.fromFieldsWithTypes(typeArg, content);
+    }
+    static fromSuiObjectData(typeArg, data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" ||
+                !isWeightHookAdminCap(data.bcs.type)) {
+                throw new Error(`object at is not a WeightHookAdminCap object`);
+            }
+            const gotTypeArgs = (0, util_1.parseTypeName)(data.bcs.type).typeArgs;
+            if (gotTypeArgs.length !== 1) {
+                throw new Error(`type argument mismatch: expected 1 type argument but got '${gotTypeArgs.length}'`);
+            }
+            const gotTypeArg = (0, util_1.compressSuiType)(gotTypeArgs[0]);
+            const expectedTypeArg = (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg));
+            if (gotTypeArg !== (0, util_1.compressSuiType)((0, reified_1.extractType)(typeArg))) {
+                throw new Error(`type argument mismatch: expected '${expectedTypeArg}' but got '${gotTypeArg}'`);
+            }
+            return WeightHookAdminCap.fromBcs(typeArg, (0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return WeightHookAdminCap.fromSuiParsedData(typeArg, 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, typeArg, 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 WeightHookAdminCap 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" ||
+                !isWeightHookAdminCap(res.data.bcs.type)) {
+                throw new Error(`object at id ${id} is not a WeightHookAdminCap object`);
+            }
+            return WeightHookAdminCap.fromSuiObjectData(typeArg, res.data);
+        });
+    }
+}
+exports.WeightHookAdminCap = WeightHookAdminCap;
+WeightHookAdminCap.$typeName = `${index_1.PKG_V1}::weight::WeightHookAdminCap`;
+WeightHookAdminCap.$numTypeParams = 1;
+WeightHookAdminCap.$isPhantom = [true];

package/sdk/src/index.d.ts

@@ -0,0 +1,44 @@
+import { SuiClient } from "@mysten/sui/client";
+import { Transaction, TransactionObjectInput } from "@mysten/sui/transactions";
+import { LiquidStakingInfo } from "./_generated/liquid_staking/liquid-staking/structs";
+export interface LiquidStakingObjectInfo {
+    id: string;
+    type: string;
+}
+export declare class LstClient {
+    liquidStakingObject: LiquidStakingObjectInfo;
+    client: SuiClient;
+    static initialize(client: SuiClient, liquidStakingObjectInfo: LiquidStakingObjectInfo): Promise<LstClient>;
+    constructor(liquidStakingObject: LiquidStakingObjectInfo, client: SuiClient);
+    getAdminCapId(address: string): Promise<string | null | undefined>;
+    getWeightHookAdminCapId(address: string): Promise<string | null | undefined>;
+    mint(tx: Transaction, suiCoinId: TransactionObjectInput): {
+        $kind: "NestedResult";
+        NestedResult: [number, number];
+    };
+    redeemLst(tx: Transaction, lstId: TransactionObjectInput): {
+        $kind: "NestedResult";
+        NestedResult: [number, number];
+    };
+    increaseValidatorStake(tx: Transaction, adminCapId: TransactionObjectInput, validatorAddress: string, suiAmount: number): void;
+    decreaseValidatorStake(tx: Transaction, adminCapId: TransactionObjectInput, validatorAddress: string, maxSuiAmount: number): void;
+    collectFees(tx: Transaction, adminCapId: TransactionObjectInput): {
+        $kind: "NestedResult";
+        NestedResult: [number, number];
+    };
+    updateFees(tx: Transaction, adminCapId: TransactionObjectInput, feeConfigArgs: FeeConfigArgs): void;
+    initializeWeightHook(tx: Transaction, adminCapId: TransactionObjectInput): {
+        $kind: "NestedResult";
+        NestedResult: [number, number];
+    };
+    setValidatorAddressesAndWeights(tx: Transaction, weightHookId: TransactionObjectInput, weightHookAdminCap: TransactionObjectInput, validatorAddressesAndWeights: Map<string, number>): void;
+    rebalance(tx: Transaction, weightHookId: TransactionObjectInput): void;
+}
+export declare function fetchLiquidStakingInfo(info: LiquidStakingObjectInfo, client: SuiClient): Promise<LiquidStakingInfo<any>>;
+interface FeeConfigArgs {
+    mintFeeBps?: number;
+    redeemFeeBps?: number;
+    spreadFee?: number;
+}
+export declare function getSpringSuiApy(client: SuiClient): Promise<number | undefined>;
+export {};