@trustwallet/wallet-core 4.2.0-dev-rc4 → 4.2.0

package/dist/generated/core_proto.js

@@ -7258,6 +7258,2269 @@
             return Aptos;
         })();
     
+        TW.BabylonStaking = (function() {
+    
+            /**
+             * Namespace BabylonStaking.
+             * @memberof TW
+             * @namespace
+             */
+            var BabylonStaking = {};
+    
+            BabylonStaking.Proto = (function() {
+    
+                /**
+                 * Namespace Proto.
+                 * @memberof TW.BabylonStaking
+                 * @namespace
+                 */
+                var Proto = {};
+    
+                Proto.PublicKeySignature = (function() {
+    
+                    /**
+                     * Properties of a PublicKeySignature.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @interface IPublicKeySignature
+                     * @property {Uint8Array|null} [publicKey] PublicKeySignature publicKey
+                     * @property {Uint8Array|null} [signature] PublicKeySignature signature
+                     */
+    
+                    /**
+                     * Constructs a new PublicKeySignature.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @classdesc Represents a PublicKeySignature.
+                     * @implements IPublicKeySignature
+                     * @constructor
+                     * @param {TW.BabylonStaking.Proto.IPublicKeySignature=} [properties] Properties to set
+                     */
+                    function PublicKeySignature(properties) {
+                        if (properties)
+                            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                if (properties[keys[i]] != null)
+                                    this[keys[i]] = properties[keys[i]];
+                    }
+    
+                    /**
+                     * PublicKeySignature publicKey.
+                     * @member {Uint8Array} publicKey
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @instance
+                     */
+                    PublicKeySignature.prototype.publicKey = $util.newBuffer([]);
+    
+                    /**
+                     * PublicKeySignature signature.
+                     * @member {Uint8Array} signature
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @instance
+                     */
+                    PublicKeySignature.prototype.signature = $util.newBuffer([]);
+    
+                    /**
+                     * Creates a new PublicKeySignature instance using the specified properties.
+                     * @function create
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IPublicKeySignature=} [properties] Properties to set
+                     * @returns {TW.BabylonStaking.Proto.PublicKeySignature} PublicKeySignature instance
+                     */
+                    PublicKeySignature.create = function create(properties) {
+                        return new PublicKeySignature(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified PublicKeySignature message. Does not implicitly {@link TW.BabylonStaking.Proto.PublicKeySignature.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IPublicKeySignature} message PublicKeySignature message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    PublicKeySignature.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.publicKey != null && Object.hasOwnProperty.call(message, "publicKey"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.publicKey);
+                        if (message.signature != null && Object.hasOwnProperty.call(message, "signature"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.signature);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a PublicKeySignature message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.BabylonStaking.Proto.PublicKeySignature} PublicKeySignature
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    PublicKeySignature.decode = function decode(reader, length) {
+                        if (!(reader instanceof $Reader))
+                            reader = $Reader.create(reader);
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.PublicKeySignature();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.publicKey = reader.bytes();
+                                break;
+                            case 2:
+                                message.signature = reader.bytes();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a PublicKeySignature message.
+                     * @function verify
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    PublicKeySignature.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.publicKey != null && message.hasOwnProperty("publicKey"))
+                            if (!(message.publicKey && typeof message.publicKey.length === "number" || $util.isString(message.publicKey)))
+                                return "publicKey: buffer expected";
+                        if (message.signature != null && message.hasOwnProperty("signature"))
+                            if (!(message.signature && typeof message.signature.length === "number" || $util.isString(message.signature)))
+                                return "signature: buffer expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a PublicKeySignature message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.BabylonStaking.Proto.PublicKeySignature} PublicKeySignature
+                     */
+                    PublicKeySignature.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.BabylonStaking.Proto.PublicKeySignature)
+                            return object;
+                        var message = new $root.TW.BabylonStaking.Proto.PublicKeySignature();
+                        if (object.publicKey != null)
+                            if (typeof object.publicKey === "string")
+                                $util.base64.decode(object.publicKey, message.publicKey = $util.newBuffer($util.base64.length(object.publicKey)), 0);
+                            else if (object.publicKey.length)
+                                message.publicKey = object.publicKey;
+                        if (object.signature != null)
+                            if (typeof object.signature === "string")
+                                $util.base64.decode(object.signature, message.signature = $util.newBuffer($util.base64.length(object.signature)), 0);
+                            else if (object.signature.length)
+                                message.signature = object.signature;
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a PublicKeySignature message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.PublicKeySignature} message PublicKeySignature
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    PublicKeySignature.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults) {
+                            if (options.bytes === String)
+                                object.publicKey = "";
+                            else {
+                                object.publicKey = [];
+                                if (options.bytes !== Array)
+                                    object.publicKey = $util.newBuffer(object.publicKey);
+                            }
+                            if (options.bytes === String)
+                                object.signature = "";
+                            else {
+                                object.signature = [];
+                                if (options.bytes !== Array)
+                                    object.signature = $util.newBuffer(object.signature);
+                            }
+                        }
+                        if (message.publicKey != null && message.hasOwnProperty("publicKey"))
+                            object.publicKey = options.bytes === String ? $util.base64.encode(message.publicKey, 0, message.publicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.publicKey) : message.publicKey;
+                        if (message.signature != null && message.hasOwnProperty("signature"))
+                            object.signature = options.bytes === String ? $util.base64.encode(message.signature, 0, message.signature.length) : options.bytes === Array ? Array.prototype.slice.call(message.signature) : message.signature;
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this PublicKeySignature to JSON.
+                     * @function toJSON
+                     * @memberof TW.BabylonStaking.Proto.PublicKeySignature
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    PublicKeySignature.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return PublicKeySignature;
+                })();
+    
+                Proto.StakingInfo = (function() {
+    
+                    /**
+                     * Properties of a StakingInfo.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @interface IStakingInfo
+                     * @property {Uint8Array|null} [stakerPublicKey] StakingInfo stakerPublicKey
+                     * @property {Uint8Array|null} [finalityProviderPublicKey] StakingInfo finalityProviderPublicKey
+                     * @property {number|null} [stakingTime] StakingInfo stakingTime
+                     * @property {Array.<Uint8Array>|null} [covenantCommitteePublicKeys] StakingInfo covenantCommitteePublicKeys
+                     * @property {number|null} [covenantQuorum] StakingInfo covenantQuorum
+                     */
+    
+                    /**
+                     * Constructs a new StakingInfo.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @classdesc Represents a StakingInfo.
+                     * @implements IStakingInfo
+                     * @constructor
+                     * @param {TW.BabylonStaking.Proto.IStakingInfo=} [properties] Properties to set
+                     */
+                    function StakingInfo(properties) {
+                        this.covenantCommitteePublicKeys = [];
+                        if (properties)
+                            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                if (properties[keys[i]] != null)
+                                    this[keys[i]] = properties[keys[i]];
+                    }
+    
+                    /**
+                     * StakingInfo stakerPublicKey.
+                     * @member {Uint8Array} stakerPublicKey
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @instance
+                     */
+                    StakingInfo.prototype.stakerPublicKey = $util.newBuffer([]);
+    
+                    /**
+                     * StakingInfo finalityProviderPublicKey.
+                     * @member {Uint8Array} finalityProviderPublicKey
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @instance
+                     */
+                    StakingInfo.prototype.finalityProviderPublicKey = $util.newBuffer([]);
+    
+                    /**
+                     * StakingInfo stakingTime.
+                     * @member {number} stakingTime
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @instance
+                     */
+                    StakingInfo.prototype.stakingTime = 0;
+    
+                    /**
+                     * StakingInfo covenantCommitteePublicKeys.
+                     * @member {Array.<Uint8Array>} covenantCommitteePublicKeys
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @instance
+                     */
+                    StakingInfo.prototype.covenantCommitteePublicKeys = $util.emptyArray;
+    
+                    /**
+                     * StakingInfo covenantQuorum.
+                     * @member {number} covenantQuorum
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @instance
+                     */
+                    StakingInfo.prototype.covenantQuorum = 0;
+    
+                    /**
+                     * Creates a new StakingInfo instance using the specified properties.
+                     * @function create
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IStakingInfo=} [properties] Properties to set
+                     * @returns {TW.BabylonStaking.Proto.StakingInfo} StakingInfo instance
+                     */
+                    StakingInfo.create = function create(properties) {
+                        return new StakingInfo(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified StakingInfo message. Does not implicitly {@link TW.BabylonStaking.Proto.StakingInfo.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IStakingInfo} message StakingInfo message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    StakingInfo.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.stakerPublicKey != null && Object.hasOwnProperty.call(message, "stakerPublicKey"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.stakerPublicKey);
+                        if (message.finalityProviderPublicKey != null && Object.hasOwnProperty.call(message, "finalityProviderPublicKey"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.finalityProviderPublicKey);
+                        if (message.stakingTime != null && Object.hasOwnProperty.call(message, "stakingTime"))
+                            writer.uint32(/* id 3, wireType 0 =*/24).uint32(message.stakingTime);
+                        if (message.covenantCommitteePublicKeys != null && message.covenantCommitteePublicKeys.length)
+                            for (var i = 0; i < message.covenantCommitteePublicKeys.length; ++i)
+                                writer.uint32(/* id 4, wireType 2 =*/34).bytes(message.covenantCommitteePublicKeys[i]);
+                        if (message.covenantQuorum != null && Object.hasOwnProperty.call(message, "covenantQuorum"))
+                            writer.uint32(/* id 5, wireType 0 =*/40).uint32(message.covenantQuorum);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a StakingInfo message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.BabylonStaking.Proto.StakingInfo} StakingInfo
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    StakingInfo.decode = function decode(reader, length) {
+                        if (!(reader instanceof $Reader))
+                            reader = $Reader.create(reader);
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.StakingInfo();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.stakerPublicKey = reader.bytes();
+                                break;
+                            case 2:
+                                message.finalityProviderPublicKey = reader.bytes();
+                                break;
+                            case 3:
+                                message.stakingTime = reader.uint32();
+                                break;
+                            case 4:
+                                if (!(message.covenantCommitteePublicKeys && message.covenantCommitteePublicKeys.length))
+                                    message.covenantCommitteePublicKeys = [];
+                                message.covenantCommitteePublicKeys.push(reader.bytes());
+                                break;
+                            case 5:
+                                message.covenantQuorum = reader.uint32();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a StakingInfo message.
+                     * @function verify
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    StakingInfo.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.stakerPublicKey != null && message.hasOwnProperty("stakerPublicKey"))
+                            if (!(message.stakerPublicKey && typeof message.stakerPublicKey.length === "number" || $util.isString(message.stakerPublicKey)))
+                                return "stakerPublicKey: buffer expected";
+                        if (message.finalityProviderPublicKey != null && message.hasOwnProperty("finalityProviderPublicKey"))
+                            if (!(message.finalityProviderPublicKey && typeof message.finalityProviderPublicKey.length === "number" || $util.isString(message.finalityProviderPublicKey)))
+                                return "finalityProviderPublicKey: buffer expected";
+                        if (message.stakingTime != null && message.hasOwnProperty("stakingTime"))
+                            if (!$util.isInteger(message.stakingTime))
+                                return "stakingTime: integer expected";
+                        if (message.covenantCommitteePublicKeys != null && message.hasOwnProperty("covenantCommitteePublicKeys")) {
+                            if (!Array.isArray(message.covenantCommitteePublicKeys))
+                                return "covenantCommitteePublicKeys: array expected";
+                            for (var i = 0; i < message.covenantCommitteePublicKeys.length; ++i)
+                                if (!(message.covenantCommitteePublicKeys[i] && typeof message.covenantCommitteePublicKeys[i].length === "number" || $util.isString(message.covenantCommitteePublicKeys[i])))
+                                    return "covenantCommitteePublicKeys: buffer[] expected";
+                        }
+                        if (message.covenantQuorum != null && message.hasOwnProperty("covenantQuorum"))
+                            if (!$util.isInteger(message.covenantQuorum))
+                                return "covenantQuorum: integer expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a StakingInfo message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.BabylonStaking.Proto.StakingInfo} StakingInfo
+                     */
+                    StakingInfo.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.BabylonStaking.Proto.StakingInfo)
+                            return object;
+                        var message = new $root.TW.BabylonStaking.Proto.StakingInfo();
+                        if (object.stakerPublicKey != null)
+                            if (typeof object.stakerPublicKey === "string")
+                                $util.base64.decode(object.stakerPublicKey, message.stakerPublicKey = $util.newBuffer($util.base64.length(object.stakerPublicKey)), 0);
+                            else if (object.stakerPublicKey.length)
+                                message.stakerPublicKey = object.stakerPublicKey;
+                        if (object.finalityProviderPublicKey != null)
+                            if (typeof object.finalityProviderPublicKey === "string")
+                                $util.base64.decode(object.finalityProviderPublicKey, message.finalityProviderPublicKey = $util.newBuffer($util.base64.length(object.finalityProviderPublicKey)), 0);
+                            else if (object.finalityProviderPublicKey.length)
+                                message.finalityProviderPublicKey = object.finalityProviderPublicKey;
+                        if (object.stakingTime != null)
+                            message.stakingTime = object.stakingTime >>> 0;
+                        if (object.covenantCommitteePublicKeys) {
+                            if (!Array.isArray(object.covenantCommitteePublicKeys))
+                                throw TypeError(".TW.BabylonStaking.Proto.StakingInfo.covenantCommitteePublicKeys: array expected");
+                            message.covenantCommitteePublicKeys = [];
+                            for (var i = 0; i < object.covenantCommitteePublicKeys.length; ++i)
+                                if (typeof object.covenantCommitteePublicKeys[i] === "string")
+                                    $util.base64.decode(object.covenantCommitteePublicKeys[i], message.covenantCommitteePublicKeys[i] = $util.newBuffer($util.base64.length(object.covenantCommitteePublicKeys[i])), 0);
+                                else if (object.covenantCommitteePublicKeys[i].length)
+                                    message.covenantCommitteePublicKeys[i] = object.covenantCommitteePublicKeys[i];
+                        }
+                        if (object.covenantQuorum != null)
+                            message.covenantQuorum = object.covenantQuorum >>> 0;
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a StakingInfo message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.StakingInfo} message StakingInfo
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    StakingInfo.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.arrays || options.defaults)
+                            object.covenantCommitteePublicKeys = [];
+                        if (options.defaults) {
+                            if (options.bytes === String)
+                                object.stakerPublicKey = "";
+                            else {
+                                object.stakerPublicKey = [];
+                                if (options.bytes !== Array)
+                                    object.stakerPublicKey = $util.newBuffer(object.stakerPublicKey);
+                            }
+                            if (options.bytes === String)
+                                object.finalityProviderPublicKey = "";
+                            else {
+                                object.finalityProviderPublicKey = [];
+                                if (options.bytes !== Array)
+                                    object.finalityProviderPublicKey = $util.newBuffer(object.finalityProviderPublicKey);
+                            }
+                            object.stakingTime = 0;
+                            object.covenantQuorum = 0;
+                        }
+                        if (message.stakerPublicKey != null && message.hasOwnProperty("stakerPublicKey"))
+                            object.stakerPublicKey = options.bytes === String ? $util.base64.encode(message.stakerPublicKey, 0, message.stakerPublicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.stakerPublicKey) : message.stakerPublicKey;
+                        if (message.finalityProviderPublicKey != null && message.hasOwnProperty("finalityProviderPublicKey"))
+                            object.finalityProviderPublicKey = options.bytes === String ? $util.base64.encode(message.finalityProviderPublicKey, 0, message.finalityProviderPublicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.finalityProviderPublicKey) : message.finalityProviderPublicKey;
+                        if (message.stakingTime != null && message.hasOwnProperty("stakingTime"))
+                            object.stakingTime = message.stakingTime;
+                        if (message.covenantCommitteePublicKeys && message.covenantCommitteePublicKeys.length) {
+                            object.covenantCommitteePublicKeys = [];
+                            for (var j = 0; j < message.covenantCommitteePublicKeys.length; ++j)
+                                object.covenantCommitteePublicKeys[j] = options.bytes === String ? $util.base64.encode(message.covenantCommitteePublicKeys[j], 0, message.covenantCommitteePublicKeys[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.covenantCommitteePublicKeys[j]) : message.covenantCommitteePublicKeys[j];
+                        }
+                        if (message.covenantQuorum != null && message.hasOwnProperty("covenantQuorum"))
+                            object.covenantQuorum = message.covenantQuorum;
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this StakingInfo to JSON.
+                     * @function toJSON
+                     * @memberof TW.BabylonStaking.Proto.StakingInfo
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    StakingInfo.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return StakingInfo;
+                })();
+    
+                Proto.InputBuilder = (function() {
+    
+                    /**
+                     * Properties of an InputBuilder.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @interface IInputBuilder
+                     */
+    
+                    /**
+                     * Constructs a new InputBuilder.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @classdesc Represents an InputBuilder.
+                     * @implements IInputBuilder
+                     * @constructor
+                     * @param {TW.BabylonStaking.Proto.IInputBuilder=} [properties] Properties to set
+                     */
+                    function InputBuilder(properties) {
+                        if (properties)
+                            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                if (properties[keys[i]] != null)
+                                    this[keys[i]] = properties[keys[i]];
+                    }
+    
+                    /**
+                     * Creates a new InputBuilder instance using the specified properties.
+                     * @function create
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IInputBuilder=} [properties] Properties to set
+                     * @returns {TW.BabylonStaking.Proto.InputBuilder} InputBuilder instance
+                     */
+                    InputBuilder.create = function create(properties) {
+                        return new InputBuilder(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified InputBuilder message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IInputBuilder} message InputBuilder message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    InputBuilder.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes an InputBuilder message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.BabylonStaking.Proto.InputBuilder} InputBuilder
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    InputBuilder.decode = function decode(reader, length) {
+                        if (!(reader instanceof $Reader))
+                            reader = $Reader.create(reader);
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.InputBuilder();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies an InputBuilder message.
+                     * @function verify
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    InputBuilder.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates an InputBuilder message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.BabylonStaking.Proto.InputBuilder} InputBuilder
+                     */
+                    InputBuilder.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.BabylonStaking.Proto.InputBuilder)
+                            return object;
+                        return new $root.TW.BabylonStaking.Proto.InputBuilder();
+                    };
+    
+                    /**
+                     * Creates a plain object from an InputBuilder message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.InputBuilder} message InputBuilder
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    InputBuilder.toObject = function toObject() {
+                        return {};
+                    };
+    
+                    /**
+                     * Converts this InputBuilder to JSON.
+                     * @function toJSON
+                     * @memberof TW.BabylonStaking.Proto.InputBuilder
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    InputBuilder.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    InputBuilder.StakingTimelockPath = (function() {
+    
+                        /**
+                         * Properties of a StakingTimelockPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @interface IStakingTimelockPath
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] StakingTimelockPath params
+                         */
+    
+                        /**
+                         * Constructs a new StakingTimelockPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @classdesc Represents a StakingTimelockPath.
+                         * @implements IStakingTimelockPath
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath=} [properties] Properties to set
+                         */
+                        function StakingTimelockPath(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * StakingTimelockPath params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @instance
+                         */
+                        StakingTimelockPath.prototype.params = null;
+    
+                        /**
+                         * Creates a new StakingTimelockPath instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath} StakingTimelockPath instance
+                         */
+                        StakingTimelockPath.create = function create(properties) {
+                            return new StakingTimelockPath(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified StakingTimelockPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath} message StakingTimelockPath message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        StakingTimelockPath.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes a StakingTimelockPath message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath} StakingTimelockPath
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        StakingTimelockPath.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies a StakingTimelockPath message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        StakingTimelockPath.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a StakingTimelockPath message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath} StakingTimelockPath
+                         */
+                        StakingTimelockPath.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a StakingTimelockPath message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath} message StakingTimelockPath
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        StakingTimelockPath.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults)
+                                object.params = null;
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this StakingTimelockPath to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        StakingTimelockPath.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return StakingTimelockPath;
+                    })();
+    
+                    InputBuilder.StakingUnbondingPath = (function() {
+    
+                        /**
+                         * Properties of a StakingUnbondingPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @interface IStakingUnbondingPath
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] StakingUnbondingPath params
+                         * @property {Array.<TW.BabylonStaking.Proto.IPublicKeySignature>|null} [covenantCommitteeSignatures] StakingUnbondingPath covenantCommitteeSignatures
+                         */
+    
+                        /**
+                         * Constructs a new StakingUnbondingPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @classdesc Represents a StakingUnbondingPath.
+                         * @implements IStakingUnbondingPath
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath=} [properties] Properties to set
+                         */
+                        function StakingUnbondingPath(properties) {
+                            this.covenantCommitteeSignatures = [];
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * StakingUnbondingPath params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @instance
+                         */
+                        StakingUnbondingPath.prototype.params = null;
+    
+                        /**
+                         * StakingUnbondingPath covenantCommitteeSignatures.
+                         * @member {Array.<TW.BabylonStaking.Proto.IPublicKeySignature>} covenantCommitteeSignatures
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @instance
+                         */
+                        StakingUnbondingPath.prototype.covenantCommitteeSignatures = $util.emptyArray;
+    
+                        /**
+                         * Creates a new StakingUnbondingPath instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath} StakingUnbondingPath instance
+                         */
+                        StakingUnbondingPath.create = function create(properties) {
+                            return new StakingUnbondingPath(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified StakingUnbondingPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath} message StakingUnbondingPath message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        StakingUnbondingPath.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            if (message.covenantCommitteeSignatures != null && message.covenantCommitteeSignatures.length)
+                                for (var i = 0; i < message.covenantCommitteeSignatures.length; ++i)
+                                    $root.TW.BabylonStaking.Proto.PublicKeySignature.encode(message.covenantCommitteeSignatures[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes a StakingUnbondingPath message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath} StakingUnbondingPath
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        StakingUnbondingPath.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                case 2:
+                                    if (!(message.covenantCommitteeSignatures && message.covenantCommitteeSignatures.length))
+                                        message.covenantCommitteeSignatures = [];
+                                    message.covenantCommitteeSignatures.push($root.TW.BabylonStaking.Proto.PublicKeySignature.decode(reader, reader.uint32()));
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies a StakingUnbondingPath message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        StakingUnbondingPath.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            if (message.covenantCommitteeSignatures != null && message.hasOwnProperty("covenantCommitteeSignatures")) {
+                                if (!Array.isArray(message.covenantCommitteeSignatures))
+                                    return "covenantCommitteeSignatures: array expected";
+                                for (var i = 0; i < message.covenantCommitteeSignatures.length; ++i) {
+                                    var error = $root.TW.BabylonStaking.Proto.PublicKeySignature.verify(message.covenantCommitteeSignatures[i]);
+                                    if (error)
+                                        return "covenantCommitteeSignatures." + error;
+                                }
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a StakingUnbondingPath message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath} StakingUnbondingPath
+                         */
+                        StakingUnbondingPath.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            if (object.covenantCommitteeSignatures) {
+                                if (!Array.isArray(object.covenantCommitteeSignatures))
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.covenantCommitteeSignatures: array expected");
+                                message.covenantCommitteeSignatures = [];
+                                for (var i = 0; i < object.covenantCommitteeSignatures.length; ++i) {
+                                    if (typeof object.covenantCommitteeSignatures[i] !== "object")
+                                        throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.covenantCommitteeSignatures: object expected");
+                                    message.covenantCommitteeSignatures[i] = $root.TW.BabylonStaking.Proto.PublicKeySignature.fromObject(object.covenantCommitteeSignatures[i]);
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a StakingUnbondingPath message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath} message StakingUnbondingPath
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        StakingUnbondingPath.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.arrays || options.defaults)
+                                object.covenantCommitteeSignatures = [];
+                            if (options.defaults)
+                                object.params = null;
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            if (message.covenantCommitteeSignatures && message.covenantCommitteeSignatures.length) {
+                                object.covenantCommitteeSignatures = [];
+                                for (var j = 0; j < message.covenantCommitteeSignatures.length; ++j)
+                                    object.covenantCommitteeSignatures[j] = $root.TW.BabylonStaking.Proto.PublicKeySignature.toObject(message.covenantCommitteeSignatures[j], options);
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this StakingUnbondingPath to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        StakingUnbondingPath.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return StakingUnbondingPath;
+                    })();
+    
+                    InputBuilder.StakingSlashingPath = (function() {
+    
+                        /**
+                         * Properties of a StakingSlashingPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @interface IStakingSlashingPath
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] StakingSlashingPath params
+                         * @property {TW.BabylonStaking.Proto.IPublicKeySignature|null} [finalityProviderSignature] StakingSlashingPath finalityProviderSignature
+                         */
+    
+                        /**
+                         * Constructs a new StakingSlashingPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @classdesc Represents a StakingSlashingPath.
+                         * @implements IStakingSlashingPath
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath=} [properties] Properties to set
+                         */
+                        function StakingSlashingPath(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * StakingSlashingPath params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @instance
+                         */
+                        StakingSlashingPath.prototype.params = null;
+    
+                        /**
+                         * StakingSlashingPath finalityProviderSignature.
+                         * @member {TW.BabylonStaking.Proto.IPublicKeySignature|null|undefined} finalityProviderSignature
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @instance
+                         */
+                        StakingSlashingPath.prototype.finalityProviderSignature = null;
+    
+                        /**
+                         * Creates a new StakingSlashingPath instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath} StakingSlashingPath instance
+                         */
+                        StakingSlashingPath.create = function create(properties) {
+                            return new StakingSlashingPath(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified StakingSlashingPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath} message StakingSlashingPath message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        StakingSlashingPath.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            if (message.finalityProviderSignature != null && Object.hasOwnProperty.call(message, "finalityProviderSignature"))
+                                $root.TW.BabylonStaking.Proto.PublicKeySignature.encode(message.finalityProviderSignature, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes a StakingSlashingPath message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath} StakingSlashingPath
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        StakingSlashingPath.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                case 2:
+                                    message.finalityProviderSignature = $root.TW.BabylonStaking.Proto.PublicKeySignature.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies a StakingSlashingPath message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        StakingSlashingPath.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            if (message.finalityProviderSignature != null && message.hasOwnProperty("finalityProviderSignature")) {
+                                var error = $root.TW.BabylonStaking.Proto.PublicKeySignature.verify(message.finalityProviderSignature);
+                                if (error)
+                                    return "finalityProviderSignature." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a StakingSlashingPath message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath} StakingSlashingPath
+                         */
+                        StakingSlashingPath.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            if (object.finalityProviderSignature != null) {
+                                if (typeof object.finalityProviderSignature !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.finalityProviderSignature: object expected");
+                                message.finalityProviderSignature = $root.TW.BabylonStaking.Proto.PublicKeySignature.fromObject(object.finalityProviderSignature);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a StakingSlashingPath message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath} message StakingSlashingPath
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        StakingSlashingPath.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.params = null;
+                                object.finalityProviderSignature = null;
+                            }
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            if (message.finalityProviderSignature != null && message.hasOwnProperty("finalityProviderSignature"))
+                                object.finalityProviderSignature = $root.TW.BabylonStaking.Proto.PublicKeySignature.toObject(message.finalityProviderSignature, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this StakingSlashingPath to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        StakingSlashingPath.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return StakingSlashingPath;
+                    })();
+    
+                    InputBuilder.UnbondingTimelockPath = (function() {
+    
+                        /**
+                         * Properties of an UnbondingTimelockPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @interface IUnbondingTimelockPath
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] UnbondingTimelockPath params
+                         */
+    
+                        /**
+                         * Constructs a new UnbondingTimelockPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @classdesc Represents an UnbondingTimelockPath.
+                         * @implements IUnbondingTimelockPath
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath=} [properties] Properties to set
+                         */
+                        function UnbondingTimelockPath(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * UnbondingTimelockPath params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @instance
+                         */
+                        UnbondingTimelockPath.prototype.params = null;
+    
+                        /**
+                         * Creates a new UnbondingTimelockPath instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath} UnbondingTimelockPath instance
+                         */
+                        UnbondingTimelockPath.create = function create(properties) {
+                            return new UnbondingTimelockPath(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified UnbondingTimelockPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath} message UnbondingTimelockPath message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UnbondingTimelockPath.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes an UnbondingTimelockPath message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath} UnbondingTimelockPath
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UnbondingTimelockPath.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies an UnbondingTimelockPath message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        UnbondingTimelockPath.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates an UnbondingTimelockPath message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath} UnbondingTimelockPath
+                         */
+                        UnbondingTimelockPath.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from an UnbondingTimelockPath message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath} message UnbondingTimelockPath
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        UnbondingTimelockPath.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults)
+                                object.params = null;
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this UnbondingTimelockPath to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        UnbondingTimelockPath.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return UnbondingTimelockPath;
+                    })();
+    
+                    InputBuilder.UnbondingSlashingPath = (function() {
+    
+                        /**
+                         * Properties of an UnbondingSlashingPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @interface IUnbondingSlashingPath
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] UnbondingSlashingPath params
+                         * @property {TW.BabylonStaking.Proto.IPublicKeySignature|null} [finalityProviderSignature] UnbondingSlashingPath finalityProviderSignature
+                         */
+    
+                        /**
+                         * Constructs a new UnbondingSlashingPath.
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder
+                         * @classdesc Represents an UnbondingSlashingPath.
+                         * @implements IUnbondingSlashingPath
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath=} [properties] Properties to set
+                         */
+                        function UnbondingSlashingPath(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * UnbondingSlashingPath params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @instance
+                         */
+                        UnbondingSlashingPath.prototype.params = null;
+    
+                        /**
+                         * UnbondingSlashingPath finalityProviderSignature.
+                         * @member {TW.BabylonStaking.Proto.IPublicKeySignature|null|undefined} finalityProviderSignature
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @instance
+                         */
+                        UnbondingSlashingPath.prototype.finalityProviderSignature = null;
+    
+                        /**
+                         * Creates a new UnbondingSlashingPath instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath} UnbondingSlashingPath instance
+                         */
+                        UnbondingSlashingPath.create = function create(properties) {
+                            return new UnbondingSlashingPath(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified UnbondingSlashingPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath} message UnbondingSlashingPath message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UnbondingSlashingPath.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            if (message.finalityProviderSignature != null && Object.hasOwnProperty.call(message, "finalityProviderSignature"))
+                                $root.TW.BabylonStaking.Proto.PublicKeySignature.encode(message.finalityProviderSignature, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes an UnbondingSlashingPath message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath} UnbondingSlashingPath
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UnbondingSlashingPath.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                case 2:
+                                    message.finalityProviderSignature = $root.TW.BabylonStaking.Proto.PublicKeySignature.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies an UnbondingSlashingPath message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        UnbondingSlashingPath.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            if (message.finalityProviderSignature != null && message.hasOwnProperty("finalityProviderSignature")) {
+                                var error = $root.TW.BabylonStaking.Proto.PublicKeySignature.verify(message.finalityProviderSignature);
+                                if (error)
+                                    return "finalityProviderSignature." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates an UnbondingSlashingPath message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath} UnbondingSlashingPath
+                         */
+                        UnbondingSlashingPath.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            if (object.finalityProviderSignature != null) {
+                                if (typeof object.finalityProviderSignature !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.finalityProviderSignature: object expected");
+                                message.finalityProviderSignature = $root.TW.BabylonStaking.Proto.PublicKeySignature.fromObject(object.finalityProviderSignature);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from an UnbondingSlashingPath message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath} message UnbondingSlashingPath
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        UnbondingSlashingPath.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.params = null;
+                                object.finalityProviderSignature = null;
+                            }
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            if (message.finalityProviderSignature != null && message.hasOwnProperty("finalityProviderSignature"))
+                                object.finalityProviderSignature = $root.TW.BabylonStaking.Proto.PublicKeySignature.toObject(message.finalityProviderSignature, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this UnbondingSlashingPath to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        UnbondingSlashingPath.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return UnbondingSlashingPath;
+                    })();
+    
+                    return InputBuilder;
+                })();
+    
+                Proto.OutputBuilder = (function() {
+    
+                    /**
+                     * Properties of an OutputBuilder.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @interface IOutputBuilder
+                     */
+    
+                    /**
+                     * Constructs a new OutputBuilder.
+                     * @memberof TW.BabylonStaking.Proto
+                     * @classdesc Represents an OutputBuilder.
+                     * @implements IOutputBuilder
+                     * @constructor
+                     * @param {TW.BabylonStaking.Proto.IOutputBuilder=} [properties] Properties to set
+                     */
+                    function OutputBuilder(properties) {
+                        if (properties)
+                            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                if (properties[keys[i]] != null)
+                                    this[keys[i]] = properties[keys[i]];
+                    }
+    
+                    /**
+                     * Creates a new OutputBuilder instance using the specified properties.
+                     * @function create
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IOutputBuilder=} [properties] Properties to set
+                     * @returns {TW.BabylonStaking.Proto.OutputBuilder} OutputBuilder instance
+                     */
+                    OutputBuilder.create = function create(properties) {
+                        return new OutputBuilder(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified OutputBuilder message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.IOutputBuilder} message OutputBuilder message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    OutputBuilder.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes an OutputBuilder message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.BabylonStaking.Proto.OutputBuilder} OutputBuilder
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    OutputBuilder.decode = function decode(reader, length) {
+                        if (!(reader instanceof $Reader))
+                            reader = $Reader.create(reader);
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.OutputBuilder();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies an OutputBuilder message.
+                     * @function verify
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    OutputBuilder.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates an OutputBuilder message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.BabylonStaking.Proto.OutputBuilder} OutputBuilder
+                     */
+                    OutputBuilder.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.BabylonStaking.Proto.OutputBuilder)
+                            return object;
+                        return new $root.TW.BabylonStaking.Proto.OutputBuilder();
+                    };
+    
+                    /**
+                     * Creates a plain object from an OutputBuilder message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @static
+                     * @param {TW.BabylonStaking.Proto.OutputBuilder} message OutputBuilder
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    OutputBuilder.toObject = function toObject() {
+                        return {};
+                    };
+    
+                    /**
+                     * Converts this OutputBuilder to JSON.
+                     * @function toJSON
+                     * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    OutputBuilder.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    OutputBuilder.StakingOutput = (function() {
+    
+                        /**
+                         * Properties of a StakingOutput.
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                         * @interface IStakingOutput
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] StakingOutput params
+                         */
+    
+                        /**
+                         * Constructs a new StakingOutput.
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                         * @classdesc Represents a StakingOutput.
+                         * @implements IStakingOutput
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput=} [properties] Properties to set
+                         */
+                        function StakingOutput(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * StakingOutput params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @instance
+                         */
+                        StakingOutput.prototype.params = null;
+    
+                        /**
+                         * Creates a new StakingOutput instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.StakingOutput} StakingOutput instance
+                         */
+                        StakingOutput.create = function create(properties) {
+                            return new StakingOutput(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified StakingOutput message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput} message StakingOutput message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        StakingOutput.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes a StakingOutput message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.StakingOutput} StakingOutput
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        StakingOutput.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies a StakingOutput message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        StakingOutput.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a StakingOutput message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.StakingOutput} StakingOutput
+                         */
+                        StakingOutput.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a StakingOutput message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.StakingOutput} message StakingOutput
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        StakingOutput.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults)
+                                object.params = null;
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this StakingOutput to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.StakingOutput
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        StakingOutput.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return StakingOutput;
+                    })();
+    
+                    OutputBuilder.UnbondingOutput = (function() {
+    
+                        /**
+                         * Properties of an UnbondingOutput.
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                         * @interface IUnbondingOutput
+                         * @property {TW.BabylonStaking.Proto.IStakingInfo|null} [params] UnbondingOutput params
+                         */
+    
+                        /**
+                         * Constructs a new UnbondingOutput.
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                         * @classdesc Represents an UnbondingOutput.
+                         * @implements IUnbondingOutput
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput=} [properties] Properties to set
+                         */
+                        function UnbondingOutput(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * UnbondingOutput params.
+                         * @member {TW.BabylonStaking.Proto.IStakingInfo|null|undefined} params
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @instance
+                         */
+                        UnbondingOutput.prototype.params = null;
+    
+                        /**
+                         * Creates a new UnbondingOutput instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput} UnbondingOutput instance
+                         */
+                        UnbondingOutput.create = function create(properties) {
+                            return new UnbondingOutput(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified UnbondingOutput message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput} message UnbondingOutput message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UnbondingOutput.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.params != null && Object.hasOwnProperty.call(message, "params"))
+                                $root.TW.BabylonStaking.Proto.StakingInfo.encode(message.params, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes an UnbondingOutput message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput} UnbondingOutput
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UnbondingOutput.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.params = $root.TW.BabylonStaking.Proto.StakingInfo.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies an UnbondingOutput message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        UnbondingOutput.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.params != null && message.hasOwnProperty("params")) {
+                                var error = $root.TW.BabylonStaking.Proto.StakingInfo.verify(message.params);
+                                if (error)
+                                    return "params." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates an UnbondingOutput message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput} UnbondingOutput
+                         */
+                        UnbondingOutput.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput();
+                            if (object.params != null) {
+                                if (typeof object.params !== "object")
+                                    throw TypeError(".TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.params: object expected");
+                                message.params = $root.TW.BabylonStaking.Proto.StakingInfo.fromObject(object.params);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from an UnbondingOutput message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput} message UnbondingOutput
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        UnbondingOutput.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults)
+                                object.params = null;
+                            if (message.params != null && message.hasOwnProperty("params"))
+                                object.params = $root.TW.BabylonStaking.Proto.StakingInfo.toObject(message.params, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this UnbondingOutput to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        UnbondingOutput.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return UnbondingOutput;
+                    })();
+    
+                    OutputBuilder.OpReturn = (function() {
+    
+                        /**
+                         * Properties of an OpReturn.
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                         * @interface IOpReturn
+                         * @property {Uint8Array|null} [tag] OpReturn tag
+                         * @property {Uint8Array|null} [stakerPublicKey] OpReturn stakerPublicKey
+                         * @property {Uint8Array|null} [finalityProviderPublicKey] OpReturn finalityProviderPublicKey
+                         * @property {number|null} [stakingTime] OpReturn stakingTime
+                         */
+    
+                        /**
+                         * Constructs a new OpReturn.
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder
+                         * @classdesc Represents an OpReturn.
+                         * @implements IOpReturn
+                         * @constructor
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IOpReturn=} [properties] Properties to set
+                         */
+                        function OpReturn(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * OpReturn tag.
+                         * @member {Uint8Array} tag
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @instance
+                         */
+                        OpReturn.prototype.tag = $util.newBuffer([]);
+    
+                        /**
+                         * OpReturn stakerPublicKey.
+                         * @member {Uint8Array} stakerPublicKey
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @instance
+                         */
+                        OpReturn.prototype.stakerPublicKey = $util.newBuffer([]);
+    
+                        /**
+                         * OpReturn finalityProviderPublicKey.
+                         * @member {Uint8Array} finalityProviderPublicKey
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @instance
+                         */
+                        OpReturn.prototype.finalityProviderPublicKey = $util.newBuffer([]);
+    
+                        /**
+                         * OpReturn stakingTime.
+                         * @member {number} stakingTime
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @instance
+                         */
+                        OpReturn.prototype.stakingTime = 0;
+    
+                        /**
+                         * Creates a new OpReturn instance using the specified properties.
+                         * @function create
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IOpReturn=} [properties] Properties to set
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.OpReturn} OpReturn instance
+                         */
+                        OpReturn.create = function create(properties) {
+                            return new OpReturn(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified OpReturn message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.OpReturn.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.IOpReturn} message OpReturn message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        OpReturn.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.tag != null && Object.hasOwnProperty.call(message, "tag"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.tag);
+                            if (message.stakerPublicKey != null && Object.hasOwnProperty.call(message, "stakerPublicKey"))
+                                writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.stakerPublicKey);
+                            if (message.finalityProviderPublicKey != null && Object.hasOwnProperty.call(message, "finalityProviderPublicKey"))
+                                writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.finalityProviderPublicKey);
+                            if (message.stakingTime != null && Object.hasOwnProperty.call(message, "stakingTime"))
+                                writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.stakingTime);
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes an OpReturn message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.OpReturn} OpReturn
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        OpReturn.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.tag = reader.bytes();
+                                    break;
+                                case 2:
+                                    message.stakerPublicKey = reader.bytes();
+                                    break;
+                                case 3:
+                                    message.finalityProviderPublicKey = reader.bytes();
+                                    break;
+                                case 4:
+                                    message.stakingTime = reader.uint32();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies an OpReturn message.
+                         * @function verify
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        OpReturn.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.tag != null && message.hasOwnProperty("tag"))
+                                if (!(message.tag && typeof message.tag.length === "number" || $util.isString(message.tag)))
+                                    return "tag: buffer expected";
+                            if (message.stakerPublicKey != null && message.hasOwnProperty("stakerPublicKey"))
+                                if (!(message.stakerPublicKey && typeof message.stakerPublicKey.length === "number" || $util.isString(message.stakerPublicKey)))
+                                    return "stakerPublicKey: buffer expected";
+                            if (message.finalityProviderPublicKey != null && message.hasOwnProperty("finalityProviderPublicKey"))
+                                if (!(message.finalityProviderPublicKey && typeof message.finalityProviderPublicKey.length === "number" || $util.isString(message.finalityProviderPublicKey)))
+                                    return "finalityProviderPublicKey: buffer expected";
+                            if (message.stakingTime != null && message.hasOwnProperty("stakingTime"))
+                                if (!$util.isInteger(message.stakingTime))
+                                    return "stakingTime: integer expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates an OpReturn message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.BabylonStaking.Proto.OutputBuilder.OpReturn} OpReturn
+                         */
+                        OpReturn.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn)
+                                return object;
+                            var message = new $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn();
+                            if (object.tag != null)
+                                if (typeof object.tag === "string")
+                                    $util.base64.decode(object.tag, message.tag = $util.newBuffer($util.base64.length(object.tag)), 0);
+                                else if (object.tag.length)
+                                    message.tag = object.tag;
+                            if (object.stakerPublicKey != null)
+                                if (typeof object.stakerPublicKey === "string")
+                                    $util.base64.decode(object.stakerPublicKey, message.stakerPublicKey = $util.newBuffer($util.base64.length(object.stakerPublicKey)), 0);
+                                else if (object.stakerPublicKey.length)
+                                    message.stakerPublicKey = object.stakerPublicKey;
+                            if (object.finalityProviderPublicKey != null)
+                                if (typeof object.finalityProviderPublicKey === "string")
+                                    $util.base64.decode(object.finalityProviderPublicKey, message.finalityProviderPublicKey = $util.newBuffer($util.base64.length(object.finalityProviderPublicKey)), 0);
+                                else if (object.finalityProviderPublicKey.length)
+                                    message.finalityProviderPublicKey = object.finalityProviderPublicKey;
+                            if (object.stakingTime != null)
+                                message.stakingTime = object.stakingTime >>> 0;
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from an OpReturn message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @static
+                         * @param {TW.BabylonStaking.Proto.OutputBuilder.OpReturn} message OpReturn
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        OpReturn.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                if (options.bytes === String)
+                                    object.tag = "";
+                                else {
+                                    object.tag = [];
+                                    if (options.bytes !== Array)
+                                        object.tag = $util.newBuffer(object.tag);
+                                }
+                                if (options.bytes === String)
+                                    object.stakerPublicKey = "";
+                                else {
+                                    object.stakerPublicKey = [];
+                                    if (options.bytes !== Array)
+                                        object.stakerPublicKey = $util.newBuffer(object.stakerPublicKey);
+                                }
+                                if (options.bytes === String)
+                                    object.finalityProviderPublicKey = "";
+                                else {
+                                    object.finalityProviderPublicKey = [];
+                                    if (options.bytes !== Array)
+                                        object.finalityProviderPublicKey = $util.newBuffer(object.finalityProviderPublicKey);
+                                }
+                                object.stakingTime = 0;
+                            }
+                            if (message.tag != null && message.hasOwnProperty("tag"))
+                                object.tag = options.bytes === String ? $util.base64.encode(message.tag, 0, message.tag.length) : options.bytes === Array ? Array.prototype.slice.call(message.tag) : message.tag;
+                            if (message.stakerPublicKey != null && message.hasOwnProperty("stakerPublicKey"))
+                                object.stakerPublicKey = options.bytes === String ? $util.base64.encode(message.stakerPublicKey, 0, message.stakerPublicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.stakerPublicKey) : message.stakerPublicKey;
+                            if (message.finalityProviderPublicKey != null && message.hasOwnProperty("finalityProviderPublicKey"))
+                                object.finalityProviderPublicKey = options.bytes === String ? $util.base64.encode(message.finalityProviderPublicKey, 0, message.finalityProviderPublicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.finalityProviderPublicKey) : message.finalityProviderPublicKey;
+                            if (message.stakingTime != null && message.hasOwnProperty("stakingTime"))
+                                object.stakingTime = message.stakingTime;
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this OpReturn to JSON.
+                         * @function toJSON
+                         * @memberof TW.BabylonStaking.Proto.OutputBuilder.OpReturn
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        OpReturn.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return OpReturn;
+                    })();
+    
+                    return OutputBuilder;
+                })();
+    
+                return Proto;
+            })();
+    
+            return BabylonStaking;
+        })();
+    
         TW.Barz = (function() {
     
             /**
@@ -17635,6 +19898,7 @@
                      * @property {boolean|null} [useMaxUtxo] SigningInput useMaxUtxo
                      * @property {boolean|null} [disableDustFilter] SigningInput disableDustFilter
                      * @property {number|null} [time] SigningInput time
+                     * @property {boolean|null} [zip_0317] SigningInput zip_0317
                      * @property {TW.BitcoinV2.Proto.ISigningInput|null} [signingV2] SigningInput signingV2
                      * @property {Long|null} [fixedDustThreshold] SigningInput fixedDustThreshold
                      */
@@ -17802,6 +20066,14 @@
                      */
                     SigningInput.prototype.time = 0;
     
+                    /**
+                     * SigningInput zip_0317.
+                     * @member {boolean} zip_0317
+                     * @memberof TW.Bitcoin.Proto.SigningInput
+                     * @instance
+                     */
+                    SigningInput.prototype.zip_0317 = false;
+    
                     /**
                      * SigningInput signingV2.
                      * @member {TW.BitcoinV2.Proto.ISigningInput|null|undefined} signingV2
@@ -17894,6 +20166,8 @@
                             writer.uint32(/* id 16, wireType 0 =*/128).bool(message.disableDustFilter);
                         if (message.time != null && Object.hasOwnProperty.call(message, "time"))
                             writer.uint32(/* id 17, wireType 0 =*/136).uint32(message.time);
+                        if (message.zip_0317 != null && Object.hasOwnProperty.call(message, "zip_0317"))
+                            writer.uint32(/* id 18, wireType 0 =*/144).bool(message.zip_0317);
                         if (message.signingV2 != null && Object.hasOwnProperty.call(message, "signingV2"))
                             $root.TW.BitcoinV2.Proto.SigningInput.encode(message.signingV2, writer.uint32(/* id 21, wireType 2 =*/170).fork()).ldelim();
                         if (message.fixedDustThreshold != null && Object.hasOwnProperty.call(message, "fixedDustThreshold"))
@@ -18000,6 +20274,9 @@
                             case 17:
                                 message.time = reader.uint32();
                                 break;
+                            case 18:
+                                message.zip_0317 = reader.bool();
+                                break;
                             case 21:
                                 message.signingV2 = $root.TW.BitcoinV2.Proto.SigningInput.decode(reader, reader.uint32());
                                 break;
@@ -18105,6 +20382,9 @@
                         if (message.time != null && message.hasOwnProperty("time"))
                             if (!$util.isInteger(message.time))
                                 return "time: integer expected";
+                        if (message.zip_0317 != null && message.hasOwnProperty("zip_0317"))
+                            if (typeof message.zip_0317 !== "boolean")
+                                return "zip_0317: boolean expected";
                         if (message.signingV2 != null && message.hasOwnProperty("signingV2")) {
                             var error = $root.TW.BitcoinV2.Proto.SigningInput.verify(message.signingV2);
                             if (error)
@@ -18221,6 +20501,8 @@
                             message.disableDustFilter = Boolean(object.disableDustFilter);
                         if (object.time != null)
                             message.time = object.time >>> 0;
+                        if (object.zip_0317 != null)
+                            message.zip_0317 = Boolean(object.zip_0317);
                         if (object.signingV2 != null) {
                             if (typeof object.signingV2 !== "object")
                                 throw TypeError(".TW.Bitcoin.Proto.SigningInput.signingV2: object expected");
@@ -18286,6 +20568,7 @@
                             object.useMaxUtxo = false;
                             object.disableDustFilter = false;
                             object.time = 0;
+                            object.zip_0317 = false;
                             object.signingV2 = null;
                             object.outputOpReturnIndex = null;
                         }
@@ -18342,6 +20625,8 @@
                             object.disableDustFilter = message.disableDustFilter;
                         if (message.time != null && message.hasOwnProperty("time"))
                             object.time = message.time;
+                        if (message.zip_0317 != null && message.hasOwnProperty("zip_0317"))
+                            object.zip_0317 = message.zip_0317;
                         if (message.signingV2 != null && message.hasOwnProperty("signingV2"))
                             object.signingV2 = $root.TW.BitcoinV2.Proto.SigningInput.toObject(message.signingV2, options);
                         if (message.fixedDustThreshold != null && message.hasOwnProperty("fixedDustThreshold")) {
@@ -20115,81 +22400,277 @@
                     PublicKeyOrHash.prototype.pubkey = null;
     
                     /**
-                     * PublicKeyOrHash hash.
-                     * @member {Uint8Array|null|undefined} hash
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * PublicKeyOrHash hash.
+                     * @member {Uint8Array|null|undefined} hash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @instance
+                     */
+                    PublicKeyOrHash.prototype.hash = null;
+    
+                    // OneOf field names bound to virtual getters and setters
+                    var $oneOfFields;
+    
+                    /**
+                     * PublicKeyOrHash variant.
+                     * @member {"pubkey"|"hash"|undefined} variant
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @instance
+                     */
+                    Object.defineProperty(PublicKeyOrHash.prototype, "variant", {
+                        get: $util.oneOfGetter($oneOfFields = ["pubkey", "hash"]),
+                        set: $util.oneOfSetter($oneOfFields)
+                    });
+    
+                    /**
+                     * Creates a new PublicKeyOrHash instance using the specified properties.
+                     * @function create
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @static
+                     * @param {TW.BitcoinV2.Proto.IPublicKeyOrHash=} [properties] Properties to set
+                     * @returns {TW.BitcoinV2.Proto.PublicKeyOrHash} PublicKeyOrHash instance
+                     */
+                    PublicKeyOrHash.create = function create(properties) {
+                        return new PublicKeyOrHash(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified PublicKeyOrHash message. Does not implicitly {@link TW.BitcoinV2.Proto.PublicKeyOrHash.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @static
+                     * @param {TW.BitcoinV2.Proto.IPublicKeyOrHash} message PublicKeyOrHash message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    PublicKeyOrHash.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.pubkey != null && Object.hasOwnProperty.call(message, "pubkey"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.pubkey);
+                        if (message.hash != null && Object.hasOwnProperty.call(message, "hash"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.hash);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a PublicKeyOrHash message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.BitcoinV2.Proto.PublicKeyOrHash} PublicKeyOrHash
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    PublicKeyOrHash.decode = function decode(reader, length) {
+                        if (!(reader instanceof $Reader))
+                            reader = $Reader.create(reader);
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BitcoinV2.Proto.PublicKeyOrHash();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.pubkey = reader.bytes();
+                                break;
+                            case 2:
+                                message.hash = reader.bytes();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a PublicKeyOrHash message.
+                     * @function verify
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    PublicKeyOrHash.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        var properties = {};
+                        if (message.pubkey != null && message.hasOwnProperty("pubkey")) {
+                            properties.variant = 1;
+                            if (!(message.pubkey && typeof message.pubkey.length === "number" || $util.isString(message.pubkey)))
+                                return "pubkey: buffer expected";
+                        }
+                        if (message.hash != null && message.hasOwnProperty("hash")) {
+                            if (properties.variant === 1)
+                                return "variant: multiple values";
+                            properties.variant = 1;
+                            if (!(message.hash && typeof message.hash.length === "number" || $util.isString(message.hash)))
+                                return "hash: buffer expected";
+                        }
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a PublicKeyOrHash message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.BitcoinV2.Proto.PublicKeyOrHash} PublicKeyOrHash
+                     */
+                    PublicKeyOrHash.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.BitcoinV2.Proto.PublicKeyOrHash)
+                            return object;
+                        var message = new $root.TW.BitcoinV2.Proto.PublicKeyOrHash();
+                        if (object.pubkey != null)
+                            if (typeof object.pubkey === "string")
+                                $util.base64.decode(object.pubkey, message.pubkey = $util.newBuffer($util.base64.length(object.pubkey)), 0);
+                            else if (object.pubkey.length)
+                                message.pubkey = object.pubkey;
+                        if (object.hash != null)
+                            if (typeof object.hash === "string")
+                                $util.base64.decode(object.hash, message.hash = $util.newBuffer($util.base64.length(object.hash)), 0);
+                            else if (object.hash.length)
+                                message.hash = object.hash;
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a PublicKeyOrHash message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @static
+                     * @param {TW.BitcoinV2.Proto.PublicKeyOrHash} message PublicKeyOrHash
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    PublicKeyOrHash.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (message.pubkey != null && message.hasOwnProperty("pubkey")) {
+                            object.pubkey = options.bytes === String ? $util.base64.encode(message.pubkey, 0, message.pubkey.length) : options.bytes === Array ? Array.prototype.slice.call(message.pubkey) : message.pubkey;
+                            if (options.oneofs)
+                                object.variant = "pubkey";
+                        }
+                        if (message.hash != null && message.hasOwnProperty("hash")) {
+                            object.hash = options.bytes === String ? $util.base64.encode(message.hash, 0, message.hash.length) : options.bytes === Array ? Array.prototype.slice.call(message.hash) : message.hash;
+                            if (options.oneofs)
+                                object.variant = "hash";
+                        }
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this PublicKeyOrHash to JSON.
+                     * @function toJSON
+                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    PublicKeyOrHash.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return PublicKeyOrHash;
+                })();
+    
+                Proto.PublicKeySignature = (function() {
+    
+                    /**
+                     * Properties of a PublicKeySignature.
+                     * @memberof TW.BitcoinV2.Proto
+                     * @interface IPublicKeySignature
+                     * @property {Uint8Array|null} [publicKey] PublicKeySignature publicKey
+                     * @property {Uint8Array|null} [signature] PublicKeySignature signature
+                     */
+    
+                    /**
+                     * Constructs a new PublicKeySignature.
+                     * @memberof TW.BitcoinV2.Proto
+                     * @classdesc Represents a PublicKeySignature.
+                     * @implements IPublicKeySignature
+                     * @constructor
+                     * @param {TW.BitcoinV2.Proto.IPublicKeySignature=} [properties] Properties to set
+                     */
+                    function PublicKeySignature(properties) {
+                        if (properties)
+                            for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                if (properties[keys[i]] != null)
+                                    this[keys[i]] = properties[keys[i]];
+                    }
+    
+                    /**
+                     * PublicKeySignature publicKey.
+                     * @member {Uint8Array} publicKey
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @instance
                      */
-                    PublicKeyOrHash.prototype.hash = null;
-    
-                    // OneOf field names bound to virtual getters and setters
-                    var $oneOfFields;
+                    PublicKeySignature.prototype.publicKey = $util.newBuffer([]);
     
                     /**
-                     * PublicKeyOrHash variant.
-                     * @member {"pubkey"|"hash"|undefined} variant
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * PublicKeySignature signature.
+                     * @member {Uint8Array} signature
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @instance
                      */
-                    Object.defineProperty(PublicKeyOrHash.prototype, "variant", {
-                        get: $util.oneOfGetter($oneOfFields = ["pubkey", "hash"]),
-                        set: $util.oneOfSetter($oneOfFields)
-                    });
+                    PublicKeySignature.prototype.signature = $util.newBuffer([]);
     
                     /**
-                     * Creates a new PublicKeyOrHash instance using the specified properties.
+                     * Creates a new PublicKeySignature instance using the specified properties.
                      * @function create
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @static
-                     * @param {TW.BitcoinV2.Proto.IPublicKeyOrHash=} [properties] Properties to set
-                     * @returns {TW.BitcoinV2.Proto.PublicKeyOrHash} PublicKeyOrHash instance
+                     * @param {TW.BitcoinV2.Proto.IPublicKeySignature=} [properties] Properties to set
+                     * @returns {TW.BitcoinV2.Proto.PublicKeySignature} PublicKeySignature instance
                      */
-                    PublicKeyOrHash.create = function create(properties) {
-                        return new PublicKeyOrHash(properties);
+                    PublicKeySignature.create = function create(properties) {
+                        return new PublicKeySignature(properties);
                     };
     
                     /**
-                     * Encodes the specified PublicKeyOrHash message. Does not implicitly {@link TW.BitcoinV2.Proto.PublicKeyOrHash.verify|verify} messages.
+                     * Encodes the specified PublicKeySignature message. Does not implicitly {@link TW.BitcoinV2.Proto.PublicKeySignature.verify|verify} messages.
                      * @function encode
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @static
-                     * @param {TW.BitcoinV2.Proto.IPublicKeyOrHash} message PublicKeyOrHash message or plain object to encode
+                     * @param {TW.BitcoinV2.Proto.IPublicKeySignature} message PublicKeySignature message or plain object to encode
                      * @param {$protobuf.Writer} [writer] Writer to encode to
                      * @returns {$protobuf.Writer} Writer
                      */
-                    PublicKeyOrHash.encode = function encode(message, writer) {
+                    PublicKeySignature.encode = function encode(message, writer) {
                         if (!writer)
                             writer = $Writer.create();
-                        if (message.pubkey != null && Object.hasOwnProperty.call(message, "pubkey"))
-                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.pubkey);
-                        if (message.hash != null && Object.hasOwnProperty.call(message, "hash"))
-                            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.hash);
+                        if (message.publicKey != null && Object.hasOwnProperty.call(message, "publicKey"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.publicKey);
+                        if (message.signature != null && Object.hasOwnProperty.call(message, "signature"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.signature);
                         return writer;
                     };
     
                     /**
-                     * Decodes a PublicKeyOrHash message from the specified reader or buffer.
+                     * Decodes a PublicKeySignature message from the specified reader or buffer.
                      * @function decode
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @static
                      * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
                      * @param {number} [length] Message length if known beforehand
-                     * @returns {TW.BitcoinV2.Proto.PublicKeyOrHash} PublicKeyOrHash
+                     * @returns {TW.BitcoinV2.Proto.PublicKeySignature} PublicKeySignature
                      * @throws {Error} If the payload is not a reader or valid buffer
                      * @throws {$protobuf.util.ProtocolError} If required fields are missing
                      */
-                    PublicKeyOrHash.decode = function decode(reader, length) {
+                    PublicKeySignature.decode = function decode(reader, length) {
                         if (!(reader instanceof $Reader))
                             reader = $Reader.create(reader);
-                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BitcoinV2.Proto.PublicKeyOrHash();
+                        var end = length === undefined ? reader.len : reader.pos + length, message = new $root.TW.BitcoinV2.Proto.PublicKeySignature();
                         while (reader.pos < end) {
                             var tag = reader.uint32();
                             switch (tag >>> 3) {
                             case 1:
-                                message.pubkey = reader.bytes();
+                                message.publicKey = reader.bytes();
                                 break;
                             case 2:
-                                message.hash = reader.bytes();
+                                message.signature = reader.bytes();
                                 break;
                             default:
                                 reader.skipType(tag & 7);
@@ -20200,95 +22681,98 @@
                     };
     
                     /**
-                     * Verifies a PublicKeyOrHash message.
+                     * Verifies a PublicKeySignature message.
                      * @function verify
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @static
                      * @param {Object.<string,*>} message Plain object to verify
                      * @returns {string|null} `null` if valid, otherwise the reason why it is not
                      */
-                    PublicKeyOrHash.verify = function verify(message) {
+                    PublicKeySignature.verify = function verify(message) {
                         if (typeof message !== "object" || message === null)
                             return "object expected";
-                        var properties = {};
-                        if (message.pubkey != null && message.hasOwnProperty("pubkey")) {
-                            properties.variant = 1;
-                            if (!(message.pubkey && typeof message.pubkey.length === "number" || $util.isString(message.pubkey)))
-                                return "pubkey: buffer expected";
-                        }
-                        if (message.hash != null && message.hasOwnProperty("hash")) {
-                            if (properties.variant === 1)
-                                return "variant: multiple values";
-                            properties.variant = 1;
-                            if (!(message.hash && typeof message.hash.length === "number" || $util.isString(message.hash)))
-                                return "hash: buffer expected";
-                        }
+                        if (message.publicKey != null && message.hasOwnProperty("publicKey"))
+                            if (!(message.publicKey && typeof message.publicKey.length === "number" || $util.isString(message.publicKey)))
+                                return "publicKey: buffer expected";
+                        if (message.signature != null && message.hasOwnProperty("signature"))
+                            if (!(message.signature && typeof message.signature.length === "number" || $util.isString(message.signature)))
+                                return "signature: buffer expected";
                         return null;
                     };
     
                     /**
-                     * Creates a PublicKeyOrHash message from a plain object. Also converts values to their respective internal types.
+                     * Creates a PublicKeySignature message from a plain object. Also converts values to their respective internal types.
                      * @function fromObject
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @static
                      * @param {Object.<string,*>} object Plain object
-                     * @returns {TW.BitcoinV2.Proto.PublicKeyOrHash} PublicKeyOrHash
+                     * @returns {TW.BitcoinV2.Proto.PublicKeySignature} PublicKeySignature
                      */
-                    PublicKeyOrHash.fromObject = function fromObject(object) {
-                        if (object instanceof $root.TW.BitcoinV2.Proto.PublicKeyOrHash)
+                    PublicKeySignature.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.BitcoinV2.Proto.PublicKeySignature)
                             return object;
-                        var message = new $root.TW.BitcoinV2.Proto.PublicKeyOrHash();
-                        if (object.pubkey != null)
-                            if (typeof object.pubkey === "string")
-                                $util.base64.decode(object.pubkey, message.pubkey = $util.newBuffer($util.base64.length(object.pubkey)), 0);
-                            else if (object.pubkey.length)
-                                message.pubkey = object.pubkey;
-                        if (object.hash != null)
-                            if (typeof object.hash === "string")
-                                $util.base64.decode(object.hash, message.hash = $util.newBuffer($util.base64.length(object.hash)), 0);
-                            else if (object.hash.length)
-                                message.hash = object.hash;
+                        var message = new $root.TW.BitcoinV2.Proto.PublicKeySignature();
+                        if (object.publicKey != null)
+                            if (typeof object.publicKey === "string")
+                                $util.base64.decode(object.publicKey, message.publicKey = $util.newBuffer($util.base64.length(object.publicKey)), 0);
+                            else if (object.publicKey.length)
+                                message.publicKey = object.publicKey;
+                        if (object.signature != null)
+                            if (typeof object.signature === "string")
+                                $util.base64.decode(object.signature, message.signature = $util.newBuffer($util.base64.length(object.signature)), 0);
+                            else if (object.signature.length)
+                                message.signature = object.signature;
                         return message;
                     };
     
                     /**
-                     * Creates a plain object from a PublicKeyOrHash message. Also converts values to other types if specified.
+                     * Creates a plain object from a PublicKeySignature message. Also converts values to other types if specified.
                      * @function toObject
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @static
-                     * @param {TW.BitcoinV2.Proto.PublicKeyOrHash} message PublicKeyOrHash
+                     * @param {TW.BitcoinV2.Proto.PublicKeySignature} message PublicKeySignature
                      * @param {$protobuf.IConversionOptions} [options] Conversion options
                      * @returns {Object.<string,*>} Plain object
                      */
-                    PublicKeyOrHash.toObject = function toObject(message, options) {
+                    PublicKeySignature.toObject = function toObject(message, options) {
                         if (!options)
                             options = {};
                         var object = {};
-                        if (message.pubkey != null && message.hasOwnProperty("pubkey")) {
-                            object.pubkey = options.bytes === String ? $util.base64.encode(message.pubkey, 0, message.pubkey.length) : options.bytes === Array ? Array.prototype.slice.call(message.pubkey) : message.pubkey;
-                            if (options.oneofs)
-                                object.variant = "pubkey";
-                        }
-                        if (message.hash != null && message.hasOwnProperty("hash")) {
-                            object.hash = options.bytes === String ? $util.base64.encode(message.hash, 0, message.hash.length) : options.bytes === Array ? Array.prototype.slice.call(message.hash) : message.hash;
-                            if (options.oneofs)
-                                object.variant = "hash";
+                        if (options.defaults) {
+                            if (options.bytes === String)
+                                object.publicKey = "";
+                            else {
+                                object.publicKey = [];
+                                if (options.bytes !== Array)
+                                    object.publicKey = $util.newBuffer(object.publicKey);
+                            }
+                            if (options.bytes === String)
+                                object.signature = "";
+                            else {
+                                object.signature = [];
+                                if (options.bytes !== Array)
+                                    object.signature = $util.newBuffer(object.signature);
+                            }
                         }
+                        if (message.publicKey != null && message.hasOwnProperty("publicKey"))
+                            object.publicKey = options.bytes === String ? $util.base64.encode(message.publicKey, 0, message.publicKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.publicKey) : message.publicKey;
+                        if (message.signature != null && message.hasOwnProperty("signature"))
+                            object.signature = options.bytes === String ? $util.base64.encode(message.signature, 0, message.signature.length) : options.bytes === Array ? Array.prototype.slice.call(message.signature) : message.signature;
                         return object;
                     };
     
                     /**
-                     * Converts this PublicKeyOrHash to JSON.
+                     * Converts this PublicKeySignature to JSON.
                      * @function toJSON
-                     * @memberof TW.BitcoinV2.Proto.PublicKeyOrHash
+                     * @memberof TW.BitcoinV2.Proto.PublicKeySignature
                      * @instance
                      * @returns {Object.<string,*>} JSON object
                      */
-                    PublicKeyOrHash.prototype.toJSON = function toJSON() {
+                    PublicKeySignature.prototype.toJSON = function toJSON() {
                         return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
                     };
     
-                    return PublicKeyOrHash;
+                    return PublicKeySignature;
                 })();
     
                 Proto.OutPoint = (function() {
@@ -21002,6 +23486,11 @@
                          * @property {TW.BitcoinV2.Proto.IPublicKeyOrHash|null} [p2wpkh] InputBuilder p2wpkh
                          * @property {Uint8Array|null} [p2trKeyPath] InputBuilder p2trKeyPath
                          * @property {TW.BitcoinV2.Proto.Input.IInputBrc20Inscription|null} [brc20Inscribe] InputBuilder brc20Inscribe
+                         * @property {TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath|null} [babylonStakingTimelockPath] InputBuilder babylonStakingTimelockPath
+                         * @property {TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath|null} [babylonStakingUnbondingPath] InputBuilder babylonStakingUnbondingPath
+                         * @property {TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath|null} [babylonStakingSlashingPath] InputBuilder babylonStakingSlashingPath
+                         * @property {TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath|null} [babylonUnbondingTimelockPath] InputBuilder babylonUnbondingTimelockPath
+                         * @property {TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath|null} [babylonUnbondingSlashingPath] InputBuilder babylonUnbondingSlashingPath
                          */
     
                         /**
@@ -21059,17 +23548,57 @@
                          */
                         InputBuilder.prototype.brc20Inscribe = null;
     
+                        /**
+                         * InputBuilder babylonStakingTimelockPath.
+                         * @member {TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath|null|undefined} babylonStakingTimelockPath
+                         * @memberof TW.BitcoinV2.Proto.Input.InputBuilder
+                         * @instance
+                         */
+                        InputBuilder.prototype.babylonStakingTimelockPath = null;
+    
+                        /**
+                         * InputBuilder babylonStakingUnbondingPath.
+                         * @member {TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath|null|undefined} babylonStakingUnbondingPath
+                         * @memberof TW.BitcoinV2.Proto.Input.InputBuilder
+                         * @instance
+                         */
+                        InputBuilder.prototype.babylonStakingUnbondingPath = null;
+    
+                        /**
+                         * InputBuilder babylonStakingSlashingPath.
+                         * @member {TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath|null|undefined} babylonStakingSlashingPath
+                         * @memberof TW.BitcoinV2.Proto.Input.InputBuilder
+                         * @instance
+                         */
+                        InputBuilder.prototype.babylonStakingSlashingPath = null;
+    
+                        /**
+                         * InputBuilder babylonUnbondingTimelockPath.
+                         * @member {TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath|null|undefined} babylonUnbondingTimelockPath
+                         * @memberof TW.BitcoinV2.Proto.Input.InputBuilder
+                         * @instance
+                         */
+                        InputBuilder.prototype.babylonUnbondingTimelockPath = null;
+    
+                        /**
+                         * InputBuilder babylonUnbondingSlashingPath.
+                         * @member {TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath|null|undefined} babylonUnbondingSlashingPath
+                         * @memberof TW.BitcoinV2.Proto.Input.InputBuilder
+                         * @instance
+                         */
+                        InputBuilder.prototype.babylonUnbondingSlashingPath = null;
+    
                         // OneOf field names bound to virtual getters and setters
                         var $oneOfFields;
     
                         /**
                          * InputBuilder variant.
-                         * @member {"p2pk"|"p2pkh"|"p2wpkh"|"p2trKeyPath"|"brc20Inscribe"|undefined} variant
+                         * @member {"p2pk"|"p2pkh"|"p2wpkh"|"p2trKeyPath"|"brc20Inscribe"|"babylonStakingTimelockPath"|"babylonStakingUnbondingPath"|"babylonStakingSlashingPath"|"babylonUnbondingTimelockPath"|"babylonUnbondingSlashingPath"|undefined} variant
                          * @memberof TW.BitcoinV2.Proto.Input.InputBuilder
                          * @instance
                          */
                         Object.defineProperty(InputBuilder.prototype, "variant", {
-                            get: $util.oneOfGetter($oneOfFields = ["p2pk", "p2pkh", "p2wpkh", "p2trKeyPath", "brc20Inscribe"]),
+                            get: $util.oneOfGetter($oneOfFields = ["p2pk", "p2pkh", "p2wpkh", "p2trKeyPath", "brc20Inscribe", "babylonStakingTimelockPath", "babylonStakingUnbondingPath", "babylonStakingSlashingPath", "babylonUnbondingTimelockPath", "babylonUnbondingSlashingPath"]),
                             set: $util.oneOfSetter($oneOfFields)
                         });
     
@@ -21107,6 +23636,16 @@
                                 writer.uint32(/* id 7, wireType 2 =*/58).bytes(message.p2trKeyPath);
                             if (message.brc20Inscribe != null && Object.hasOwnProperty.call(message, "brc20Inscribe"))
                                 $root.TW.BitcoinV2.Proto.Input.InputBrc20Inscription.encode(message.brc20Inscribe, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
+                            if (message.babylonStakingTimelockPath != null && Object.hasOwnProperty.call(message, "babylonStakingTimelockPath"))
+                                $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.encode(message.babylonStakingTimelockPath, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
+                            if (message.babylonStakingUnbondingPath != null && Object.hasOwnProperty.call(message, "babylonStakingUnbondingPath"))
+                                $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.encode(message.babylonStakingUnbondingPath, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
+                            if (message.babylonStakingSlashingPath != null && Object.hasOwnProperty.call(message, "babylonStakingSlashingPath"))
+                                $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.encode(message.babylonStakingSlashingPath, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
+                            if (message.babylonUnbondingTimelockPath != null && Object.hasOwnProperty.call(message, "babylonUnbondingTimelockPath"))
+                                $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.encode(message.babylonUnbondingTimelockPath, writer.uint32(/* id 18, wireType 2 =*/146).fork()).ldelim();
+                            if (message.babylonUnbondingSlashingPath != null && Object.hasOwnProperty.call(message, "babylonUnbondingSlashingPath"))
+                                $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.encode(message.babylonUnbondingSlashingPath, writer.uint32(/* id 19, wireType 2 =*/154).fork()).ldelim();
                             return writer;
                         };
     
@@ -21143,6 +23682,21 @@
                                 case 9:
                                     message.brc20Inscribe = $root.TW.BitcoinV2.Proto.Input.InputBrc20Inscription.decode(reader, reader.uint32());
                                     break;
+                                case 15:
+                                    message.babylonStakingTimelockPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.decode(reader, reader.uint32());
+                                    break;
+                                case 16:
+                                    message.babylonStakingUnbondingPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.decode(reader, reader.uint32());
+                                    break;
+                                case 17:
+                                    message.babylonStakingSlashingPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.decode(reader, reader.uint32());
+                                    break;
+                                case 18:
+                                    message.babylonUnbondingTimelockPath = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.decode(reader, reader.uint32());
+                                    break;
+                                case 19:
+                                    message.babylonUnbondingSlashingPath = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.decode(reader, reader.uint32());
+                                    break;
                                 default:
                                     reader.skipType(tag & 7);
                                     break;
@@ -21205,6 +23759,56 @@
                                         return "brc20Inscribe." + error;
                                 }
                             }
+                            if (message.babylonStakingTimelockPath != null && message.hasOwnProperty("babylonStakingTimelockPath")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.verify(message.babylonStakingTimelockPath);
+                                    if (error)
+                                        return "babylonStakingTimelockPath." + error;
+                                }
+                            }
+                            if (message.babylonStakingUnbondingPath != null && message.hasOwnProperty("babylonStakingUnbondingPath")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.verify(message.babylonStakingUnbondingPath);
+                                    if (error)
+                                        return "babylonStakingUnbondingPath." + error;
+                                }
+                            }
+                            if (message.babylonStakingSlashingPath != null && message.hasOwnProperty("babylonStakingSlashingPath")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.verify(message.babylonStakingSlashingPath);
+                                    if (error)
+                                        return "babylonStakingSlashingPath." + error;
+                                }
+                            }
+                            if (message.babylonUnbondingTimelockPath != null && message.hasOwnProperty("babylonUnbondingTimelockPath")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.verify(message.babylonUnbondingTimelockPath);
+                                    if (error)
+                                        return "babylonUnbondingTimelockPath." + error;
+                                }
+                            }
+                            if (message.babylonUnbondingSlashingPath != null && message.hasOwnProperty("babylonUnbondingSlashingPath")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.verify(message.babylonUnbondingSlashingPath);
+                                    if (error)
+                                        return "babylonUnbondingSlashingPath." + error;
+                                }
+                            }
                             return null;
                         };
     
@@ -21245,6 +23849,31 @@
                                     throw TypeError(".TW.BitcoinV2.Proto.Input.InputBuilder.brc20Inscribe: object expected");
                                 message.brc20Inscribe = $root.TW.BitcoinV2.Proto.Input.InputBrc20Inscription.fromObject(object.brc20Inscribe);
                             }
+                            if (object.babylonStakingTimelockPath != null) {
+                                if (typeof object.babylonStakingTimelockPath !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Input.InputBuilder.babylonStakingTimelockPath: object expected");
+                                message.babylonStakingTimelockPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.fromObject(object.babylonStakingTimelockPath);
+                            }
+                            if (object.babylonStakingUnbondingPath != null) {
+                                if (typeof object.babylonStakingUnbondingPath !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Input.InputBuilder.babylonStakingUnbondingPath: object expected");
+                                message.babylonStakingUnbondingPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.fromObject(object.babylonStakingUnbondingPath);
+                            }
+                            if (object.babylonStakingSlashingPath != null) {
+                                if (typeof object.babylonStakingSlashingPath !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Input.InputBuilder.babylonStakingSlashingPath: object expected");
+                                message.babylonStakingSlashingPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.fromObject(object.babylonStakingSlashingPath);
+                            }
+                            if (object.babylonUnbondingTimelockPath != null) {
+                                if (typeof object.babylonUnbondingTimelockPath !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Input.InputBuilder.babylonUnbondingTimelockPath: object expected");
+                                message.babylonUnbondingTimelockPath = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.fromObject(object.babylonUnbondingTimelockPath);
+                            }
+                            if (object.babylonUnbondingSlashingPath != null) {
+                                if (typeof object.babylonUnbondingSlashingPath !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Input.InputBuilder.babylonUnbondingSlashingPath: object expected");
+                                message.babylonUnbondingSlashingPath = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.fromObject(object.babylonUnbondingSlashingPath);
+                            }
                             return message;
                         };
     
@@ -21286,6 +23915,31 @@
                                 if (options.oneofs)
                                     object.variant = "brc20Inscribe";
                             }
+                            if (message.babylonStakingTimelockPath != null && message.hasOwnProperty("babylonStakingTimelockPath")) {
+                                object.babylonStakingTimelockPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.toObject(message.babylonStakingTimelockPath, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonStakingTimelockPath";
+                            }
+                            if (message.babylonStakingUnbondingPath != null && message.hasOwnProperty("babylonStakingUnbondingPath")) {
+                                object.babylonStakingUnbondingPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.toObject(message.babylonStakingUnbondingPath, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonStakingUnbondingPath";
+                            }
+                            if (message.babylonStakingSlashingPath != null && message.hasOwnProperty("babylonStakingSlashingPath")) {
+                                object.babylonStakingSlashingPath = $root.TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.toObject(message.babylonStakingSlashingPath, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonStakingSlashingPath";
+                            }
+                            if (message.babylonUnbondingTimelockPath != null && message.hasOwnProperty("babylonUnbondingTimelockPath")) {
+                                object.babylonUnbondingTimelockPath = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.toObject(message.babylonUnbondingTimelockPath, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonUnbondingTimelockPath";
+                            }
+                            if (message.babylonUnbondingSlashingPath != null && message.hasOwnProperty("babylonUnbondingSlashingPath")) {
+                                object.babylonUnbondingSlashingPath = $root.TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.toObject(message.babylonUnbondingSlashingPath, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonUnbondingSlashingPath";
+                            }
                             return object;
                         };
     
@@ -22008,6 +24662,9 @@
                          * @property {Uint8Array|null} [p2trDangerousAssumeTweaked] OutputBuilder p2trDangerousAssumeTweaked
                          * @property {TW.BitcoinV2.Proto.Output.IOutputBrc20Inscription|null} [brc20Inscribe] OutputBuilder brc20Inscribe
                          * @property {Uint8Array|null} [opReturn] OutputBuilder opReturn
+                         * @property {TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput|null} [babylonStaking] OutputBuilder babylonStaking
+                         * @property {TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput|null} [babylonUnbonding] OutputBuilder babylonUnbonding
+                         * @property {TW.BabylonStaking.Proto.OutputBuilder.IOpReturn|null} [babylonStakingOpReturn] OutputBuilder babylonStakingOpReturn
                          */
     
                         /**
@@ -22105,17 +24762,41 @@
                          */
                         OutputBuilder.prototype.opReturn = null;
     
+                        /**
+                         * OutputBuilder babylonStaking.
+                         * @member {TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput|null|undefined} babylonStaking
+                         * @memberof TW.BitcoinV2.Proto.Output.OutputBuilder
+                         * @instance
+                         */
+                        OutputBuilder.prototype.babylonStaking = null;
+    
+                        /**
+                         * OutputBuilder babylonUnbonding.
+                         * @member {TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput|null|undefined} babylonUnbonding
+                         * @memberof TW.BitcoinV2.Proto.Output.OutputBuilder
+                         * @instance
+                         */
+                        OutputBuilder.prototype.babylonUnbonding = null;
+    
+                        /**
+                         * OutputBuilder babylonStakingOpReturn.
+                         * @member {TW.BabylonStaking.Proto.OutputBuilder.IOpReturn|null|undefined} babylonStakingOpReturn
+                         * @memberof TW.BitcoinV2.Proto.Output.OutputBuilder
+                         * @instance
+                         */
+                        OutputBuilder.prototype.babylonStakingOpReturn = null;
+    
                         // OneOf field names bound to virtual getters and setters
                         var $oneOfFields;
     
                         /**
                          * OutputBuilder variant.
-                         * @member {"p2sh"|"p2pk"|"p2pkh"|"p2wsh"|"p2wpkh"|"p2trKeyPath"|"p2trScriptPath"|"p2trDangerousAssumeTweaked"|"brc20Inscribe"|"opReturn"|undefined} variant
+                         * @member {"p2sh"|"p2pk"|"p2pkh"|"p2wsh"|"p2wpkh"|"p2trKeyPath"|"p2trScriptPath"|"p2trDangerousAssumeTweaked"|"brc20Inscribe"|"opReturn"|"babylonStaking"|"babylonUnbonding"|"babylonStakingOpReturn"|undefined} variant
                          * @memberof TW.BitcoinV2.Proto.Output.OutputBuilder
                          * @instance
                          */
                         Object.defineProperty(OutputBuilder.prototype, "variant", {
-                            get: $util.oneOfGetter($oneOfFields = ["p2sh", "p2pk", "p2pkh", "p2wsh", "p2wpkh", "p2trKeyPath", "p2trScriptPath", "p2trDangerousAssumeTweaked", "brc20Inscribe", "opReturn"]),
+                            get: $util.oneOfGetter($oneOfFields = ["p2sh", "p2pk", "p2pkh", "p2wsh", "p2wpkh", "p2trKeyPath", "p2trScriptPath", "p2trDangerousAssumeTweaked", "brc20Inscribe", "opReturn", "babylonStaking", "babylonUnbonding", "babylonStakingOpReturn"]),
                             set: $util.oneOfSetter($oneOfFields)
                         });
     
@@ -22163,6 +24844,12 @@
                                 $root.TW.BitcoinV2.Proto.Output.OutputBrc20Inscription.encode(message.brc20Inscribe, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
                             if (message.opReturn != null && Object.hasOwnProperty.call(message, "opReturn"))
                                 writer.uint32(/* id 12, wireType 2 =*/98).bytes(message.opReturn);
+                            if (message.babylonStaking != null && Object.hasOwnProperty.call(message, "babylonStaking"))
+                                $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.encode(message.babylonStaking, writer.uint32(/* id 15, wireType 2 =*/122).fork()).ldelim();
+                            if (message.babylonUnbonding != null && Object.hasOwnProperty.call(message, "babylonUnbonding"))
+                                $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.encode(message.babylonUnbonding, writer.uint32(/* id 16, wireType 2 =*/130).fork()).ldelim();
+                            if (message.babylonStakingOpReturn != null && Object.hasOwnProperty.call(message, "babylonStakingOpReturn"))
+                                $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn.encode(message.babylonStakingOpReturn, writer.uint32(/* id 17, wireType 2 =*/138).fork()).ldelim();
                             return writer;
                         };
     
@@ -22214,6 +24901,15 @@
                                 case 12:
                                     message.opReturn = reader.bytes();
                                     break;
+                                case 15:
+                                    message.babylonStaking = $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.decode(reader, reader.uint32());
+                                    break;
+                                case 16:
+                                    message.babylonUnbonding = $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.decode(reader, reader.uint32());
+                                    break;
+                                case 17:
+                                    message.babylonStakingOpReturn = $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn.decode(reader, reader.uint32());
+                                    break;
                                 default:
                                     reader.skipType(tag & 7);
                                     break;
@@ -22320,6 +25016,36 @@
                                 if (!(message.opReturn && typeof message.opReturn.length === "number" || $util.isString(message.opReturn)))
                                     return "opReturn: buffer expected";
                             }
+                            if (message.babylonStaking != null && message.hasOwnProperty("babylonStaking")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.verify(message.babylonStaking);
+                                    if (error)
+                                        return "babylonStaking." + error;
+                                }
+                            }
+                            if (message.babylonUnbonding != null && message.hasOwnProperty("babylonUnbonding")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.verify(message.babylonUnbonding);
+                                    if (error)
+                                        return "babylonUnbonding." + error;
+                                }
+                            }
+                            if (message.babylonStakingOpReturn != null && message.hasOwnProperty("babylonStakingOpReturn")) {
+                                if (properties.variant === 1)
+                                    return "variant: multiple values";
+                                properties.variant = 1;
+                                {
+                                    var error = $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn.verify(message.babylonStakingOpReturn);
+                                    if (error)
+                                        return "babylonStakingOpReturn." + error;
+                                }
+                            }
                             return null;
                         };
     
@@ -22385,6 +25111,21 @@
                                     $util.base64.decode(object.opReturn, message.opReturn = $util.newBuffer($util.base64.length(object.opReturn)), 0);
                                 else if (object.opReturn.length)
                                     message.opReturn = object.opReturn;
+                            if (object.babylonStaking != null) {
+                                if (typeof object.babylonStaking !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Output.OutputBuilder.babylonStaking: object expected");
+                                message.babylonStaking = $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.fromObject(object.babylonStaking);
+                            }
+                            if (object.babylonUnbonding != null) {
+                                if (typeof object.babylonUnbonding !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Output.OutputBuilder.babylonUnbonding: object expected");
+                                message.babylonUnbonding = $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.fromObject(object.babylonUnbonding);
+                            }
+                            if (object.babylonStakingOpReturn != null) {
+                                if (typeof object.babylonStakingOpReturn !== "object")
+                                    throw TypeError(".TW.BitcoinV2.Proto.Output.OutputBuilder.babylonStakingOpReturn: object expected");
+                                message.babylonStakingOpReturn = $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn.fromObject(object.babylonStakingOpReturn);
+                            }
                             return message;
                         };
     
@@ -22451,6 +25192,21 @@
                                 if (options.oneofs)
                                     object.variant = "opReturn";
                             }
+                            if (message.babylonStaking != null && message.hasOwnProperty("babylonStaking")) {
+                                object.babylonStaking = $root.TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.toObject(message.babylonStaking, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonStaking";
+                            }
+                            if (message.babylonUnbonding != null && message.hasOwnProperty("babylonUnbonding")) {
+                                object.babylonUnbonding = $root.TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.toObject(message.babylonUnbonding, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonUnbonding";
+                            }
+                            if (message.babylonStakingOpReturn != null && message.hasOwnProperty("babylonStakingOpReturn")) {
+                                object.babylonStakingOpReturn = $root.TW.BabylonStaking.Proto.OutputBuilder.OpReturn.toObject(message.babylonStakingOpReturn, options);
+                                if (options.oneofs)
+                                    object.variant = "babylonStakingOpReturn";
+                            }
                             return object;
                         };