@allbridge/bridge-core-sdk 3.20.0 → 3.21.0-alpha.1

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

@@ -0,0 +1,656 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecipientReplaced = exports.TokensSentEvent = exports.TokensReceivedEvent = exports.ReceiveFeeEvent = void 0;
+exports.isReceiveFeeEvent = isReceiveFeeEvent;
+exports.isTokensReceivedEvent = isTokensReceivedEvent;
+exports.isTokensSentEvent = isTokensSentEvent;
+exports.isRecipientReplaced = isRecipientReplaced;
+// @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");
+/* ============================== 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;
+    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.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(),
+            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),
+            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),
+            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(),
+            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),
+            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;
+/* ============================== 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;
+    message;
+    recipient;
+    extraGasValue;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(TokensReceivedEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.message = fields.message;
+        this.recipient = fields.recipient;
+        this.extraGasValue = fields.extraGasValue;
+    }
+    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,
+            message: structs_1.String.bcs,
+            recipient: bcs_1.bcs.bytes(32).transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }),
+            extra_gas_value: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return TokensReceivedEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            message: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.message),
+            recipient: (0, reified_1.decodeFromFields)("address", fields.recipient),
+            extraGasValue: (0, reified_1.decodeFromFields)("u64", fields.extra_gas_value),
+        });
+    }
+    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),
+            message: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.message),
+            recipient: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.recipient),
+            extraGasValue: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.extra_gas_value),
+        });
+    }
+    static fromBcs(data) {
+        return TokensReceivedEvent.fromFields(TokensReceivedEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            message: this.message,
+            recipient: this.recipient,
+            extraGasValue: this.extraGasValue.toString(),
+        };
+    }
+    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),
+            message: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.message),
+            recipient: (0, reified_1.decodeFromJSONField)("address", field.recipient),
+            extraGasValue: (0, reified_1.decodeFromJSONField)("u64", field.extraGasValue),
+        });
+    }
+    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;
+    amount;
+    adminFee;
+    sender;
+    recipient;
+    recipientWalletAddress;
+    destinationChainId;
+    nonce;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(TokensSentEvent.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.amount = fields.amount;
+        this.adminFee = fields.adminFee;
+        this.sender = fields.sender;
+        this.recipient = fields.recipient;
+        this.recipientWalletAddress = fields.recipientWalletAddress;
+        this.destinationChainId = fields.destinationChainId;
+        this.nonce = fields.nonce;
+    }
+    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,
+            amount: bcs_1.bcs.u64(),
+            admin_fee: 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,
+            recipient_wallet_address: structs_1.String.bcs,
+            destination_chain_id: bcs_1.bcs.u8(),
+            nonce: bcs_1.bcs.u64(),
+        });
+    }
+    static fromFields(fields) {
+        return TokensSentEvent.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            amount: (0, reified_1.decodeFromFields)("u64", fields.amount),
+            adminFee: (0, reified_1.decodeFromFields)("u64", fields.admin_fee),
+            sender: (0, reified_1.decodeFromFields)("address", fields.sender),
+            recipient: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.recipient),
+            recipientWalletAddress: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.recipient_wallet_address),
+            destinationChainId: (0, reified_1.decodeFromFields)("u8", fields.destination_chain_id),
+            nonce: (0, reified_1.decodeFromFields)("u64", fields.nonce),
+        });
+    }
+    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),
+            amount: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.amount),
+            adminFee: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.admin_fee),
+            sender: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.sender),
+            recipient: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.recipient),
+            recipientWalletAddress: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.recipient_wallet_address),
+            destinationChainId: (0, reified_1.decodeFromFieldsWithTypes)("u8", item.fields.destination_chain_id),
+            nonce: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.nonce),
+        });
+    }
+    static fromBcs(data) {
+        return TokensSentEvent.fromFields(TokensSentEvent.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            amount: this.amount.toString(),
+            adminFee: this.adminFee.toString(),
+            sender: this.sender,
+            recipient: this.recipient,
+            recipientWalletAddress: this.recipientWalletAddress,
+            destinationChainId: this.destinationChainId,
+            nonce: this.nonce.toString(),
+        };
+    }
+    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),
+            amount: (0, reified_1.decodeFromJSONField)("u64", field.amount),
+            adminFee: (0, reified_1.decodeFromJSONField)("u64", field.adminFee),
+            sender: (0, reified_1.decodeFromJSONField)("address", field.sender),
+            recipient: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.recipient),
+            recipientWalletAddress: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.recipientWalletAddress),
+            destinationChainId: (0, reified_1.decodeFromJSONField)("u8", field.destinationChainId),
+            nonce: (0, reified_1.decodeFromJSONField)("u64", field.nonce),
+        });
+    }
+    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;
+/* ============================== RecipientReplaced =============================== */
+function isRecipientReplaced(type) {
+    type = (0, util_1.compressSuiType)(type);
+    return type === `${index_1.PKG_V1}::events::RecipientReplaced`;
+}
+class RecipientReplaced {
+    __StructClass = true;
+    static get $typeName() {
+        return `${index_1.PKG_V1}::events::RecipientReplaced`;
+    }
+    static $numTypeParams = 0;
+    static $isPhantom = [];
+    $typeName = RecipientReplaced.$typeName;
+    $fullTypeName;
+    $typeArgs;
+    $isPhantom = RecipientReplaced.$isPhantom;
+    token;
+    sender;
+    nonce;
+    newRecipitne;
+    constructor(typeArgs, fields) {
+        this.$fullTypeName = (0, util_1.composeSuiType)(RecipientReplaced.$typeName, ...typeArgs);
+        this.$typeArgs = typeArgs;
+        this.token = fields.token;
+        this.sender = fields.sender;
+        this.nonce = fields.nonce;
+        this.newRecipitne = fields.newRecipitne;
+    }
+    static reified() {
+        return {
+            typeName: RecipientReplaced.$typeName,
+            fullTypeName: (0, util_1.composeSuiType)(RecipientReplaced.$typeName, ...[]),
+            typeArgs: [],
+            isPhantom: RecipientReplaced.$isPhantom,
+            reifiedTypeArgs: [],
+            fromFields: (fields) => RecipientReplaced.fromFields(fields),
+            fromFieldsWithTypes: (item) => RecipientReplaced.fromFieldsWithTypes(item),
+            fromBcs: (data) => RecipientReplaced.fromBcs(data),
+            bcs: RecipientReplaced.bcs,
+            fromJSONField: (field) => RecipientReplaced.fromJSONField(field),
+            fromJSON: (json) => RecipientReplaced.fromJSON(json),
+            fromSuiParsedData: (content) => RecipientReplaced.fromSuiParsedData(content),
+            fromSuiObjectData: (content) => RecipientReplaced.fromSuiObjectData(content),
+            fetch: async (client, id) => RecipientReplaced.fetch(client, id),
+            new: (fields) => {
+                return new RecipientReplaced([], fields);
+            },
+            kind: "StructClassReified",
+        };
+    }
+    static get r() {
+        return RecipientReplaced.reified();
+    }
+    static phantom() {
+        return (0, reified_1.phantom)(RecipientReplaced.reified());
+    }
+    static get p() {
+        return RecipientReplaced.phantom();
+    }
+    static get bcs() {
+        return bcs_1.bcs.struct("RecipientReplaced", {
+            token: structs_1.String.bcs,
+            sender: bcs_1.bcs.bytes(32).transform({
+                input: (val) => (0, utils_1.fromHEX)(val),
+                output: (val) => (0, utils_1.toHEX)(val),
+            }),
+            nonce: bcs_1.bcs.u64(),
+            new_recipitne: structs_1.String.bcs,
+        });
+    }
+    static fromFields(fields) {
+        return RecipientReplaced.reified().new({
+            token: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.token),
+            sender: (0, reified_1.decodeFromFields)("address", fields.sender),
+            nonce: (0, reified_1.decodeFromFields)("u64", fields.nonce),
+            newRecipitne: (0, reified_1.decodeFromFields)(structs_1.String.reified(), fields.new_recipitne),
+        });
+    }
+    static fromFieldsWithTypes(item) {
+        if (!isRecipientReplaced(item.type)) {
+            throw new Error("not a RecipientReplaced type");
+        }
+        return RecipientReplaced.reified().new({
+            token: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.token),
+            sender: (0, reified_1.decodeFromFieldsWithTypes)("address", item.fields.sender),
+            nonce: (0, reified_1.decodeFromFieldsWithTypes)("u64", item.fields.nonce),
+            newRecipitne: (0, reified_1.decodeFromFieldsWithTypes)(structs_1.String.reified(), item.fields.new_recipitne),
+        });
+    }
+    static fromBcs(data) {
+        return RecipientReplaced.fromFields(RecipientReplaced.bcs.parse(data));
+    }
+    toJSONField() {
+        return {
+            token: this.token,
+            sender: this.sender,
+            nonce: this.nonce.toString(),
+            newRecipitne: this.newRecipitne,
+        };
+    }
+    toJSON() {
+        return {
+            $typeName: this.$typeName,
+            $typeArgs: this.$typeArgs,
+            ...this.toJSONField(),
+        };
+    }
+    static fromJSONField(field) {
+        return RecipientReplaced.reified().new({
+            token: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.token),
+            sender: (0, reified_1.decodeFromJSONField)("address", field.sender),
+            nonce: (0, reified_1.decodeFromJSONField)("u64", field.nonce),
+            newRecipitne: (0, reified_1.decodeFromJSONField)(structs_1.String.reified(), field.newRecipitne),
+        });
+    }
+    static fromJSON(json) {
+        if (json.$typeName !== RecipientReplaced.$typeName) {
+            throw new Error("not a WithTwoGenerics json object");
+        }
+        return RecipientReplaced.fromJSONField(json);
+    }
+    static fromSuiParsedData(content) {
+        if (content.dataType !== "moveObject") {
+            throw new Error("not an object");
+        }
+        if (!isRecipientReplaced(content.type)) {
+            throw new Error(`object at ${content.fields.id} is not a RecipientReplaced object`);
+        }
+        return RecipientReplaced.fromFieldsWithTypes(content);
+    }
+    static fromSuiObjectData(data) {
+        if (data.bcs) {
+            if (data.bcs.dataType !== "moveObject" || !isRecipientReplaced(data.bcs.type)) {
+                throw new Error(`object at is not a RecipientReplaced object`);
+            }
+            return RecipientReplaced.fromBcs((0, utils_1.fromB64)(data.bcs.bcsBytes));
+        }
+        if (data.content) {
+            return RecipientReplaced.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 RecipientReplaced object at id ${id}: ${res.error.code}`);
+        }
+        if (res.data?.bcs?.dataType !== "moveObject" || !isRecipientReplaced(res.data.bcs.type)) {
+            throw new Error(`object at id ${id} is not a RecipientReplaced object`);
+        }
+        return RecipientReplaced.fromSuiObjectData(res.data);
+    }
+}
+exports.RecipientReplaced = RecipientReplaced;
+//# sourceMappingURL=structs.js.map