@typus/typus-sdk 1.4.3-c → 1.4.3-e

package/src/typus-perp/admin/structs.ts

@@ -0,0 +1,793 @@
+import * as reified from "../../_framework/reified";
+import { TypeName } from "../../_dependencies/source/0x1/type-name/structs";
+import { UID } from "../../_dependencies/source/0x2/object/structs";
+import { VecSet } from "../../_dependencies/source/0x2/vec-set/structs";
+import {
+    PhantomReified,
+    Reified,
+    StructClass,
+    ToField,
+    ToTypeStr,
+    Vector,
+    decodeFromFields,
+    decodeFromFieldsWithTypes,
+    decodeFromJSONField,
+    fieldToJSON,
+    phantom,
+} from "../../_framework/reified";
+import { FieldsWithTypes, composeSuiType, compressSuiType } from "../../_framework/util";
+import { bcs, fromB64, fromHEX, toHEX } from "@mysten/bcs";
+import { SuiClient, SuiParsedData } from "@mysten/sui.js/client";
+
+/* ============================== Version =============================== */
+
+export function isVersion(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::Version";
+}
+
+export interface VersionFields {
+    id: ToField<UID>;
+    value: ToField<"u64">;
+    feePool: ToField<FeePool>;
+    liquidatorFeePool: ToField<FeePool>;
+    authority: ToField<VecSet<"address">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type VersionReified = Reified<Version, VersionFields>;
+
+export class Version implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::Version";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = Version.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::Version";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly value: ToField<"u64">;
+    readonly feePool: ToField<FeePool>;
+    readonly liquidatorFeePool: ToField<FeePool>;
+    readonly authority: ToField<VecSet<"address">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: VersionFields) {
+        this.$fullTypeName = composeSuiType(
+            Version.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::Version";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.value = fields.value;
+        this.feePool = fields.feePool;
+        this.liquidatorFeePool = fields.liquidatorFeePool;
+        this.authority = fields.authority;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): VersionReified {
+        return {
+            typeName: Version.$typeName,
+            fullTypeName: composeSuiType(
+                Version.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::Version",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => Version.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => Version.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => Version.fromBcs(data),
+            bcs: Version.bcs,
+            fromJSONField: (field: any) => Version.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => Version.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => Version.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => Version.fetch(client, id),
+            new: (fields: VersionFields) => {
+                return new Version([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return Version.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<Version>> {
+        return phantom(Version.reified());
+    }
+    static get p() {
+        return Version.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("Version", {
+            id: UID.bcs,
+            value: bcs.u64(),
+            fee_pool: FeePool.bcs,
+            liquidator_fee_pool: FeePool.bcs,
+            authority: VecSet.bcs(
+                bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) })
+            ),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): Version {
+        return Version.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            value: decodeFromFields("u64", fields.value),
+            feePool: decodeFromFields(FeePool.reified(), fields.fee_pool),
+            liquidatorFeePool: decodeFromFields(FeePool.reified(), fields.liquidator_fee_pool),
+            authority: decodeFromFields(VecSet.reified("address"), fields.authority),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): Version {
+        if (!isVersion(item.type)) {
+            throw new Error("not a Version type");
+        }
+
+        return Version.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            value: decodeFromFieldsWithTypes("u64", item.fields.value),
+            feePool: decodeFromFieldsWithTypes(FeePool.reified(), item.fields.fee_pool),
+            liquidatorFeePool: decodeFromFieldsWithTypes(FeePool.reified(), item.fields.liquidator_fee_pool),
+            authority: decodeFromFieldsWithTypes(VecSet.reified("address"), item.fields.authority),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): Version {
+        return Version.fromFields(Version.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            value: this.value.toString(),
+            feePool: this.feePool.toJSONField(),
+            liquidatorFeePool: this.liquidatorFeePool.toJSONField(),
+            authority: this.authority.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): Version {
+        return Version.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            value: decodeFromJSONField("u64", field.value),
+            feePool: decodeFromJSONField(FeePool.reified(), field.feePool),
+            liquidatorFeePool: decodeFromJSONField(FeePool.reified(), field.liquidatorFeePool),
+            authority: decodeFromJSONField(VecSet.reified("address"), field.authority),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): Version {
+        if (json.$typeName !== Version.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return Version.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): Version {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isVersion(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a Version object`);
+        }
+        return Version.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<Version> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Version object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isVersion(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Version object`);
+        }
+        return Version.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ManagerCap =============================== */
+
+export function isManagerCap(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::ManagerCap";
+}
+
+export interface ManagerCapFields {
+    dummyField: ToField<"bool">;
+}
+
+export type ManagerCapReified = Reified<ManagerCap, ManagerCapFields>;
+
+export class ManagerCap implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::ManagerCap";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ManagerCap.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::ManagerCap";
+
+    readonly $typeArgs: [];
+
+    readonly dummyField: ToField<"bool">;
+
+    private constructor(typeArgs: [], fields: ManagerCapFields) {
+        this.$fullTypeName = composeSuiType(
+            ManagerCap.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::ManagerCap";
+        this.$typeArgs = typeArgs;
+
+        this.dummyField = fields.dummyField;
+    }
+
+    static reified(): ManagerCapReified {
+        return {
+            typeName: ManagerCap.$typeName,
+            fullTypeName: composeSuiType(
+                ManagerCap.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::ManagerCap",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ManagerCap.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ManagerCap.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ManagerCap.fromBcs(data),
+            bcs: ManagerCap.bcs,
+            fromJSONField: (field: any) => ManagerCap.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ManagerCap.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ManagerCap.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ManagerCap.fetch(client, id),
+            new: (fields: ManagerCapFields) => {
+                return new ManagerCap([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ManagerCap.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ManagerCap>> {
+        return phantom(ManagerCap.reified());
+    }
+    static get p() {
+        return ManagerCap.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ManagerCap", {
+            dummy_field: bcs.bool(),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ManagerCap {
+        return ManagerCap.reified().new({ dummyField: decodeFromFields("bool", fields.dummy_field) });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ManagerCap {
+        if (!isManagerCap(item.type)) {
+            throw new Error("not a ManagerCap type");
+        }
+
+        return ManagerCap.reified().new({ dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) });
+    }
+
+    static fromBcs(data: Uint8Array): ManagerCap {
+        return ManagerCap.fromFields(ManagerCap.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): ManagerCap {
+        return ManagerCap.reified().new({ dummyField: decodeFromJSONField("bool", field.dummyField) });
+    }
+
+    static fromJSON(json: Record<string, any>): ManagerCap {
+        if (json.$typeName !== ManagerCap.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ManagerCap.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ManagerCap {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isManagerCap(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ManagerCap object`);
+        }
+        return ManagerCap.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ManagerCap> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ManagerCap object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isManagerCap(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ManagerCap object`);
+        }
+        return ManagerCap.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== FeeInfo =============================== */
+
+export function isFeeInfo(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeeInfo";
+}
+
+export interface FeeInfoFields {
+    token: ToField<TypeName>;
+    value: ToField<"u64">;
+}
+
+export type FeeInfoReified = Reified<FeeInfo, FeeInfoFields>;
+
+export class FeeInfo implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeeInfo";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = FeeInfo.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeeInfo";
+
+    readonly $typeArgs: [];
+
+    readonly token: ToField<TypeName>;
+    readonly value: ToField<"u64">;
+
+    private constructor(typeArgs: [], fields: FeeInfoFields) {
+        this.$fullTypeName = composeSuiType(
+            FeeInfo.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeeInfo";
+        this.$typeArgs = typeArgs;
+
+        this.token = fields.token;
+        this.value = fields.value;
+    }
+
+    static reified(): FeeInfoReified {
+        return {
+            typeName: FeeInfo.$typeName,
+            fullTypeName: composeSuiType(
+                FeeInfo.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeeInfo",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => FeeInfo.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => FeeInfo.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => FeeInfo.fromBcs(data),
+            bcs: FeeInfo.bcs,
+            fromJSONField: (field: any) => FeeInfo.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => FeeInfo.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => FeeInfo.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => FeeInfo.fetch(client, id),
+            new: (fields: FeeInfoFields) => {
+                return new FeeInfo([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return FeeInfo.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<FeeInfo>> {
+        return phantom(FeeInfo.reified());
+    }
+    static get p() {
+        return FeeInfo.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("FeeInfo", {
+            token: TypeName.bcs,
+            value: bcs.u64(),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): FeeInfo {
+        return FeeInfo.reified().new({
+            token: decodeFromFields(TypeName.reified(), fields.token),
+            value: decodeFromFields("u64", fields.value),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): FeeInfo {
+        if (!isFeeInfo(item.type)) {
+            throw new Error("not a FeeInfo type");
+        }
+
+        return FeeInfo.reified().new({
+            token: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.token),
+            value: decodeFromFieldsWithTypes("u64", item.fields.value),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): FeeInfo {
+        return FeeInfo.fromFields(FeeInfo.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            token: this.token.toJSONField(),
+            value: this.value.toString(),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): FeeInfo {
+        return FeeInfo.reified().new({
+            token: decodeFromJSONField(TypeName.reified(), field.token),
+            value: decodeFromJSONField("u64", field.value),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): FeeInfo {
+        if (json.$typeName !== FeeInfo.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return FeeInfo.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): FeeInfo {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isFeeInfo(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a FeeInfo object`);
+        }
+        return FeeInfo.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<FeeInfo> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching FeeInfo object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isFeeInfo(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a FeeInfo object`);
+        }
+        return FeeInfo.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== FeePool =============================== */
+
+export function isFeePool(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeePool";
+}
+
+export interface FeePoolFields {
+    id: ToField<UID>;
+    feeInfos: ToField<Vector<FeeInfo>>;
+}
+
+export type FeePoolReified = Reified<FeePool, FeePoolFields>;
+
+export class FeePool implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeePool";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = FeePool.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeePool";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly feeInfos: ToField<Vector<FeeInfo>>;
+
+    private constructor(typeArgs: [], fields: FeePoolFields) {
+        this.$fullTypeName = composeSuiType(
+            FeePool.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeePool";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.feeInfos = fields.feeInfos;
+    }
+
+    static reified(): FeePoolReified {
+        return {
+            typeName: FeePool.$typeName,
+            fullTypeName: composeSuiType(
+                FeePool.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeePool",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => FeePool.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => FeePool.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => FeePool.fromBcs(data),
+            bcs: FeePool.bcs,
+            fromJSONField: (field: any) => FeePool.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => FeePool.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => FeePool.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => FeePool.fetch(client, id),
+            new: (fields: FeePoolFields) => {
+                return new FeePool([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return FeePool.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<FeePool>> {
+        return phantom(FeePool.reified());
+    }
+    static get p() {
+        return FeePool.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("FeePool", {
+            id: UID.bcs,
+            fee_infos: bcs.vector(FeeInfo.bcs),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): FeePool {
+        return FeePool.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            feeInfos: decodeFromFields(reified.vector(FeeInfo.reified()), fields.fee_infos),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): FeePool {
+        if (!isFeePool(item.type)) {
+            throw new Error("not a FeePool type");
+        }
+
+        return FeePool.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            feeInfos: decodeFromFieldsWithTypes(reified.vector(FeeInfo.reified()), item.fields.fee_infos),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): FeePool {
+        return FeePool.fromFields(FeePool.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            feeInfos: fieldToJSON<Vector<FeeInfo>>(
+                `vector<0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::FeeInfo>`,
+                this.feeInfos
+            ),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): FeePool {
+        return FeePool.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            feeInfos: decodeFromJSONField(reified.vector(FeeInfo.reified()), field.feeInfos),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): FeePool {
+        if (json.$typeName !== FeePool.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return FeePool.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): FeePool {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isFeePool(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a FeePool object`);
+        }
+        return FeePool.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<FeePool> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching FeePool object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isFeePool(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a FeePool object`);
+        }
+        return FeePool.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SendFeeEvent =============================== */
+
+export function isSendFeeEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::SendFeeEvent";
+}
+
+export interface SendFeeEventFields {
+    token: ToField<TypeName>;
+    amount: ToField<"u64">;
+}
+
+export type SendFeeEventReified = Reified<SendFeeEvent, SendFeeEventFields>;
+
+export class SendFeeEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::SendFeeEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SendFeeEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::SendFeeEvent";
+
+    readonly $typeArgs: [];
+
+    readonly token: ToField<TypeName>;
+    readonly amount: ToField<"u64">;
+
+    private constructor(typeArgs: [], fields: SendFeeEventFields) {
+        this.$fullTypeName = composeSuiType(
+            SendFeeEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::SendFeeEvent";
+        this.$typeArgs = typeArgs;
+
+        this.token = fields.token;
+        this.amount = fields.amount;
+    }
+
+    static reified(): SendFeeEventReified {
+        return {
+            typeName: SendFeeEvent.$typeName,
+            fullTypeName: composeSuiType(
+                SendFeeEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::admin::SendFeeEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SendFeeEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SendFeeEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SendFeeEvent.fromBcs(data),
+            bcs: SendFeeEvent.bcs,
+            fromJSONField: (field: any) => SendFeeEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SendFeeEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SendFeeEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SendFeeEvent.fetch(client, id),
+            new: (fields: SendFeeEventFields) => {
+                return new SendFeeEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SendFeeEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SendFeeEvent>> {
+        return phantom(SendFeeEvent.reified());
+    }
+    static get p() {
+        return SendFeeEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SendFeeEvent", {
+            token: TypeName.bcs,
+            amount: bcs.u64(),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SendFeeEvent {
+        return SendFeeEvent.reified().new({
+            token: decodeFromFields(TypeName.reified(), fields.token),
+            amount: decodeFromFields("u64", fields.amount),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SendFeeEvent {
+        if (!isSendFeeEvent(item.type)) {
+            throw new Error("not a SendFeeEvent type");
+        }
+
+        return SendFeeEvent.reified().new({
+            token: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.token),
+            amount: decodeFromFieldsWithTypes("u64", item.fields.amount),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SendFeeEvent {
+        return SendFeeEvent.fromFields(SendFeeEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            token: this.token.toJSONField(),
+            amount: this.amount.toString(),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SendFeeEvent {
+        return SendFeeEvent.reified().new({
+            token: decodeFromJSONField(TypeName.reified(), field.token),
+            amount: decodeFromJSONField("u64", field.amount),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SendFeeEvent {
+        if (json.$typeName !== SendFeeEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SendFeeEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SendFeeEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSendFeeEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SendFeeEvent object`);
+        }
+        return SendFeeEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SendFeeEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SendFeeEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSendFeeEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SendFeeEvent object`);
+        }
+        return SendFeeEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}