@pushchain/core 5.0.0 → 5.1.0

package/src/lib/generated/uexecutor/v2/types.js

@@ -0,0 +1,660 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniversalTxV2Codec = exports.OutboundTxV2Codec = exports.RevertInstructions = exports.OutboundObservation = exports.OriginatingPcTx = exports.OutboundStatus = exports.TxType = exports.PCTx = exports.Inbound = exports.UniversalPayload = exports.universalTxStatusToJSON = exports.universalTxStatusFromJSON = exports.UniversalTxStatus = exports.verificationTypeToJSON = exports.verificationTypeFromJSON = exports.VerificationType = exports.protobufPackage = void 0;
+exports.txTypeFromJSON = txTypeFromJSON;
+exports.txTypeToJSON = txTypeToJSON;
+exports.outboundStatusFromJSON = outboundStatusFromJSON;
+exports.outboundStatusToJSON = outboundStatusToJSON;
+// Code generated to match uexecutor/v1/types.proto with expanded OutboundTx
+// This provides v2 types with full OutboundTx fields and repeated outbound_tx array
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+exports.protobufPackage = 'uexecutor.v2';
+// Re-export enums from v1 that are unchanged
+var types_1 = require("../v1/types");
+Object.defineProperty(exports, "VerificationType", { enumerable: true, get: function () { return types_1.VerificationType; } });
+Object.defineProperty(exports, "verificationTypeFromJSON", { enumerable: true, get: function () { return types_1.verificationTypeFromJSON; } });
+Object.defineProperty(exports, "verificationTypeToJSON", { enumerable: true, get: function () { return types_1.verificationTypeToJSON; } });
+Object.defineProperty(exports, "UniversalTxStatus", { enumerable: true, get: function () { return types_1.UniversalTxStatus; } });
+Object.defineProperty(exports, "universalTxStatusFromJSON", { enumerable: true, get: function () { return types_1.universalTxStatusFromJSON; } });
+Object.defineProperty(exports, "universalTxStatusToJSON", { enumerable: true, get: function () { return types_1.universalTxStatusToJSON; } });
+// Import types from v1 that are unchanged
+const types_2 = require("../v1/types");
+Object.defineProperty(exports, "UniversalPayload", { enumerable: true, get: function () { return types_2.UniversalPayload; } });
+Object.defineProperty(exports, "Inbound", { enumerable: true, get: function () { return types_2.Inbound; } });
+Object.defineProperty(exports, "PCTx", { enumerable: true, get: function () { return types_2.PCTx; } });
+/**
+ * TxType enum for outbound transaction types
+ * Matches chain proto: uexecutor/v1/types.proto TxType
+ */
+var TxType;
+(function (TxType) {
+    TxType[TxType["UNSPECIFIED_TX"] = 0] = "UNSPECIFIED_TX";
+    TxType[TxType["GAS"] = 1] = "GAS";
+    TxType[TxType["GAS_AND_PAYLOAD"] = 2] = "GAS_AND_PAYLOAD";
+    TxType[TxType["FUNDS"] = 3] = "FUNDS";
+    TxType[TxType["FUNDS_AND_PAYLOAD"] = 4] = "FUNDS_AND_PAYLOAD";
+    TxType[TxType["PAYLOAD"] = 5] = "PAYLOAD";
+    TxType[TxType["INBOUND_REVERT"] = 6] = "INBOUND_REVERT";
+    TxType[TxType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(TxType || (exports.TxType = TxType = {}));
+function txTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case 'UNSPECIFIED_TX':
+            return TxType.UNSPECIFIED_TX;
+        case 1:
+        case 'GAS':
+            return TxType.GAS;
+        case 2:
+        case 'GAS_AND_PAYLOAD':
+            return TxType.GAS_AND_PAYLOAD;
+        case 3:
+        case 'FUNDS':
+            return TxType.FUNDS;
+        case 4:
+        case 'FUNDS_AND_PAYLOAD':
+            return TxType.FUNDS_AND_PAYLOAD;
+        case 5:
+        case 'PAYLOAD':
+            return TxType.PAYLOAD;
+        case 6:
+        case 'INBOUND_REVERT':
+            return TxType.INBOUND_REVERT;
+        case -1:
+        case 'UNRECOGNIZED':
+        default:
+            return TxType.UNRECOGNIZED;
+    }
+}
+function txTypeToJSON(object) {
+    switch (object) {
+        case TxType.UNSPECIFIED_TX:
+            return 'UNSPECIFIED_TX';
+        case TxType.GAS:
+            return 'GAS';
+        case TxType.GAS_AND_PAYLOAD:
+            return 'GAS_AND_PAYLOAD';
+        case TxType.FUNDS:
+            return 'FUNDS';
+        case TxType.FUNDS_AND_PAYLOAD:
+            return 'FUNDS_AND_PAYLOAD';
+        case TxType.PAYLOAD:
+            return 'PAYLOAD';
+        case TxType.INBOUND_REVERT:
+            return 'INBOUND_REVERT';
+        case TxType.UNRECOGNIZED:
+        default:
+            return 'UNRECOGNIZED';
+    }
+}
+/**
+ * OutboundStatus enum for outbound transaction status
+ */
+var OutboundStatus;
+(function (OutboundStatus) {
+    OutboundStatus[OutboundStatus["OUTBOUND_STATUS_UNSPECIFIED"] = 0] = "OUTBOUND_STATUS_UNSPECIFIED";
+    OutboundStatus[OutboundStatus["PENDING"] = 1] = "PENDING";
+    OutboundStatus[OutboundStatus["OBSERVED"] = 2] = "OBSERVED";
+    OutboundStatus[OutboundStatus["REVERTED"] = 3] = "REVERTED";
+    OutboundStatus[OutboundStatus["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(OutboundStatus || (exports.OutboundStatus = OutboundStatus = {}));
+function outboundStatusFromJSON(object) {
+    switch (object) {
+        case 0:
+        case 'OUTBOUND_STATUS_UNSPECIFIED':
+            return OutboundStatus.OUTBOUND_STATUS_UNSPECIFIED;
+        case 1:
+        case 'PENDING':
+            return OutboundStatus.PENDING;
+        case 2:
+        case 'OBSERVED':
+            return OutboundStatus.OBSERVED;
+        case 3:
+        case 'REVERTED':
+            return OutboundStatus.REVERTED;
+        case -1:
+        case 'UNRECOGNIZED':
+        default:
+            return OutboundStatus.UNRECOGNIZED;
+    }
+}
+function outboundStatusToJSON(object) {
+    switch (object) {
+        case OutboundStatus.OUTBOUND_STATUS_UNSPECIFIED:
+            return 'OUTBOUND_STATUS_UNSPECIFIED';
+        case OutboundStatus.PENDING:
+            return 'PENDING';
+        case OutboundStatus.OBSERVED:
+            return 'OBSERVED';
+        case OutboundStatus.REVERTED:
+            return 'REVERTED';
+        case OutboundStatus.UNRECOGNIZED:
+        default:
+            return 'UNRECOGNIZED';
+    }
+}
+// ============================================================================
+// Encoder/Decoder implementations
+// ============================================================================
+function createBaseOriginatingPcTx() {
+    return {
+        txHash: '',
+        logIndex: '',
+    };
+}
+exports.OriginatingPcTx = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.txHash !== '')
+            writer.uint32(10).string(message.txHash);
+        if (message.logIndex !== '')
+            writer.uint32(18).string(message.logIndex);
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOriginatingPcTx();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.txHash = reader.string();
+                    break;
+                case 2:
+                    message.logIndex = reader.string();
+                    break;
+                default:
+                    if ((tag & 7) === 4 || tag === 0)
+                        return message;
+                    reader.skip(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            txHash: isSet(object.txHash) ? globalThis.String(object.txHash) : '',
+            logIndex: isSet(object.logIndex)
+                ? globalThis.String(object.logIndex)
+                : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.txHash !== '')
+            obj.txHash = message.txHash;
+        if (message.logIndex !== '')
+            obj.logIndex = message.logIndex;
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseOriginatingPcTx();
+        message.txHash = (_a = object.txHash) !== null && _a !== void 0 ? _a : '';
+        message.logIndex = (_b = object.logIndex) !== null && _b !== void 0 ? _b : '';
+        return message;
+    },
+};
+function createBaseOutboundObservation() {
+    return { success: false, blockHeight: 0, txHash: '', errorMsg: '' };
+}
+exports.OutboundObservation = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.success !== false)
+            writer.uint32(8).bool(message.success);
+        if (message.blockHeight !== 0)
+            writer.uint32(16).uint64(message.blockHeight);
+        if (message.txHash !== '')
+            writer.uint32(26).string(message.txHash);
+        if (message.errorMsg !== '')
+            writer.uint32(34).string(message.errorMsg);
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOutboundObservation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.success = reader.bool();
+                    break;
+                case 2:
+                    message.blockHeight = Number(reader.uint64());
+                    break;
+                case 3:
+                    message.txHash = reader.string();
+                    break;
+                case 4:
+                    message.errorMsg = reader.string();
+                    break;
+                default:
+                    if ((tag & 7) === 4 || tag === 0)
+                        return message;
+                    reader.skip(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            success: isSet(object.success)
+                ? globalThis.Boolean(object.success)
+                : false,
+            blockHeight: isSet(object.blockHeight)
+                ? globalThis.Number(object.blockHeight)
+                : 0,
+            txHash: isSet(object.txHash) ? globalThis.String(object.txHash) : '',
+            errorMsg: isSet(object.errorMsg)
+                ? globalThis.String(object.errorMsg)
+                : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.success !== false)
+            obj.success = message.success;
+        if (message.blockHeight !== 0)
+            obj.blockHeight = message.blockHeight;
+        if (message.txHash !== '')
+            obj.txHash = message.txHash;
+        if (message.errorMsg !== '')
+            obj.errorMsg = message.errorMsg;
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d;
+        const message = createBaseOutboundObservation();
+        message.success = (_a = object.success) !== null && _a !== void 0 ? _a : false;
+        message.blockHeight = (_b = object.blockHeight) !== null && _b !== void 0 ? _b : 0;
+        message.txHash = (_c = object.txHash) !== null && _c !== void 0 ? _c : '';
+        message.errorMsg = (_d = object.errorMsg) !== null && _d !== void 0 ? _d : '';
+        return message;
+    },
+};
+function createBaseRevertInstructions() {
+    return { fundRecipient: '' };
+}
+exports.RevertInstructions = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.fundRecipient !== '')
+            writer.uint32(10).string(message.fundRecipient);
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRevertInstructions();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.fundRecipient = reader.string();
+                    break;
+                default:
+                    if ((tag & 7) === 4 || tag === 0)
+                        return message;
+                    reader.skip(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            fundRecipient: isSet(object.fundRecipient)
+                ? globalThis.String(object.fundRecipient)
+                : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.fundRecipient !== '')
+            obj.fundRecipient = message.fundRecipient;
+        return obj;
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseRevertInstructions();
+        message.fundRecipient = (_a = object.fundRecipient) !== null && _a !== void 0 ? _a : '';
+        return message;
+    },
+};
+function createBaseOutboundTxV2() {
+    return {
+        destinationChain: '',
+        recipient: '',
+        amount: '',
+        externalAssetAddr: '',
+        prc20AssetAddr: '',
+        sender: '',
+        payload: '',
+        gasLimit: '',
+        txType: 0,
+        pcTx: undefined,
+        observedTx: undefined,
+        id: '',
+        outboundStatus: 0,
+        revertInstructions: undefined,
+        pcRevertExecution: undefined,
+    };
+}
+// Import PCTx encoder from v1
+const types_3 = require("../v1/types");
+exports.OutboundTxV2Codec = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.destinationChain !== '')
+            writer.uint32(10).string(message.destinationChain);
+        if (message.recipient !== '')
+            writer.uint32(18).string(message.recipient);
+        if (message.amount !== '')
+            writer.uint32(26).string(message.amount);
+        if (message.externalAssetAddr !== '')
+            writer.uint32(34).string(message.externalAssetAddr);
+        if (message.prc20AssetAddr !== '')
+            writer.uint32(42).string(message.prc20AssetAddr);
+        if (message.sender !== '')
+            writer.uint32(50).string(message.sender);
+        if (message.payload !== '')
+            writer.uint32(58).string(message.payload);
+        if (message.gasLimit !== '')
+            writer.uint32(66).string(message.gasLimit);
+        if (message.txType !== 0)
+            writer.uint32(72).int32(message.txType);
+        if (message.pcTx !== undefined)
+            exports.OriginatingPcTx.encode(message.pcTx, writer.uint32(82).fork()).join();
+        if (message.observedTx !== undefined)
+            exports.OutboundObservation.encode(message.observedTx, writer.uint32(90).fork()).join();
+        if (message.id !== '')
+            writer.uint32(98).string(message.id);
+        if (message.outboundStatus !== 0)
+            writer.uint32(104).int32(message.outboundStatus);
+        if (message.revertInstructions !== undefined)
+            exports.RevertInstructions.encode(message.revertInstructions, writer.uint32(114).fork()).join();
+        if (message.pcRevertExecution !== undefined)
+            types_3.PCTx.encode(message.pcRevertExecution, writer.uint32(122).fork()).join();
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOutboundTxV2();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.destinationChain = reader.string();
+                    break;
+                case 2:
+                    message.recipient = reader.string();
+                    break;
+                case 3:
+                    message.amount = reader.string();
+                    break;
+                case 4:
+                    message.externalAssetAddr = reader.string();
+                    break;
+                case 5:
+                    message.prc20AssetAddr = reader.string();
+                    break;
+                case 6:
+                    message.sender = reader.string();
+                    break;
+                case 7:
+                    message.payload = reader.string();
+                    break;
+                case 8:
+                    message.gasLimit = reader.string();
+                    break;
+                case 9:
+                    message.txType = reader.int32();
+                    break;
+                case 10:
+                    message.pcTx = exports.OriginatingPcTx.decode(reader, reader.uint32());
+                    break;
+                case 11:
+                    message.observedTx = exports.OutboundObservation.decode(reader, reader.uint32());
+                    break;
+                case 12:
+                    message.id = reader.string();
+                    break;
+                case 13:
+                    message.outboundStatus = reader.int32();
+                    break;
+                case 14:
+                    message.revertInstructions = exports.RevertInstructions.decode(reader, reader.uint32());
+                    break;
+                case 15:
+                    message.pcRevertExecution = types_3.PCTx.decode(reader, reader.uint32());
+                    break;
+                default:
+                    if ((tag & 7) === 4 || tag === 0)
+                        return message;
+                    reader.skip(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            destinationChain: isSet(object.destinationChain)
+                ? globalThis.String(object.destinationChain)
+                : '',
+            recipient: isSet(object.recipient)
+                ? globalThis.String(object.recipient)
+                : '',
+            amount: isSet(object.amount) ? globalThis.String(object.amount) : '',
+            externalAssetAddr: isSet(object.externalAssetAddr)
+                ? globalThis.String(object.externalAssetAddr)
+                : '',
+            prc20AssetAddr: isSet(object.prc20AssetAddr)
+                ? globalThis.String(object.prc20AssetAddr)
+                : '',
+            sender: isSet(object.sender) ? globalThis.String(object.sender) : '',
+            payload: isSet(object.payload) ? globalThis.String(object.payload) : '',
+            gasLimit: isSet(object.gasLimit)
+                ? globalThis.String(object.gasLimit)
+                : '',
+            txType: isSet(object.txType) ? txTypeFromJSON(object.txType) : 0,
+            pcTx: isSet(object.pcTx)
+                ? exports.OriginatingPcTx.fromJSON(object.pcTx)
+                : undefined,
+            observedTx: isSet(object.observedTx)
+                ? exports.OutboundObservation.fromJSON(object.observedTx)
+                : undefined,
+            id: isSet(object.id) ? globalThis.String(object.id) : '',
+            outboundStatus: isSet(object.outboundStatus)
+                ? outboundStatusFromJSON(object.outboundStatus)
+                : 0,
+            revertInstructions: isSet(object.revertInstructions)
+                ? exports.RevertInstructions.fromJSON(object.revertInstructions)
+                : undefined,
+            pcRevertExecution: isSet(object.pcRevertExecution)
+                ? types_3.PCTx.fromJSON(object.pcRevertExecution)
+                : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.destinationChain !== '')
+            obj.destinationChain = message.destinationChain;
+        if (message.recipient !== '')
+            obj.recipient = message.recipient;
+        if (message.amount !== '')
+            obj.amount = message.amount;
+        if (message.externalAssetAddr !== '')
+            obj.externalAssetAddr = message.externalAssetAddr;
+        if (message.prc20AssetAddr !== '')
+            obj.prc20AssetAddr = message.prc20AssetAddr;
+        if (message.sender !== '')
+            obj.sender = message.sender;
+        if (message.payload !== '')
+            obj.payload = message.payload;
+        if (message.gasLimit !== '')
+            obj.gasLimit = message.gasLimit;
+        if (message.txType !== 0)
+            obj.txType = txTypeToJSON(message.txType);
+        if (message.pcTx !== undefined)
+            obj.pcTx = exports.OriginatingPcTx.toJSON(message.pcTx);
+        if (message.observedTx !== undefined)
+            obj.observedTx = exports.OutboundObservation.toJSON(message.observedTx);
+        if (message.id !== '')
+            obj.id = message.id;
+        if (message.outboundStatus !== 0)
+            obj.outboundStatus = outboundStatusToJSON(message.outboundStatus);
+        if (message.revertInstructions !== undefined)
+            obj.revertInstructions = exports.RevertInstructions.toJSON(message.revertInstructions);
+        if (message.pcRevertExecution !== undefined)
+            obj.pcRevertExecution = types_3.PCTx.toJSON(message.pcRevertExecution);
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const message = createBaseOutboundTxV2();
+        message.destinationChain = (_a = object.destinationChain) !== null && _a !== void 0 ? _a : '';
+        message.recipient = (_b = object.recipient) !== null && _b !== void 0 ? _b : '';
+        message.amount = (_c = object.amount) !== null && _c !== void 0 ? _c : '';
+        message.externalAssetAddr = (_d = object.externalAssetAddr) !== null && _d !== void 0 ? _d : '';
+        message.prc20AssetAddr = (_e = object.prc20AssetAddr) !== null && _e !== void 0 ? _e : '';
+        message.sender = (_f = object.sender) !== null && _f !== void 0 ? _f : '';
+        message.payload = (_g = object.payload) !== null && _g !== void 0 ? _g : '';
+        message.gasLimit = (_h = object.gasLimit) !== null && _h !== void 0 ? _h : '';
+        message.txType = (_j = object.txType) !== null && _j !== void 0 ? _j : 0;
+        message.pcTx =
+            object.pcTx !== undefined && object.pcTx !== null
+                ? exports.OriginatingPcTx.fromPartial(object.pcTx)
+                : undefined;
+        message.observedTx =
+            object.observedTx !== undefined && object.observedTx !== null
+                ? exports.OutboundObservation.fromPartial(object.observedTx)
+                : undefined;
+        message.id = (_k = object.id) !== null && _k !== void 0 ? _k : '';
+        message.outboundStatus = (_l = object.outboundStatus) !== null && _l !== void 0 ? _l : 0;
+        message.revertInstructions =
+            object.revertInstructions !== undefined &&
+                object.revertInstructions !== null
+                ? exports.RevertInstructions.fromPartial(object.revertInstructions)
+                : undefined;
+        message.pcRevertExecution =
+            object.pcRevertExecution !== undefined &&
+                object.pcRevertExecution !== null
+                ? types_3.PCTx.fromPartial(object.pcRevertExecution)
+                : undefined;
+        return message;
+    },
+};
+// Import Inbound encoder from v1
+const types_4 = require("../v1/types");
+function createBaseUniversalTxV2() {
+    return {
+        id: '',
+        inboundTx: undefined,
+        pcTx: [],
+        outboundTx: [],
+        universalStatus: 0,
+    };
+}
+exports.UniversalTxV2Codec = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.id !== '')
+            writer.uint32(10).string(message.id);
+        if (message.inboundTx !== undefined)
+            types_4.Inbound.encode(message.inboundTx, writer.uint32(18).fork()).join();
+        for (const v of message.pcTx) {
+            types_3.PCTx.encode(v, writer.uint32(26).fork()).join();
+        }
+        for (const v of message.outboundTx) {
+            exports.OutboundTxV2Codec.encode(v, writer.uint32(34).fork()).join();
+        }
+        if (message.universalStatus !== 0)
+            writer.uint32(40).int32(message.universalStatus);
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUniversalTxV2();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.id = reader.string();
+                    break;
+                case 2:
+                    message.inboundTx = types_4.Inbound.decode(reader, reader.uint32());
+                    break;
+                case 3:
+                    message.pcTx.push(types_3.PCTx.decode(reader, reader.uint32()));
+                    break;
+                case 4:
+                    message.outboundTx.push(exports.OutboundTxV2Codec.decode(reader, reader.uint32()));
+                    break;
+                case 5:
+                    message.universalStatus = reader.int32();
+                    break;
+                default:
+                    if ((tag & 7) === 4 || tag === 0)
+                        return message;
+                    reader.skip(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            id: isSet(object.id) ? globalThis.String(object.id) : '',
+            inboundTx: isSet(object.inboundTx)
+                ? types_4.Inbound.fromJSON(object.inboundTx)
+                : undefined,
+            pcTx: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.pcTx)
+                ? object.pcTx.map((e) => types_3.PCTx.fromJSON(e))
+                : [],
+            outboundTx: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.outboundTx)
+                ? object.outboundTx.map((e) => exports.OutboundTxV2Codec.fromJSON(e))
+                : [],
+            universalStatus: isSet(object.universalStatus)
+                ? object.universalStatus
+                : 0,
+        };
+    },
+    toJSON(message) {
+        var _a, _b;
+        const obj = {};
+        if (message.id !== '')
+            obj.id = message.id;
+        if (message.inboundTx !== undefined)
+            obj.inboundTx = types_4.Inbound.toJSON(message.inboundTx);
+        if ((_a = message.pcTx) === null || _a === void 0 ? void 0 : _a.length)
+            obj.pcTx = message.pcTx.map((e) => types_3.PCTx.toJSON(e));
+        if ((_b = message.outboundTx) === null || _b === void 0 ? void 0 : _b.length)
+            obj.outboundTx = message.outboundTx.map((e) => exports.OutboundTxV2Codec.toJSON(e));
+        if (message.universalStatus !== 0)
+            obj.universalStatus = message.universalStatus;
+        return obj;
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d;
+        const message = createBaseUniversalTxV2();
+        message.id = (_a = object.id) !== null && _a !== void 0 ? _a : '';
+        message.inboundTx =
+            object.inboundTx !== undefined && object.inboundTx !== null
+                ? types_4.Inbound.fromPartial(object.inboundTx)
+                : undefined;
+        message.pcTx = ((_b = object.pcTx) === null || _b === void 0 ? void 0 : _b.map((e) => types_3.PCTx.fromPartial(e))) || [];
+        message.outboundTx =
+            ((_c = object.outboundTx) === null || _c === void 0 ? void 0 : _c.map((e) => exports.OutboundTxV2Codec.fromPartial(e))) || [];
+        message.universalStatus = (_d = object.universalStatus) !== null && _d !== void 0 ? _d : 0;
+        return message;
+    },
+};
+// Helper types
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=types.js.map