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

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

@@ -0,0 +1,4541 @@
+import * as reified from "../../_framework/reified";
+import { Option } from "../../_dependencies/source/0x1/option/structs";
+import { TypeName } from "../../_dependencies/source/0x1/type-name/structs";
+import { ObjectTable } from "../../_dependencies/source/0x2/object-table/structs";
+import { UID } from "../../_dependencies/source/0x2/object/structs";
+import { BigVector } from "../../_dependencies/source/0x4213e12a2220f15f1837a76897110d2260786558169bd8d0847f21e9b551f277/big-vector/structs";
+import {
+    PhantomReified,
+    Reified,
+    StructClass,
+    ToField,
+    ToTypeStr,
+    Vector,
+    decodeFromFields,
+    decodeFromFieldsWithTypes,
+    decodeFromJSONField,
+    fieldToJSON,
+    phantom,
+    ToTypeStr as ToPhantom,
+} 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";
+
+/* ============================== AddTradingSymbolEvent =============================== */
+
+export function isAddTradingSymbolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::AddTradingSymbolEvent";
+}
+
+export interface AddTradingSymbolEventFields {
+    index: ToField<"u64">;
+    baseTokenType: ToField<TypeName>;
+    marketInfo: ToField<MarketInfo>;
+    marketConfig: ToField<MarketConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type AddTradingSymbolEventReified = Reified<AddTradingSymbolEvent, AddTradingSymbolEventFields>;
+
+export class AddTradingSymbolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::AddTradingSymbolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = AddTradingSymbolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::AddTradingSymbolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly baseTokenType: ToField<TypeName>;
+    readonly marketInfo: ToField<MarketInfo>;
+    readonly marketConfig: ToField<MarketConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: AddTradingSymbolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            AddTradingSymbolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::AddTradingSymbolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.baseTokenType = fields.baseTokenType;
+        this.marketInfo = fields.marketInfo;
+        this.marketConfig = fields.marketConfig;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): AddTradingSymbolEventReified {
+        return {
+            typeName: AddTradingSymbolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                AddTradingSymbolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::AddTradingSymbolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => AddTradingSymbolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => AddTradingSymbolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => AddTradingSymbolEvent.fromBcs(data),
+            bcs: AddTradingSymbolEvent.bcs,
+            fromJSONField: (field: any) => AddTradingSymbolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => AddTradingSymbolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => AddTradingSymbolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => AddTradingSymbolEvent.fetch(client, id),
+            new: (fields: AddTradingSymbolEventFields) => {
+                return new AddTradingSymbolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return AddTradingSymbolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<AddTradingSymbolEvent>> {
+        return phantom(AddTradingSymbolEvent.reified());
+    }
+    static get p() {
+        return AddTradingSymbolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("AddTradingSymbolEvent", {
+            index: bcs.u64(),
+            base_token_type: TypeName.bcs,
+            market_info: MarketInfo.bcs,
+            market_config: MarketConfig.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): AddTradingSymbolEvent {
+        return AddTradingSymbolEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            baseTokenType: decodeFromFields(TypeName.reified(), fields.base_token_type),
+            marketInfo: decodeFromFields(MarketInfo.reified(), fields.market_info),
+            marketConfig: decodeFromFields(MarketConfig.reified(), fields.market_config),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): AddTradingSymbolEvent {
+        if (!isAddTradingSymbolEvent(item.type)) {
+            throw new Error("not a AddTradingSymbolEvent type");
+        }
+
+        return AddTradingSymbolEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            baseTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token_type),
+            marketInfo: decodeFromFieldsWithTypes(MarketInfo.reified(), item.fields.market_info),
+            marketConfig: decodeFromFieldsWithTypes(MarketConfig.reified(), item.fields.market_config),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): AddTradingSymbolEvent {
+        return AddTradingSymbolEvent.fromFields(AddTradingSymbolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            baseTokenType: this.baseTokenType.toJSONField(),
+            marketInfo: this.marketInfo.toJSONField(),
+            marketConfig: this.marketConfig.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): AddTradingSymbolEvent {
+        return AddTradingSymbolEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            baseTokenType: decodeFromJSONField(TypeName.reified(), field.baseTokenType),
+            marketInfo: decodeFromJSONField(MarketInfo.reified(), field.marketInfo),
+            marketConfig: decodeFromJSONField(MarketConfig.reified(), field.marketConfig),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): AddTradingSymbolEvent {
+        if (json.$typeName !== AddTradingSymbolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return AddTradingSymbolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): AddTradingSymbolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isAddTradingSymbolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a AddTradingSymbolEvent object`);
+        }
+        return AddTradingSymbolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<AddTradingSymbolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching AddTradingSymbolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isAddTradingSymbolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a AddTradingSymbolEvent object`);
+        }
+        return AddTradingSymbolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== CancelTradingOrderEvent =============================== */
+
+export function isCancelTradingOrderEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CancelTradingOrderEvent";
+}
+
+export interface CancelTradingOrderEventFields {
+    user: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    orderId: ToField<"u64">;
+    triggerPrice: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    releasedCollateralAmount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type CancelTradingOrderEventReified = Reified<CancelTradingOrderEvent, CancelTradingOrderEventFields>;
+
+export class CancelTradingOrderEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CancelTradingOrderEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = CancelTradingOrderEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CancelTradingOrderEvent";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly orderId: ToField<"u64">;
+    readonly triggerPrice: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly releasedCollateralAmount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: CancelTradingOrderEventFields) {
+        this.$fullTypeName = composeSuiType(
+            CancelTradingOrderEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CancelTradingOrderEvent";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.marketIndex = fields.marketIndex;
+        this.orderId = fields.orderId;
+        this.triggerPrice = fields.triggerPrice;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.releasedCollateralAmount = fields.releasedCollateralAmount;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): CancelTradingOrderEventReified {
+        return {
+            typeName: CancelTradingOrderEvent.$typeName,
+            fullTypeName: composeSuiType(
+                CancelTradingOrderEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CancelTradingOrderEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => CancelTradingOrderEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => CancelTradingOrderEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => CancelTradingOrderEvent.fromBcs(data),
+            bcs: CancelTradingOrderEvent.bcs,
+            fromJSONField: (field: any) => CancelTradingOrderEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => CancelTradingOrderEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => CancelTradingOrderEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => CancelTradingOrderEvent.fetch(client, id),
+            new: (fields: CancelTradingOrderEventFields) => {
+                return new CancelTradingOrderEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return CancelTradingOrderEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<CancelTradingOrderEvent>> {
+        return phantom(CancelTradingOrderEvent.reified());
+    }
+    static get p() {
+        return CancelTradingOrderEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("CancelTradingOrderEvent", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            market_index: bcs.u64(),
+            order_id: bcs.u64(),
+            trigger_price: bcs.u64(),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            released_collateral_amount: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): CancelTradingOrderEvent {
+        return CancelTradingOrderEvent.reified().new({
+            user: decodeFromFields("address", fields.user),
+            marketIndex: decodeFromFields("u64", fields.market_index),
+            orderId: decodeFromFields("u64", fields.order_id),
+            triggerPrice: decodeFromFields("u64", fields.trigger_price),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            releasedCollateralAmount: decodeFromFields("u64", fields.released_collateral_amount),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): CancelTradingOrderEvent {
+        if (!isCancelTradingOrderEvent(item.type)) {
+            throw new Error("not a CancelTradingOrderEvent type");
+        }
+
+        return CancelTradingOrderEvent.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            marketIndex: decodeFromFieldsWithTypes("u64", item.fields.market_index),
+            orderId: decodeFromFieldsWithTypes("u64", item.fields.order_id),
+            triggerPrice: decodeFromFieldsWithTypes("u64", item.fields.trigger_price),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            releasedCollateralAmount: decodeFromFieldsWithTypes("u64", item.fields.released_collateral_amount),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): CancelTradingOrderEvent {
+        return CancelTradingOrderEvent.fromFields(CancelTradingOrderEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            marketIndex: this.marketIndex.toString(),
+            orderId: this.orderId.toString(),
+            triggerPrice: this.triggerPrice.toString(),
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            releasedCollateralAmount: this.releasedCollateralAmount.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): CancelTradingOrderEvent {
+        return CancelTradingOrderEvent.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            marketIndex: decodeFromJSONField("u64", field.marketIndex),
+            orderId: decodeFromJSONField("u64", field.orderId),
+            triggerPrice: decodeFromJSONField("u64", field.triggerPrice),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            releasedCollateralAmount: decodeFromJSONField("u64", field.releasedCollateralAmount),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): CancelTradingOrderEvent {
+        if (json.$typeName !== CancelTradingOrderEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return CancelTradingOrderEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): CancelTradingOrderEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isCancelTradingOrderEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a CancelTradingOrderEvent object`);
+        }
+        return CancelTradingOrderEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<CancelTradingOrderEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching CancelTradingOrderEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isCancelTradingOrderEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a CancelTradingOrderEvent object`);
+        }
+        return CancelTradingOrderEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== CreateTradingOrderEvent =============================== */
+
+export function isCreateTradingOrderEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderEvent";
+}
+
+export interface CreateTradingOrderEventFields {
+    user: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    poolIndex: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    linkedPositionId: ToField<Option<"u64">>;
+    collateralAmount: ToField<"u64">;
+    leveragePct: ToField<"u64">;
+    reduceOnly: ToField<"bool">;
+    isLong: ToField<"bool">;
+    isStopOrder: ToField<"bool">;
+    size: ToField<"u64">;
+    triggerPrice: ToField<"u64">;
+    filled: ToField<"bool">;
+    filledPrice: ToField<Option<"u64">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type CreateTradingOrderEventReified = Reified<CreateTradingOrderEvent, CreateTradingOrderEventFields>;
+
+export class CreateTradingOrderEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = CreateTradingOrderEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderEvent";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly poolIndex: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly linkedPositionId: ToField<Option<"u64">>;
+    readonly collateralAmount: ToField<"u64">;
+    readonly leveragePct: ToField<"u64">;
+    readonly reduceOnly: ToField<"bool">;
+    readonly isLong: ToField<"bool">;
+    readonly isStopOrder: ToField<"bool">;
+    readonly size: ToField<"u64">;
+    readonly triggerPrice: ToField<"u64">;
+    readonly filled: ToField<"bool">;
+    readonly filledPrice: ToField<Option<"u64">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: CreateTradingOrderEventFields) {
+        this.$fullTypeName = composeSuiType(
+            CreateTradingOrderEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderEvent";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.marketIndex = fields.marketIndex;
+        this.poolIndex = fields.poolIndex;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.linkedPositionId = fields.linkedPositionId;
+        this.collateralAmount = fields.collateralAmount;
+        this.leveragePct = fields.leveragePct;
+        this.reduceOnly = fields.reduceOnly;
+        this.isLong = fields.isLong;
+        this.isStopOrder = fields.isStopOrder;
+        this.size = fields.size;
+        this.triggerPrice = fields.triggerPrice;
+        this.filled = fields.filled;
+        this.filledPrice = fields.filledPrice;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): CreateTradingOrderEventReified {
+        return {
+            typeName: CreateTradingOrderEvent.$typeName,
+            fullTypeName: composeSuiType(
+                CreateTradingOrderEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => CreateTradingOrderEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => CreateTradingOrderEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => CreateTradingOrderEvent.fromBcs(data),
+            bcs: CreateTradingOrderEvent.bcs,
+            fromJSONField: (field: any) => CreateTradingOrderEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => CreateTradingOrderEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => CreateTradingOrderEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => CreateTradingOrderEvent.fetch(client, id),
+            new: (fields: CreateTradingOrderEventFields) => {
+                return new CreateTradingOrderEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return CreateTradingOrderEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<CreateTradingOrderEvent>> {
+        return phantom(CreateTradingOrderEvent.reified());
+    }
+    static get p() {
+        return CreateTradingOrderEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("CreateTradingOrderEvent", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            market_index: bcs.u64(),
+            pool_index: bcs.u64(),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            linked_position_id: Option.bcs(bcs.u64()),
+            collateral_amount: bcs.u64(),
+            leverage_pct: bcs.u64(),
+            reduce_only: bcs.bool(),
+            is_long: bcs.bool(),
+            is_stop_order: bcs.bool(),
+            size: bcs.u64(),
+            trigger_price: bcs.u64(),
+            filled: bcs.bool(),
+            filled_price: Option.bcs(bcs.u64()),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): CreateTradingOrderEvent {
+        return CreateTradingOrderEvent.reified().new({
+            user: decodeFromFields("address", fields.user),
+            marketIndex: decodeFromFields("u64", fields.market_index),
+            poolIndex: decodeFromFields("u64", fields.pool_index),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            linkedPositionId: decodeFromFields(Option.reified("u64"), fields.linked_position_id),
+            collateralAmount: decodeFromFields("u64", fields.collateral_amount),
+            leveragePct: decodeFromFields("u64", fields.leverage_pct),
+            reduceOnly: decodeFromFields("bool", fields.reduce_only),
+            isLong: decodeFromFields("bool", fields.is_long),
+            isStopOrder: decodeFromFields("bool", fields.is_stop_order),
+            size: decodeFromFields("u64", fields.size),
+            triggerPrice: decodeFromFields("u64", fields.trigger_price),
+            filled: decodeFromFields("bool", fields.filled),
+            filledPrice: decodeFromFields(Option.reified("u64"), fields.filled_price),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): CreateTradingOrderEvent {
+        if (!isCreateTradingOrderEvent(item.type)) {
+            throw new Error("not a CreateTradingOrderEvent type");
+        }
+
+        return CreateTradingOrderEvent.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            marketIndex: decodeFromFieldsWithTypes("u64", item.fields.market_index),
+            poolIndex: decodeFromFieldsWithTypes("u64", item.fields.pool_index),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            linkedPositionId: decodeFromFieldsWithTypes(Option.reified("u64"), item.fields.linked_position_id),
+            collateralAmount: decodeFromFieldsWithTypes("u64", item.fields.collateral_amount),
+            leveragePct: decodeFromFieldsWithTypes("u64", item.fields.leverage_pct),
+            reduceOnly: decodeFromFieldsWithTypes("bool", item.fields.reduce_only),
+            isLong: decodeFromFieldsWithTypes("bool", item.fields.is_long),
+            isStopOrder: decodeFromFieldsWithTypes("bool", item.fields.is_stop_order),
+            size: decodeFromFieldsWithTypes("u64", item.fields.size),
+            triggerPrice: decodeFromFieldsWithTypes("u64", item.fields.trigger_price),
+            filled: decodeFromFieldsWithTypes("bool", item.fields.filled),
+            filledPrice: decodeFromFieldsWithTypes(Option.reified("u64"), item.fields.filled_price),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): CreateTradingOrderEvent {
+        return CreateTradingOrderEvent.fromFields(CreateTradingOrderEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            marketIndex: this.marketIndex.toString(),
+            poolIndex: this.poolIndex.toString(),
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            linkedPositionId: fieldToJSON<Option<"u64">>(`0x1::option::Option<u64>`, this.linkedPositionId),
+            collateralAmount: this.collateralAmount.toString(),
+            leveragePct: this.leveragePct.toString(),
+            reduceOnly: this.reduceOnly,
+            isLong: this.isLong,
+            isStopOrder: this.isStopOrder,
+            size: this.size.toString(),
+            triggerPrice: this.triggerPrice.toString(),
+            filled: this.filled,
+            filledPrice: fieldToJSON<Option<"u64">>(`0x1::option::Option<u64>`, this.filledPrice),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): CreateTradingOrderEvent {
+        return CreateTradingOrderEvent.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            marketIndex: decodeFromJSONField("u64", field.marketIndex),
+            poolIndex: decodeFromJSONField("u64", field.poolIndex),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            linkedPositionId: decodeFromJSONField(Option.reified("u64"), field.linkedPositionId),
+            collateralAmount: decodeFromJSONField("u64", field.collateralAmount),
+            leveragePct: decodeFromJSONField("u64", field.leveragePct),
+            reduceOnly: decodeFromJSONField("bool", field.reduceOnly),
+            isLong: decodeFromJSONField("bool", field.isLong),
+            isStopOrder: decodeFromJSONField("bool", field.isStopOrder),
+            size: decodeFromJSONField("u64", field.size),
+            triggerPrice: decodeFromJSONField("u64", field.triggerPrice),
+            filled: decodeFromJSONField("bool", field.filled),
+            filledPrice: decodeFromJSONField(Option.reified("u64"), field.filledPrice),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): CreateTradingOrderEvent {
+        if (json.$typeName !== CreateTradingOrderEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return CreateTradingOrderEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): CreateTradingOrderEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isCreateTradingOrderEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a CreateTradingOrderEvent object`);
+        }
+        return CreateTradingOrderEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<CreateTradingOrderEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching CreateTradingOrderEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isCreateTradingOrderEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a CreateTradingOrderEvent object`);
+        }
+        return CreateTradingOrderEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== CreateTradingOrderWithBidReceiptsEvent =============================== */
+
+export function isCreateTradingOrderWithBidReceiptsEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderWithBidReceiptsEvent";
+}
+
+export interface CreateTradingOrderWithBidReceiptsEventFields {
+    user: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    poolIndex: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    collateralInDepositToken: ToField<"u64">;
+    isLong: ToField<"bool">;
+    size: ToField<"u64">;
+    triggerPrice: ToField<"u64">;
+    filled: ToField<"bool">;
+    filledPrice: ToField<Option<"u64">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type CreateTradingOrderWithBidReceiptsEventReified = Reified<
+    CreateTradingOrderWithBidReceiptsEvent,
+    CreateTradingOrderWithBidReceiptsEventFields
+>;
+
+export class CreateTradingOrderWithBidReceiptsEvent implements StructClass {
+    static readonly $typeName =
+        "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderWithBidReceiptsEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = CreateTradingOrderWithBidReceiptsEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderWithBidReceiptsEvent";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly poolIndex: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly collateralInDepositToken: ToField<"u64">;
+    readonly isLong: ToField<"bool">;
+    readonly size: ToField<"u64">;
+    readonly triggerPrice: ToField<"u64">;
+    readonly filled: ToField<"bool">;
+    readonly filledPrice: ToField<Option<"u64">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: CreateTradingOrderWithBidReceiptsEventFields) {
+        this.$fullTypeName = composeSuiType(
+            CreateTradingOrderWithBidReceiptsEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderWithBidReceiptsEvent";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.marketIndex = fields.marketIndex;
+        this.poolIndex = fields.poolIndex;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.collateralInDepositToken = fields.collateralInDepositToken;
+        this.isLong = fields.isLong;
+        this.size = fields.size;
+        this.triggerPrice = fields.triggerPrice;
+        this.filled = fields.filled;
+        this.filledPrice = fields.filledPrice;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): CreateTradingOrderWithBidReceiptsEventReified {
+        return {
+            typeName: CreateTradingOrderWithBidReceiptsEvent.$typeName,
+            fullTypeName: composeSuiType(
+                CreateTradingOrderWithBidReceiptsEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::CreateTradingOrderWithBidReceiptsEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => CreateTradingOrderWithBidReceiptsEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => CreateTradingOrderWithBidReceiptsEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => CreateTradingOrderWithBidReceiptsEvent.fromBcs(data),
+            bcs: CreateTradingOrderWithBidReceiptsEvent.bcs,
+            fromJSONField: (field: any) => CreateTradingOrderWithBidReceiptsEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => CreateTradingOrderWithBidReceiptsEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => CreateTradingOrderWithBidReceiptsEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => CreateTradingOrderWithBidReceiptsEvent.fetch(client, id),
+            new: (fields: CreateTradingOrderWithBidReceiptsEventFields) => {
+                return new CreateTradingOrderWithBidReceiptsEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return CreateTradingOrderWithBidReceiptsEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<CreateTradingOrderWithBidReceiptsEvent>> {
+        return phantom(CreateTradingOrderWithBidReceiptsEvent.reified());
+    }
+    static get p() {
+        return CreateTradingOrderWithBidReceiptsEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("CreateTradingOrderWithBidReceiptsEvent", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            market_index: bcs.u64(),
+            pool_index: bcs.u64(),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            collateral_in_deposit_token: bcs.u64(),
+            is_long: bcs.bool(),
+            size: bcs.u64(),
+            trigger_price: bcs.u64(),
+            filled: bcs.bool(),
+            filled_price: Option.bcs(bcs.u64()),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): CreateTradingOrderWithBidReceiptsEvent {
+        return CreateTradingOrderWithBidReceiptsEvent.reified().new({
+            user: decodeFromFields("address", fields.user),
+            marketIndex: decodeFromFields("u64", fields.market_index),
+            poolIndex: decodeFromFields("u64", fields.pool_index),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            collateralInDepositToken: decodeFromFields("u64", fields.collateral_in_deposit_token),
+            isLong: decodeFromFields("bool", fields.is_long),
+            size: decodeFromFields("u64", fields.size),
+            triggerPrice: decodeFromFields("u64", fields.trigger_price),
+            filled: decodeFromFields("bool", fields.filled),
+            filledPrice: decodeFromFields(Option.reified("u64"), fields.filled_price),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): CreateTradingOrderWithBidReceiptsEvent {
+        if (!isCreateTradingOrderWithBidReceiptsEvent(item.type)) {
+            throw new Error("not a CreateTradingOrderWithBidReceiptsEvent type");
+        }
+
+        return CreateTradingOrderWithBidReceiptsEvent.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            marketIndex: decodeFromFieldsWithTypes("u64", item.fields.market_index),
+            poolIndex: decodeFromFieldsWithTypes("u64", item.fields.pool_index),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            collateralInDepositToken: decodeFromFieldsWithTypes("u64", item.fields.collateral_in_deposit_token),
+            isLong: decodeFromFieldsWithTypes("bool", item.fields.is_long),
+            size: decodeFromFieldsWithTypes("u64", item.fields.size),
+            triggerPrice: decodeFromFieldsWithTypes("u64", item.fields.trigger_price),
+            filled: decodeFromFieldsWithTypes("bool", item.fields.filled),
+            filledPrice: decodeFromFieldsWithTypes(Option.reified("u64"), item.fields.filled_price),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): CreateTradingOrderWithBidReceiptsEvent {
+        return CreateTradingOrderWithBidReceiptsEvent.fromFields(CreateTradingOrderWithBidReceiptsEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            marketIndex: this.marketIndex.toString(),
+            poolIndex: this.poolIndex.toString(),
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            collateralInDepositToken: this.collateralInDepositToken.toString(),
+            isLong: this.isLong,
+            size: this.size.toString(),
+            triggerPrice: this.triggerPrice.toString(),
+            filled: this.filled,
+            filledPrice: fieldToJSON<Option<"u64">>(`0x1::option::Option<u64>`, this.filledPrice),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): CreateTradingOrderWithBidReceiptsEvent {
+        return CreateTradingOrderWithBidReceiptsEvent.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            marketIndex: decodeFromJSONField("u64", field.marketIndex),
+            poolIndex: decodeFromJSONField("u64", field.poolIndex),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            collateralInDepositToken: decodeFromJSONField("u64", field.collateralInDepositToken),
+            isLong: decodeFromJSONField("bool", field.isLong),
+            size: decodeFromJSONField("u64", field.size),
+            triggerPrice: decodeFromJSONField("u64", field.triggerPrice),
+            filled: decodeFromJSONField("bool", field.filled),
+            filledPrice: decodeFromJSONField(Option.reified("u64"), field.filledPrice),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): CreateTradingOrderWithBidReceiptsEvent {
+        if (json.$typeName !== CreateTradingOrderWithBidReceiptsEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return CreateTradingOrderWithBidReceiptsEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): CreateTradingOrderWithBidReceiptsEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isCreateTradingOrderWithBidReceiptsEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a CreateTradingOrderWithBidReceiptsEvent object`);
+        }
+        return CreateTradingOrderWithBidReceiptsEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<CreateTradingOrderWithBidReceiptsEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching CreateTradingOrderWithBidReceiptsEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isCreateTradingOrderWithBidReceiptsEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a CreateTradingOrderWithBidReceiptsEvent object`);
+        }
+        return CreateTradingOrderWithBidReceiptsEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== IncreaseCollateralEvent =============================== */
+
+export function isIncreaseCollateralEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::IncreaseCollateralEvent";
+}
+
+export interface IncreaseCollateralEventFields {
+    user: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    poolIndex: ToField<"u64">;
+    positionId: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    increasedCollateralAmount: ToField<"u64">;
+    remainingCollateralAmount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type IncreaseCollateralEventReified = Reified<IncreaseCollateralEvent, IncreaseCollateralEventFields>;
+
+export class IncreaseCollateralEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::IncreaseCollateralEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = IncreaseCollateralEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::IncreaseCollateralEvent";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly poolIndex: ToField<"u64">;
+    readonly positionId: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly increasedCollateralAmount: ToField<"u64">;
+    readonly remainingCollateralAmount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: IncreaseCollateralEventFields) {
+        this.$fullTypeName = composeSuiType(
+            IncreaseCollateralEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::IncreaseCollateralEvent";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.marketIndex = fields.marketIndex;
+        this.poolIndex = fields.poolIndex;
+        this.positionId = fields.positionId;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.increasedCollateralAmount = fields.increasedCollateralAmount;
+        this.remainingCollateralAmount = fields.remainingCollateralAmount;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): IncreaseCollateralEventReified {
+        return {
+            typeName: IncreaseCollateralEvent.$typeName,
+            fullTypeName: composeSuiType(
+                IncreaseCollateralEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::IncreaseCollateralEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => IncreaseCollateralEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => IncreaseCollateralEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => IncreaseCollateralEvent.fromBcs(data),
+            bcs: IncreaseCollateralEvent.bcs,
+            fromJSONField: (field: any) => IncreaseCollateralEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => IncreaseCollateralEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => IncreaseCollateralEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => IncreaseCollateralEvent.fetch(client, id),
+            new: (fields: IncreaseCollateralEventFields) => {
+                return new IncreaseCollateralEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return IncreaseCollateralEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<IncreaseCollateralEvent>> {
+        return phantom(IncreaseCollateralEvent.reified());
+    }
+    static get p() {
+        return IncreaseCollateralEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("IncreaseCollateralEvent", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            market_index: bcs.u64(),
+            pool_index: bcs.u64(),
+            position_id: bcs.u64(),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            increased_collateral_amount: bcs.u64(),
+            remaining_collateral_amount: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): IncreaseCollateralEvent {
+        return IncreaseCollateralEvent.reified().new({
+            user: decodeFromFields("address", fields.user),
+            marketIndex: decodeFromFields("u64", fields.market_index),
+            poolIndex: decodeFromFields("u64", fields.pool_index),
+            positionId: decodeFromFields("u64", fields.position_id),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            increasedCollateralAmount: decodeFromFields("u64", fields.increased_collateral_amount),
+            remainingCollateralAmount: decodeFromFields("u64", fields.remaining_collateral_amount),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): IncreaseCollateralEvent {
+        if (!isIncreaseCollateralEvent(item.type)) {
+            throw new Error("not a IncreaseCollateralEvent type");
+        }
+
+        return IncreaseCollateralEvent.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            marketIndex: decodeFromFieldsWithTypes("u64", item.fields.market_index),
+            poolIndex: decodeFromFieldsWithTypes("u64", item.fields.pool_index),
+            positionId: decodeFromFieldsWithTypes("u64", item.fields.position_id),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            increasedCollateralAmount: decodeFromFieldsWithTypes("u64", item.fields.increased_collateral_amount),
+            remainingCollateralAmount: decodeFromFieldsWithTypes("u64", item.fields.remaining_collateral_amount),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): IncreaseCollateralEvent {
+        return IncreaseCollateralEvent.fromFields(IncreaseCollateralEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            marketIndex: this.marketIndex.toString(),
+            poolIndex: this.poolIndex.toString(),
+            positionId: this.positionId.toString(),
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            increasedCollateralAmount: this.increasedCollateralAmount.toString(),
+            remainingCollateralAmount: this.remainingCollateralAmount.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): IncreaseCollateralEvent {
+        return IncreaseCollateralEvent.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            marketIndex: decodeFromJSONField("u64", field.marketIndex),
+            poolIndex: decodeFromJSONField("u64", field.poolIndex),
+            positionId: decodeFromJSONField("u64", field.positionId),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            increasedCollateralAmount: decodeFromJSONField("u64", field.increasedCollateralAmount),
+            remainingCollateralAmount: decodeFromJSONField("u64", field.remainingCollateralAmount),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): IncreaseCollateralEvent {
+        if (json.$typeName !== IncreaseCollateralEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return IncreaseCollateralEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): IncreaseCollateralEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isIncreaseCollateralEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a IncreaseCollateralEvent object`);
+        }
+        return IncreaseCollateralEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<IncreaseCollateralEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching IncreaseCollateralEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isIncreaseCollateralEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a IncreaseCollateralEvent object`);
+        }
+        return IncreaseCollateralEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== LinkedOrdersInfo =============================== */
+
+export function isLinkedOrdersInfo(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LinkedOrdersInfo";
+}
+
+export interface LinkedOrdersInfoFields {
+    users: ToField<Vector<"address">>;
+    ids: ToField<Vector<Vector<"u64">>>;
+    prices: ToField<Vector<Vector<"u64">>>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type LinkedOrdersInfoReified = Reified<LinkedOrdersInfo, LinkedOrdersInfoFields>;
+
+export class LinkedOrdersInfo implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LinkedOrdersInfo";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = LinkedOrdersInfo.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LinkedOrdersInfo";
+
+    readonly $typeArgs: [];
+
+    readonly users: ToField<Vector<"address">>;
+    readonly ids: ToField<Vector<Vector<"u64">>>;
+    readonly prices: ToField<Vector<Vector<"u64">>>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: LinkedOrdersInfoFields) {
+        this.$fullTypeName = composeSuiType(
+            LinkedOrdersInfo.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LinkedOrdersInfo";
+        this.$typeArgs = typeArgs;
+
+        this.users = fields.users;
+        this.ids = fields.ids;
+        this.prices = fields.prices;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): LinkedOrdersInfoReified {
+        return {
+            typeName: LinkedOrdersInfo.$typeName,
+            fullTypeName: composeSuiType(
+                LinkedOrdersInfo.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LinkedOrdersInfo",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => LinkedOrdersInfo.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => LinkedOrdersInfo.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => LinkedOrdersInfo.fromBcs(data),
+            bcs: LinkedOrdersInfo.bcs,
+            fromJSONField: (field: any) => LinkedOrdersInfo.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => LinkedOrdersInfo.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => LinkedOrdersInfo.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => LinkedOrdersInfo.fetch(client, id),
+            new: (fields: LinkedOrdersInfoFields) => {
+                return new LinkedOrdersInfo([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return LinkedOrdersInfo.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<LinkedOrdersInfo>> {
+        return phantom(LinkedOrdersInfo.reified());
+    }
+    static get p() {
+        return LinkedOrdersInfo.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("LinkedOrdersInfo", {
+            users: bcs.vector(bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) })),
+            ids: bcs.vector(bcs.vector(bcs.u64())),
+            prices: bcs.vector(bcs.vector(bcs.u64())),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): LinkedOrdersInfo {
+        return LinkedOrdersInfo.reified().new({
+            users: decodeFromFields(reified.vector("address"), fields.users),
+            ids: decodeFromFields(reified.vector(reified.vector("u64")), fields.ids),
+            prices: decodeFromFields(reified.vector(reified.vector("u64")), fields.prices),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): LinkedOrdersInfo {
+        if (!isLinkedOrdersInfo(item.type)) {
+            throw new Error("not a LinkedOrdersInfo type");
+        }
+
+        return LinkedOrdersInfo.reified().new({
+            users: decodeFromFieldsWithTypes(reified.vector("address"), item.fields.users),
+            ids: decodeFromFieldsWithTypes(reified.vector(reified.vector("u64")), item.fields.ids),
+            prices: decodeFromFieldsWithTypes(reified.vector(reified.vector("u64")), item.fields.prices),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): LinkedOrdersInfo {
+        return LinkedOrdersInfo.fromFields(LinkedOrdersInfo.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            users: fieldToJSON<Vector<"address">>(`vector<address>`, this.users),
+            ids: fieldToJSON<Vector<Vector<"u64">>>(`vector<vector<u64>>`, this.ids),
+            prices: fieldToJSON<Vector<Vector<"u64">>>(`vector<vector<u64>>`, this.prices),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): LinkedOrdersInfo {
+        return LinkedOrdersInfo.reified().new({
+            users: decodeFromJSONField(reified.vector("address"), field.users),
+            ids: decodeFromJSONField(reified.vector(reified.vector("u64")), field.ids),
+            prices: decodeFromJSONField(reified.vector(reified.vector("u64")), field.prices),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): LinkedOrdersInfo {
+        if (json.$typeName !== LinkedOrdersInfo.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return LinkedOrdersInfo.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): LinkedOrdersInfo {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isLinkedOrdersInfo(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a LinkedOrdersInfo object`);
+        }
+        return LinkedOrdersInfo.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<LinkedOrdersInfo> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching LinkedOrdersInfo object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isLinkedOrdersInfo(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a LinkedOrdersInfo object`);
+        }
+        return LinkedOrdersInfo.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== LiquidateEvent =============================== */
+
+export function isLiquidateEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LiquidateEvent";
+}
+
+export interface LiquidateEventFields {
+    user: ToField<"address">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    positionId: ToField<"u64">;
+    collateralPrice: ToField<"u64">;
+    tradingPrice: ToField<"u64">;
+    liquidatorFeeValue: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type LiquidateEventReified = Reified<LiquidateEvent, LiquidateEventFields>;
+
+export class LiquidateEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LiquidateEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = LiquidateEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LiquidateEvent";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly positionId: ToField<"u64">;
+    readonly collateralPrice: ToField<"u64">;
+    readonly tradingPrice: ToField<"u64">;
+    readonly liquidatorFeeValue: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: LiquidateEventFields) {
+        this.$fullTypeName = composeSuiType(
+            LiquidateEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LiquidateEvent";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.positionId = fields.positionId;
+        this.collateralPrice = fields.collateralPrice;
+        this.tradingPrice = fields.tradingPrice;
+        this.liquidatorFeeValue = fields.liquidatorFeeValue;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): LiquidateEventReified {
+        return {
+            typeName: LiquidateEvent.$typeName,
+            fullTypeName: composeSuiType(
+                LiquidateEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::LiquidateEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => LiquidateEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => LiquidateEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => LiquidateEvent.fromBcs(data),
+            bcs: LiquidateEvent.bcs,
+            fromJSONField: (field: any) => LiquidateEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => LiquidateEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => LiquidateEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => LiquidateEvent.fetch(client, id),
+            new: (fields: LiquidateEventFields) => {
+                return new LiquidateEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return LiquidateEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<LiquidateEvent>> {
+        return phantom(LiquidateEvent.reified());
+    }
+    static get p() {
+        return LiquidateEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("LiquidateEvent", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            position_id: bcs.u64(),
+            collateral_price: bcs.u64(),
+            trading_price: bcs.u64(),
+            liquidator_fee_value: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): LiquidateEvent {
+        return LiquidateEvent.reified().new({
+            user: decodeFromFields("address", fields.user),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            positionId: decodeFromFields("u64", fields.position_id),
+            collateralPrice: decodeFromFields("u64", fields.collateral_price),
+            tradingPrice: decodeFromFields("u64", fields.trading_price),
+            liquidatorFeeValue: decodeFromFields("u64", fields.liquidator_fee_value),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): LiquidateEvent {
+        if (!isLiquidateEvent(item.type)) {
+            throw new Error("not a LiquidateEvent type");
+        }
+
+        return LiquidateEvent.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            positionId: decodeFromFieldsWithTypes("u64", item.fields.position_id),
+            collateralPrice: decodeFromFieldsWithTypes("u64", item.fields.collateral_price),
+            tradingPrice: decodeFromFieldsWithTypes("u64", item.fields.trading_price),
+            liquidatorFeeValue: decodeFromFieldsWithTypes("u64", item.fields.liquidator_fee_value),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): LiquidateEvent {
+        return LiquidateEvent.fromFields(LiquidateEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            positionId: this.positionId.toString(),
+            collateralPrice: this.collateralPrice.toString(),
+            tradingPrice: this.tradingPrice.toString(),
+            liquidatorFeeValue: this.liquidatorFeeValue.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): LiquidateEvent {
+        return LiquidateEvent.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            positionId: decodeFromJSONField("u64", field.positionId),
+            collateralPrice: decodeFromJSONField("u64", field.collateralPrice),
+            tradingPrice: decodeFromJSONField("u64", field.tradingPrice),
+            liquidatorFeeValue: decodeFromJSONField("u64", field.liquidatorFeeValue),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): LiquidateEvent {
+        if (json.$typeName !== LiquidateEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return LiquidateEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): LiquidateEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isLiquidateEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a LiquidateEvent object`);
+        }
+        return LiquidateEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<LiquidateEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching LiquidateEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isLiquidateEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a LiquidateEvent object`);
+        }
+        return LiquidateEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ManagerReducePosition =============================== */
+
+export function isManagerReducePosition(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ManagerReducePosition";
+}
+
+export interface ManagerReducePositionFields {
+    user: ToField<"address">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    positionId: ToField<"u64">;
+    reducedSize: ToField<"u64">;
+    collateralPrice: ToField<"u64">;
+    tradingPrice: ToField<"u64">;
+    cancelledOrderIds: ToField<Vector<"u64">>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ManagerReducePositionReified = Reified<ManagerReducePosition, ManagerReducePositionFields>;
+
+export class ManagerReducePosition implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ManagerReducePosition";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ManagerReducePosition.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ManagerReducePosition";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly positionId: ToField<"u64">;
+    readonly reducedSize: ToField<"u64">;
+    readonly collateralPrice: ToField<"u64">;
+    readonly tradingPrice: ToField<"u64">;
+    readonly cancelledOrderIds: ToField<Vector<"u64">>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ManagerReducePositionFields) {
+        this.$fullTypeName = composeSuiType(
+            ManagerReducePosition.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ManagerReducePosition";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.positionId = fields.positionId;
+        this.reducedSize = fields.reducedSize;
+        this.collateralPrice = fields.collateralPrice;
+        this.tradingPrice = fields.tradingPrice;
+        this.cancelledOrderIds = fields.cancelledOrderIds;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ManagerReducePositionReified {
+        return {
+            typeName: ManagerReducePosition.$typeName,
+            fullTypeName: composeSuiType(
+                ManagerReducePosition.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ManagerReducePosition",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ManagerReducePosition.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ManagerReducePosition.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ManagerReducePosition.fromBcs(data),
+            bcs: ManagerReducePosition.bcs,
+            fromJSONField: (field: any) => ManagerReducePosition.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ManagerReducePosition.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ManagerReducePosition.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ManagerReducePosition.fetch(client, id),
+            new: (fields: ManagerReducePositionFields) => {
+                return new ManagerReducePosition([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ManagerReducePosition.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ManagerReducePosition>> {
+        return phantom(ManagerReducePosition.reified());
+    }
+    static get p() {
+        return ManagerReducePosition.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ManagerReducePosition", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            position_id: bcs.u64(),
+            reduced_size: bcs.u64(),
+            collateral_price: bcs.u64(),
+            trading_price: bcs.u64(),
+            cancelled_order_ids: bcs.vector(bcs.u64()),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ManagerReducePosition {
+        return ManagerReducePosition.reified().new({
+            user: decodeFromFields("address", fields.user),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            positionId: decodeFromFields("u64", fields.position_id),
+            reducedSize: decodeFromFields("u64", fields.reduced_size),
+            collateralPrice: decodeFromFields("u64", fields.collateral_price),
+            tradingPrice: decodeFromFields("u64", fields.trading_price),
+            cancelledOrderIds: decodeFromFields(reified.vector("u64"), fields.cancelled_order_ids),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ManagerReducePosition {
+        if (!isManagerReducePosition(item.type)) {
+            throw new Error("not a ManagerReducePosition type");
+        }
+
+        return ManagerReducePosition.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            positionId: decodeFromFieldsWithTypes("u64", item.fields.position_id),
+            reducedSize: decodeFromFieldsWithTypes("u64", item.fields.reduced_size),
+            collateralPrice: decodeFromFieldsWithTypes("u64", item.fields.collateral_price),
+            tradingPrice: decodeFromFieldsWithTypes("u64", item.fields.trading_price),
+            cancelledOrderIds: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.cancelled_order_ids),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): ManagerReducePosition {
+        return ManagerReducePosition.fromFields(ManagerReducePosition.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            positionId: this.positionId.toString(),
+            reducedSize: this.reducedSize.toString(),
+            collateralPrice: this.collateralPrice.toString(),
+            tradingPrice: this.tradingPrice.toString(),
+            cancelledOrderIds: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.cancelledOrderIds),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): ManagerReducePosition {
+        return ManagerReducePosition.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            positionId: decodeFromJSONField("u64", field.positionId),
+            reducedSize: decodeFromJSONField("u64", field.reducedSize),
+            collateralPrice: decodeFromJSONField("u64", field.collateralPrice),
+            tradingPrice: decodeFromJSONField("u64", field.tradingPrice),
+            cancelledOrderIds: decodeFromJSONField(reified.vector("u64"), field.cancelledOrderIds),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): ManagerReducePosition {
+        if (json.$typeName !== ManagerReducePosition.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ManagerReducePosition.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ManagerReducePosition {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isManagerReducePosition(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ManagerReducePosition object`);
+        }
+        return ManagerReducePosition.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ManagerReducePosition> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ManagerReducePosition object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isManagerReducePosition(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ManagerReducePosition object`);
+        }
+        return ManagerReducePosition.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== MarketConfig =============================== */
+
+export function isMarketConfig(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketConfig";
+}
+
+export interface MarketConfigFields {
+    oracleId: ToField<"address">;
+    maxLeveragePct: ToField<"u64">;
+    minSize: ToField<"u64">;
+    lotSize: ToField<"u64">;
+    tradingFeeRate: ToField<"u64">;
+    tradingFeeDecimal: ToField<"u64">;
+    basicFundingRate: ToField<"u64">;
+    fundingIntervalTsMs: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MarketConfigReified = Reified<MarketConfig, MarketConfigFields>;
+
+export class MarketConfig implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketConfig";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = MarketConfig.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketConfig";
+
+    readonly $typeArgs: [];
+
+    readonly oracleId: ToField<"address">;
+    readonly maxLeveragePct: ToField<"u64">;
+    readonly minSize: ToField<"u64">;
+    readonly lotSize: ToField<"u64">;
+    readonly tradingFeeRate: ToField<"u64">;
+    readonly tradingFeeDecimal: ToField<"u64">;
+    readonly basicFundingRate: ToField<"u64">;
+    readonly fundingIntervalTsMs: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MarketConfigFields) {
+        this.$fullTypeName = composeSuiType(
+            MarketConfig.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketConfig";
+        this.$typeArgs = typeArgs;
+
+        this.oracleId = fields.oracleId;
+        this.maxLeveragePct = fields.maxLeveragePct;
+        this.minSize = fields.minSize;
+        this.lotSize = fields.lotSize;
+        this.tradingFeeRate = fields.tradingFeeRate;
+        this.tradingFeeDecimal = fields.tradingFeeDecimal;
+        this.basicFundingRate = fields.basicFundingRate;
+        this.fundingIntervalTsMs = fields.fundingIntervalTsMs;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MarketConfigReified {
+        return {
+            typeName: MarketConfig.$typeName,
+            fullTypeName: composeSuiType(
+                MarketConfig.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketConfig",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => MarketConfig.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => MarketConfig.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => MarketConfig.fromBcs(data),
+            bcs: MarketConfig.bcs,
+            fromJSONField: (field: any) => MarketConfig.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => MarketConfig.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => MarketConfig.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => MarketConfig.fetch(client, id),
+            new: (fields: MarketConfigFields) => {
+                return new MarketConfig([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return MarketConfig.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<MarketConfig>> {
+        return phantom(MarketConfig.reified());
+    }
+    static get p() {
+        return MarketConfig.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("MarketConfig", {
+            oracle_id: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            max_leverage_pct: bcs.u64(),
+            min_size: bcs.u64(),
+            lot_size: bcs.u64(),
+            trading_fee_rate: bcs.u64(),
+            trading_fee_decimal: bcs.u64(),
+            basic_funding_rate: bcs.u64(),
+            funding_interval_ts_ms: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): MarketConfig {
+        return MarketConfig.reified().new({
+            oracleId: decodeFromFields("address", fields.oracle_id),
+            maxLeveragePct: decodeFromFields("u64", fields.max_leverage_pct),
+            minSize: decodeFromFields("u64", fields.min_size),
+            lotSize: decodeFromFields("u64", fields.lot_size),
+            tradingFeeRate: decodeFromFields("u64", fields.trading_fee_rate),
+            tradingFeeDecimal: decodeFromFields("u64", fields.trading_fee_decimal),
+            basicFundingRate: decodeFromFields("u64", fields.basic_funding_rate),
+            fundingIntervalTsMs: decodeFromFields("u64", fields.funding_interval_ts_ms),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarketConfig {
+        if (!isMarketConfig(item.type)) {
+            throw new Error("not a MarketConfig type");
+        }
+
+        return MarketConfig.reified().new({
+            oracleId: decodeFromFieldsWithTypes("address", item.fields.oracle_id),
+            maxLeveragePct: decodeFromFieldsWithTypes("u64", item.fields.max_leverage_pct),
+            minSize: decodeFromFieldsWithTypes("u64", item.fields.min_size),
+            lotSize: decodeFromFieldsWithTypes("u64", item.fields.lot_size),
+            tradingFeeRate: decodeFromFieldsWithTypes("u64", item.fields.trading_fee_rate),
+            tradingFeeDecimal: decodeFromFieldsWithTypes("u64", item.fields.trading_fee_decimal),
+            basicFundingRate: decodeFromFieldsWithTypes("u64", item.fields.basic_funding_rate),
+            fundingIntervalTsMs: decodeFromFieldsWithTypes("u64", item.fields.funding_interval_ts_ms),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): MarketConfig {
+        return MarketConfig.fromFields(MarketConfig.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            oracleId: this.oracleId,
+            maxLeveragePct: this.maxLeveragePct.toString(),
+            minSize: this.minSize.toString(),
+            lotSize: this.lotSize.toString(),
+            tradingFeeRate: this.tradingFeeRate.toString(),
+            tradingFeeDecimal: this.tradingFeeDecimal.toString(),
+            basicFundingRate: this.basicFundingRate.toString(),
+            fundingIntervalTsMs: this.fundingIntervalTsMs.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): MarketConfig {
+        return MarketConfig.reified().new({
+            oracleId: decodeFromJSONField("address", field.oracleId),
+            maxLeveragePct: decodeFromJSONField("u64", field.maxLeveragePct),
+            minSize: decodeFromJSONField("u64", field.minSize),
+            lotSize: decodeFromJSONField("u64", field.lotSize),
+            tradingFeeRate: decodeFromJSONField("u64", field.tradingFeeRate),
+            tradingFeeDecimal: decodeFromJSONField("u64", field.tradingFeeDecimal),
+            basicFundingRate: decodeFromJSONField("u64", field.basicFundingRate),
+            fundingIntervalTsMs: decodeFromJSONField("u64", field.fundingIntervalTsMs),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): MarketConfig {
+        if (json.$typeName !== MarketConfig.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return MarketConfig.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): MarketConfig {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMarketConfig(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a MarketConfig object`);
+        }
+        return MarketConfig.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<MarketConfig> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MarketConfig object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMarketConfig(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MarketConfig object`);
+        }
+        return MarketConfig.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== MarketInfo =============================== */
+
+export function isMarketInfo(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketInfo";
+}
+
+export interface MarketInfoFields {
+    isActive: ToField<"bool">;
+    sizeDecimal: ToField<"u64">;
+    userLongPositionSize: ToField<"u64">;
+    userShortPositionSize: ToField<"u64">;
+    nextPositionId: ToField<"u64">;
+    userLongOrderSize: ToField<"u64">;
+    userShortOrderSize: ToField<"u64">;
+    nextOrderId: ToField<"u64">;
+    lastFundingTsMs: ToField<"u64">;
+    cumulativeFundingRateIndexSign: ToField<"bool">;
+    cumulativeFundingRateIndex: ToField<"u64">;
+    previousLastFundingTsMs: ToField<"u64">;
+    previousCumulativeFundingRateIndexSign: ToField<"bool">;
+    previousCumulativeFundingRateIndex: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MarketInfoReified = Reified<MarketInfo, MarketInfoFields>;
+
+export class MarketInfo implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketInfo";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = MarketInfo.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketInfo";
+
+    readonly $typeArgs: [];
+
+    readonly isActive: ToField<"bool">;
+    readonly sizeDecimal: ToField<"u64">;
+    readonly userLongPositionSize: ToField<"u64">;
+    readonly userShortPositionSize: ToField<"u64">;
+    readonly nextPositionId: ToField<"u64">;
+    readonly userLongOrderSize: ToField<"u64">;
+    readonly userShortOrderSize: ToField<"u64">;
+    readonly nextOrderId: ToField<"u64">;
+    readonly lastFundingTsMs: ToField<"u64">;
+    readonly cumulativeFundingRateIndexSign: ToField<"bool">;
+    readonly cumulativeFundingRateIndex: ToField<"u64">;
+    readonly previousLastFundingTsMs: ToField<"u64">;
+    readonly previousCumulativeFundingRateIndexSign: ToField<"bool">;
+    readonly previousCumulativeFundingRateIndex: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MarketInfoFields) {
+        this.$fullTypeName = composeSuiType(
+            MarketInfo.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketInfo";
+        this.$typeArgs = typeArgs;
+
+        this.isActive = fields.isActive;
+        this.sizeDecimal = fields.sizeDecimal;
+        this.userLongPositionSize = fields.userLongPositionSize;
+        this.userShortPositionSize = fields.userShortPositionSize;
+        this.nextPositionId = fields.nextPositionId;
+        this.userLongOrderSize = fields.userLongOrderSize;
+        this.userShortOrderSize = fields.userShortOrderSize;
+        this.nextOrderId = fields.nextOrderId;
+        this.lastFundingTsMs = fields.lastFundingTsMs;
+        this.cumulativeFundingRateIndexSign = fields.cumulativeFundingRateIndexSign;
+        this.cumulativeFundingRateIndex = fields.cumulativeFundingRateIndex;
+        this.previousLastFundingTsMs = fields.previousLastFundingTsMs;
+        this.previousCumulativeFundingRateIndexSign = fields.previousCumulativeFundingRateIndexSign;
+        this.previousCumulativeFundingRateIndex = fields.previousCumulativeFundingRateIndex;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MarketInfoReified {
+        return {
+            typeName: MarketInfo.$typeName,
+            fullTypeName: composeSuiType(
+                MarketInfo.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketInfo",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => MarketInfo.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => MarketInfo.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => MarketInfo.fromBcs(data),
+            bcs: MarketInfo.bcs,
+            fromJSONField: (field: any) => MarketInfo.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => MarketInfo.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => MarketInfo.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => MarketInfo.fetch(client, id),
+            new: (fields: MarketInfoFields) => {
+                return new MarketInfo([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return MarketInfo.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<MarketInfo>> {
+        return phantom(MarketInfo.reified());
+    }
+    static get p() {
+        return MarketInfo.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("MarketInfo", {
+            is_active: bcs.bool(),
+            size_decimal: bcs.u64(),
+            user_long_position_size: bcs.u64(),
+            user_short_position_size: bcs.u64(),
+            next_position_id: bcs.u64(),
+            user_long_order_size: bcs.u64(),
+            user_short_order_size: bcs.u64(),
+            next_order_id: bcs.u64(),
+            last_funding_ts_ms: bcs.u64(),
+            cumulative_funding_rate_index_sign: bcs.bool(),
+            cumulative_funding_rate_index: bcs.u64(),
+            previous_last_funding_ts_ms: bcs.u64(),
+            previous_cumulative_funding_rate_index_sign: bcs.bool(),
+            previous_cumulative_funding_rate_index: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): MarketInfo {
+        return MarketInfo.reified().new({
+            isActive: decodeFromFields("bool", fields.is_active),
+            sizeDecimal: decodeFromFields("u64", fields.size_decimal),
+            userLongPositionSize: decodeFromFields("u64", fields.user_long_position_size),
+            userShortPositionSize: decodeFromFields("u64", fields.user_short_position_size),
+            nextPositionId: decodeFromFields("u64", fields.next_position_id),
+            userLongOrderSize: decodeFromFields("u64", fields.user_long_order_size),
+            userShortOrderSize: decodeFromFields("u64", fields.user_short_order_size),
+            nextOrderId: decodeFromFields("u64", fields.next_order_id),
+            lastFundingTsMs: decodeFromFields("u64", fields.last_funding_ts_ms),
+            cumulativeFundingRateIndexSign: decodeFromFields("bool", fields.cumulative_funding_rate_index_sign),
+            cumulativeFundingRateIndex: decodeFromFields("u64", fields.cumulative_funding_rate_index),
+            previousLastFundingTsMs: decodeFromFields("u64", fields.previous_last_funding_ts_ms),
+            previousCumulativeFundingRateIndexSign: decodeFromFields("bool", fields.previous_cumulative_funding_rate_index_sign),
+            previousCumulativeFundingRateIndex: decodeFromFields("u64", fields.previous_cumulative_funding_rate_index),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarketInfo {
+        if (!isMarketInfo(item.type)) {
+            throw new Error("not a MarketInfo type");
+        }
+
+        return MarketInfo.reified().new({
+            isActive: decodeFromFieldsWithTypes("bool", item.fields.is_active),
+            sizeDecimal: decodeFromFieldsWithTypes("u64", item.fields.size_decimal),
+            userLongPositionSize: decodeFromFieldsWithTypes("u64", item.fields.user_long_position_size),
+            userShortPositionSize: decodeFromFieldsWithTypes("u64", item.fields.user_short_position_size),
+            nextPositionId: decodeFromFieldsWithTypes("u64", item.fields.next_position_id),
+            userLongOrderSize: decodeFromFieldsWithTypes("u64", item.fields.user_long_order_size),
+            userShortOrderSize: decodeFromFieldsWithTypes("u64", item.fields.user_short_order_size),
+            nextOrderId: decodeFromFieldsWithTypes("u64", item.fields.next_order_id),
+            lastFundingTsMs: decodeFromFieldsWithTypes("u64", item.fields.last_funding_ts_ms),
+            cumulativeFundingRateIndexSign: decodeFromFieldsWithTypes("bool", item.fields.cumulative_funding_rate_index_sign),
+            cumulativeFundingRateIndex: decodeFromFieldsWithTypes("u64", item.fields.cumulative_funding_rate_index),
+            previousLastFundingTsMs: decodeFromFieldsWithTypes("u64", item.fields.previous_last_funding_ts_ms),
+            previousCumulativeFundingRateIndexSign: decodeFromFieldsWithTypes(
+                "bool",
+                item.fields.previous_cumulative_funding_rate_index_sign
+            ),
+            previousCumulativeFundingRateIndex: decodeFromFieldsWithTypes("u64", item.fields.previous_cumulative_funding_rate_index),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): MarketInfo {
+        return MarketInfo.fromFields(MarketInfo.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            isActive: this.isActive,
+            sizeDecimal: this.sizeDecimal.toString(),
+            userLongPositionSize: this.userLongPositionSize.toString(),
+            userShortPositionSize: this.userShortPositionSize.toString(),
+            nextPositionId: this.nextPositionId.toString(),
+            userLongOrderSize: this.userLongOrderSize.toString(),
+            userShortOrderSize: this.userShortOrderSize.toString(),
+            nextOrderId: this.nextOrderId.toString(),
+            lastFundingTsMs: this.lastFundingTsMs.toString(),
+            cumulativeFundingRateIndexSign: this.cumulativeFundingRateIndexSign,
+            cumulativeFundingRateIndex: this.cumulativeFundingRateIndex.toString(),
+            previousLastFundingTsMs: this.previousLastFundingTsMs.toString(),
+            previousCumulativeFundingRateIndexSign: this.previousCumulativeFundingRateIndexSign,
+            previousCumulativeFundingRateIndex: this.previousCumulativeFundingRateIndex.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): MarketInfo {
+        return MarketInfo.reified().new({
+            isActive: decodeFromJSONField("bool", field.isActive),
+            sizeDecimal: decodeFromJSONField("u64", field.sizeDecimal),
+            userLongPositionSize: decodeFromJSONField("u64", field.userLongPositionSize),
+            userShortPositionSize: decodeFromJSONField("u64", field.userShortPositionSize),
+            nextPositionId: decodeFromJSONField("u64", field.nextPositionId),
+            userLongOrderSize: decodeFromJSONField("u64", field.userLongOrderSize),
+            userShortOrderSize: decodeFromJSONField("u64", field.userShortOrderSize),
+            nextOrderId: decodeFromJSONField("u64", field.nextOrderId),
+            lastFundingTsMs: decodeFromJSONField("u64", field.lastFundingTsMs),
+            cumulativeFundingRateIndexSign: decodeFromJSONField("bool", field.cumulativeFundingRateIndexSign),
+            cumulativeFundingRateIndex: decodeFromJSONField("u64", field.cumulativeFundingRateIndex),
+            previousLastFundingTsMs: decodeFromJSONField("u64", field.previousLastFundingTsMs),
+            previousCumulativeFundingRateIndexSign: decodeFromJSONField("bool", field.previousCumulativeFundingRateIndexSign),
+            previousCumulativeFundingRateIndex: decodeFromJSONField("u64", field.previousCumulativeFundingRateIndex),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): MarketInfo {
+        if (json.$typeName !== MarketInfo.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return MarketInfo.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): MarketInfo {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMarketInfo(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a MarketInfo object`);
+        }
+        return MarketInfo.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<MarketInfo> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MarketInfo object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMarketInfo(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MarketInfo object`);
+        }
+        return MarketInfo.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== MarketRegistry =============================== */
+
+export function isMarketRegistry(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketRegistry";
+}
+
+export interface MarketRegistryFields {
+    id: ToField<UID>;
+    referralRegistry: ToField<UID>;
+    numMarket: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MarketRegistryReified = Reified<MarketRegistry, MarketRegistryFields>;
+
+export class MarketRegistry implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketRegistry";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = MarketRegistry.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketRegistry";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly referralRegistry: ToField<UID>;
+    readonly numMarket: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MarketRegistryFields) {
+        this.$fullTypeName = composeSuiType(
+            MarketRegistry.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketRegistry";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.referralRegistry = fields.referralRegistry;
+        this.numMarket = fields.numMarket;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MarketRegistryReified {
+        return {
+            typeName: MarketRegistry.$typeName,
+            fullTypeName: composeSuiType(
+                MarketRegistry.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MarketRegistry",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => MarketRegistry.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => MarketRegistry.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => MarketRegistry.fromBcs(data),
+            bcs: MarketRegistry.bcs,
+            fromJSONField: (field: any) => MarketRegistry.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => MarketRegistry.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => MarketRegistry.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => MarketRegistry.fetch(client, id),
+            new: (fields: MarketRegistryFields) => {
+                return new MarketRegistry([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return MarketRegistry.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<MarketRegistry>> {
+        return phantom(MarketRegistry.reified());
+    }
+    static get p() {
+        return MarketRegistry.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("MarketRegistry", {
+            id: UID.bcs,
+            referral_registry: UID.bcs,
+            num_market: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): MarketRegistry {
+        return MarketRegistry.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            referralRegistry: decodeFromFields(UID.reified(), fields.referral_registry),
+            numMarket: decodeFromFields("u64", fields.num_market),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): MarketRegistry {
+        if (!isMarketRegistry(item.type)) {
+            throw new Error("not a MarketRegistry type");
+        }
+
+        return MarketRegistry.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            referralRegistry: decodeFromFieldsWithTypes(UID.reified(), item.fields.referral_registry),
+            numMarket: decodeFromFieldsWithTypes("u64", item.fields.num_market),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): MarketRegistry {
+        return MarketRegistry.fromFields(MarketRegistry.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            referralRegistry: this.referralRegistry,
+            numMarket: this.numMarket.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): MarketRegistry {
+        return MarketRegistry.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            referralRegistry: decodeFromJSONField(UID.reified(), field.referralRegistry),
+            numMarket: decodeFromJSONField("u64", field.numMarket),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): MarketRegistry {
+        if (json.$typeName !== MarketRegistry.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return MarketRegistry.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): MarketRegistry {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMarketRegistry(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a MarketRegistry object`);
+        }
+        return MarketRegistry.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<MarketRegistry> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MarketRegistry object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMarketRegistry(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MarketRegistry object`);
+        }
+        return MarketRegistry.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== Markets =============================== */
+
+export function isMarkets(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::Markets";
+}
+
+export interface MarketsFields {
+    id: ToField<UID>;
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    quoteTokenType: ToField<TypeName>;
+    isActive: ToField<"bool">;
+    protocolFeeShareBp: ToField<"u64">;
+    symbols: ToField<Vector<TypeName>>;
+    symbolMarkets: ToField<ObjectTable<ToPhantom<TypeName>, ToPhantom<SymbolMarket>>>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MarketsReified = Reified<Markets, MarketsFields>;
+
+export class Markets implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::Markets";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = Markets.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::Markets";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly quoteTokenType: ToField<TypeName>;
+    readonly isActive: ToField<"bool">;
+    readonly protocolFeeShareBp: ToField<"u64">;
+    readonly symbols: ToField<Vector<TypeName>>;
+    readonly symbolMarkets: ToField<ObjectTable<ToPhantom<TypeName>, ToPhantom<SymbolMarket>>>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MarketsFields) {
+        this.$fullTypeName = composeSuiType(
+            Markets.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::Markets";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.index = fields.index;
+        this.lpTokenType = fields.lpTokenType;
+        this.quoteTokenType = fields.quoteTokenType;
+        this.isActive = fields.isActive;
+        this.protocolFeeShareBp = fields.protocolFeeShareBp;
+        this.symbols = fields.symbols;
+        this.symbolMarkets = fields.symbolMarkets;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MarketsReified {
+        return {
+            typeName: Markets.$typeName,
+            fullTypeName: composeSuiType(
+                Markets.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::Markets",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => Markets.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => Markets.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => Markets.fromBcs(data),
+            bcs: Markets.bcs,
+            fromJSONField: (field: any) => Markets.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => Markets.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => Markets.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => Markets.fetch(client, id),
+            new: (fields: MarketsFields) => {
+                return new Markets([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return Markets.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<Markets>> {
+        return phantom(Markets.reified());
+    }
+    static get p() {
+        return Markets.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("Markets", {
+            id: UID.bcs,
+            index: bcs.u64(),
+            lp_token_type: TypeName.bcs,
+            quote_token_type: TypeName.bcs,
+            is_active: bcs.bool(),
+            protocol_fee_share_bp: bcs.u64(),
+            symbols: bcs.vector(TypeName.bcs),
+            symbol_markets: ObjectTable.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): Markets {
+        return Markets.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            index: decodeFromFields("u64", fields.index),
+            lpTokenType: decodeFromFields(TypeName.reified(), fields.lp_token_type),
+            quoteTokenType: decodeFromFields(TypeName.reified(), fields.quote_token_type),
+            isActive: decodeFromFields("bool", fields.is_active),
+            protocolFeeShareBp: decodeFromFields("u64", fields.protocol_fee_share_bp),
+            symbols: decodeFromFields(reified.vector(TypeName.reified()), fields.symbols),
+            symbolMarkets: decodeFromFields(
+                ObjectTable.reified(reified.phantom(TypeName.reified()), reified.phantom(SymbolMarket.reified())),
+                fields.symbol_markets
+            ),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): Markets {
+        if (!isMarkets(item.type)) {
+            throw new Error("not a Markets type");
+        }
+
+        return Markets.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            lpTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.lp_token_type),
+            quoteTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.quote_token_type),
+            isActive: decodeFromFieldsWithTypes("bool", item.fields.is_active),
+            protocolFeeShareBp: decodeFromFieldsWithTypes("u64", item.fields.protocol_fee_share_bp),
+            symbols: decodeFromFieldsWithTypes(reified.vector(TypeName.reified()), item.fields.symbols),
+            symbolMarkets: decodeFromFieldsWithTypes(
+                ObjectTable.reified(reified.phantom(TypeName.reified()), reified.phantom(SymbolMarket.reified())),
+                item.fields.symbol_markets
+            ),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): Markets {
+        return Markets.fromFields(Markets.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            index: this.index.toString(),
+            lpTokenType: this.lpTokenType.toJSONField(),
+            quoteTokenType: this.quoteTokenType.toJSONField(),
+            isActive: this.isActive,
+            protocolFeeShareBp: this.protocolFeeShareBp.toString(),
+            symbols: fieldToJSON<Vector<TypeName>>(`vector<0x1::type_name::TypeName>`, this.symbols),
+            symbolMarkets: this.symbolMarkets.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): Markets {
+        return Markets.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            index: decodeFromJSONField("u64", field.index),
+            lpTokenType: decodeFromJSONField(TypeName.reified(), field.lpTokenType),
+            quoteTokenType: decodeFromJSONField(TypeName.reified(), field.quoteTokenType),
+            isActive: decodeFromJSONField("bool", field.isActive),
+            protocolFeeShareBp: decodeFromJSONField("u64", field.protocolFeeShareBp),
+            symbols: decodeFromJSONField(reified.vector(TypeName.reified()), field.symbols),
+            symbolMarkets: decodeFromJSONField(
+                ObjectTable.reified(reified.phantom(TypeName.reified()), reified.phantom(SymbolMarket.reified())),
+                field.symbolMarkets
+            ),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): Markets {
+        if (json.$typeName !== Markets.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return Markets.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): Markets {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMarkets(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a Markets object`);
+        }
+        return Markets.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<Markets> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching Markets object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMarkets(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a Markets object`);
+        }
+        return Markets.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== MatchTradingOrderEvent =============================== */
+
+export function isMatchTradingOrderEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MatchTradingOrderEvent";
+}
+
+export interface MatchTradingOrderEventFields {
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    matchedOrderIds: ToField<Vector<"u64">>;
+    linkedOrdersToBeCancelled: ToField<LinkedOrdersInfo>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type MatchTradingOrderEventReified = Reified<MatchTradingOrderEvent, MatchTradingOrderEventFields>;
+
+export class MatchTradingOrderEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MatchTradingOrderEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = MatchTradingOrderEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MatchTradingOrderEvent";
+
+    readonly $typeArgs: [];
+
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly matchedOrderIds: ToField<Vector<"u64">>;
+    readonly linkedOrdersToBeCancelled: ToField<LinkedOrdersInfo>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: MatchTradingOrderEventFields) {
+        this.$fullTypeName = composeSuiType(
+            MatchTradingOrderEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MatchTradingOrderEvent";
+        this.$typeArgs = typeArgs;
+
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.matchedOrderIds = fields.matchedOrderIds;
+        this.linkedOrdersToBeCancelled = fields.linkedOrdersToBeCancelled;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): MatchTradingOrderEventReified {
+        return {
+            typeName: MatchTradingOrderEvent.$typeName,
+            fullTypeName: composeSuiType(
+                MatchTradingOrderEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::MatchTradingOrderEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => MatchTradingOrderEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => MatchTradingOrderEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => MatchTradingOrderEvent.fromBcs(data),
+            bcs: MatchTradingOrderEvent.bcs,
+            fromJSONField: (field: any) => MatchTradingOrderEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => MatchTradingOrderEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => MatchTradingOrderEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => MatchTradingOrderEvent.fetch(client, id),
+            new: (fields: MatchTradingOrderEventFields) => {
+                return new MatchTradingOrderEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return MatchTradingOrderEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<MatchTradingOrderEvent>> {
+        return phantom(MatchTradingOrderEvent.reified());
+    }
+    static get p() {
+        return MatchTradingOrderEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("MatchTradingOrderEvent", {
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            matched_order_ids: bcs.vector(bcs.u64()),
+            linked_orders_to_be_cancelled: LinkedOrdersInfo.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): MatchTradingOrderEvent {
+        return MatchTradingOrderEvent.reified().new({
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            matchedOrderIds: decodeFromFields(reified.vector("u64"), fields.matched_order_ids),
+            linkedOrdersToBeCancelled: decodeFromFields(LinkedOrdersInfo.reified(), fields.linked_orders_to_be_cancelled),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): MatchTradingOrderEvent {
+        if (!isMatchTradingOrderEvent(item.type)) {
+            throw new Error("not a MatchTradingOrderEvent type");
+        }
+
+        return MatchTradingOrderEvent.reified().new({
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            matchedOrderIds: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.matched_order_ids),
+            linkedOrdersToBeCancelled: decodeFromFieldsWithTypes(LinkedOrdersInfo.reified(), item.fields.linked_orders_to_be_cancelled),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): MatchTradingOrderEvent {
+        return MatchTradingOrderEvent.fromFields(MatchTradingOrderEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            matchedOrderIds: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.matchedOrderIds),
+            linkedOrdersToBeCancelled: this.linkedOrdersToBeCancelled.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): MatchTradingOrderEvent {
+        return MatchTradingOrderEvent.reified().new({
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            matchedOrderIds: decodeFromJSONField(reified.vector("u64"), field.matchedOrderIds),
+            linkedOrdersToBeCancelled: decodeFromJSONField(LinkedOrdersInfo.reified(), field.linkedOrdersToBeCancelled),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): MatchTradingOrderEvent {
+        if (json.$typeName !== MatchTradingOrderEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return MatchTradingOrderEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): MatchTradingOrderEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isMatchTradingOrderEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a MatchTradingOrderEvent object`);
+        }
+        return MatchTradingOrderEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<MatchTradingOrderEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching MatchTradingOrderEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isMatchTradingOrderEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a MatchTradingOrderEvent object`);
+        }
+        return MatchTradingOrderEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== NewMarketsEvent =============================== */
+
+export function isNewMarketsEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::NewMarketsEvent";
+}
+
+export interface NewMarketsEventFields {
+    index: ToField<"u64">;
+    lpTokenType: ToField<TypeName>;
+    quoteTokenType: ToField<TypeName>;
+    protocolFeeShareBp: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type NewMarketsEventReified = Reified<NewMarketsEvent, NewMarketsEventFields>;
+
+export class NewMarketsEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::NewMarketsEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = NewMarketsEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::NewMarketsEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly lpTokenType: ToField<TypeName>;
+    readonly quoteTokenType: ToField<TypeName>;
+    readonly protocolFeeShareBp: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: NewMarketsEventFields) {
+        this.$fullTypeName = composeSuiType(
+            NewMarketsEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::NewMarketsEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.lpTokenType = fields.lpTokenType;
+        this.quoteTokenType = fields.quoteTokenType;
+        this.protocolFeeShareBp = fields.protocolFeeShareBp;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): NewMarketsEventReified {
+        return {
+            typeName: NewMarketsEvent.$typeName,
+            fullTypeName: composeSuiType(
+                NewMarketsEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::NewMarketsEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => NewMarketsEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => NewMarketsEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => NewMarketsEvent.fromBcs(data),
+            bcs: NewMarketsEvent.bcs,
+            fromJSONField: (field: any) => NewMarketsEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => NewMarketsEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => NewMarketsEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => NewMarketsEvent.fetch(client, id),
+            new: (fields: NewMarketsEventFields) => {
+                return new NewMarketsEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return NewMarketsEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<NewMarketsEvent>> {
+        return phantom(NewMarketsEvent.reified());
+    }
+    static get p() {
+        return NewMarketsEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("NewMarketsEvent", {
+            index: bcs.u64(),
+            lp_token_type: TypeName.bcs,
+            quote_token_type: TypeName.bcs,
+            protocol_fee_share_bp: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): NewMarketsEvent {
+        return NewMarketsEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            lpTokenType: decodeFromFields(TypeName.reified(), fields.lp_token_type),
+            quoteTokenType: decodeFromFields(TypeName.reified(), fields.quote_token_type),
+            protocolFeeShareBp: decodeFromFields("u64", fields.protocol_fee_share_bp),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): NewMarketsEvent {
+        if (!isNewMarketsEvent(item.type)) {
+            throw new Error("not a NewMarketsEvent type");
+        }
+
+        return NewMarketsEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            lpTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.lp_token_type),
+            quoteTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.quote_token_type),
+            protocolFeeShareBp: decodeFromFieldsWithTypes("u64", item.fields.protocol_fee_share_bp),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): NewMarketsEvent {
+        return NewMarketsEvent.fromFields(NewMarketsEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            lpTokenType: this.lpTokenType.toJSONField(),
+            quoteTokenType: this.quoteTokenType.toJSONField(),
+            protocolFeeShareBp: this.protocolFeeShareBp.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): NewMarketsEvent {
+        return NewMarketsEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            lpTokenType: decodeFromJSONField(TypeName.reified(), field.lpTokenType),
+            quoteTokenType: decodeFromJSONField(TypeName.reified(), field.quoteTokenType),
+            protocolFeeShareBp: decodeFromJSONField("u64", field.protocolFeeShareBp),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): NewMarketsEvent {
+        if (json.$typeName !== NewMarketsEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return NewMarketsEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): NewMarketsEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isNewMarketsEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a NewMarketsEvent object`);
+        }
+        return NewMarketsEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<NewMarketsEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching NewMarketsEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isNewMarketsEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a NewMarketsEvent object`);
+        }
+        return NewMarketsEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ReleaseCollateralEvent =============================== */
+
+export function isReleaseCollateralEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ReleaseCollateralEvent";
+}
+
+export interface ReleaseCollateralEventFields {
+    user: ToField<"address">;
+    marketIndex: ToField<"u64">;
+    poolIndex: ToField<"u64">;
+    positionId: ToField<"u64">;
+    collateralToken: ToField<TypeName>;
+    baseToken: ToField<TypeName>;
+    releasedCollateralAmount: ToField<"u64">;
+    remainingCollateralAmount: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ReleaseCollateralEventReified = Reified<ReleaseCollateralEvent, ReleaseCollateralEventFields>;
+
+export class ReleaseCollateralEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ReleaseCollateralEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ReleaseCollateralEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ReleaseCollateralEvent";
+
+    readonly $typeArgs: [];
+
+    readonly user: ToField<"address">;
+    readonly marketIndex: ToField<"u64">;
+    readonly poolIndex: ToField<"u64">;
+    readonly positionId: ToField<"u64">;
+    readonly collateralToken: ToField<TypeName>;
+    readonly baseToken: ToField<TypeName>;
+    readonly releasedCollateralAmount: ToField<"u64">;
+    readonly remainingCollateralAmount: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ReleaseCollateralEventFields) {
+        this.$fullTypeName = composeSuiType(
+            ReleaseCollateralEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ReleaseCollateralEvent";
+        this.$typeArgs = typeArgs;
+
+        this.user = fields.user;
+        this.marketIndex = fields.marketIndex;
+        this.poolIndex = fields.poolIndex;
+        this.positionId = fields.positionId;
+        this.collateralToken = fields.collateralToken;
+        this.baseToken = fields.baseToken;
+        this.releasedCollateralAmount = fields.releasedCollateralAmount;
+        this.remainingCollateralAmount = fields.remainingCollateralAmount;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ReleaseCollateralEventReified {
+        return {
+            typeName: ReleaseCollateralEvent.$typeName,
+            fullTypeName: composeSuiType(
+                ReleaseCollateralEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ReleaseCollateralEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ReleaseCollateralEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ReleaseCollateralEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ReleaseCollateralEvent.fromBcs(data),
+            bcs: ReleaseCollateralEvent.bcs,
+            fromJSONField: (field: any) => ReleaseCollateralEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ReleaseCollateralEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ReleaseCollateralEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ReleaseCollateralEvent.fetch(client, id),
+            new: (fields: ReleaseCollateralEventFields) => {
+                return new ReleaseCollateralEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ReleaseCollateralEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ReleaseCollateralEvent>> {
+        return phantom(ReleaseCollateralEvent.reified());
+    }
+    static get p() {
+        return ReleaseCollateralEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ReleaseCollateralEvent", {
+            user: bcs.bytes(32).transform({ input: (val: string) => fromHEX(val), output: (val: Uint8Array) => toHEX(val) }),
+            market_index: bcs.u64(),
+            pool_index: bcs.u64(),
+            position_id: bcs.u64(),
+            collateral_token: TypeName.bcs,
+            base_token: TypeName.bcs,
+            released_collateral_amount: bcs.u64(),
+            remaining_collateral_amount: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ReleaseCollateralEvent {
+        return ReleaseCollateralEvent.reified().new({
+            user: decodeFromFields("address", fields.user),
+            marketIndex: decodeFromFields("u64", fields.market_index),
+            poolIndex: decodeFromFields("u64", fields.pool_index),
+            positionId: decodeFromFields("u64", fields.position_id),
+            collateralToken: decodeFromFields(TypeName.reified(), fields.collateral_token),
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            releasedCollateralAmount: decodeFromFields("u64", fields.released_collateral_amount),
+            remainingCollateralAmount: decodeFromFields("u64", fields.remaining_collateral_amount),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ReleaseCollateralEvent {
+        if (!isReleaseCollateralEvent(item.type)) {
+            throw new Error("not a ReleaseCollateralEvent type");
+        }
+
+        return ReleaseCollateralEvent.reified().new({
+            user: decodeFromFieldsWithTypes("address", item.fields.user),
+            marketIndex: decodeFromFieldsWithTypes("u64", item.fields.market_index),
+            poolIndex: decodeFromFieldsWithTypes("u64", item.fields.pool_index),
+            positionId: decodeFromFieldsWithTypes("u64", item.fields.position_id),
+            collateralToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.collateral_token),
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            releasedCollateralAmount: decodeFromFieldsWithTypes("u64", item.fields.released_collateral_amount),
+            remainingCollateralAmount: decodeFromFieldsWithTypes("u64", item.fields.remaining_collateral_amount),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): ReleaseCollateralEvent {
+        return ReleaseCollateralEvent.fromFields(ReleaseCollateralEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            user: this.user,
+            marketIndex: this.marketIndex.toString(),
+            poolIndex: this.poolIndex.toString(),
+            positionId: this.positionId.toString(),
+            collateralToken: this.collateralToken.toJSONField(),
+            baseToken: this.baseToken.toJSONField(),
+            releasedCollateralAmount: this.releasedCollateralAmount.toString(),
+            remainingCollateralAmount: this.remainingCollateralAmount.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): ReleaseCollateralEvent {
+        return ReleaseCollateralEvent.reified().new({
+            user: decodeFromJSONField("address", field.user),
+            marketIndex: decodeFromJSONField("u64", field.marketIndex),
+            poolIndex: decodeFromJSONField("u64", field.poolIndex),
+            positionId: decodeFromJSONField("u64", field.positionId),
+            collateralToken: decodeFromJSONField(TypeName.reified(), field.collateralToken),
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            releasedCollateralAmount: decodeFromJSONField("u64", field.releasedCollateralAmount),
+            remainingCollateralAmount: decodeFromJSONField("u64", field.remainingCollateralAmount),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): ReleaseCollateralEvent {
+        if (json.$typeName !== ReleaseCollateralEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ReleaseCollateralEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ReleaseCollateralEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isReleaseCollateralEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ReleaseCollateralEvent object`);
+        }
+        return ReleaseCollateralEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ReleaseCollateralEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ReleaseCollateralEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isReleaseCollateralEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ReleaseCollateralEvent object`);
+        }
+        return ReleaseCollateralEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ResumeMarketEvent =============================== */
+
+export function isResumeMarketEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeMarketEvent";
+}
+
+export interface ResumeMarketEventFields {
+    index: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ResumeMarketEventReified = Reified<ResumeMarketEvent, ResumeMarketEventFields>;
+
+export class ResumeMarketEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeMarketEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ResumeMarketEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeMarketEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ResumeMarketEventFields) {
+        this.$fullTypeName = composeSuiType(
+            ResumeMarketEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeMarketEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ResumeMarketEventReified {
+        return {
+            typeName: ResumeMarketEvent.$typeName,
+            fullTypeName: composeSuiType(
+                ResumeMarketEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeMarketEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ResumeMarketEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ResumeMarketEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ResumeMarketEvent.fromBcs(data),
+            bcs: ResumeMarketEvent.bcs,
+            fromJSONField: (field: any) => ResumeMarketEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ResumeMarketEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ResumeMarketEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ResumeMarketEvent.fetch(client, id),
+            new: (fields: ResumeMarketEventFields) => {
+                return new ResumeMarketEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ResumeMarketEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ResumeMarketEvent>> {
+        return phantom(ResumeMarketEvent.reified());
+    }
+    static get p() {
+        return ResumeMarketEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ResumeMarketEvent", {
+            index: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ResumeMarketEvent {
+        return ResumeMarketEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ResumeMarketEvent {
+        if (!isResumeMarketEvent(item.type)) {
+            throw new Error("not a ResumeMarketEvent type");
+        }
+
+        return ResumeMarketEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): ResumeMarketEvent {
+        return ResumeMarketEvent.fromFields(ResumeMarketEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            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): ResumeMarketEvent {
+        return ResumeMarketEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): ResumeMarketEvent {
+        if (json.$typeName !== ResumeMarketEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ResumeMarketEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ResumeMarketEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isResumeMarketEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ResumeMarketEvent object`);
+        }
+        return ResumeMarketEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ResumeMarketEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ResumeMarketEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isResumeMarketEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ResumeMarketEvent object`);
+        }
+        return ResumeMarketEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== ResumeTradingSymbolEvent =============================== */
+
+export function isResumeTradingSymbolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeTradingSymbolEvent";
+}
+
+export interface ResumeTradingSymbolEventFields {
+    index: ToField<"u64">;
+    resumedBaseToken: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type ResumeTradingSymbolEventReified = Reified<ResumeTradingSymbolEvent, ResumeTradingSymbolEventFields>;
+
+export class ResumeTradingSymbolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeTradingSymbolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = ResumeTradingSymbolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeTradingSymbolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly resumedBaseToken: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: ResumeTradingSymbolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            ResumeTradingSymbolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeTradingSymbolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.resumedBaseToken = fields.resumedBaseToken;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): ResumeTradingSymbolEventReified {
+        return {
+            typeName: ResumeTradingSymbolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                ResumeTradingSymbolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::ResumeTradingSymbolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => ResumeTradingSymbolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => ResumeTradingSymbolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => ResumeTradingSymbolEvent.fromBcs(data),
+            bcs: ResumeTradingSymbolEvent.bcs,
+            fromJSONField: (field: any) => ResumeTradingSymbolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => ResumeTradingSymbolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => ResumeTradingSymbolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => ResumeTradingSymbolEvent.fetch(client, id),
+            new: (fields: ResumeTradingSymbolEventFields) => {
+                return new ResumeTradingSymbolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return ResumeTradingSymbolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<ResumeTradingSymbolEvent>> {
+        return phantom(ResumeTradingSymbolEvent.reified());
+    }
+    static get p() {
+        return ResumeTradingSymbolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("ResumeTradingSymbolEvent", {
+            index: bcs.u64(),
+            resumed_base_token: TypeName.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): ResumeTradingSymbolEvent {
+        return ResumeTradingSymbolEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            resumedBaseToken: decodeFromFields(TypeName.reified(), fields.resumed_base_token),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): ResumeTradingSymbolEvent {
+        if (!isResumeTradingSymbolEvent(item.type)) {
+            throw new Error("not a ResumeTradingSymbolEvent type");
+        }
+
+        return ResumeTradingSymbolEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            resumedBaseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.resumed_base_token),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): ResumeTradingSymbolEvent {
+        return ResumeTradingSymbolEvent.fromFields(ResumeTradingSymbolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            resumedBaseToken: this.resumedBaseToken.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): ResumeTradingSymbolEvent {
+        return ResumeTradingSymbolEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            resumedBaseToken: decodeFromJSONField(TypeName.reified(), field.resumedBaseToken),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): ResumeTradingSymbolEvent {
+        if (json.$typeName !== ResumeTradingSymbolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return ResumeTradingSymbolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): ResumeTradingSymbolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isResumeTradingSymbolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a ResumeTradingSymbolEvent object`);
+        }
+        return ResumeTradingSymbolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<ResumeTradingSymbolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ResumeTradingSymbolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isResumeTradingSymbolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ResumeTradingSymbolEvent object`);
+        }
+        return ResumeTradingSymbolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SuspendMarketEvent =============================== */
+
+export function isSuspendMarketEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendMarketEvent";
+}
+
+export interface SuspendMarketEventFields {
+    index: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type SuspendMarketEventReified = Reified<SuspendMarketEvent, SuspendMarketEventFields>;
+
+export class SuspendMarketEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendMarketEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SuspendMarketEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendMarketEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: SuspendMarketEventFields) {
+        this.$fullTypeName = composeSuiType(
+            SuspendMarketEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendMarketEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): SuspendMarketEventReified {
+        return {
+            typeName: SuspendMarketEvent.$typeName,
+            fullTypeName: composeSuiType(
+                SuspendMarketEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendMarketEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SuspendMarketEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SuspendMarketEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SuspendMarketEvent.fromBcs(data),
+            bcs: SuspendMarketEvent.bcs,
+            fromJSONField: (field: any) => SuspendMarketEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SuspendMarketEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SuspendMarketEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SuspendMarketEvent.fetch(client, id),
+            new: (fields: SuspendMarketEventFields) => {
+                return new SuspendMarketEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SuspendMarketEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SuspendMarketEvent>> {
+        return phantom(SuspendMarketEvent.reified());
+    }
+    static get p() {
+        return SuspendMarketEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SuspendMarketEvent", {
+            index: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SuspendMarketEvent {
+        return SuspendMarketEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SuspendMarketEvent {
+        if (!isSuspendMarketEvent(item.type)) {
+            throw new Error("not a SuspendMarketEvent type");
+        }
+
+        return SuspendMarketEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SuspendMarketEvent {
+        return SuspendMarketEvent.fromFields(SuspendMarketEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            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): SuspendMarketEvent {
+        return SuspendMarketEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SuspendMarketEvent {
+        if (json.$typeName !== SuspendMarketEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SuspendMarketEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SuspendMarketEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSuspendMarketEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SuspendMarketEvent object`);
+        }
+        return SuspendMarketEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SuspendMarketEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SuspendMarketEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSuspendMarketEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SuspendMarketEvent object`);
+        }
+        return SuspendMarketEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SuspendTradingSymbolEvent =============================== */
+
+export function isSuspendTradingSymbolEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendTradingSymbolEvent";
+}
+
+export interface SuspendTradingSymbolEventFields {
+    index: ToField<"u64">;
+    suspendedBaseToken: ToField<TypeName>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type SuspendTradingSymbolEventReified = Reified<SuspendTradingSymbolEvent, SuspendTradingSymbolEventFields>;
+
+export class SuspendTradingSymbolEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendTradingSymbolEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SuspendTradingSymbolEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendTradingSymbolEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly suspendedBaseToken: ToField<TypeName>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: SuspendTradingSymbolEventFields) {
+        this.$fullTypeName = composeSuiType(
+            SuspendTradingSymbolEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendTradingSymbolEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.suspendedBaseToken = fields.suspendedBaseToken;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): SuspendTradingSymbolEventReified {
+        return {
+            typeName: SuspendTradingSymbolEvent.$typeName,
+            fullTypeName: composeSuiType(
+                SuspendTradingSymbolEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SuspendTradingSymbolEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SuspendTradingSymbolEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SuspendTradingSymbolEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SuspendTradingSymbolEvent.fromBcs(data),
+            bcs: SuspendTradingSymbolEvent.bcs,
+            fromJSONField: (field: any) => SuspendTradingSymbolEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SuspendTradingSymbolEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SuspendTradingSymbolEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SuspendTradingSymbolEvent.fetch(client, id),
+            new: (fields: SuspendTradingSymbolEventFields) => {
+                return new SuspendTradingSymbolEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SuspendTradingSymbolEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SuspendTradingSymbolEvent>> {
+        return phantom(SuspendTradingSymbolEvent.reified());
+    }
+    static get p() {
+        return SuspendTradingSymbolEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SuspendTradingSymbolEvent", {
+            index: bcs.u64(),
+            suspended_base_token: TypeName.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SuspendTradingSymbolEvent {
+        return SuspendTradingSymbolEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            suspendedBaseToken: decodeFromFields(TypeName.reified(), fields.suspended_base_token),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SuspendTradingSymbolEvent {
+        if (!isSuspendTradingSymbolEvent(item.type)) {
+            throw new Error("not a SuspendTradingSymbolEvent type");
+        }
+
+        return SuspendTradingSymbolEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            suspendedBaseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.suspended_base_token),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SuspendTradingSymbolEvent {
+        return SuspendTradingSymbolEvent.fromFields(SuspendTradingSymbolEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            suspendedBaseToken: this.suspendedBaseToken.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SuspendTradingSymbolEvent {
+        return SuspendTradingSymbolEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            suspendedBaseToken: decodeFromJSONField(TypeName.reified(), field.suspendedBaseToken),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SuspendTradingSymbolEvent {
+        if (json.$typeName !== SuspendTradingSymbolEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SuspendTradingSymbolEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SuspendTradingSymbolEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSuspendTradingSymbolEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SuspendTradingSymbolEvent object`);
+        }
+        return SuspendTradingSymbolEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SuspendTradingSymbolEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SuspendTradingSymbolEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSuspendTradingSymbolEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SuspendTradingSymbolEvent object`);
+        }
+        return SuspendTradingSymbolEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== SymbolMarket =============================== */
+
+export function isSymbolMarket(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SymbolMarket";
+}
+
+export interface SymbolMarketFields {
+    id: ToField<UID>;
+    userPositions: ToField<BigVector>;
+    tokenCollateralOrders: ToField<UID>;
+    optionCollateralOrders: ToField<UID>;
+    marketInfo: ToField<MarketInfo>;
+    marketConfig: ToField<MarketConfig>;
+}
+
+export type SymbolMarketReified = Reified<SymbolMarket, SymbolMarketFields>;
+
+export class SymbolMarket implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SymbolMarket";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = SymbolMarket.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SymbolMarket";
+
+    readonly $typeArgs: [];
+
+    readonly id: ToField<UID>;
+    readonly userPositions: ToField<BigVector>;
+    readonly tokenCollateralOrders: ToField<UID>;
+    readonly optionCollateralOrders: ToField<UID>;
+    readonly marketInfo: ToField<MarketInfo>;
+    readonly marketConfig: ToField<MarketConfig>;
+
+    private constructor(typeArgs: [], fields: SymbolMarketFields) {
+        this.$fullTypeName = composeSuiType(
+            SymbolMarket.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SymbolMarket";
+        this.$typeArgs = typeArgs;
+
+        this.id = fields.id;
+        this.userPositions = fields.userPositions;
+        this.tokenCollateralOrders = fields.tokenCollateralOrders;
+        this.optionCollateralOrders = fields.optionCollateralOrders;
+        this.marketInfo = fields.marketInfo;
+        this.marketConfig = fields.marketConfig;
+    }
+
+    static reified(): SymbolMarketReified {
+        return {
+            typeName: SymbolMarket.$typeName,
+            fullTypeName: composeSuiType(
+                SymbolMarket.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::SymbolMarket",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => SymbolMarket.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => SymbolMarket.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => SymbolMarket.fromBcs(data),
+            bcs: SymbolMarket.bcs,
+            fromJSONField: (field: any) => SymbolMarket.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => SymbolMarket.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => SymbolMarket.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => SymbolMarket.fetch(client, id),
+            new: (fields: SymbolMarketFields) => {
+                return new SymbolMarket([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return SymbolMarket.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<SymbolMarket>> {
+        return phantom(SymbolMarket.reified());
+    }
+    static get p() {
+        return SymbolMarket.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("SymbolMarket", {
+            id: UID.bcs,
+            user_positions: BigVector.bcs,
+            token_collateral_orders: UID.bcs,
+            option_collateral_orders: UID.bcs,
+            market_info: MarketInfo.bcs,
+            market_config: MarketConfig.bcs,
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): SymbolMarket {
+        return SymbolMarket.reified().new({
+            id: decodeFromFields(UID.reified(), fields.id),
+            userPositions: decodeFromFields(BigVector.reified(), fields.user_positions),
+            tokenCollateralOrders: decodeFromFields(UID.reified(), fields.token_collateral_orders),
+            optionCollateralOrders: decodeFromFields(UID.reified(), fields.option_collateral_orders),
+            marketInfo: decodeFromFields(MarketInfo.reified(), fields.market_info),
+            marketConfig: decodeFromFields(MarketConfig.reified(), fields.market_config),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): SymbolMarket {
+        if (!isSymbolMarket(item.type)) {
+            throw new Error("not a SymbolMarket type");
+        }
+
+        return SymbolMarket.reified().new({
+            id: decodeFromFieldsWithTypes(UID.reified(), item.fields.id),
+            userPositions: decodeFromFieldsWithTypes(BigVector.reified(), item.fields.user_positions),
+            tokenCollateralOrders: decodeFromFieldsWithTypes(UID.reified(), item.fields.token_collateral_orders),
+            optionCollateralOrders: decodeFromFieldsWithTypes(UID.reified(), item.fields.option_collateral_orders),
+            marketInfo: decodeFromFieldsWithTypes(MarketInfo.reified(), item.fields.market_info),
+            marketConfig: decodeFromFieldsWithTypes(MarketConfig.reified(), item.fields.market_config),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): SymbolMarket {
+        return SymbolMarket.fromFields(SymbolMarket.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            id: this.id,
+            userPositions: this.userPositions.toJSONField(),
+            tokenCollateralOrders: this.tokenCollateralOrders,
+            optionCollateralOrders: this.optionCollateralOrders,
+            marketInfo: this.marketInfo.toJSONField(),
+            marketConfig: this.marketConfig.toJSONField(),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): SymbolMarket {
+        return SymbolMarket.reified().new({
+            id: decodeFromJSONField(UID.reified(), field.id),
+            userPositions: decodeFromJSONField(BigVector.reified(), field.userPositions),
+            tokenCollateralOrders: decodeFromJSONField(UID.reified(), field.tokenCollateralOrders),
+            optionCollateralOrders: decodeFromJSONField(UID.reified(), field.optionCollateralOrders),
+            marketInfo: decodeFromJSONField(MarketInfo.reified(), field.marketInfo),
+            marketConfig: decodeFromJSONField(MarketConfig.reified(), field.marketConfig),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): SymbolMarket {
+        if (json.$typeName !== SymbolMarket.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return SymbolMarket.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): SymbolMarket {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSymbolMarket(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a SymbolMarket object`);
+        }
+        return SymbolMarket.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<SymbolMarket> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SymbolMarket object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSymbolMarket(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SymbolMarket object`);
+        }
+        return SymbolMarket.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== USD =============================== */
+
+export function isUSD(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::USD";
+}
+
+export interface USDFields {
+    dummyField: ToField<"bool">;
+}
+
+export type USDReified = Reified<USD, USDFields>;
+
+export class USD implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::USD";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = USD.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::USD";
+
+    readonly $typeArgs: [];
+
+    readonly dummyField: ToField<"bool">;
+
+    private constructor(typeArgs: [], fields: USDFields) {
+        this.$fullTypeName = composeSuiType(
+            USD.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::USD";
+        this.$typeArgs = typeArgs;
+
+        this.dummyField = fields.dummyField;
+    }
+
+    static reified(): USDReified {
+        return {
+            typeName: USD.$typeName,
+            fullTypeName: composeSuiType(
+                USD.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::USD",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => USD.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => USD.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => USD.fromBcs(data),
+            bcs: USD.bcs,
+            fromJSONField: (field: any) => USD.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => USD.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => USD.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => USD.fetch(client, id),
+            new: (fields: USDFields) => {
+                return new USD([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return USD.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<USD>> {
+        return phantom(USD.reified());
+    }
+    static get p() {
+        return USD.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("USD", {
+            dummy_field: bcs.bool(),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): USD {
+        return USD.reified().new({ dummyField: decodeFromFields("bool", fields.dummy_field) });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): USD {
+        if (!isUSD(item.type)) {
+            throw new Error("not a USD type");
+        }
+
+        return USD.reified().new({ dummyField: decodeFromFieldsWithTypes("bool", item.fields.dummy_field) });
+    }
+
+    static fromBcs(data: Uint8Array): USD {
+        return USD.fromFields(USD.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            dummyField: this.dummyField,
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): USD {
+        return USD.reified().new({ dummyField: decodeFromJSONField("bool", field.dummyField) });
+    }
+
+    static fromJSON(json: Record<string, any>): USD {
+        if (json.$typeName !== USD.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return USD.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): USD {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUSD(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a USD object`);
+        }
+        return USD.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<USD> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching USD object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUSD(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a USD object`);
+        }
+        return USD.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateFundingRateEvent =============================== */
+
+export function isUpdateFundingRateEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateFundingRateEvent";
+}
+
+export interface UpdateFundingRateEventFields {
+    baseToken: ToField<TypeName>;
+    newFundingTsMs: ToField<"u64">;
+    intervalsCount: ToField<"u64">;
+    previousCumulativeFundingRateIndexSign: ToField<"bool">;
+    previousCumulativeFundingRateIndex: ToField<"u64">;
+    cumulativeFundingRateIndexSign: ToField<"bool">;
+    cumulativeFundingRateIndex: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateFundingRateEventReified = Reified<UpdateFundingRateEvent, UpdateFundingRateEventFields>;
+
+export class UpdateFundingRateEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateFundingRateEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateFundingRateEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateFundingRateEvent";
+
+    readonly $typeArgs: [];
+
+    readonly baseToken: ToField<TypeName>;
+    readonly newFundingTsMs: ToField<"u64">;
+    readonly intervalsCount: ToField<"u64">;
+    readonly previousCumulativeFundingRateIndexSign: ToField<"bool">;
+    readonly previousCumulativeFundingRateIndex: ToField<"u64">;
+    readonly cumulativeFundingRateIndexSign: ToField<"bool">;
+    readonly cumulativeFundingRateIndex: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateFundingRateEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateFundingRateEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateFundingRateEvent";
+        this.$typeArgs = typeArgs;
+
+        this.baseToken = fields.baseToken;
+        this.newFundingTsMs = fields.newFundingTsMs;
+        this.intervalsCount = fields.intervalsCount;
+        this.previousCumulativeFundingRateIndexSign = fields.previousCumulativeFundingRateIndexSign;
+        this.previousCumulativeFundingRateIndex = fields.previousCumulativeFundingRateIndex;
+        this.cumulativeFundingRateIndexSign = fields.cumulativeFundingRateIndexSign;
+        this.cumulativeFundingRateIndex = fields.cumulativeFundingRateIndex;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateFundingRateEventReified {
+        return {
+            typeName: UpdateFundingRateEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateFundingRateEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateFundingRateEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateFundingRateEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateFundingRateEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateFundingRateEvent.fromBcs(data),
+            bcs: UpdateFundingRateEvent.bcs,
+            fromJSONField: (field: any) => UpdateFundingRateEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateFundingRateEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateFundingRateEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateFundingRateEvent.fetch(client, id),
+            new: (fields: UpdateFundingRateEventFields) => {
+                return new UpdateFundingRateEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateFundingRateEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateFundingRateEvent>> {
+        return phantom(UpdateFundingRateEvent.reified());
+    }
+    static get p() {
+        return UpdateFundingRateEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateFundingRateEvent", {
+            base_token: TypeName.bcs,
+            new_funding_ts_ms: bcs.u64(),
+            intervals_count: bcs.u64(),
+            previous_cumulative_funding_rate_index_sign: bcs.bool(),
+            previous_cumulative_funding_rate_index: bcs.u64(),
+            cumulative_funding_rate_index_sign: bcs.bool(),
+            cumulative_funding_rate_index: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateFundingRateEvent {
+        return UpdateFundingRateEvent.reified().new({
+            baseToken: decodeFromFields(TypeName.reified(), fields.base_token),
+            newFundingTsMs: decodeFromFields("u64", fields.new_funding_ts_ms),
+            intervalsCount: decodeFromFields("u64", fields.intervals_count),
+            previousCumulativeFundingRateIndexSign: decodeFromFields("bool", fields.previous_cumulative_funding_rate_index_sign),
+            previousCumulativeFundingRateIndex: decodeFromFields("u64", fields.previous_cumulative_funding_rate_index),
+            cumulativeFundingRateIndexSign: decodeFromFields("bool", fields.cumulative_funding_rate_index_sign),
+            cumulativeFundingRateIndex: decodeFromFields("u64", fields.cumulative_funding_rate_index),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateFundingRateEvent {
+        if (!isUpdateFundingRateEvent(item.type)) {
+            throw new Error("not a UpdateFundingRateEvent type");
+        }
+
+        return UpdateFundingRateEvent.reified().new({
+            baseToken: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token),
+            newFundingTsMs: decodeFromFieldsWithTypes("u64", item.fields.new_funding_ts_ms),
+            intervalsCount: decodeFromFieldsWithTypes("u64", item.fields.intervals_count),
+            previousCumulativeFundingRateIndexSign: decodeFromFieldsWithTypes(
+                "bool",
+                item.fields.previous_cumulative_funding_rate_index_sign
+            ),
+            previousCumulativeFundingRateIndex: decodeFromFieldsWithTypes("u64", item.fields.previous_cumulative_funding_rate_index),
+            cumulativeFundingRateIndexSign: decodeFromFieldsWithTypes("bool", item.fields.cumulative_funding_rate_index_sign),
+            cumulativeFundingRateIndex: decodeFromFieldsWithTypes("u64", item.fields.cumulative_funding_rate_index),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateFundingRateEvent {
+        return UpdateFundingRateEvent.fromFields(UpdateFundingRateEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            baseToken: this.baseToken.toJSONField(),
+            newFundingTsMs: this.newFundingTsMs.toString(),
+            intervalsCount: this.intervalsCount.toString(),
+            previousCumulativeFundingRateIndexSign: this.previousCumulativeFundingRateIndexSign,
+            previousCumulativeFundingRateIndex: this.previousCumulativeFundingRateIndex.toString(),
+            cumulativeFundingRateIndexSign: this.cumulativeFundingRateIndexSign,
+            cumulativeFundingRateIndex: this.cumulativeFundingRateIndex.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateFundingRateEvent {
+        return UpdateFundingRateEvent.reified().new({
+            baseToken: decodeFromJSONField(TypeName.reified(), field.baseToken),
+            newFundingTsMs: decodeFromJSONField("u64", field.newFundingTsMs),
+            intervalsCount: decodeFromJSONField("u64", field.intervalsCount),
+            previousCumulativeFundingRateIndexSign: decodeFromJSONField("bool", field.previousCumulativeFundingRateIndexSign),
+            previousCumulativeFundingRateIndex: decodeFromJSONField("u64", field.previousCumulativeFundingRateIndex),
+            cumulativeFundingRateIndexSign: decodeFromJSONField("bool", field.cumulativeFundingRateIndexSign),
+            cumulativeFundingRateIndex: decodeFromJSONField("u64", field.cumulativeFundingRateIndex),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateFundingRateEvent {
+        if (json.$typeName !== UpdateFundingRateEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateFundingRateEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateFundingRateEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateFundingRateEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateFundingRateEvent object`);
+        }
+        return UpdateFundingRateEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateFundingRateEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateFundingRateEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateFundingRateEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateFundingRateEvent object`);
+        }
+        return UpdateFundingRateEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateMarketConfigEvent =============================== */
+
+export function isUpdateMarketConfigEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateMarketConfigEvent";
+}
+
+export interface UpdateMarketConfigEventFields {
+    index: ToField<"u64">;
+    baseTokenType: ToField<TypeName>;
+    previousMarketConfig: ToField<MarketConfig>;
+    newMarketConfig: ToField<MarketConfig>;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateMarketConfigEventReified = Reified<UpdateMarketConfigEvent, UpdateMarketConfigEventFields>;
+
+export class UpdateMarketConfigEvent implements StructClass {
+    static readonly $typeName = "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateMarketConfigEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateMarketConfigEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateMarketConfigEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly baseTokenType: ToField<TypeName>;
+    readonly previousMarketConfig: ToField<MarketConfig>;
+    readonly newMarketConfig: ToField<MarketConfig>;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateMarketConfigEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateMarketConfigEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateMarketConfigEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.baseTokenType = fields.baseTokenType;
+        this.previousMarketConfig = fields.previousMarketConfig;
+        this.newMarketConfig = fields.newMarketConfig;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateMarketConfigEventReified {
+        return {
+            typeName: UpdateMarketConfigEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateMarketConfigEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateMarketConfigEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateMarketConfigEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateMarketConfigEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateMarketConfigEvent.fromBcs(data),
+            bcs: UpdateMarketConfigEvent.bcs,
+            fromJSONField: (field: any) => UpdateMarketConfigEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateMarketConfigEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateMarketConfigEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateMarketConfigEvent.fetch(client, id),
+            new: (fields: UpdateMarketConfigEventFields) => {
+                return new UpdateMarketConfigEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateMarketConfigEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateMarketConfigEvent>> {
+        return phantom(UpdateMarketConfigEvent.reified());
+    }
+    static get p() {
+        return UpdateMarketConfigEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateMarketConfigEvent", {
+            index: bcs.u64(),
+            base_token_type: TypeName.bcs,
+            previous_market_config: MarketConfig.bcs,
+            new_market_config: MarketConfig.bcs,
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateMarketConfigEvent {
+        return UpdateMarketConfigEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            baseTokenType: decodeFromFields(TypeName.reified(), fields.base_token_type),
+            previousMarketConfig: decodeFromFields(MarketConfig.reified(), fields.previous_market_config),
+            newMarketConfig: decodeFromFields(MarketConfig.reified(), fields.new_market_config),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateMarketConfigEvent {
+        if (!isUpdateMarketConfigEvent(item.type)) {
+            throw new Error("not a UpdateMarketConfigEvent type");
+        }
+
+        return UpdateMarketConfigEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            baseTokenType: decodeFromFieldsWithTypes(TypeName.reified(), item.fields.base_token_type),
+            previousMarketConfig: decodeFromFieldsWithTypes(MarketConfig.reified(), item.fields.previous_market_config),
+            newMarketConfig: decodeFromFieldsWithTypes(MarketConfig.reified(), item.fields.new_market_config),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateMarketConfigEvent {
+        return UpdateMarketConfigEvent.fromFields(UpdateMarketConfigEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            baseTokenType: this.baseTokenType.toJSONField(),
+            previousMarketConfig: this.previousMarketConfig.toJSONField(),
+            newMarketConfig: this.newMarketConfig.toJSONField(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateMarketConfigEvent {
+        return UpdateMarketConfigEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            baseTokenType: decodeFromJSONField(TypeName.reified(), field.baseTokenType),
+            previousMarketConfig: decodeFromJSONField(MarketConfig.reified(), field.previousMarketConfig),
+            newMarketConfig: decodeFromJSONField(MarketConfig.reified(), field.newMarketConfig),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateMarketConfigEvent {
+        if (json.$typeName !== UpdateMarketConfigEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateMarketConfigEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateMarketConfigEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateMarketConfigEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateMarketConfigEvent object`);
+        }
+        return UpdateMarketConfigEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateMarketConfigEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateMarketConfigEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateMarketConfigEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateMarketConfigEvent object`);
+        }
+        return UpdateMarketConfigEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}
+
+/* ============================== UpdateProtocolFeeShareBpEvent =============================== */
+
+export function isUpdateProtocolFeeShareBpEvent(type: string): boolean {
+    type = compressSuiType(type);
+    return type === "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateProtocolFeeShareBpEvent";
+}
+
+export interface UpdateProtocolFeeShareBpEventFields {
+    index: ToField<"u64">;
+    previousProtocolFeeShareBp: ToField<"u64">;
+    newProtocolFeeShareBp: ToField<"u64">;
+    u64Padding: ToField<Vector<"u64">>;
+}
+
+export type UpdateProtocolFeeShareBpEventReified = Reified<UpdateProtocolFeeShareBpEvent, UpdateProtocolFeeShareBpEventFields>;
+
+export class UpdateProtocolFeeShareBpEvent implements StructClass {
+    static readonly $typeName =
+        "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateProtocolFeeShareBpEvent";
+    static readonly $numTypeParams = 0;
+
+    readonly $typeName = UpdateProtocolFeeShareBpEvent.$typeName;
+
+    readonly $fullTypeName: "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateProtocolFeeShareBpEvent";
+
+    readonly $typeArgs: [];
+
+    readonly index: ToField<"u64">;
+    readonly previousProtocolFeeShareBp: ToField<"u64">;
+    readonly newProtocolFeeShareBp: ToField<"u64">;
+    readonly u64Padding: ToField<Vector<"u64">>;
+
+    private constructor(typeArgs: [], fields: UpdateProtocolFeeShareBpEventFields) {
+        this.$fullTypeName = composeSuiType(
+            UpdateProtocolFeeShareBpEvent.$typeName,
+            ...typeArgs
+        ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateProtocolFeeShareBpEvent";
+        this.$typeArgs = typeArgs;
+
+        this.index = fields.index;
+        this.previousProtocolFeeShareBp = fields.previousProtocolFeeShareBp;
+        this.newProtocolFeeShareBp = fields.newProtocolFeeShareBp;
+        this.u64Padding = fields.u64Padding;
+    }
+
+    static reified(): UpdateProtocolFeeShareBpEventReified {
+        return {
+            typeName: UpdateProtocolFeeShareBpEvent.$typeName,
+            fullTypeName: composeSuiType(
+                UpdateProtocolFeeShareBpEvent.$typeName,
+                ...[]
+            ) as "0x4bcf9eade4480bcb9fcd3139ec8d22afda34b25af06092904fcccb06e1b8043c::trading::UpdateProtocolFeeShareBpEvent",
+            typeArgs: [] as [],
+            reifiedTypeArgs: [],
+            fromFields: (fields: Record<string, any>) => UpdateProtocolFeeShareBpEvent.fromFields(fields),
+            fromFieldsWithTypes: (item: FieldsWithTypes) => UpdateProtocolFeeShareBpEvent.fromFieldsWithTypes(item),
+            fromBcs: (data: Uint8Array) => UpdateProtocolFeeShareBpEvent.fromBcs(data),
+            bcs: UpdateProtocolFeeShareBpEvent.bcs,
+            fromJSONField: (field: any) => UpdateProtocolFeeShareBpEvent.fromJSONField(field),
+            fromJSON: (json: Record<string, any>) => UpdateProtocolFeeShareBpEvent.fromJSON(json),
+            fromSuiParsedData: (content: SuiParsedData) => UpdateProtocolFeeShareBpEvent.fromSuiParsedData(content),
+            fetch: async (client: SuiClient, id: string) => UpdateProtocolFeeShareBpEvent.fetch(client, id),
+            new: (fields: UpdateProtocolFeeShareBpEventFields) => {
+                return new UpdateProtocolFeeShareBpEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+
+    static get r() {
+        return UpdateProtocolFeeShareBpEvent.reified();
+    }
+
+    static phantom(): PhantomReified<ToTypeStr<UpdateProtocolFeeShareBpEvent>> {
+        return phantom(UpdateProtocolFeeShareBpEvent.reified());
+    }
+    static get p() {
+        return UpdateProtocolFeeShareBpEvent.phantom();
+    }
+
+    static get bcs() {
+        return bcs.struct("UpdateProtocolFeeShareBpEvent", {
+            index: bcs.u64(),
+            previous_protocol_fee_share_bp: bcs.u64(),
+            new_protocol_fee_share_bp: bcs.u64(),
+            u64_padding: bcs.vector(bcs.u64()),
+        });
+    }
+
+    static fromFields(fields: Record<string, any>): UpdateProtocolFeeShareBpEvent {
+        return UpdateProtocolFeeShareBpEvent.reified().new({
+            index: decodeFromFields("u64", fields.index),
+            previousProtocolFeeShareBp: decodeFromFields("u64", fields.previous_protocol_fee_share_bp),
+            newProtocolFeeShareBp: decodeFromFields("u64", fields.new_protocol_fee_share_bp),
+            u64Padding: decodeFromFields(reified.vector("u64"), fields.u64_padding),
+        });
+    }
+
+    static fromFieldsWithTypes(item: FieldsWithTypes): UpdateProtocolFeeShareBpEvent {
+        if (!isUpdateProtocolFeeShareBpEvent(item.type)) {
+            throw new Error("not a UpdateProtocolFeeShareBpEvent type");
+        }
+
+        return UpdateProtocolFeeShareBpEvent.reified().new({
+            index: decodeFromFieldsWithTypes("u64", item.fields.index),
+            previousProtocolFeeShareBp: decodeFromFieldsWithTypes("u64", item.fields.previous_protocol_fee_share_bp),
+            newProtocolFeeShareBp: decodeFromFieldsWithTypes("u64", item.fields.new_protocol_fee_share_bp),
+            u64Padding: decodeFromFieldsWithTypes(reified.vector("u64"), item.fields.u64_padding),
+        });
+    }
+
+    static fromBcs(data: Uint8Array): UpdateProtocolFeeShareBpEvent {
+        return UpdateProtocolFeeShareBpEvent.fromFields(UpdateProtocolFeeShareBpEvent.bcs.parse(data));
+    }
+
+    toJSONField() {
+        return {
+            index: this.index.toString(),
+            previousProtocolFeeShareBp: this.previousProtocolFeeShareBp.toString(),
+            newProtocolFeeShareBp: this.newProtocolFeeShareBp.toString(),
+            u64Padding: fieldToJSON<Vector<"u64">>(`vector<u64>`, this.u64Padding),
+        };
+    }
+
+    toJSON() {
+        return { $typeName: this.$typeName, $typeArgs: this.$typeArgs, ...this.toJSONField() };
+    }
+
+    static fromJSONField(field: any): UpdateProtocolFeeShareBpEvent {
+        return UpdateProtocolFeeShareBpEvent.reified().new({
+            index: decodeFromJSONField("u64", field.index),
+            previousProtocolFeeShareBp: decodeFromJSONField("u64", field.previousProtocolFeeShareBp),
+            newProtocolFeeShareBp: decodeFromJSONField("u64", field.newProtocolFeeShareBp),
+            u64Padding: decodeFromJSONField(reified.vector("u64"), field.u64Padding),
+        });
+    }
+
+    static fromJSON(json: Record<string, any>): UpdateProtocolFeeShareBpEvent {
+        if (json.$typeName !== UpdateProtocolFeeShareBpEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+
+        return UpdateProtocolFeeShareBpEvent.fromJSONField(json);
+    }
+
+    static fromSuiParsedData(content: SuiParsedData): UpdateProtocolFeeShareBpEvent {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isUpdateProtocolFeeShareBpEvent(content.type)) {
+            throw new Error(`object at ${(content.fields as any).id} is not a UpdateProtocolFeeShareBpEvent object`);
+        }
+        return UpdateProtocolFeeShareBpEvent.fromFieldsWithTypes(content);
+    }
+
+    static async fetch(client: SuiClient, id: string): Promise<UpdateProtocolFeeShareBpEvent> {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching UpdateProtocolFeeShareBpEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isUpdateProtocolFeeShareBpEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a UpdateProtocolFeeShareBpEvent object`);
+        }
+        return UpdateProtocolFeeShareBpEvent.fromBcs(fromB64(res.data.bcs.bcsBytes));
+    }
+}