@typus/typus-sdk 1.4.3-d → 1.4.3-f

package/src/typus-perp/lp-pool/structs.ts

@@ -0,0 +1,3884 @@
+import * as reified from "../../_framework/reified";
+import { TypeName } from "../../_dependencies/source/0x1/type-name/structs";
+import { UID } from "../../_dependencies/source/0x2/object/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";
+
+/* ============================== Config =============================== */
+
+export function isConfig(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Config";
+}
+
+export interface ConfigFields {
+    oracleId: ToField<"address">;
+    liquidityTokenDecimal: ToField<"u64">;
+    spotConfig: ToField<SpotConfig>;
+    marginConfig: ToField<MarginConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ConfigReified = Reified<Config, ConfigFields>;
+
+export class Config implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Config";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = Config.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Config";
+
+    readonly $typeArgs: [];
+
+    readonly oracleId: ToField<"address">;
+    readonly liquidityTokenDecimal: ToField<"u64">;
+    readonly spotConfig: ToField<SpotConfig>;
+    readonly marginConfig: ToField<MarginConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ConfigFields) {
+        this.$fullTypeName = composeSuiType(
+            Config.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Config";
+        this.$typeArgs = typeArgs;
+
+        this.oracleId = fields.oracleId;
+        this.liquidityTokenDecimal = fields.liquidityTokenDecimal;
+        this.spotConfig = fields.spotConfig;
+        this.marginConfig = fields.marginConfig;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ConfigReified {
+        return {
+            typeName: Config.$typeName,
+            fullTypeName: composeSuiType(
+                Config.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Config",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => Config.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => Config.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => Config.fromBcs(data),
+            bcs: Config.bcs,
+            fromJSONField: (field: any) => Config.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => Config.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => Config.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => Config.fetch(client, id),
+            new: (fields: ConfigFields) => {
+                return new Config([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return Config.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<Config>> {
+        return phantom(Config.reified());
+    }
+    static get p() {
+        return Config.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("Config", {
+            oracle_id: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            liquidity_token_decimal: bcs.u64(),
+            spot_config: SpotConfig.bcs,
+            margin_config: MarginConfig.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): Config {
+        return Config.reified().new({
+            oracleId: decodeFromFields("address", fields.oracle_id),
+            liquidityTokenDecimal: decodeFromFields("u64", fields.liquidity_token_decimal),
+            spotConfig: decodeFromFields(SpotConfig.reified(), fields.spot_config),
+            marginConfig: decodeFromFields(MarginConfig.reified(), fields.margin_config),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): Config {
+        if (!isConfig(item.type)) {
+            throw new Error("not a Config type");
+        }
+
+        return Config.reified().new({
+            oracleId: decodeFromFieldsWithTypes("address", item.fields.oracle_id),
+            liquidityTokenDecimal: decodeFromFieldsWithTypes("u64", item.fields.liquidity_token_decimal),
+            spotConfig: decodeFromFieldsWithTypes(SpotConfig.reified(), item.fields.spot_config),
+            marginConfig: decodeFromFieldsWithTypes(MarginConfig.reified(), item.fields.margin_config),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): Config {
+        return Config.fromFields(Config.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            oracleId: this.oracleId,
+            liquidityTokenDecimal: this.liquidityTokenDecimal.toString(),
+            spotConfig: this.spotConfig.toJSONField(),
+            marginConfig: this.marginConfig.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): Config {
+        return Config.reified().new({
+            oracleId: decodeFromJSONField("address", field.oracleId),
+            liquidityTokenDecimal: decodeFromJSONField("u64", field.liquidityTokenDecimal),
+            spotConfig: decodeFromJSONField(SpotConfig.reified(), field.spotConfig),
+            marginConfig: decodeFromJSONField(MarginConfig.reified(), field.marginConfig),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): Config {
+        if (json.$typeName !== Config.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return Config.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): Config {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isConfig(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a Config object`);
+        }
+        return Config.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<Config> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Config object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isConfig(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Config object`);
+        }
+        return Config.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== State =============================== */
+
+export function isState(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::State";
+}
+
+export interface StateFields {
+    liquidityAmount: ToField<"u64">;
+    valueInUsd: ToField<"u64">;
+    reservedAmount: ToField<"u64">;
+    updateTsMs: ToField<"u64">;
+    isActive: ToField<"bool">;
+    lastBorrowRateTsMs: ToField<"u64">;
+    cumulativeBorrowRate: ToField<"u64">;
+    previousLastBorrowRateTsMs: ToField<"u64">;
+    previousCumulativeBorrowRate: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type StateReified = Reified<State, StateFields>;
+
+export class State implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::State";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = State.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::State";
+
+    readonly $typeArgs: [];
+
+    readonly liquidityAmount: ToField<"u64">;
+    readonly valueInUsd: ToField<"u64">;
+    readonly reservedAmount: ToField<"u64">;
+    readonly updateTsMs: ToField<"u64">;
+    readonly isActive: ToField<"bool">;
+    readonly lastBorrowRateTsMs: ToField<"u64">;
+    readonly cumulativeBorrowRate: ToField<"u64">;
+    readonly previousLastBorrowRateTsMs: ToField<"u64">;
+    readonly previousCumulativeBorrowRate: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: StateFields) {
+        this.$fullTypeName = composeSuiType(
+            State.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::State";
+        this.$typeArgs = typeArgs;
+
+        this.liquidityAmount = fields.liquidityAmount;
+        this.valueInUsd = fields.valueInUsd;
+        this.reservedAmount = fields.reservedAmount;
+        this.updateTsMs = fields.updateTsMs;
+        this.isActive = fields.isActive;
+        this.lastBorrowRateTsMs = fields.lastBorrowRateTsMs;
+        this.cumulativeBorrowRate = fields.cumulativeBorrowRate;
+        this.previousLastBorrowRateTsMs = fields.previousLastBorrowRateTsMs;
+        this.previousCumulativeBorrowRate = fields.previousCumulativeBorrowRate;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): StateReified {
+        return {
+            typeName: State.$typeName,
+            fullTypeName: composeSuiType(
+                State.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::State",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => State.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => State.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => State.fromBcs(data),
+            bcs: State.bcs,
+            fromJSONField: (field: any) => State.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => State.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => State.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => State.fetch(client, id),
+            new: (fields: StateFields) => {
+                return new State([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return State.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<State>> {
+        return phantom(State.reified());
+    }
+    static get p() {
+        return State.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("State", {
+            liquidity_amount: bcs.u64(),
+            value_in_usd: bcs.u64(),
+            reserved_amount: bcs.u64(),
+            update_ts_ms: bcs.u64(),
+            is_active: bcs.bool(),
+            last_borrow_rate_ts_ms: bcs.u64(),
+            cumulative_borrow_rate: bcs.u64(),
+            previous_last_borrow_rate_ts_ms: bcs.u64(),
+            previous_cumulative_borrow_rate: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): State {
+        return State.reified().new({
+            liquidityAmount: decodeFromFields("u64", fields.liquidity_amount),
+            valueInUsd: decodeFromFields("u64", fields.value_in_usd),
+            reservedAmount: decodeFromFields("u64", fields.reserved_amount),
+            updateTsMs: decodeFromFields("u64", fields.update_ts_ms),
+            isActive: decodeFromFields("bool", fields.is_active),
+            lastBorrowRateTsMs: decodeFromFields("u64", fields.last_borrow_rate_ts_ms),
+            cumulativeBorrowRate: decodeFromFields("u64", fields.cumulative_borrow_rate),
+            previousLastBorrowRateTsMs: decodeFromFields("u64", fields.previous_last_borrow_rate_ts_ms),
+            previousCumulativeBorrowRate: decodeFromFields("u64", fields.previous_cumulative_borrow_rate),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): State {
+        if (!isState(item.type)) {
+            throw new Error("not a State type");
+        }
+
+        return State.reified().new({
+            liquidityAmount: decodeFromFieldsWithTypes("u64", item.fields.liquidity_amount),
+            valueInUsd: decodeFromFieldsWithTypes("u64", item.fields.value_in_usd),
+            reservedAmount: decodeFromFieldsWithTypes("u64", item.fields.reserved_amount),
+            updateTsMs: decodeFromFieldsWithTypes("u64", item.fields.update_ts_ms),
+            isActive: decodeFromFieldsWithTypes("bool", item.fields.is_active),
+            lastBorrowRateTsMs: decodeFromFieldsWithTypes("u64", item.fields.last_borrow_rate_ts_ms),
+            cumulativeBorrowRate: decodeFromFieldsWithTypes("u64", item.fields.cumulative_borrow_rate),
+            previousLastBorrowRateTsMs: decodeFromFieldsWithTypes("u64", item.fields.previous_last_borrow_rate_ts_ms),
+            previousCumulativeBorrowRate: decodeFromFieldsWithTypes("u64", item.fields.previous_cumulative_borrow_rate),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): State {
+        return State.fromFields(State.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            liquidityAmount: this.liquidityAmount.toString(),
+            valueInUsd: this.valueInUsd.toString(),
+            reservedAmount: this.reservedAmount.toString(),
+            updateTsMs: this.updateTsMs.toString(),
+            isActive: this.isActive,
+            lastBorrowRateTsMs: this.lastBorrowRateTsMs.toString(),
+            cumulativeBorrowRate: this.cumulativeBorrowRate.toString(),
+            previousLastBorrowRateTsMs: this.previousLastBorrowRateTsMs.toString(),
+            previousCumulativeBorrowRate: this.previousCumulativeBorrowRate.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): State {
+        return State.reified().new({
+            liquidityAmount: decodeFromJSONField("u64", field.liquidityAmount),
+            valueInUsd: decodeFromJSONField("u64", field.valueInUsd),
+            reservedAmount: decodeFromJSONField("u64", field.reservedAmount),
+            updateTsMs: decodeFromJSONField("u64", field.updateTsMs),
+            isActive: decodeFromJSONField("bool", field.isActive),
+            lastBorrowRateTsMs: decodeFromJSONField("u64", field.lastBorrowRateTsMs),
+            cumulativeBorrowRate: decodeFromJSONField("u64", field.cumulativeBorrowRate),
+            previousLastBorrowRateTsMs: decodeFromJSONField("u64", field.previousLastBorrowRateTsMs),
+            previousCumulativeBorrowRate: decodeFromJSONField("u64", field.previousCumulativeBorrowRate),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): State {
+        if (json.$typeName !== State.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return State.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): State {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isState(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a State object`);
+        }
+        return State.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<State> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching State object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isState(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a State object`);
+        }
+        return State.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== AddLiquidityTokenEvent =============================== */
+
+export function isAddLiquidityTokenEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::AddLiquidityTokenEvent";
+}
+
+export interface AddLiquidityTokenEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    tokenType: ToField<TypeName>;
+    config: ToField<Config>;
+    state: ToField<State>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type AddLiquidityTokenEventReified = Reified<AddLiquidityTokenEvent, AddLiquidityTokenEventFields>;
+
+export class AddLiquidityTokenEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::AddLiquidityTokenEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = AddLiquidityTokenEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::AddLiquidityTokenEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly tokenType: ToField<TypeName>;
+    readonly config: ToField<Config>;
+    readonly state: ToField<State>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: AddLiquidityTokenEventFields) {
+        this.$fullTypeName = composeSuiType(
+            AddLiquidityTokenEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::AddLiquidityTokenEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.tokenType = fields.tokenType;
+        this.config = fields.config;
+        this.state = fields.state;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): AddLiquidityTokenEventReified {
+        return {
+            typeName: AddLiquidityTokenEvent.$typeName,
+            fullTypeName: composeSuiType(
+                AddLiquidityTokenEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::AddLiquidityTokenEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => AddLiquidityTokenEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => AddLiquidityTokenEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => AddLiquidityTokenEvent.fromBcs(data),
+            bcs: AddLiquidityTokenEvent.bcs,
+            fromJSONField: (field: any) => AddLiquidityTokenEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => AddLiquidityTokenEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => AddLiquidityTokenEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => AddLiquidityTokenEvent.fetch(client, id),
+            new: (fields: AddLiquidityTokenEventFields) => {
+                return new AddLiquidityTokenEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return AddLiquidityTokenEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<AddLiquidityTokenEvent>> {
+        return phantom(AddLiquidityTokenEvent.reified());
+    }
+    static get p() {
+        return AddLiquidityTokenEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("AddLiquidityTokenEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            token_type: TypeName.bcs,
+            config: Config.bcs,
+            state: State.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): AddLiquidityTokenEvent {
+        return AddLiquidityTokenEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            tokenType: decodeFromFields(TypeName.reified(), fields.token_type),
+            config: decodeFromFields(Config.reified(), fields.config),
+            state: decodeFromFields(State.reified(), fields.state),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): AddLiquidityTokenEvent {
+        if (!isAddLiquidityTokenEvent(item.type)) {
+            throw new Error("not a AddLiquidityTokenEvent type");
+        }
+
+        return AddLiquidityTokenEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            tokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.token_type),
+            config: decodeFromFieldsWithTypes(Config.reified(), item.fields.config),
+            state: decodeFromFieldsWithTypes(State.reified(), item.fields.state),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): AddLiquidityTokenEvent {
+        return AddLiquidityTokenEvent.fromFields(AddLiquidityTokenEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            tokenType: this.tokenType.toJSONField(),
+            config: this.config.toJSONField(),
+            state: this.state.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): AddLiquidityTokenEvent {
+        return AddLiquidityTokenEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            tokenType: decodeFromJSONField(TypeName.reified(), field.tokenType),
+            config: decodeFromJSONField(Config.reified(), field.config),
+            state: decodeFromJSONField(State.reified(), field.state),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): AddLiquidityTokenEvent {
+        if (json.$typeName !== AddLiquidityTokenEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return AddLiquidityTokenEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): AddLiquidityTokenEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isAddLiquidityTokenEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a AddLiquidityTokenEvent object`);
+        }
+        return AddLiquidityTokenEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<AddLiquidityTokenEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching AddLiquidityTokenEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isAddLiquidityTokenEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a AddLiquidityTokenEvent object`);
+        }
+        return AddLiquidityTokenEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== BurnLpEvent =============================== */
+
+export function isBurnLpEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::BurnLpEvent";
+}
+
+export interface BurnLpEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    burnLpAmount: ToField<"u64">;
+    burnAmountUsd: ToField<"u64">;
+    burnFeeUsd: ToField<"u64">;
+    liquidityTokenType: ToField<TypeName>;
+    withdrawTokenAmount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type BurnLpEventReified = Reified<BurnLpEvent, BurnLpEventFields>;
+
+export class BurnLpEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::BurnLpEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = BurnLpEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::BurnLpEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly burnLpAmount: ToField<"u64">;
+    readonly burnAmountUsd: ToField<"u64">;
+    readonly burnFeeUsd: ToField<"u64">;
+    readonly liquidityTokenType: ToField<TypeName>;
+    readonly withdrawTokenAmount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: BurnLpEventFields) {
+        this.$fullTypeName = composeSuiType(
+            BurnLpEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::BurnLpEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.lpTokenType = fields.lpTokenType;
+        this.burnLpAmount = fields.burnLpAmount;
+        this.burnAmountUsd = fields.burnAmountUsd;
+        this.burnFeeUsd = fields.burnFeeUsd;
+        this.liquidityTokenType = fields.liquidityTokenType;
+        this.withdrawTokenAmount = fields.withdrawTokenAmount;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): BurnLpEventReified {
+        return {
+            typeName: BurnLpEvent.$typeName,
+            fullTypeName: composeSuiType(
+                BurnLpEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::BurnLpEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => BurnLpEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => BurnLpEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => BurnLpEvent.fromBcs(data),
+            bcs: BurnLpEvent.bcs,
+            fromJSONField: (field: any) => BurnLpEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => BurnLpEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => BurnLpEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => BurnLpEvent.fetch(client, id),
+            new: (fields: BurnLpEventFields) => {
+                return new BurnLpEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return BurnLpEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<BurnLpEvent>> {
+        return phantom(BurnLpEvent.reified());
+    }
+    static get p() {
+        return BurnLpEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("BurnLpEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            lp_token_type: TypeName.bcs,
+            burn_lp_amount: bcs.u64(),
+            burn_amount_usd: bcs.u64(),
+            burn_fee_usd: bcs.u64(),
+            liquidity_token_type: TypeName.bcs,
+            withdraw_token_amount: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): BurnLpEvent {
+        return BurnLpEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            lpTokenType: decodeFromFields(TypeName.reified(), fields.lp_token_type),
+            burnLpAmount: decodeFromFields("u64", fields.burn_lp_amount),
+            burnAmountUsd: decodeFromFields("u64", fields.burn_amount_usd),
+            burnFeeUsd: decodeFromFields("u64", fields.burn_fee_usd),
+            liquidityTokenType: decodeFromFields(TypeName.reified(), fields.liquidity_token_type),
+            withdrawTokenAmount: decodeFromFields("u64", fields.withdraw_token_amount),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): BurnLpEvent {
+        if (!isBurnLpEvent(item.type)) {
+            throw new Error("not a BurnLpEvent type");
+        }
+
+        return BurnLpEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            lpTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.lp_token_type),
+            burnLpAmount: decodeFromFieldsWithTypes("u64", item.fields.burn_lp_amount),
+            burnAmountUsd: decodeFromFieldsWithTypes("u64", item.fields.burn_amount_usd),
+            burnFeeUsd: decodeFromFieldsWithTypes("u64", item.fields.burn_fee_usd),
+            liquidityTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token_type),
+            withdrawTokenAmount: decodeFromFieldsWithTypes("u64", item.fields.withdraw_token_amount),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): BurnLpEvent {
+        return BurnLpEvent.fromFields(BurnLpEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            lpTokenType: this.lpTokenType.toJSONField(),
+            burnLpAmount: this.burnLpAmount.toString(),
+            burnAmountUsd: this.burnAmountUsd.toString(),
+            burnFeeUsd: this.burnFeeUsd.toString(),
+            liquidityTokenType: this.liquidityTokenType.toJSONField(),
+            withdrawTokenAmount: this.withdrawTokenAmount.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): BurnLpEvent {
+        return BurnLpEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            lpTokenType: decodeFromJSONField(TypeName.reified(), field.lpTokenType),
+            burnLpAmount: decodeFromJSONField("u64", field.burnLpAmount),
+            burnAmountUsd: decodeFromJSONField("u64", field.burnAmountUsd),
+            burnFeeUsd: decodeFromJSONField("u64", field.burnFeeUsd),
+            liquidityTokenType: decodeFromJSONField(TypeName.reified(), field.liquidityTokenType),
+            withdrawTokenAmount: decodeFromJSONField("u64", field.withdrawTokenAmount),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): BurnLpEvent {
+        if (json.$typeName !== BurnLpEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return BurnLpEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): BurnLpEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isBurnLpEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a BurnLpEvent object`);
+        }
+        return BurnLpEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<BurnLpEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching BurnLpEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isBurnLpEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a BurnLpEvent object`);
+        }
+        return BurnLpEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== LiquidityPool =============================== */
+
+export function isLiquidityPool(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPool";
+}
+
+export interface LiquidityPoolFields {
+    id: ToField<UID>;
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    liquidityTokens: ToField<Vector<TypeName>>;
+    tokenPools: ToField<Vector<TokenPool>>;
+    poolInfo: ToField<LiquidityPoolInfo>;
+    u64Padding: ToField<Vector<"u64">>;
+    bcsPadding: ToField<Vector<"u8">>;
+}
+
+export type LiquidityPoolReified = Reified<LiquidityPool, LiquidityPoolFields>;
+
+export class LiquidityPool implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPool";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = LiquidityPool.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPool";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly liquidityTokens: ToField<Vector<TypeName>>;
+    readonly tokenPools: ToField<Vector<TokenPool>>;
+    readonly poolInfo: ToField<LiquidityPoolInfo>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+    readonly bcsPadding: ToField<Vector<"u8">>;
+
+    private constructor(typeArgs: [], fields: LiquidityPoolFields) {
+        this.$fullTypeName = composeSuiType(
+            LiquidityPool.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPool";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.index = fields.index;
+        this.lpTokenType = fields.lpTokenType;
+        this.liquidityTokens = fields.liquidityTokens;
+        this.tokenPools = fields.tokenPools;
+        this.poolInfo = fields.poolInfo;
+        this.u64Padding = fields.u64Padding;
+        this.bcsPadding = fields.bcsPadding;
+    }
+
+    static reified(): LiquidityPoolReified {
+        return {
+            typeName: LiquidityPool.$typeName,
+            fullTypeName: composeSuiType(
+                LiquidityPool.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPool",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => LiquidityPool.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => LiquidityPool.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => LiquidityPool.fromBcs(data),
+            bcs: LiquidityPool.bcs,
+            fromJSONField: (field: any) => LiquidityPool.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => LiquidityPool.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => LiquidityPool.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => LiquidityPool.fetch(client, id),
+            new: (fields: LiquidityPoolFields) => {
+                return new LiquidityPool([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return LiquidityPool.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<LiquidityPool>> {
+        return phantom(LiquidityPool.reified());
+    }
+    static get p() {
+        return LiquidityPool.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("LiquidityPool", {
+            id: UID.bcs,
+            index: bcs.u64(),
+            lp_token_type: TypeName.bcs,
+            liquidity_tokens: bcs.vector(TypeName.bcs),
+            token_pools: bcs.vector(TokenPool.bcs),
+            pool_info: LiquidityPoolInfo.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+            bcs_padding: bcs.vector(bcs.u8()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): LiquidityPool {
+        return LiquidityPool.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            index: decodeFromFields("u64", fields.index),
+            lpTokenType: decodeFromFields(TypeName.reified(), fields.lp_token_type),
+            liquidityTokens: decodeFromFields(reified.vector(TypeName.reified()), fields.liquidity_tokens),
+            tokenPools: decodeFromFields(reified.vector(TokenPool.reified()), fields.token_pools),
+            poolInfo: decodeFromFields(LiquidityPoolInfo.reified(), fields.pool_info),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+            bcsPadding: decodeFromFields(reified.vector("u8"), fields.bcs_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): LiquidityPool {
+        if (!isLiquidityPool(item.type)) {
+            throw new Error("not a LiquidityPool type");
+        }
+
+        return LiquidityPool.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            lpTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.lp_token_type),
+            liquidityTokens: decodeFromFieldsWithTypes(reified.vector(TypeName.reified()), item.fields.liquidity_tokens),
+            tokenPools: decodeFromFieldsWithTypes(reified.vector(TokenPool.reified()), item.fields.token_pools),
+            poolInfo: decodeFromFieldsWithTypes(LiquidityPoolInfo.reified(), item.fields.pool_info),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+            bcsPadding: decodeFromFieldsWithTypes(reified.vector("u8"), item.fields.bcs_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): LiquidityPool {
+        return LiquidityPool.fromFields(LiquidityPool.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            index: this.index.toString(),
+            lpTokenType: this.lpTokenType.toJSONField(),
+            liquidityTokens: fieldToJSON<Vector<TypeName>>(`vector<0x1::type_name::TypeName>`, this.liquidityTokens),
+            tokenPools: fieldToJSON<Vector<TokenPool>>(
+                `vector<0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::TokenPool>`,
+                this.tokenPools
+            ),
+            poolInfo: this.poolInfo.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+            bcsPadding: fieldToJSON<Vector<"u8">>(`vector<u8>`, this.bcsPadding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): LiquidityPool {
+        return LiquidityPool.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            index: decodeFromJSONField("u64", field.index),
+            lpTokenType: decodeFromJSONField(TypeName.reified(), field.lpTokenType),
+            liquidityTokens: decodeFromJSONField(reified.vector(TypeName.reified()), field.liquidityTokens),
+            tokenPools: decodeFromJSONField(reified.vector(TokenPool.reified()), field.tokenPools),
+            poolInfo: decodeFromJSONField(LiquidityPoolInfo.reified(), field.poolInfo),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+            bcsPadding: decodeFromJSONField(reified.vector("u8"), field.bcsPadding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): LiquidityPool {
+        if (json.$typeName !== LiquidityPool.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return LiquidityPool.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): LiquidityPool {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isLiquidityPool(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a LiquidityPool object`);
+        }
+        return LiquidityPool.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<LiquidityPool> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching LiquidityPool object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isLiquidityPool(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a LiquidityPool object`);
+        }
+        return LiquidityPool.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== LiquidityPoolInfo =============================== */
+
+export function isLiquidityPoolInfo(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPoolInfo";
+}
+
+export interface LiquidityPoolInfoFields {
+    lpTokenDecimal: ToField<"u64">;
+    totalShareSupply: ToField<"u64">;
+    tvlUsd: ToField<"u64">;
+    isActive: ToField<"bool">;
+}
+
+export type LiquidityPoolInfoReified = Reified<LiquidityPoolInfo, LiquidityPoolInfoFields>;
+
+export class LiquidityPoolInfo implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPoolInfo";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = LiquidityPoolInfo.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPoolInfo";
+
+    readonly $typeArgs: [];
+
+    readonly lpTokenDecimal: ToField<"u64">;
+    readonly totalShareSupply: ToField<"u64">;
+    readonly tvlUsd: ToField<"u64">;
+    readonly isActive: ToField<"bool">;
+
+    private constructor(typeArgs: [], fields: LiquidityPoolInfoFields) {
+        this.$fullTypeName = composeSuiType(
+            LiquidityPoolInfo.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPoolInfo";
+        this.$typeArgs = typeArgs;
+
+        this.lpTokenDecimal = fields.lpTokenDecimal;
+        this.totalShareSupply = fields.totalShareSupply;
+        this.tvlUsd = fields.tvlUsd;
+        this.isActive = fields.isActive;
+    }
+
+    static reified(): LiquidityPoolInfoReified {
+        return {
+            typeName: LiquidityPoolInfo.$typeName,
+            fullTypeName: composeSuiType(
+                LiquidityPoolInfo.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::LiquidityPoolInfo",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => LiquidityPoolInfo.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => LiquidityPoolInfo.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => LiquidityPoolInfo.fromBcs(data),
+            bcs: LiquidityPoolInfo.bcs,
+            fromJSONField: (field: any) => LiquidityPoolInfo.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => LiquidityPoolInfo.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => LiquidityPoolInfo.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => LiquidityPoolInfo.fetch(client, id),
+            new: (fields: LiquidityPoolInfoFields) => {
+                return new LiquidityPoolInfo([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return LiquidityPoolInfo.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<LiquidityPoolInfo>> {
+        return phantom(LiquidityPoolInfo.reified());
+    }
+    static get p() {
+        return LiquidityPoolInfo.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("LiquidityPoolInfo", {
+            lp_token_decimal: bcs.u64(),
+            total_share_supply: bcs.u64(),
+            tvl_usd: bcs.u64(),
+            is_active: bcs.bool(),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): LiquidityPoolInfo {
+        return LiquidityPoolInfo.reified().new({
+            lpTokenDecimal: decodeFromFields("u64", fields.lp_token_decimal),
+            totalShareSupply: decodeFromFields("u64", fields.total_share_supply),
+            tvlUsd: decodeFromFields("u64", fields.tvl_usd),
+            isActive: decodeFromFields("bool", fields.is_active),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): LiquidityPoolInfo {
+        if (!isLiquidityPoolInfo(item.type)) {
+            throw new Error("not a LiquidityPoolInfo type");
+        }
+
+        return LiquidityPoolInfo.reified().new({
+            lpTokenDecimal: decodeFromFieldsWithTypes("u64", item.fields.lp_token_decimal),
+            totalShareSupply: decodeFromFieldsWithTypes("u64", item.fields.total_share_supply),
+            tvlUsd: decodeFromFieldsWithTypes("u64", item.fields.tvl_usd),
+            isActive: decodeFromFieldsWithTypes("bool", item.fields.is_active),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): LiquidityPoolInfo {
+        return LiquidityPoolInfo.fromFields(LiquidityPoolInfo.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            lpTokenDecimal: this.lpTokenDecimal.toString(),
+            totalShareSupply: this.totalShareSupply.toString(),
+            tvlUsd: this.tvlUsd.toString(),
+            isActive: this.isActive,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): LiquidityPoolInfo {
+        return LiquidityPoolInfo.reified().new({
+            lpTokenDecimal: decodeFromJSONField("u64", field.lpTokenDecimal),
+            totalShareSupply: decodeFromJSONField("u64", field.totalShareSupply),
+            tvlUsd: decodeFromJSONField("u64", field.tvlUsd),
+            isActive: decodeFromJSONField("bool", field.isActive),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): LiquidityPoolInfo {
+        if (json.$typeName !== LiquidityPoolInfo.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return LiquidityPoolInfo.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): LiquidityPoolInfo {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isLiquidityPoolInfo(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a LiquidityPoolInfo object`);
+        }
+        return LiquidityPoolInfo.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<LiquidityPoolInfo> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching LiquidityPoolInfo object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isLiquidityPoolInfo(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a LiquidityPoolInfo object`);
+        }
+        return LiquidityPoolInfo.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== MarginConfig =============================== */
+
+export function isMarginConfig(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MarginConfig";
+}
+
+export interface MarginConfigFields {
+    basicBorrowRate0: ToField<"u64">;
+    basicBorrowRate1: ToField<"u64">;
+    basicBorrowRate2: ToField<"u64">;
+    utilizationThresholdBp0: ToField<"u64">;
+    utilizationThresholdBp1: ToField<"u64">;
+    borrowIntervalTsMs: ToField<"u64">;
+    maxOrderReserveRatioBp: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MarginConfigReified = Reified<MarginConfig, MarginConfigFields>;
+
+export class MarginConfig implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MarginConfig";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = MarginConfig.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MarginConfig";
+
+    readonly $typeArgs: [];
+
+    readonly basicBorrowRate0: ToField<"u64">;
+    readonly basicBorrowRate1: ToField<"u64">;
+    readonly basicBorrowRate2: ToField<"u64">;
+    readonly utilizationThresholdBp0: ToField<"u64">;
+    readonly utilizationThresholdBp1: ToField<"u64">;
+    readonly borrowIntervalTsMs: ToField<"u64">;
+    readonly maxOrderReserveRatioBp: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MarginConfigFields) {
+        this.$fullTypeName = composeSuiType(
+            MarginConfig.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MarginConfig";
+        this.$typeArgs = typeArgs;
+
+        this.basicBorrowRate0 = fields.basicBorrowRate0;
+        this.basicBorrowRate1 = fields.basicBorrowRate1;
+        this.basicBorrowRate2 = fields.basicBorrowRate2;
+        this.utilizationThresholdBp0 = fields.utilizationThresholdBp0;
+        this.utilizationThresholdBp1 = fields.utilizationThresholdBp1;
+        this.borrowIntervalTsMs = fields.borrowIntervalTsMs;
+        this.maxOrderReserveRatioBp = fields.maxOrderReserveRatioBp;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MarginConfigReified {
+        return {
+            typeName: MarginConfig.$typeName,
+            fullTypeName: composeSuiType(
+                MarginConfig.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MarginConfig",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => MarginConfig.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => MarginConfig.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => MarginConfig.fromBcs(data),
+            bcs: MarginConfig.bcs,
+            fromJSONField: (field: any) => MarginConfig.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => MarginConfig.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => MarginConfig.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => MarginConfig.fetch(client, id),
+            new: (fields: MarginConfigFields) => {
+                return new MarginConfig([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return MarginConfig.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<MarginConfig>> {
+        return phantom(MarginConfig.reified());
+    }
+    static get p() {
+        return MarginConfig.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("MarginConfig", {
+            basic_borrow_rate_0: bcs.u64(),
+            basic_borrow_rate_1: bcs.u64(),
+            basic_borrow_rate_2: bcs.u64(),
+            utilization_threshold_bp_0: bcs.u64(),
+            utilization_threshold_bp_1: bcs.u64(),
+            borrow_interval_ts_ms: bcs.u64(),
+            max_order_reserve_ratio_bp: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): MarginConfig {
+        return MarginConfig.reified().new({
+            basicBorrowRate0: decodeFromFields("u64", fields.basic_borrow_rate_0),
+            basicBorrowRate1: decodeFromFields("u64", fields.basic_borrow_rate_1),
+            basicBorrowRate2: decodeFromFields("u64", fields.basic_borrow_rate_2),
+            utilizationThresholdBp0: decodeFromFields("u64", fields.utilization_threshold_bp_0),
+            utilizationThresholdBp1: decodeFromFields("u64", fields.utilization_threshold_bp_1),
+            borrowIntervalTsMs: decodeFromFields("u64", fields.borrow_interval_ts_ms),
+            maxOrderReserveRatioBp: decodeFromFields("u64", fields.max_order_reserve_ratio_bp),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarginConfig {
+        if (!isMarginConfig(item.type)) {
+            throw new Error("not a MarginConfig type");
+        }
+
+        return MarginConfig.reified().new({
+            basicBorrowRate0: decodeFromFieldsWithTypes("u64", item.fields.basic_borrow_rate_0),
+            basicBorrowRate1: decodeFromFieldsWithTypes("u64", item.fields.basic_borrow_rate_1),
+            basicBorrowRate2: decodeFromFieldsWithTypes("u64", item.fields.basic_borrow_rate_2),
+            utilizationThresholdBp0: decodeFromFieldsWithTypes("u64", item.fields.utilization_threshold_bp_0),
+            utilizationThresholdBp1: decodeFromFieldsWithTypes("u64", item.fields.utilization_threshold_bp_1),
+            borrowIntervalTsMs: decodeFromFieldsWithTypes("u64", item.fields.borrow_interval_ts_ms),
+            maxOrderReserveRatioBp: decodeFromFieldsWithTypes("u64", item.fields.max_order_reserve_ratio_bp),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): MarginConfig {
+        return MarginConfig.fromFields(MarginConfig.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            basicBorrowRate0: this.basicBorrowRate0.toString(),
+            basicBorrowRate1: this.basicBorrowRate1.toString(),
+            basicBorrowRate2: this.basicBorrowRate2.toString(),
+            utilizationThresholdBp0: this.utilizationThresholdBp0.toString(),
+            utilizationThresholdBp1: this.utilizationThresholdBp1.toString(),
+            borrowIntervalTsMs: this.borrowIntervalTsMs.toString(),
+            maxOrderReserveRatioBp: this.maxOrderReserveRatioBp.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): MarginConfig {
+        return MarginConfig.reified().new({
+            basicBorrowRate0: decodeFromJSONField("u64", field.basicBorrowRate0),
+            basicBorrowRate1: decodeFromJSONField("u64", field.basicBorrowRate1),
+            basicBorrowRate2: decodeFromJSONField("u64", field.basicBorrowRate2),
+            utilizationThresholdBp0: decodeFromJSONField("u64", field.utilizationThresholdBp0),
+            utilizationThresholdBp1: decodeFromJSONField("u64", field.utilizationThresholdBp1),
+            borrowIntervalTsMs: decodeFromJSONField("u64", field.borrowIntervalTsMs),
+            maxOrderReserveRatioBp: decodeFromJSONField("u64", field.maxOrderReserveRatioBp),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): MarginConfig {
+        if (json.$typeName !== MarginConfig.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return MarginConfig.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): MarginConfig {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMarginConfig(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a MarginConfig object`);
+        }
+        return MarginConfig.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<MarginConfig> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MarginConfig object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMarginConfig(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MarginConfig object`);
+        }
+        return MarginConfig.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== MintLpEvent =============================== */
+
+export function isMintLpEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MintLpEvent";
+}
+
+export interface MintLpEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    liquidityTokenType: ToField<TypeName>;
+    depositAmount: ToField<"u64">;
+    depositAmountUsd: ToField<"u64">;
+    mintFeeUsd: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    mintedLpAmount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MintLpEventReified = Reified<MintLpEvent, MintLpEventFields>;
+
+export class MintLpEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MintLpEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = MintLpEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MintLpEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly liquidityTokenType: ToField<TypeName>;
+    readonly depositAmount: ToField<"u64">;
+    readonly depositAmountUsd: ToField<"u64">;
+    readonly mintFeeUsd: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly mintedLpAmount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MintLpEventFields) {
+        this.$fullTypeName = composeSuiType(
+            MintLpEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MintLpEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.liquidityTokenType = fields.liquidityTokenType;
+        this.depositAmount = fields.depositAmount;
+        this.depositAmountUsd = fields.depositAmountUsd;
+        this.mintFeeUsd = fields.mintFeeUsd;
+        this.lpTokenType = fields.lpTokenType;
+        this.mintedLpAmount = fields.mintedLpAmount;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MintLpEventReified {
+        return {
+            typeName: MintLpEvent.$typeName,
+            fullTypeName: composeSuiType(
+                MintLpEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::MintLpEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => MintLpEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => MintLpEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => MintLpEvent.fromBcs(data),
+            bcs: MintLpEvent.bcs,
+            fromJSONField: (field: any) => MintLpEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => MintLpEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => MintLpEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => MintLpEvent.fetch(client, id),
+            new: (fields: MintLpEventFields) => {
+                return new MintLpEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return MintLpEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<MintLpEvent>> {
+        return phantom(MintLpEvent.reified());
+    }
+    static get p() {
+        return MintLpEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("MintLpEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            liquidity_token_type: TypeName.bcs,
+            deposit_amount: bcs.u64(),
+            deposit_amount_usd: bcs.u64(),
+            mint_fee_usd: bcs.u64(),
+            lp_token_type: TypeName.bcs,
+            minted_lp_amount: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): MintLpEvent {
+        return MintLpEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            liquidityTokenType: decodeFromFields(TypeName.reified(), fields.liquidity_token_type),
+            depositAmount: decodeFromFields("u64", fields.deposit_amount),
+            depositAmountUsd: decodeFromFields("u64", fields.deposit_amount_usd),
+            mintFeeUsd: decodeFromFields("u64", fields.mint_fee_usd),
+            lpTokenType: decodeFromFields(TypeName.reified(), fields.lp_token_type),
+            mintedLpAmount: decodeFromFields("u64", fields.minted_lp_amount),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): MintLpEvent {
+        if (!isMintLpEvent(item.type)) {
+            throw new Error("not a MintLpEvent type");
+        }
+
+        return MintLpEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token_type),
+            depositAmount: decodeFromFieldsWithTypes("u64", item.fields.deposit_amount),
+            depositAmountUsd: decodeFromFieldsWithTypes("u64", item.fields.deposit_amount_usd),
+            mintFeeUsd: decodeFromFieldsWithTypes("u64", item.fields.mint_fee_usd),
+            lpTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.lp_token_type),
+            mintedLpAmount: decodeFromFieldsWithTypes("u64", item.fields.minted_lp_amount),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): MintLpEvent {
+        return MintLpEvent.fromFields(MintLpEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            liquidityTokenType: this.liquidityTokenType.toJSONField(),
+            depositAmount: this.depositAmount.toString(),
+            depositAmountUsd: this.depositAmountUsd.toString(),
+            mintFeeUsd: this.mintFeeUsd.toString(),
+            lpTokenType: this.lpTokenType.toJSONField(),
+            mintedLpAmount: this.mintedLpAmount.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): MintLpEvent {
+        return MintLpEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            liquidityTokenType: decodeFromJSONField(TypeName.reified(), field.liquidityTokenType),
+            depositAmount: decodeFromJSONField("u64", field.depositAmount),
+            depositAmountUsd: decodeFromJSONField("u64", field.depositAmountUsd),
+            mintFeeUsd: decodeFromJSONField("u64", field.mintFeeUsd),
+            lpTokenType: decodeFromJSONField(TypeName.reified(), field.lpTokenType),
+            mintedLpAmount: decodeFromJSONField("u64", field.mintedLpAmount),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): MintLpEvent {
+        if (json.$typeName !== MintLpEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return MintLpEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): MintLpEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMintLpEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a MintLpEvent object`);
+        }
+        return MintLpEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<MintLpEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MintLpEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMintLpEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MintLpEvent object`);
+        }
+        return MintLpEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== NewLiquidityPoolEvent =============================== */
+
+export function isNewLiquidityPoolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::NewLiquidityPoolEvent";
+}
+
+export interface NewLiquidityPoolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    lpTokenDecimal: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type NewLiquidityPoolEventReified = Reified<NewLiquidityPoolEvent, NewLiquidityPoolEventFields>;
+
+export class NewLiquidityPoolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::NewLiquidityPoolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = NewLiquidityPoolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::NewLiquidityPoolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly lpTokenDecimal: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: NewLiquidityPoolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            NewLiquidityPoolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::NewLiquidityPoolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.lpTokenType = fields.lpTokenType;
+        this.lpTokenDecimal = fields.lpTokenDecimal;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): NewLiquidityPoolEventReified {
+        return {
+            typeName: NewLiquidityPoolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                NewLiquidityPoolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::NewLiquidityPoolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => NewLiquidityPoolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => NewLiquidityPoolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => NewLiquidityPoolEvent.fromBcs(data),
+            bcs: NewLiquidityPoolEvent.bcs,
+            fromJSONField: (field: any) => NewLiquidityPoolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => NewLiquidityPoolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => NewLiquidityPoolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => NewLiquidityPoolEvent.fetch(client, id),
+            new: (fields: NewLiquidityPoolEventFields) => {
+                return new NewLiquidityPoolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return NewLiquidityPoolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<NewLiquidityPoolEvent>> {
+        return phantom(NewLiquidityPoolEvent.reified());
+    }
+    static get p() {
+        return NewLiquidityPoolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("NewLiquidityPoolEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            lp_token_type: TypeName.bcs,
+            lp_token_decimal: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): NewLiquidityPoolEvent {
+        return NewLiquidityPoolEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            lpTokenType: decodeFromFields(TypeName.reified(), fields.lp_token_type),
+            lpTokenDecimal: decodeFromFields("u64", fields.lp_token_decimal),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): NewLiquidityPoolEvent {
+        if (!isNewLiquidityPoolEvent(item.type)) {
+            throw new Error("not a NewLiquidityPoolEvent type");
+        }
+
+        return NewLiquidityPoolEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            lpTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.lp_token_type),
+            lpTokenDecimal: decodeFromFieldsWithTypes("u64", item.fields.lp_token_decimal),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): NewLiquidityPoolEvent {
+        return NewLiquidityPoolEvent.fromFields(NewLiquidityPoolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            lpTokenType: this.lpTokenType.toJSONField(),
+            lpTokenDecimal: this.lpTokenDecimal.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): NewLiquidityPoolEvent {
+        return NewLiquidityPoolEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            lpTokenType: decodeFromJSONField(TypeName.reified(), field.lpTokenType),
+            lpTokenDecimal: decodeFromJSONField("u64", field.lpTokenDecimal),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): NewLiquidityPoolEvent {
+        if (json.$typeName !== NewLiquidityPoolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return NewLiquidityPoolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): NewLiquidityPoolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isNewLiquidityPoolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a NewLiquidityPoolEvent object`);
+        }
+        return NewLiquidityPoolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<NewLiquidityPoolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching NewLiquidityPoolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isNewLiquidityPoolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a NewLiquidityPoolEvent object`);
+        }
+        return NewLiquidityPoolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== Registry =============================== */
+
+export function isRegistry(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Registry";
+}
+
+export interface RegistryFields {
+    id: ToField<UID>;
+    numPool: ToField<"u64">;
+    liquidityPoolRegistry: ToField<UID>;
+}
+
+export type RegistryReified = Reified<Registry, RegistryFields>;
+
+export class Registry implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Registry";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = Registry.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Registry";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly numPool: ToField<"u64">;
+    readonly liquidityPoolRegistry: ToField<UID>;
+
+    private constructor(typeArgs: [], fields: RegistryFields) {
+        this.$fullTypeName = composeSuiType(
+            Registry.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Registry";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.numPool = fields.numPool;
+        this.liquidityPoolRegistry = fields.liquidityPoolRegistry;
+    }
+
+    static reified(): RegistryReified {
+        return {
+            typeName: Registry.$typeName,
+            fullTypeName: composeSuiType(
+                Registry.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::Registry",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => Registry.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => Registry.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => Registry.fromBcs(data),
+            bcs: Registry.bcs,
+            fromJSONField: (field: any) => Registry.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => Registry.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => Registry.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => Registry.fetch(client, id),
+            new: (fields: RegistryFields) => {
+                return new Registry([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return Registry.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<Registry>> {
+        return phantom(Registry.reified());
+    }
+    static get p() {
+        return Registry.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("Registry", {
+            id: UID.bcs,
+            num_pool: bcs.u64(),
+            liquidity_pool_registry: UID.bcs,
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): Registry {
+        return Registry.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            numPool: decodeFromFields("u64", fields.num_pool),
+            liquidityPoolRegistry: decodeFromFields(UID.reified(), fields.liquidity_pool_registry),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): Registry {
+        if (!isRegistry(item.type)) {
+            throw new Error("not a Registry type");
+        }
+
+        return Registry.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            numPool: decodeFromFieldsWithTypes("u64", item.fields.num_pool),
+            liquidityPoolRegistry: decodeFromFieldsWithTypes(UID.reified(), item.fields.liquidity_pool_registry),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): Registry {
+        return Registry.fromFields(Registry.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            numPool: this.numPool.toString(),
+            liquidityPoolRegistry: this.liquidityPoolRegistry,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): Registry {
+        return Registry.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            numPool: decodeFromJSONField("u64", field.numPool),
+            liquidityPoolRegistry: decodeFromJSONField(UID.reified(), field.liquidityPoolRegistry),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): Registry {
+        if (json.$typeName !== Registry.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return Registry.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): Registry {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isRegistry(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a Registry object`);
+        }
+        return Registry.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<Registry> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Registry object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isRegistry(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Registry object`);
+        }
+        return Registry.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ResumePoolEvent =============================== */
+
+export function isResumePoolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumePoolEvent";
+}
+
+export interface ResumePoolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ResumePoolEventReified = Reified<ResumePoolEvent, ResumePoolEventFields>;
+
+export class ResumePoolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumePoolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ResumePoolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumePoolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ResumePoolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            ResumePoolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumePoolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ResumePoolEventReified {
+        return {
+            typeName: ResumePoolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                ResumePoolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumePoolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ResumePoolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ResumePoolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ResumePoolEvent.fromBcs(data),
+            bcs: ResumePoolEvent.bcs,
+            fromJSONField: (field: any) => ResumePoolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ResumePoolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ResumePoolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ResumePoolEvent.fetch(client, id),
+            new: (fields: ResumePoolEventFields) => {
+                return new ResumePoolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ResumePoolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ResumePoolEvent>> {
+        return phantom(ResumePoolEvent.reified());
+    }
+    static get p() {
+        return ResumePoolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ResumePoolEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ResumePoolEvent {
+        return ResumePoolEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ResumePoolEvent {
+        if (!isResumePoolEvent(item.type)) {
+            throw new Error("not a ResumePoolEvent type");
+        }
+
+        return ResumePoolEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): ResumePoolEvent {
+        return ResumePoolEvent.fromFields(ResumePoolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): ResumePoolEvent {
+        return ResumePoolEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): ResumePoolEvent {
+        if (json.$typeName !== ResumePoolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ResumePoolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ResumePoolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isResumePoolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ResumePoolEvent object`);
+        }
+        return ResumePoolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ResumePoolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ResumePoolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isResumePoolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ResumePoolEvent object`);
+        }
+        return ResumePoolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ResumeTokenPoolEvent =============================== */
+
+export function isResumeTokenPoolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumeTokenPoolEvent";
+}
+
+export interface ResumeTokenPoolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    liquidityToken: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ResumeTokenPoolEventReified = Reified<ResumeTokenPoolEvent, ResumeTokenPoolEventFields>;
+
+export class ResumeTokenPoolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumeTokenPoolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ResumeTokenPoolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumeTokenPoolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly liquidityToken: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ResumeTokenPoolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            ResumeTokenPoolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumeTokenPoolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.liquidityToken = fields.liquidityToken;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ResumeTokenPoolEventReified {
+        return {
+            typeName: ResumeTokenPoolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                ResumeTokenPoolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::ResumeTokenPoolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ResumeTokenPoolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ResumeTokenPoolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ResumeTokenPoolEvent.fromBcs(data),
+            bcs: ResumeTokenPoolEvent.bcs,
+            fromJSONField: (field: any) => ResumeTokenPoolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ResumeTokenPoolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ResumeTokenPoolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ResumeTokenPoolEvent.fetch(client, id),
+            new: (fields: ResumeTokenPoolEventFields) => {
+                return new ResumeTokenPoolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ResumeTokenPoolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ResumeTokenPoolEvent>> {
+        return phantom(ResumeTokenPoolEvent.reified());
+    }
+    static get p() {
+        return ResumeTokenPoolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ResumeTokenPoolEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            liquidity_token: TypeName.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ResumeTokenPoolEvent {
+        return ResumeTokenPoolEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            liquidityToken: decodeFromFields(TypeName.reified(), fields.liquidity_token),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ResumeTokenPoolEvent {
+        if (!isResumeTokenPoolEvent(item.type)) {
+            throw new Error("not a ResumeTokenPoolEvent type");
+        }
+
+        return ResumeTokenPoolEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): ResumeTokenPoolEvent {
+        return ResumeTokenPoolEvent.fromFields(ResumeTokenPoolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            liquidityToken: this.liquidityToken.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): ResumeTokenPoolEvent {
+        return ResumeTokenPoolEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            liquidityToken: decodeFromJSONField(TypeName.reified(), field.liquidityToken),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): ResumeTokenPoolEvent {
+        if (json.$typeName !== ResumeTokenPoolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ResumeTokenPoolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ResumeTokenPoolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isResumeTokenPoolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ResumeTokenPoolEvent object`);
+        }
+        return ResumeTokenPoolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ResumeTokenPoolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ResumeTokenPoolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isResumeTokenPoolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ResumeTokenPoolEvent object`);
+        }
+        return ResumeTokenPoolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SpotConfig =============================== */
+
+export function isSpotConfig(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SpotConfig";
+}
+
+export interface SpotConfigFields {
+    minDeposit: ToField<"u64">;
+    maxCapacity: ToField<"u64">;
+    targetWeightBp: ToField<"u64">;
+    basicMintFeeBp: ToField<"u64">;
+    additionalMintFeeBp: ToField<"u64">;
+    basicBurnFeeBp: ToField<"u64">;
+    additionalBurnFeeBp: ToField<"u64">;
+    swapFeeBp: ToField<"u64">;
+    swapFeeProtocolShareBp: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type SpotConfigReified = Reified<SpotConfig, SpotConfigFields>;
+
+export class SpotConfig implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SpotConfig";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SpotConfig.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SpotConfig";
+
+    readonly $typeArgs: [];
+
+    readonly minDeposit: ToField<"u64">;
+    readonly maxCapacity: ToField<"u64">;
+    readonly targetWeightBp: ToField<"u64">;
+    readonly basicMintFeeBp: ToField<"u64">;
+    readonly additionalMintFeeBp: ToField<"u64">;
+    readonly basicBurnFeeBp: ToField<"u64">;
+    readonly additionalBurnFeeBp: ToField<"u64">;
+    readonly swapFeeBp: ToField<"u64">;
+    readonly swapFeeProtocolShareBp: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: SpotConfigFields) {
+        this.$fullTypeName = composeSuiType(
+            SpotConfig.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SpotConfig";
+        this.$typeArgs = typeArgs;
+
+        this.minDeposit = fields.minDeposit;
+        this.maxCapacity = fields.maxCapacity;
+        this.targetWeightBp = fields.targetWeightBp;
+        this.basicMintFeeBp = fields.basicMintFeeBp;
+        this.additionalMintFeeBp = fields.additionalMintFeeBp;
+        this.basicBurnFeeBp = fields.basicBurnFeeBp;
+        this.additionalBurnFeeBp = fields.additionalBurnFeeBp;
+        this.swapFeeBp = fields.swapFeeBp;
+        this.swapFeeProtocolShareBp = fields.swapFeeProtocolShareBp;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): SpotConfigReified {
+        return {
+            typeName: SpotConfig.$typeName,
+            fullTypeName: composeSuiType(
+                SpotConfig.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SpotConfig",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SpotConfig.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SpotConfig.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SpotConfig.fromBcs(data),
+            bcs: SpotConfig.bcs,
+            fromJSONField: (field: any) => SpotConfig.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SpotConfig.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SpotConfig.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SpotConfig.fetch(client, id),
+            new: (fields: SpotConfigFields) => {
+                return new SpotConfig([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SpotConfig.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SpotConfig>> {
+        return phantom(SpotConfig.reified());
+    }
+    static get p() {
+        return SpotConfig.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SpotConfig", {
+            min_deposit: bcs.u64(),
+            max_capacity: bcs.u64(),
+            target_weight_bp: bcs.u64(),
+            basic_mint_fee_bp: bcs.u64(),
+            additional_mint_fee_bp: bcs.u64(),
+            basic_burn_fee_bp: bcs.u64(),
+            additional_burn_fee_bp: bcs.u64(),
+            swap_fee_bp: bcs.u64(),
+            swap_fee_protocol_share_bp: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SpotConfig {
+        return SpotConfig.reified().new({
+            minDeposit: decodeFromFields("u64", fields.min_deposit),
+            maxCapacity: decodeFromFields("u64", fields.max_capacity),
+            targetWeightBp: decodeFromFields("u64", fields.target_weight_bp),
+            basicMintFeeBp: decodeFromFields("u64", fields.basic_mint_fee_bp),
+            additionalMintFeeBp: decodeFromFields("u64", fields.additional_mint_fee_bp),
+            basicBurnFeeBp: decodeFromFields("u64", fields.basic_burn_fee_bp),
+            additionalBurnFeeBp: decodeFromFields("u64", fields.additional_burn_fee_bp),
+            swapFeeBp: decodeFromFields("u64", fields.swap_fee_bp),
+            swapFeeProtocolShareBp: decodeFromFields("u64", fields.swap_fee_protocol_share_bp),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SpotConfig {
+        if (!isSpotConfig(item.type)) {
+            throw new Error("not a SpotConfig type");
+        }
+
+        return SpotConfig.reified().new({
+            minDeposit: decodeFromFieldsWithTypes("u64", item.fields.min_deposit),
+            maxCapacity: decodeFromFieldsWithTypes("u64", item.fields.max_capacity),
+            targetWeightBp: decodeFromFieldsWithTypes("u64", item.fields.target_weight_bp),
+            basicMintFeeBp: decodeFromFieldsWithTypes("u64", item.fields.basic_mint_fee_bp),
+            additionalMintFeeBp: decodeFromFieldsWithTypes("u64", item.fields.additional_mint_fee_bp),
+            basicBurnFeeBp: decodeFromFieldsWithTypes("u64", item.fields.basic_burn_fee_bp),
+            additionalBurnFeeBp: decodeFromFieldsWithTypes("u64", item.fields.additional_burn_fee_bp),
+            swapFeeBp: decodeFromFieldsWithTypes("u64", item.fields.swap_fee_bp),
+            swapFeeProtocolShareBp: decodeFromFieldsWithTypes("u64", item.fields.swap_fee_protocol_share_bp),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SpotConfig {
+        return SpotConfig.fromFields(SpotConfig.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            minDeposit: this.minDeposit.toString(),
+            maxCapacity: this.maxCapacity.toString(),
+            targetWeightBp: this.targetWeightBp.toString(),
+            basicMintFeeBp: this.basicMintFeeBp.toString(),
+            additionalMintFeeBp: this.additionalMintFeeBp.toString(),
+            basicBurnFeeBp: this.basicBurnFeeBp.toString(),
+            additionalBurnFeeBp: this.additionalBurnFeeBp.toString(),
+            swapFeeBp: this.swapFeeBp.toString(),
+            swapFeeProtocolShareBp: this.swapFeeProtocolShareBp.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SpotConfig {
+        return SpotConfig.reified().new({
+            minDeposit: decodeFromJSONField("u64", field.minDeposit),
+            maxCapacity: decodeFromJSONField("u64", field.maxCapacity),
+            targetWeightBp: decodeFromJSONField("u64", field.targetWeightBp),
+            basicMintFeeBp: decodeFromJSONField("u64", field.basicMintFeeBp),
+            additionalMintFeeBp: decodeFromJSONField("u64", field.additionalMintFeeBp),
+            basicBurnFeeBp: decodeFromJSONField("u64", field.basicBurnFeeBp),
+            additionalBurnFeeBp: decodeFromJSONField("u64", field.additionalBurnFeeBp),
+            swapFeeBp: decodeFromJSONField("u64", field.swapFeeBp),
+            swapFeeProtocolShareBp: decodeFromJSONField("u64", field.swapFeeProtocolShareBp),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SpotConfig {
+        if (json.$typeName !== SpotConfig.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SpotConfig.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SpotConfig {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSpotConfig(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SpotConfig object`);
+        }
+        return SpotConfig.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SpotConfig> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SpotConfig object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSpotConfig(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SpotConfig object`);
+        }
+        return SpotConfig.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SuspendPoolEvent =============================== */
+
+export function isSuspendPoolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendPoolEvent";
+}
+
+export interface SuspendPoolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type SuspendPoolEventReified = Reified<SuspendPoolEvent, SuspendPoolEventFields>;
+
+export class SuspendPoolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendPoolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SuspendPoolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendPoolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: SuspendPoolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            SuspendPoolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendPoolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): SuspendPoolEventReified {
+        return {
+            typeName: SuspendPoolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                SuspendPoolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendPoolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SuspendPoolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SuspendPoolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SuspendPoolEvent.fromBcs(data),
+            bcs: SuspendPoolEvent.bcs,
+            fromJSONField: (field: any) => SuspendPoolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SuspendPoolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SuspendPoolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SuspendPoolEvent.fetch(client, id),
+            new: (fields: SuspendPoolEventFields) => {
+                return new SuspendPoolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SuspendPoolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SuspendPoolEvent>> {
+        return phantom(SuspendPoolEvent.reified());
+    }
+    static get p() {
+        return SuspendPoolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SuspendPoolEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SuspendPoolEvent {
+        return SuspendPoolEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SuspendPoolEvent {
+        if (!isSuspendPoolEvent(item.type)) {
+            throw new Error("not a SuspendPoolEvent type");
+        }
+
+        return SuspendPoolEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SuspendPoolEvent {
+        return SuspendPoolEvent.fromFields(SuspendPoolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SuspendPoolEvent {
+        return SuspendPoolEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SuspendPoolEvent {
+        if (json.$typeName !== SuspendPoolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SuspendPoolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SuspendPoolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSuspendPoolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SuspendPoolEvent object`);
+        }
+        return SuspendPoolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SuspendPoolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SuspendPoolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSuspendPoolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SuspendPoolEvent object`);
+        }
+        return SuspendPoolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SuspendTokenPoolEvent =============================== */
+
+export function isSuspendTokenPoolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendTokenPoolEvent";
+}
+
+export interface SuspendTokenPoolEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    liquidityToken: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type SuspendTokenPoolEventReified = Reified<SuspendTokenPoolEvent, SuspendTokenPoolEventFields>;
+
+export class SuspendTokenPoolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendTokenPoolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SuspendTokenPoolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendTokenPoolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly liquidityToken: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: SuspendTokenPoolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            SuspendTokenPoolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendTokenPoolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.liquidityToken = fields.liquidityToken;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): SuspendTokenPoolEventReified {
+        return {
+            typeName: SuspendTokenPoolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                SuspendTokenPoolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SuspendTokenPoolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SuspendTokenPoolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SuspendTokenPoolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SuspendTokenPoolEvent.fromBcs(data),
+            bcs: SuspendTokenPoolEvent.bcs,
+            fromJSONField: (field: any) => SuspendTokenPoolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SuspendTokenPoolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SuspendTokenPoolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SuspendTokenPoolEvent.fetch(client, id),
+            new: (fields: SuspendTokenPoolEventFields) => {
+                return new SuspendTokenPoolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SuspendTokenPoolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SuspendTokenPoolEvent>> {
+        return phantom(SuspendTokenPoolEvent.reified());
+    }
+    static get p() {
+        return SuspendTokenPoolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SuspendTokenPoolEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            liquidity_token: TypeName.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SuspendTokenPoolEvent {
+        return SuspendTokenPoolEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            liquidityToken: decodeFromFields(TypeName.reified(), fields.liquidity_token),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SuspendTokenPoolEvent {
+        if (!isSuspendTokenPoolEvent(item.type)) {
+            throw new Error("not a SuspendTokenPoolEvent type");
+        }
+
+        return SuspendTokenPoolEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SuspendTokenPoolEvent {
+        return SuspendTokenPoolEvent.fromFields(SuspendTokenPoolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            liquidityToken: this.liquidityToken.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SuspendTokenPoolEvent {
+        return SuspendTokenPoolEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            liquidityToken: decodeFromJSONField(TypeName.reified(), field.liquidityToken),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SuspendTokenPoolEvent {
+        if (json.$typeName !== SuspendTokenPoolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SuspendTokenPoolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SuspendTokenPoolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSuspendTokenPoolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SuspendTokenPoolEvent object`);
+        }
+        return SuspendTokenPoolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SuspendTokenPoolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SuspendTokenPoolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSuspendTokenPoolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SuspendTokenPoolEvent object`);
+        }
+        return SuspendTokenPoolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SwapEvent =============================== */
+
+export function isSwapEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SwapEvent";
+}
+
+export interface SwapEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    fromTokenType: ToField<TypeName>;
+    fromAmount: ToField<"u64">;
+    toTokenType: ToField<TypeName>;
+    minToAmount: ToField<"u64">;
+    actualToAmount: ToField<"u64">;
+    feeAmount: ToField<"u64">;
+    feeAmountUsd: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type SwapEventReified = Reified<SwapEvent, SwapEventFields>;
+
+export class SwapEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SwapEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SwapEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SwapEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly fromTokenType: ToField<TypeName>;
+    readonly fromAmount: ToField<"u64">;
+    readonly toTokenType: ToField<TypeName>;
+    readonly minToAmount: ToField<"u64">;
+    readonly actualToAmount: ToField<"u64">;
+    readonly feeAmount: ToField<"u64">;
+    readonly feeAmountUsd: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: SwapEventFields) {
+        this.$fullTypeName = composeSuiType(
+            SwapEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SwapEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.fromTokenType = fields.fromTokenType;
+        this.fromAmount = fields.fromAmount;
+        this.toTokenType = fields.toTokenType;
+        this.minToAmount = fields.minToAmount;
+        this.actualToAmount = fields.actualToAmount;
+        this.feeAmount = fields.feeAmount;
+        this.feeAmountUsd = fields.feeAmountUsd;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): SwapEventReified {
+        return {
+            typeName: SwapEvent.$typeName,
+            fullTypeName: composeSuiType(
+                SwapEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::SwapEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SwapEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SwapEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SwapEvent.fromBcs(data),
+            bcs: SwapEvent.bcs,
+            fromJSONField: (field: any) => SwapEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SwapEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SwapEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SwapEvent.fetch(client, id),
+            new: (fields: SwapEventFields) => {
+                return new SwapEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SwapEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SwapEvent>> {
+        return phantom(SwapEvent.reified());
+    }
+    static get p() {
+        return SwapEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SwapEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            from_token_type: TypeName.bcs,
+            from_amount: bcs.u64(),
+            to_token_type: TypeName.bcs,
+            min_to_amount: bcs.u64(),
+            actual_to_amount: bcs.u64(),
+            fee_amount: bcs.u64(),
+            fee_amount_usd: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SwapEvent {
+        return SwapEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            fromTokenType: decodeFromFields(TypeName.reified(), fields.from_token_type),
+            fromAmount: decodeFromFields("u64", fields.from_amount),
+            toTokenType: decodeFromFields(TypeName.reified(), fields.to_token_type),
+            minToAmount: decodeFromFields("u64", fields.min_to_amount),
+            actualToAmount: decodeFromFields("u64", fields.actual_to_amount),
+            feeAmount: decodeFromFields("u64", fields.fee_amount),
+            feeAmountUsd: decodeFromFields("u64", fields.fee_amount_usd),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SwapEvent {
+        if (!isSwapEvent(item.type)) {
+            throw new Error("not a SwapEvent type");
+        }
+
+        return SwapEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            fromTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.from_token_type),
+            fromAmount: decodeFromFieldsWithTypes("u64", item.fields.from_amount),
+            toTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.to_token_type),
+            minToAmount: decodeFromFieldsWithTypes("u64", item.fields.min_to_amount),
+            actualToAmount: decodeFromFieldsWithTypes("u64", item.fields.actual_to_amount),
+            feeAmount: decodeFromFieldsWithTypes("u64", item.fields.fee_amount),
+            feeAmountUsd: decodeFromFieldsWithTypes("u64", item.fields.fee_amount_usd),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SwapEvent {
+        return SwapEvent.fromFields(SwapEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            fromTokenType: this.fromTokenType.toJSONField(),
+            fromAmount: this.fromAmount.toString(),
+            toTokenType: this.toTokenType.toJSONField(),
+            minToAmount: this.minToAmount.toString(),
+            actualToAmount: this.actualToAmount.toString(),
+            feeAmount: this.feeAmount.toString(),
+            feeAmountUsd: this.feeAmountUsd.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SwapEvent {
+        return SwapEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            fromTokenType: decodeFromJSONField(TypeName.reified(), field.fromTokenType),
+            fromAmount: decodeFromJSONField("u64", field.fromAmount),
+            toTokenType: decodeFromJSONField(TypeName.reified(), field.toTokenType),
+            minToAmount: decodeFromJSONField("u64", field.minToAmount),
+            actualToAmount: decodeFromJSONField("u64", field.actualToAmount),
+            feeAmount: decodeFromJSONField("u64", field.feeAmount),
+            feeAmountUsd: decodeFromJSONField("u64", field.feeAmountUsd),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SwapEvent {
+        if (json.$typeName !== SwapEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SwapEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SwapEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSwapEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SwapEvent object`);
+        }
+        return SwapEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SwapEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SwapEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSwapEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SwapEvent object`);
+        }
+        return SwapEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== TokenPool =============================== */
+
+export function isTokenPool(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::TokenPool";
+}
+
+export interface TokenPoolFields {
+    tokenType: ToField<TypeName>;
+    config: ToField<Config>;
+    state: ToField<State>;
+}
+
+export type TokenPoolReified = Reified<TokenPool, TokenPoolFields>;
+
+export class TokenPool implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::TokenPool";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = TokenPool.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::TokenPool";
+
+    readonly $typeArgs: [];
+
+    readonly tokenType: ToField<TypeName>;
+    readonly config: ToField<Config>;
+    readonly state: ToField<State>;
+
+    private constructor(typeArgs: [], fields: TokenPoolFields) {
+        this.$fullTypeName = composeSuiType(
+            TokenPool.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::TokenPool";
+        this.$typeArgs = typeArgs;
+
+        this.tokenType = fields.tokenType;
+        this.config = fields.config;
+        this.state = fields.state;
+    }
+
+    static reified(): TokenPoolReified {
+        return {
+            typeName: TokenPool.$typeName,
+            fullTypeName: composeSuiType(
+                TokenPool.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::TokenPool",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => TokenPool.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => TokenPool.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => TokenPool.fromBcs(data),
+            bcs: TokenPool.bcs,
+            fromJSONField: (field: any) => TokenPool.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => TokenPool.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => TokenPool.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => TokenPool.fetch(client, id),
+            new: (fields: TokenPoolFields) => {
+                return new TokenPool([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return TokenPool.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<TokenPool>> {
+        return phantom(TokenPool.reified());
+    }
+    static get p() {
+        return TokenPool.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("TokenPool", {
+            token_type: TypeName.bcs,
+            config: Config.bcs,
+            state: State.bcs,
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): TokenPool {
+        return TokenPool.reified().new({
+            tokenType: decodeFromFields(TypeName.reified(), fields.token_type),
+            config: decodeFromFields(Config.reified(), fields.config),
+            state: decodeFromFields(State.reified(), fields.state),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): TokenPool {
+        if (!isTokenPool(item.type)) {
+            throw new Error("not a TokenPool type");
+        }
+
+        return TokenPool.reified().new({
+            tokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.token_type),
+            config: decodeFromFieldsWithTypes(Config.reified(), item.fields.config),
+            state: decodeFromFieldsWithTypes(State.reified(), item.fields.state),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): TokenPool {
+        return TokenPool.fromFields(TokenPool.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            tokenType: this.tokenType.toJSONField(),
+            config: this.config.toJSONField(),
+            state: this.state.toJSONField(),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): TokenPool {
+        return TokenPool.reified().new({
+            tokenType: decodeFromJSONField(TypeName.reified(), field.tokenType),
+            config: decodeFromJSONField(Config.reified(), field.config),
+            state: decodeFromJSONField(State.reified(), field.state),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): TokenPool {
+        if (json.$typeName !== TokenPool.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return TokenPool.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): TokenPool {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTokenPool(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a TokenPool object`);
+        }
+        return TokenPool.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<TokenPool> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching TokenPool object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTokenPool(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a TokenPool object`);
+        }
+        return TokenPool.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateBorrowInfoEvent =============================== */
+
+export function isUpdateBorrowInfoEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateBorrowInfoEvent";
+}
+
+export interface UpdateBorrowInfoEventFields {
+    index: ToField<"u64">;
+    liquidityTokenType: ToField<TypeName>;
+    previousBorrowTsMs: ToField<"u64">;
+    previousCumulativeBorrowRate: ToField<"u64">;
+    borrowIntervalTsMs: ToField<"u64">;
+    lastBorrowRateTsMs: ToField<"u64">;
+    lastCumulativeBorrowRate: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateBorrowInfoEventReified = Reified<UpdateBorrowInfoEvent, UpdateBorrowInfoEventFields>;
+
+export class UpdateBorrowInfoEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateBorrowInfoEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateBorrowInfoEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateBorrowInfoEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly liquidityTokenType: ToField<TypeName>;
+    readonly previousBorrowTsMs: ToField<"u64">;
+    readonly previousCumulativeBorrowRate: ToField<"u64">;
+    readonly borrowIntervalTsMs: ToField<"u64">;
+    readonly lastBorrowRateTsMs: ToField<"u64">;
+    readonly lastCumulativeBorrowRate: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateBorrowInfoEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateBorrowInfoEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateBorrowInfoEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.liquidityTokenType = fields.liquidityTokenType;
+        this.previousBorrowTsMs = fields.previousBorrowTsMs;
+        this.previousCumulativeBorrowRate = fields.previousCumulativeBorrowRate;
+        this.borrowIntervalTsMs = fields.borrowIntervalTsMs;
+        this.lastBorrowRateTsMs = fields.lastBorrowRateTsMs;
+        this.lastCumulativeBorrowRate = fields.lastCumulativeBorrowRate;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateBorrowInfoEventReified {
+        return {
+            typeName: UpdateBorrowInfoEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateBorrowInfoEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateBorrowInfoEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateBorrowInfoEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateBorrowInfoEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateBorrowInfoEvent.fromBcs(data),
+            bcs: UpdateBorrowInfoEvent.bcs,
+            fromJSONField: (field: any) => UpdateBorrowInfoEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateBorrowInfoEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateBorrowInfoEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateBorrowInfoEvent.fetch(client, id),
+            new: (fields: UpdateBorrowInfoEventFields) => {
+                return new UpdateBorrowInfoEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateBorrowInfoEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateBorrowInfoEvent>> {
+        return phantom(UpdateBorrowInfoEvent.reified());
+    }
+    static get p() {
+        return UpdateBorrowInfoEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateBorrowInfoEvent", {
+            index: bcs.u64(),
+            liquidity_token_type: TypeName.bcs,
+            previous_borrow_ts_ms: bcs.u64(),
+            previous_cumulative_borrow_rate: bcs.u64(),
+            borrow_interval_ts_ms: bcs.u64(),
+            last_borrow_rate_ts_ms: bcs.u64(),
+            last_cumulative_borrow_rate: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateBorrowInfoEvent {
+        return UpdateBorrowInfoEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            liquidityTokenType: decodeFromFields(TypeName.reified(), fields.liquidity_token_type),
+            previousBorrowTsMs: decodeFromFields("u64", fields.previous_borrow_ts_ms),
+            previousCumulativeBorrowRate: decodeFromFields("u64", fields.previous_cumulative_borrow_rate),
+            borrowIntervalTsMs: decodeFromFields("u64", fields.borrow_interval_ts_ms),
+            lastBorrowRateTsMs: decodeFromFields("u64", fields.last_borrow_rate_ts_ms),
+            lastCumulativeBorrowRate: decodeFromFields("u64", fields.last_cumulative_borrow_rate),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateBorrowInfoEvent {
+        if (!isUpdateBorrowInfoEvent(item.type)) {
+            throw new Error("not a UpdateBorrowInfoEvent type");
+        }
+
+        return UpdateBorrowInfoEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token_type),
+            previousBorrowTsMs: decodeFromFieldsWithTypes("u64", item.fields.previous_borrow_ts_ms),
+            previousCumulativeBorrowRate: decodeFromFieldsWithTypes("u64", item.fields.previous_cumulative_borrow_rate),
+            borrowIntervalTsMs: decodeFromFieldsWithTypes("u64", item.fields.borrow_interval_ts_ms),
+            lastBorrowRateTsMs: decodeFromFieldsWithTypes("u64", item.fields.last_borrow_rate_ts_ms),
+            lastCumulativeBorrowRate: decodeFromFieldsWithTypes("u64", item.fields.last_cumulative_borrow_rate),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateBorrowInfoEvent {
+        return UpdateBorrowInfoEvent.fromFields(UpdateBorrowInfoEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            liquidityTokenType: this.liquidityTokenType.toJSONField(),
+            previousBorrowTsMs: this.previousBorrowTsMs.toString(),
+            previousCumulativeBorrowRate: this.previousCumulativeBorrowRate.toString(),
+            borrowIntervalTsMs: this.borrowIntervalTsMs.toString(),
+            lastBorrowRateTsMs: this.lastBorrowRateTsMs.toString(),
+            lastCumulativeBorrowRate: this.lastCumulativeBorrowRate.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateBorrowInfoEvent {
+        return UpdateBorrowInfoEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            liquidityTokenType: decodeFromJSONField(TypeName.reified(), field.liquidityTokenType),
+            previousBorrowTsMs: decodeFromJSONField("u64", field.previousBorrowTsMs),
+            previousCumulativeBorrowRate: decodeFromJSONField("u64", field.previousCumulativeBorrowRate),
+            borrowIntervalTsMs: decodeFromJSONField("u64", field.borrowIntervalTsMs),
+            lastBorrowRateTsMs: decodeFromJSONField("u64", field.lastBorrowRateTsMs),
+            lastCumulativeBorrowRate: decodeFromJSONField("u64", field.lastCumulativeBorrowRate),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateBorrowInfoEvent {
+        if (json.$typeName !== UpdateBorrowInfoEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateBorrowInfoEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateBorrowInfoEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateBorrowInfoEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateBorrowInfoEvent object`);
+        }
+        return UpdateBorrowInfoEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateBorrowInfoEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateBorrowInfoEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateBorrowInfoEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateBorrowInfoEvent object`);
+        }
+        return UpdateBorrowInfoEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateLiquidityValueEvent =============================== */
+
+export function isUpdateLiquidityValueEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateLiquidityValueEvent";
+}
+
+export interface UpdateLiquidityValueEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    liquidityToken: ToField<TypeName>;
+    price: ToField<"u64">;
+    valueInUsd: ToField<"u64">;
+    lpPoolTvlUsd: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateLiquidityValueEventReified = Reified<UpdateLiquidityValueEvent, UpdateLiquidityValueEventFields>;
+
+export class UpdateLiquidityValueEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateLiquidityValueEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateLiquidityValueEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateLiquidityValueEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly liquidityToken: ToField<TypeName>;
+    readonly price: ToField<"u64">;
+    readonly valueInUsd: ToField<"u64">;
+    readonly lpPoolTvlUsd: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateLiquidityValueEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateLiquidityValueEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateLiquidityValueEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.liquidityToken = fields.liquidityToken;
+        this.price = fields.price;
+        this.valueInUsd = fields.valueInUsd;
+        this.lpPoolTvlUsd = fields.lpPoolTvlUsd;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateLiquidityValueEventReified {
+        return {
+            typeName: UpdateLiquidityValueEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateLiquidityValueEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateLiquidityValueEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateLiquidityValueEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateLiquidityValueEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateLiquidityValueEvent.fromBcs(data),
+            bcs: UpdateLiquidityValueEvent.bcs,
+            fromJSONField: (field: any) => UpdateLiquidityValueEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateLiquidityValueEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateLiquidityValueEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateLiquidityValueEvent.fetch(client, id),
+            new: (fields: UpdateLiquidityValueEventFields) => {
+                return new UpdateLiquidityValueEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateLiquidityValueEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateLiquidityValueEvent>> {
+        return phantom(UpdateLiquidityValueEvent.reified());
+    }
+    static get p() {
+        return UpdateLiquidityValueEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateLiquidityValueEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            liquidity_token: TypeName.bcs,
+            price: bcs.u64(),
+            value_in_usd: bcs.u64(),
+            lp_pool_tvl_usd: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateLiquidityValueEvent {
+        return UpdateLiquidityValueEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            liquidityToken: decodeFromFields(TypeName.reified(), fields.liquidity_token),
+            price: decodeFromFields("u64", fields.price),
+            valueInUsd: decodeFromFields("u64", fields.value_in_usd),
+            lpPoolTvlUsd: decodeFromFields("u64", fields.lp_pool_tvl_usd),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateLiquidityValueEvent {
+        if (!isUpdateLiquidityValueEvent(item.type)) {
+            throw new Error("not a UpdateLiquidityValueEvent type");
+        }
+
+        return UpdateLiquidityValueEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token),
+            price: decodeFromFieldsWithTypes("u64", item.fields.price),
+            valueInUsd: decodeFromFieldsWithTypes("u64", item.fields.value_in_usd),
+            lpPoolTvlUsd: decodeFromFieldsWithTypes("u64", item.fields.lp_pool_tvl_usd),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateLiquidityValueEvent {
+        return UpdateLiquidityValueEvent.fromFields(UpdateLiquidityValueEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            liquidityToken: this.liquidityToken.toJSONField(),
+            price: this.price.toString(),
+            valueInUsd: this.valueInUsd.toString(),
+            lpPoolTvlUsd: this.lpPoolTvlUsd.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateLiquidityValueEvent {
+        return UpdateLiquidityValueEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            liquidityToken: decodeFromJSONField(TypeName.reified(), field.liquidityToken),
+            price: decodeFromJSONField("u64", field.price),
+            valueInUsd: decodeFromJSONField("u64", field.valueInUsd),
+            lpPoolTvlUsd: decodeFromJSONField("u64", field.lpPoolTvlUsd),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateLiquidityValueEvent {
+        if (json.$typeName !== UpdateLiquidityValueEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateLiquidityValueEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateLiquidityValueEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateLiquidityValueEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateLiquidityValueEvent object`);
+        }
+        return UpdateLiquidityValueEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateLiquidityValueEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateLiquidityValueEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateLiquidityValueEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateLiquidityValueEvent object`);
+        }
+        return UpdateLiquidityValueEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateMarginConfigEvent =============================== */
+
+export function isUpdateMarginConfigEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateMarginConfigEvent";
+}
+
+export interface UpdateMarginConfigEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    liquidityTokenType: ToField<TypeName>;
+    previousMarginConfig: ToField<MarginConfig>;
+    newMarginConfig: ToField<MarginConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateMarginConfigEventReified = Reified<UpdateMarginConfigEvent, UpdateMarginConfigEventFields>;
+
+export class UpdateMarginConfigEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateMarginConfigEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateMarginConfigEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateMarginConfigEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly liquidityTokenType: ToField<TypeName>;
+    readonly previousMarginConfig: ToField<MarginConfig>;
+    readonly newMarginConfig: ToField<MarginConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateMarginConfigEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateMarginConfigEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateMarginConfigEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.liquidityTokenType = fields.liquidityTokenType;
+        this.previousMarginConfig = fields.previousMarginConfig;
+        this.newMarginConfig = fields.newMarginConfig;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateMarginConfigEventReified {
+        return {
+            typeName: UpdateMarginConfigEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateMarginConfigEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateMarginConfigEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateMarginConfigEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateMarginConfigEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateMarginConfigEvent.fromBcs(data),
+            bcs: UpdateMarginConfigEvent.bcs,
+            fromJSONField: (field: any) => UpdateMarginConfigEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateMarginConfigEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateMarginConfigEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateMarginConfigEvent.fetch(client, id),
+            new: (fields: UpdateMarginConfigEventFields) => {
+                return new UpdateMarginConfigEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateMarginConfigEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateMarginConfigEvent>> {
+        return phantom(UpdateMarginConfigEvent.reified());
+    }
+    static get p() {
+        return UpdateMarginConfigEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateMarginConfigEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            liquidity_token_type: TypeName.bcs,
+            previous_margin_config: MarginConfig.bcs,
+            new_margin_config: MarginConfig.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateMarginConfigEvent {
+        return UpdateMarginConfigEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            liquidityTokenType: decodeFromFields(TypeName.reified(), fields.liquidity_token_type),
+            previousMarginConfig: decodeFromFields(MarginConfig.reified(), fields.previous_margin_config),
+            newMarginConfig: decodeFromFields(MarginConfig.reified(), fields.new_margin_config),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateMarginConfigEvent {
+        if (!isUpdateMarginConfigEvent(item.type)) {
+            throw new Error("not a UpdateMarginConfigEvent type");
+        }
+
+        return UpdateMarginConfigEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token_type),
+            previousMarginConfig: decodeFromFieldsWithTypes(MarginConfig.reified(), item.fields.previous_margin_config),
+            newMarginConfig: decodeFromFieldsWithTypes(MarginConfig.reified(), item.fields.new_margin_config),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateMarginConfigEvent {
+        return UpdateMarginConfigEvent.fromFields(UpdateMarginConfigEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            liquidityTokenType: this.liquidityTokenType.toJSONField(),
+            previousMarginConfig: this.previousMarginConfig.toJSONField(),
+            newMarginConfig: this.newMarginConfig.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateMarginConfigEvent {
+        return UpdateMarginConfigEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            liquidityTokenType: decodeFromJSONField(TypeName.reified(), field.liquidityTokenType),
+            previousMarginConfig: decodeFromJSONField(MarginConfig.reified(), field.previousMarginConfig),
+            newMarginConfig: decodeFromJSONField(MarginConfig.reified(), field.newMarginConfig),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateMarginConfigEvent {
+        if (json.$typeName !== UpdateMarginConfigEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateMarginConfigEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateMarginConfigEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateMarginConfigEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateMarginConfigEvent object`);
+        }
+        return UpdateMarginConfigEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateMarginConfigEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateMarginConfigEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateMarginConfigEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateMarginConfigEvent object`);
+        }
+        return UpdateMarginConfigEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateSpotConfigEvent =============================== */
+
+export function isUpdateSpotConfigEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateSpotConfigEvent";
+}
+
+export interface UpdateSpotConfigEventFields {
+    sender: ToField<"address">;
+    index: ToField<"u64">;
+    liquidityTokenType: ToField<TypeName>;
+    previousSpotConfig: ToField<SpotConfig>;
+    newSpotConfig: ToField<SpotConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateSpotConfigEventReified = Reified<UpdateSpotConfigEvent, UpdateSpotConfigEventFields>;
+
+export class UpdateSpotConfigEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateSpotConfigEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateSpotConfigEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateSpotConfigEvent";
+
+    readonly $typeArgs: [];
+
+    readonly sender: ToField<"address">;
+    readonly index: ToField<"u64">;
+    readonly liquidityTokenType: ToField<TypeName>;
+    readonly previousSpotConfig: ToField<SpotConfig>;
+    readonly newSpotConfig: ToField<SpotConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateSpotConfigEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateSpotConfigEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateSpotConfigEvent";
+        this.$typeArgs = typeArgs;
+
+        this.sender = fields.sender;
+        this.index = fields.index;
+        this.liquidityTokenType = fields.liquidityTokenType;
+        this.previousSpotConfig = fields.previousSpotConfig;
+        this.newSpotConfig = fields.newSpotConfig;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateSpotConfigEventReified {
+        return {
+            typeName: UpdateSpotConfigEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateSpotConfigEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::lp_pool::UpdateSpotConfigEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateSpotConfigEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateSpotConfigEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateSpotConfigEvent.fromBcs(data),
+            bcs: UpdateSpotConfigEvent.bcs,
+            fromJSONField: (field: any) => UpdateSpotConfigEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateSpotConfigEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateSpotConfigEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateSpotConfigEvent.fetch(client, id),
+            new: (fields: UpdateSpotConfigEventFields) => {
+                return new UpdateSpotConfigEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateSpotConfigEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateSpotConfigEvent>> {
+        return phantom(UpdateSpotConfigEvent.reified());
+    }
+    static get p() {
+        return UpdateSpotConfigEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateSpotConfigEvent", {
+            sender: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            index: bcs.u64(),
+            liquidity_token_type: TypeName.bcs,
+            previous_spot_config: SpotConfig.bcs,
+            new_spot_config: SpotConfig.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateSpotConfigEvent {
+        return UpdateSpotConfigEvent.reified().new({
+            sender: decodeFromFields("address", fields.sender),
+            index: decodeFromFields("u64", fields.index),
+            liquidityTokenType: decodeFromFields(TypeName.reified(), fields.liquidity_token_type),
+            previousSpotConfig: decodeFromFields(SpotConfig.reified(), fields.previous_spot_config),
+            newSpotConfig: decodeFromFields(SpotConfig.reified(), fields.new_spot_config),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateSpotConfigEvent {
+        if (!isUpdateSpotConfigEvent(item.type)) {
+            throw new Error("not a UpdateSpotConfigEvent type");
+        }
+
+        return UpdateSpotConfigEvent.reified().new({
+            sender: decodeFromFieldsWithTypes("address", item.fields.sender),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            liquidityTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.liquidity_token_type),
+            previousSpotConfig: decodeFromFieldsWithTypes(SpotConfig.reified(), item.fields.previous_spot_config),
+            newSpotConfig: decodeFromFieldsWithTypes(SpotConfig.reified(), item.fields.new_spot_config),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateSpotConfigEvent {
+        return UpdateSpotConfigEvent.fromFields(UpdateSpotConfigEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            sender: this.sender,
+            index: this.index.toString(),
+            liquidityTokenType: this.liquidityTokenType.toJSONField(),
+            previousSpotConfig: this.previousSpotConfig.toJSONField(),
+            newSpotConfig: this.newSpotConfig.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateSpotConfigEvent {
+        return UpdateSpotConfigEvent.reified().new({
+            sender: decodeFromJSONField("address", field.sender),
+            index: decodeFromJSONField("u64", field.index),
+            liquidityTokenType: decodeFromJSONField(TypeName.reified(), field.liquidityTokenType),
+            previousSpotConfig: decodeFromJSONField(SpotConfig.reified(), field.previousSpotConfig),
+            newSpotConfig: decodeFromJSONField(SpotConfig.reified(), field.newSpotConfig),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateSpotConfigEvent {
+        if (json.$typeName !== UpdateSpotConfigEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateSpotConfigEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateSpotConfigEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateSpotConfigEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateSpotConfigEvent object`);
+        }
+        return UpdateSpotConfigEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateSpotConfigEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateSpotConfigEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateSpotConfigEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateSpotConfigEvent object`);
+        }
+        return UpdateSpotConfigEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}