@allbridge/bridge-core-sdk 3.20.0 → 3.21.0

package/dist/src/services/models/sui/bridge/events/structs.js

@@ -0,0 +1,1430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithdrawEvent = exports.TokensSentEvent = exports.TokensReceivedEvent = exports.SwappedToVUsdEvent = exports.SwappedFromVUsdEvent = exports.SwappedEvent = exports.RewardsClaimedEvent = exports.ReceiveFeeEvent = exports.DepositEvent = void 0;
+exports.isDepositEvent = isDepositEvent;
+exports.isReceiveFeeEvent = isReceiveFeeEvent;
+exports.isRewardsClaimedEvent = isRewardsClaimedEvent;
+exports.isSwappedEvent = isSwappedEvent;
+exports.isSwappedFromVUsdEvent = isSwappedFromVUsdEvent;
+exports.isSwappedToVUsdEvent = isSwappedToVUsdEvent;
+exports.isTokensReceivedEvent = isTokensReceivedEvent;
+exports.isTokensSentEvent = isTokensSentEvent;
+exports.isWithdrawEvent = isWithdrawEvent;
+// @ts-nocheck
+const structs_1 = require("../../_dependencies/source/0x1/ascii/structs");
+const reified_1 = require("../../_framework/reified");
+const util_1 = require("../../_framework/util");
+const index_1 = require("../index");
+const bcs_1 = require("@mysten/sui/bcs");
+const utils_1 = require("@mysten/sui/utils");
+/* ============================== DepositEvent =============================== */
+function isDepositEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::DepositEvent`;
+}
+class DepositEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::DepositEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = DepositEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = DepositEvent.$isPhantom;
+    token;
+    amount;
+    lpAmount;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(DepositEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+        this.lpAmount = fields.lpAmount;
+    }
+    static reified() {
+        return {
+            typeName: DepositEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(DepositEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: DepositEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => DepositEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => DepositEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => DepositEvent.fromBcs(data),
+            bcs: DepositEvent.bcs,
+            fromJSONField: (field) => DepositEvent.fromJSONField(field),
+            fromJSON: (json) => DepositEvent.fromJSON(json),
+            fromSuiParsedData: (content) => DepositEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => DepositEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => DepositEvent.fetch(client, id),
+            new: (fields) => {
+                return new DepositEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return DepositEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(DepositEvent.reified());
+    }
+    static get p() {
+        return DepositEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("DepositEvent", {
+            token: structs_1.String.bcs,
+            amount: bcs_1.bcs.u64(),
+            lp_amount: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return DepositEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+            lpAmount: (0, reified_1.decodeFromFields)("u64", fields.lp_amount),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isDepositEvent(item.type)) {
+            throw new Error("not a DepositEvent type");
+        }
+        return DepositEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+            lpAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.lp_amount),
+        });
+    }
+    static fromBcs(data) {
+        return DepositEvent.fromFields(DepositEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+            lpAmount: this.lpAmount.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return DepositEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+            lpAmount: (0, reified_1.decodeFromJSONField)("u64", field.lpAmount),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== DepositEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return DepositEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isDepositEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a DepositEvent object`);
+        }
+        return DepositEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isDepositEvent(data.bcs.type)) {
+                throw new Error(`object at is not a DepositEvent object`);
+            }
+            return DepositEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return DepositEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching DepositEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isDepositEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a DepositEvent object`);
+        }
+        return DepositEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.DepositEvent = DepositEvent;
+/* ============================== ReceiveFeeEvent =============================== */
+function isReceiveFeeEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::ReceiveFeeEvent`;
+}
+class ReceiveFeeEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::ReceiveFeeEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = ReceiveFeeEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = ReceiveFeeEvent.$isPhantom;
+    userPaySui;
+    userPayStable;
+    totalPaySui;
+    bridgeFeeSui;
+    messengerFeeSui;
+    totalFeeSui;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(ReceiveFeeEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.userPaySui = fields.userPaySui;
+        this.userPayStable = fields.userPayStable;
+        this.totalPaySui = fields.totalPaySui;
+        this.bridgeFeeSui = fields.bridgeFeeSui;
+        this.messengerFeeSui = fields.messengerFeeSui;
+        this.totalFeeSui = fields.totalFeeSui;
+    }
+    static reified() {
+        return {
+            typeName: ReceiveFeeEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(ReceiveFeeEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: ReceiveFeeEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => ReceiveFeeEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => ReceiveFeeEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => ReceiveFeeEvent.fromBcs(data),
+            bcs: ReceiveFeeEvent.bcs,
+            fromJSONField: (field) => ReceiveFeeEvent.fromJSONField(field),
+            fromJSON: (json) => ReceiveFeeEvent.fromJSON(json),
+            fromSuiParsedData: (content) => ReceiveFeeEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => ReceiveFeeEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => ReceiveFeeEvent.fetch(client, id),
+            new: (fields) => {
+                return new ReceiveFeeEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return ReceiveFeeEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(ReceiveFeeEvent.reified());
+    }
+    static get p() {
+        return ReceiveFeeEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("ReceiveFeeEvent", {
+            user_pay_sui: bcs_1.bcs.u64(),
+            user_pay_stable: bcs_1.bcs.u64(),
+            total_pay_sui: bcs_1.bcs.u64(),
+            bridge_fee_sui: bcs_1.bcs.u64(),
+            messenger_fee_sui: bcs_1.bcs.u64(),
+            total_fee_sui: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return ReceiveFeeEvent.reified().new({
+            userPaySui: (0, reified_1.decodeFromFields)("u64", fields.user_pay_sui),
+            userPayStable: (0, reified_1.decodeFromFields)("u64", fields.user_pay_stable),
+            totalPaySui: (0, reified_1.decodeFromFields)("u64", fields.total_pay_sui),
+            bridgeFeeSui: (0, reified_1.decodeFromFields)("u64", fields.bridge_fee_sui),
+            messengerFeeSui: (0, reified_1.decodeFromFields)("u64", fields.messenger_fee_sui),
+            totalFeeSui: (0, reified_1.decodeFromFields)("u64", fields.total_fee_sui),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isReceiveFeeEvent(item.type)) {
+            throw new Error("not a ReceiveFeeEvent type");
+        }
+        return ReceiveFeeEvent.reified().new({
+            userPaySui: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.user_pay_sui),
+            userPayStable: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.user_pay_stable),
+            totalPaySui: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.total_pay_sui),
+            bridgeFeeSui: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.bridge_fee_sui),
+            messengerFeeSui: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.messenger_fee_sui),
+            totalFeeSui: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.total_fee_sui),
+        });
+    }
+    static fromBcs(data) {
+        return ReceiveFeeEvent.fromFields(ReceiveFeeEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            userPaySui: this.userPaySui.toString(),
+            userPayStable: this.userPayStable.toString(),
+            totalPaySui: this.totalPaySui.toString(),
+            bridgeFeeSui: this.bridgeFeeSui.toString(),
+            messengerFeeSui: this.messengerFeeSui.toString(),
+            totalFeeSui: this.totalFeeSui.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return ReceiveFeeEvent.reified().new({
+            userPaySui: (0, reified_1.decodeFromJSONField)("u64", field.userPaySui),
+            userPayStable: (0, reified_1.decodeFromJSONField)("u64", field.userPayStable),
+            totalPaySui: (0, reified_1.decodeFromJSONField)("u64", field.totalPaySui),
+            bridgeFeeSui: (0, reified_1.decodeFromJSONField)("u64", field.bridgeFeeSui),
+            messengerFeeSui: (0, reified_1.decodeFromJSONField)("u64", field.messengerFeeSui),
+            totalFeeSui: (0, reified_1.decodeFromJSONField)("u64", field.totalFeeSui),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== ReceiveFeeEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return ReceiveFeeEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isReceiveFeeEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a ReceiveFeeEvent object`);
+        }
+        return ReceiveFeeEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isReceiveFeeEvent(data.bcs.type)) {
+                throw new Error(`object at is not a ReceiveFeeEvent object`);
+            }
+            return ReceiveFeeEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return ReceiveFeeEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching ReceiveFeeEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isReceiveFeeEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a ReceiveFeeEvent object`);
+        }
+        return ReceiveFeeEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.ReceiveFeeEvent = ReceiveFeeEvent;
+/* ============================== RewardsClaimedEvent =============================== */
+function isRewardsClaimedEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::RewardsClaimedEvent`;
+}
+class RewardsClaimedEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::RewardsClaimedEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RewardsClaimedEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RewardsClaimedEvent.$isPhantom;
+    token;
+    amount;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(RewardsClaimedEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+    }
+    static reified() {
+        return {
+            typeName: RewardsClaimedEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(RewardsClaimedEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: RewardsClaimedEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RewardsClaimedEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => RewardsClaimedEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => RewardsClaimedEvent.fromBcs(data),
+            bcs: RewardsClaimedEvent.bcs,
+            fromJSONField: (field) => RewardsClaimedEvent.fromJSONField(field),
+            fromJSON: (json) => RewardsClaimedEvent.fromJSON(json),
+            fromSuiParsedData: (content) => RewardsClaimedEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => RewardsClaimedEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => RewardsClaimedEvent.fetch(client, id),
+            new: (fields) => {
+                return new RewardsClaimedEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return RewardsClaimedEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(RewardsClaimedEvent.reified());
+    }
+    static get p() {
+        return RewardsClaimedEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("RewardsClaimedEvent", {
+            token: structs_1.String.bcs,
+            amount: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return RewardsClaimedEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRewardsClaimedEvent(item.type)) {
+            throw new Error("not a RewardsClaimedEvent type");
+        }
+        return RewardsClaimedEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+        });
+    }
+    static fromBcs(data) {
+        return RewardsClaimedEvent.fromFields(RewardsClaimedEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return RewardsClaimedEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RewardsClaimedEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return RewardsClaimedEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isRewardsClaimedEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a RewardsClaimedEvent object`);
+        }
+        return RewardsClaimedEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isRewardsClaimedEvent(data.bcs.type)) {
+                throw new Error(`object at is not a RewardsClaimedEvent object`);
+            }
+            return RewardsClaimedEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return RewardsClaimedEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching RewardsClaimedEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isRewardsClaimedEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a RewardsClaimedEvent object`);
+        }
+        return RewardsClaimedEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.RewardsClaimedEvent = RewardsClaimedEvent;
+/* ============================== SwappedEvent =============================== */
+function isSwappedEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::SwappedEvent`;
+}
+class SwappedEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::SwappedEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = SwappedEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = SwappedEvent.$isPhantom;
+    tokenFrom;
+    tokenTo;
+    sentAmount;
+    receivedAmount;
+    sender;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(SwappedEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.tokenFrom = fields.tokenFrom;
+        this.tokenTo = fields.tokenTo;
+        this.sentAmount = fields.sentAmount;
+        this.receivedAmount = fields.receivedAmount;
+        this.sender = fields.sender;
+    }
+    static reified() {
+        return {
+            typeName: SwappedEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(SwappedEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: SwappedEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => SwappedEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => SwappedEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => SwappedEvent.fromBcs(data),
+            bcs: SwappedEvent.bcs,
+            fromJSONField: (field) => SwappedEvent.fromJSONField(field),
+            fromJSON: (json) => SwappedEvent.fromJSON(json),
+            fromSuiParsedData: (content) => SwappedEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => SwappedEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => SwappedEvent.fetch(client, id),
+            new: (fields) => {
+                return new SwappedEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return SwappedEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(SwappedEvent.reified());
+    }
+    static get p() {
+        return SwappedEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("SwappedEvent", {
+            token_from: structs_1.String.bcs,
+            token_to: structs_1.String.bcs,
+            sent_amount: bcs_1.bcs.u64(),
+            received_amount: bcs_1.bcs.u64(),
+            sender: bcs_1.bcs.bytes(32).transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }),
+        });
+    }
+    static fromFields(fields) {
+        return SwappedEvent.reified().new({
+            tokenFrom: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token_from),
+            tokenTo: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token_to),
+            sentAmount: (0, reified_1.decodeFromFields)("u64", fields.sent_amount),
+            receivedAmount: (0, reified_1.decodeFromFields)("u64", fields.received_amount),
+            sender: (0, reified_1.decodeFromFields)("address", fields.sender),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isSwappedEvent(item.type)) {
+            throw new Error("not a SwappedEvent type");
+        }
+        return SwappedEvent.reified().new({
+            tokenFrom: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token_from),
+            tokenTo: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token_to),
+            sentAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.sent_amount),
+            receivedAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.received_amount),
+            sender: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.sender),
+        });
+    }
+    static fromBcs(data) {
+        return SwappedEvent.fromFields(SwappedEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            tokenFrom: this.tokenFrom,
+            tokenTo: this.tokenTo,
+            sentAmount: this.sentAmount.toString(),
+            receivedAmount: this.receivedAmount.toString(),
+            sender: this.sender,
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return SwappedEvent.reified().new({
+            tokenFrom: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.tokenFrom),
+            tokenTo: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.tokenTo),
+            sentAmount: (0, reified_1.decodeFromJSONField)("u64", field.sentAmount),
+            receivedAmount: (0, reified_1.decodeFromJSONField)("u64", field.receivedAmount),
+            sender: (0, reified_1.decodeFromJSONField)("address", field.sender),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== SwappedEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return SwappedEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSwappedEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a SwappedEvent object`);
+        }
+        return SwappedEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isSwappedEvent(data.bcs.type)) {
+                throw new Error(`object at is not a SwappedEvent object`);
+            }
+            return SwappedEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return SwappedEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SwappedEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSwappedEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SwappedEvent object`);
+        }
+        return SwappedEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.SwappedEvent = SwappedEvent;
+/* ============================== SwappedFromVUsdEvent =============================== */
+function isSwappedFromVUsdEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::SwappedFromVUsdEvent`;
+}
+class SwappedFromVUsdEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::SwappedFromVUsdEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = SwappedFromVUsdEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = SwappedFromVUsdEvent.$isPhantom;
+    token;
+    amount;
+    vusdAmount;
+    fee;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(SwappedFromVUsdEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+        this.vusdAmount = fields.vusdAmount;
+        this.fee = fields.fee;
+    }
+    static reified() {
+        return {
+            typeName: SwappedFromVUsdEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(SwappedFromVUsdEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: SwappedFromVUsdEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => SwappedFromVUsdEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => SwappedFromVUsdEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => SwappedFromVUsdEvent.fromBcs(data),
+            bcs: SwappedFromVUsdEvent.bcs,
+            fromJSONField: (field) => SwappedFromVUsdEvent.fromJSONField(field),
+            fromJSON: (json) => SwappedFromVUsdEvent.fromJSON(json),
+            fromSuiParsedData: (content) => SwappedFromVUsdEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => SwappedFromVUsdEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => SwappedFromVUsdEvent.fetch(client, id),
+            new: (fields) => {
+                return new SwappedFromVUsdEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return SwappedFromVUsdEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(SwappedFromVUsdEvent.reified());
+    }
+    static get p() {
+        return SwappedFromVUsdEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("SwappedFromVUsdEvent", {
+            token: structs_1.String.bcs,
+            amount: bcs_1.bcs.u64(),
+            vusd_amount: bcs_1.bcs.u64(),
+            fee: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return SwappedFromVUsdEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+            vusdAmount: (0, reified_1.decodeFromFields)("u64", fields.vusd_amount),
+            fee: (0, reified_1.decodeFromFields)("u64", fields.fee),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isSwappedFromVUsdEvent(item.type)) {
+            throw new Error("not a SwappedFromVUsdEvent type");
+        }
+        return SwappedFromVUsdEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+            vusdAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.vusd_amount),
+            fee: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.fee),
+        });
+    }
+    static fromBcs(data) {
+        return SwappedFromVUsdEvent.fromFields(SwappedFromVUsdEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+            vusdAmount: this.vusdAmount.toString(),
+            fee: this.fee.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return SwappedFromVUsdEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+            vusdAmount: (0, reified_1.decodeFromJSONField)("u64", field.vusdAmount),
+            fee: (0, reified_1.decodeFromJSONField)("u64", field.fee),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== SwappedFromVUsdEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return SwappedFromVUsdEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSwappedFromVUsdEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a SwappedFromVUsdEvent object`);
+        }
+        return SwappedFromVUsdEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isSwappedFromVUsdEvent(data.bcs.type)) {
+                throw new Error(`object at is not a SwappedFromVUsdEvent object`);
+            }
+            return SwappedFromVUsdEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return SwappedFromVUsdEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SwappedFromVUsdEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSwappedFromVUsdEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SwappedFromVUsdEvent object`);
+        }
+        return SwappedFromVUsdEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.SwappedFromVUsdEvent = SwappedFromVUsdEvent;
+/* ============================== SwappedToVUsdEvent =============================== */
+function isSwappedToVUsdEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::SwappedToVUsdEvent`;
+}
+class SwappedToVUsdEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::SwappedToVUsdEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = SwappedToVUsdEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = SwappedToVUsdEvent.$isPhantom;
+    token;
+    amount;
+    vusdAmount;
+    fee;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(SwappedToVUsdEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+        this.vusdAmount = fields.vusdAmount;
+        this.fee = fields.fee;
+    }
+    static reified() {
+        return {
+            typeName: SwappedToVUsdEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(SwappedToVUsdEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: SwappedToVUsdEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => SwappedToVUsdEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => SwappedToVUsdEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => SwappedToVUsdEvent.fromBcs(data),
+            bcs: SwappedToVUsdEvent.bcs,
+            fromJSONField: (field) => SwappedToVUsdEvent.fromJSONField(field),
+            fromJSON: (json) => SwappedToVUsdEvent.fromJSON(json),
+            fromSuiParsedData: (content) => SwappedToVUsdEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => SwappedToVUsdEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => SwappedToVUsdEvent.fetch(client, id),
+            new: (fields) => {
+                return new SwappedToVUsdEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return SwappedToVUsdEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(SwappedToVUsdEvent.reified());
+    }
+    static get p() {
+        return SwappedToVUsdEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("SwappedToVUsdEvent", {
+            token: structs_1.String.bcs,
+            amount: bcs_1.bcs.u64(),
+            vusd_amount: bcs_1.bcs.u64(),
+            fee: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return SwappedToVUsdEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+            vusdAmount: (0, reified_1.decodeFromFields)("u64", fields.vusd_amount),
+            fee: (0, reified_1.decodeFromFields)("u64", fields.fee),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isSwappedToVUsdEvent(item.type)) {
+            throw new Error("not a SwappedToVUsdEvent type");
+        }
+        return SwappedToVUsdEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+            vusdAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.vusd_amount),
+            fee: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.fee),
+        });
+    }
+    static fromBcs(data) {
+        return SwappedToVUsdEvent.fromFields(SwappedToVUsdEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+            vusdAmount: this.vusdAmount.toString(),
+            fee: this.fee.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return SwappedToVUsdEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+            vusdAmount: (0, reified_1.decodeFromJSONField)("u64", field.vusdAmount),
+            fee: (0, reified_1.decodeFromJSONField)("u64", field.fee),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== SwappedToVUsdEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return SwappedToVUsdEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isSwappedToVUsdEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a SwappedToVUsdEvent object`);
+        }
+        return SwappedToVUsdEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isSwappedToVUsdEvent(data.bcs.type)) {
+                throw new Error(`object at is not a SwappedToVUsdEvent object`);
+            }
+            return SwappedToVUsdEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return SwappedToVUsdEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching SwappedToVUsdEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isSwappedToVUsdEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a SwappedToVUsdEvent object`);
+        }
+        return SwappedToVUsdEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.SwappedToVUsdEvent = SwappedToVUsdEvent;
+/* ============================== TokensReceivedEvent =============================== */
+function isTokensReceivedEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::TokensReceivedEvent`;
+}
+class TokensReceivedEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::TokensReceivedEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = TokensReceivedEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = TokensReceivedEvent.$isPhantom;
+    token;
+    amount;
+    extraGasAmount;
+    recipient;
+    nonce;
+    messenger;
+    message;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(TokensReceivedEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+        this.extraGasAmount = fields.extraGasAmount;
+        this.recipient = fields.recipient;
+        this.nonce = fields.nonce;
+        this.messenger = fields.messenger;
+        this.message = fields.message;
+    }
+    static reified() {
+        return {
+            typeName: TokensReceivedEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(TokensReceivedEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: TokensReceivedEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => TokensReceivedEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => TokensReceivedEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => TokensReceivedEvent.fromBcs(data),
+            bcs: TokensReceivedEvent.bcs,
+            fromJSONField: (field) => TokensReceivedEvent.fromJSONField(field),
+            fromJSON: (json) => TokensReceivedEvent.fromJSON(json),
+            fromSuiParsedData: (content) => TokensReceivedEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => TokensReceivedEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => TokensReceivedEvent.fetch(client, id),
+            new: (fields) => {
+                return new TokensReceivedEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return TokensReceivedEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(TokensReceivedEvent.reified());
+    }
+    static get p() {
+        return TokensReceivedEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("TokensReceivedEvent", {
+            token: structs_1.String.bcs,
+            amount: bcs_1.bcs.u64(),
+            extra_gas_amount: bcs_1.bcs.u64(),
+            recipient: bcs_1.bcs.bytes(32).transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }),
+            nonce: bcs_1.bcs.u256(),
+            messenger: bcs_1.bcs.u8(),
+            message: structs_1.String.bcs,
+        });
+    }
+    static fromFields(fields) {
+        return TokensReceivedEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+            extraGasAmount: (0, reified_1.decodeFromFields)("u64", fields.extra_gas_amount),
+            recipient: (0, reified_1.decodeFromFields)("address", fields.recipient),
+            nonce: (0, reified_1.decodeFromFields)("u256", fields.nonce),
+            messenger: (0, reified_1.decodeFromFields)("u8", fields.messenger),
+            message: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.message),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isTokensReceivedEvent(item.type)) {
+            throw new Error("not a TokensReceivedEvent type");
+        }
+        return TokensReceivedEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+            extraGasAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.extra_gas_amount),
+            recipient: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.recipient),
+            nonce: (0, reified_1.decodeFromFieldsWithTypes)("u256", item.fields.nonce),
+            messenger: (0, reified_1.decodeFromFieldsWithTypes)("u8", item.fields.messenger),
+            message: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.message),
+        });
+    }
+    static fromBcs(data) {
+        return TokensReceivedEvent.fromFields(TokensReceivedEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+            extraGasAmount: this.extraGasAmount.toString(),
+            recipient: this.recipient,
+            nonce: this.nonce.toString(),
+            messenger: this.messenger,
+            message: this.message,
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return TokensReceivedEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+            extraGasAmount: (0, reified_1.decodeFromJSONField)("u64", field.extraGasAmount),
+            recipient: (0, reified_1.decodeFromJSONField)("address", field.recipient),
+            nonce: (0, reified_1.decodeFromJSONField)("u256", field.nonce),
+            messenger: (0, reified_1.decodeFromJSONField)("u8", field.messenger),
+            message: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.message),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== TokensReceivedEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return TokensReceivedEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTokensReceivedEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a TokensReceivedEvent object`);
+        }
+        return TokensReceivedEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isTokensReceivedEvent(data.bcs.type)) {
+                throw new Error(`object at is not a TokensReceivedEvent object`);
+            }
+            return TokensReceivedEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return TokensReceivedEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching TokensReceivedEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTokensReceivedEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a TokensReceivedEvent object`);
+        }
+        return TokensReceivedEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.TokensReceivedEvent = TokensReceivedEvent;
+/* ============================== TokensSentEvent =============================== */
+function isTokensSentEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::TokensSentEvent`;
+}
+class TokensSentEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::TokensSentEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = TokensSentEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = TokensSentEvent.$isPhantom;
+    token;
+    vusdAmount;
+    sender;
+    recipient;
+    destinationChainId;
+    receiveToken;
+    nonce;
+    messenger;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(TokensSentEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.vusdAmount = fields.vusdAmount;
+        this.sender = fields.sender;
+        this.recipient = fields.recipient;
+        this.destinationChainId = fields.destinationChainId;
+        this.receiveToken = fields.receiveToken;
+        this.nonce = fields.nonce;
+        this.messenger = fields.messenger;
+    }
+    static reified() {
+        return {
+            typeName: TokensSentEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(TokensSentEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: TokensSentEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => TokensSentEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => TokensSentEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => TokensSentEvent.fromBcs(data),
+            bcs: TokensSentEvent.bcs,
+            fromJSONField: (field) => TokensSentEvent.fromJSONField(field),
+            fromJSON: (json) => TokensSentEvent.fromJSON(json),
+            fromSuiParsedData: (content) => TokensSentEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => TokensSentEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => TokensSentEvent.fetch(client, id),
+            new: (fields) => {
+                return new TokensSentEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return TokensSentEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(TokensSentEvent.reified());
+    }
+    static get p() {
+        return TokensSentEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("TokensSentEvent", {
+            token: structs_1.String.bcs,
+            vusd_amount: bcs_1.bcs.u64(),
+            sender: bcs_1.bcs.bytes(32).transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }),
+            recipient: structs_1.String.bcs,
+            destination_chain_id: bcs_1.bcs.u8(),
+            receive_token: structs_1.String.bcs,
+            nonce: bcs_1.bcs.u256(),
+            messenger: bcs_1.bcs.u8(),
+        });
+    }
+    static fromFields(fields) {
+        return TokensSentEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            vusdAmount: (0, reified_1.decodeFromFields)("u64", fields.vusd_amount),
+            sender: (0, reified_1.decodeFromFields)("address", fields.sender),
+            recipient: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.recipient),
+            destinationChainId: (0, reified_1.decodeFromFields)("u8", fields.destination_chain_id),
+            receiveToken: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.receive_token),
+            nonce: (0, reified_1.decodeFromFields)("u256", fields.nonce),
+            messenger: (0, reified_1.decodeFromFields)("u8", fields.messenger),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isTokensSentEvent(item.type)) {
+            throw new Error("not a TokensSentEvent type");
+        }
+        return TokensSentEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            vusdAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.vusd_amount),
+            sender: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.sender),
+            recipient: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.recipient),
+            destinationChainId: (0, reified_1.decodeFromFieldsWithTypes)("u8", item.fields.destination_chain_id),
+            receiveToken: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.receive_token),
+            nonce: (0, reified_1.decodeFromFieldsWithTypes)("u256", item.fields.nonce),
+            messenger: (0, reified_1.decodeFromFieldsWithTypes)("u8", item.fields.messenger),
+        });
+    }
+    static fromBcs(data) {
+        return TokensSentEvent.fromFields(TokensSentEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            vusdAmount: this.vusdAmount.toString(),
+            sender: this.sender,
+            recipient: this.recipient,
+            destinationChainId: this.destinationChainId,
+            receiveToken: this.receiveToken,
+            nonce: this.nonce.toString(),
+            messenger: this.messenger,
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return TokensSentEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            vusdAmount: (0, reified_1.decodeFromJSONField)("u64", field.vusdAmount),
+            sender: (0, reified_1.decodeFromJSONField)("address", field.sender),
+            recipient: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.recipient),
+            destinationChainId: (0, reified_1.decodeFromJSONField)("u8", field.destinationChainId),
+            receiveToken: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.receiveToken),
+            nonce: (0, reified_1.decodeFromJSONField)("u256", field.nonce),
+            messenger: (0, reified_1.decodeFromJSONField)("u8", field.messenger),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== TokensSentEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return TokensSentEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isTokensSentEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a TokensSentEvent object`);
+        }
+        return TokensSentEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isTokensSentEvent(data.bcs.type)) {
+                throw new Error(`object at is not a TokensSentEvent object`);
+            }
+            return TokensSentEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return TokensSentEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching TokensSentEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isTokensSentEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a TokensSentEvent object`);
+        }
+        return TokensSentEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.TokensSentEvent = TokensSentEvent;
+/* ============================== WithdrawEvent =============================== */
+function isWithdrawEvent(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::WithdrawEvent`;
+}
+class WithdrawEvent {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::WithdrawEvent`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = WithdrawEvent.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = WithdrawEvent.$isPhantom;
+    token;
+    amount;
+    lpAmount;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(WithdrawEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+        this.lpAmount = fields.lpAmount;
+    }
+    static reified() {
+        return {
+            typeName: WithdrawEvent.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(WithdrawEvent.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: WithdrawEvent.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => WithdrawEvent.fromFields(fields),
+            fromFieldsWithTypes: (item) => WithdrawEvent.fromFieldsWithTypes(item),
+            fromBcs: (data) => WithdrawEvent.fromBcs(data),
+            bcs: WithdrawEvent.bcs,
+            fromJSONField: (field) => WithdrawEvent.fromJSONField(field),
+            fromJSON: (json) => WithdrawEvent.fromJSON(json),
+            fromSuiParsedData: (content) => WithdrawEvent.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => WithdrawEvent.fromSuiObjectData(content),
+            fetch: async (client, id) => WithdrawEvent.fetch(client, id),
+            new: (fields) => {
+                return new WithdrawEvent([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return WithdrawEvent.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(WithdrawEvent.reified());
+    }
+    static get p() {
+        return WithdrawEvent.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("WithdrawEvent", {
+            token: structs_1.String.bcs,
+            amount: bcs_1.bcs.u64(),
+            lp_amount: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return WithdrawEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+            lpAmount: (0, reified_1.decodeFromFields)("u64", fields.lp_amount),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isWithdrawEvent(item.type)) {
+            throw new Error("not a WithdrawEvent type");
+        }
+        return WithdrawEvent.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+            lpAmount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.lp_amount),
+        });
+    }
+    static fromBcs(data) {
+        return WithdrawEvent.fromFields(WithdrawEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+            lpAmount: this.lpAmount.toString(),
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return WithdrawEvent.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+            lpAmount: (0, reified_1.decodeFromJSONField)("u64", field.lpAmount),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== WithdrawEvent.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return WithdrawEvent.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isWithdrawEvent(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a WithdrawEvent object`);
+        }
+        return WithdrawEvent.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isWithdrawEvent(data.bcs.type)) {
+                throw new Error(`object at is not a WithdrawEvent object`);
+            }
+            return WithdrawEvent.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return WithdrawEvent.fromSuiParsedData(data.content);
+        }
+        throw new Error("Both `bcs` and `content` fields are missing from the data. Include `showBcs` or `showContent` in the request.");
+    }
+    static async fetch(client, id) {
+        const res = await client.getObject({ id, options: { showBcs: true } });
+        if (res.error) {
+            throw new Error(`error fetching WithdrawEvent object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isWithdrawEvent(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a WithdrawEvent object`);
+        }
+        return WithdrawEvent.fromSuiObjectData(res.data);
+    }
+}
+exports.WithdrawEvent = WithdrawEvent;
+//# sourceMappingURL=structs.js.map