@trustwallet/wallet-core 4.2.0-dev-rc4 → 4.2.1-hot-fix

package/dist/generated/core_proto.d.ts

@@ -1268,6 +1268,91 @@ export namespace TW {
                 public toJSON(): { [k: string]: any };
             }
 
+            /** Properties of a FungibleAssetTransferMessage. */
+            interface IFungibleAssetTransferMessage {
+
+                /** FungibleAssetTransferMessage metadataAddress */
+                metadataAddress?: (string|null);
+
+                /** FungibleAssetTransferMessage to */
+                to?: (string|null);
+
+                /** FungibleAssetTransferMessage amount */
+                amount?: (Long|null);
+            }
+
+            /** Represents a FungibleAssetTransferMessage. */
+            class FungibleAssetTransferMessage implements IFungibleAssetTransferMessage {
+
+                /**
+                 * Constructs a new FungibleAssetTransferMessage.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.Aptos.Proto.IFungibleAssetTransferMessage);
+
+                /** FungibleAssetTransferMessage metadataAddress. */
+                public metadataAddress: string;
+
+                /** FungibleAssetTransferMessage to. */
+                public to: string;
+
+                /** FungibleAssetTransferMessage amount. */
+                public amount: Long;
+
+                /**
+                 * Creates a new FungibleAssetTransferMessage instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns FungibleAssetTransferMessage instance
+                 */
+                public static create(properties?: TW.Aptos.Proto.IFungibleAssetTransferMessage): TW.Aptos.Proto.FungibleAssetTransferMessage;
+
+                /**
+                 * Encodes the specified FungibleAssetTransferMessage message. Does not implicitly {@link TW.Aptos.Proto.FungibleAssetTransferMessage.verify|verify} messages.
+                 * @param message FungibleAssetTransferMessage message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.Aptos.Proto.IFungibleAssetTransferMessage, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes a FungibleAssetTransferMessage message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns FungibleAssetTransferMessage
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.Aptos.Proto.FungibleAssetTransferMessage;
+
+                /**
+                 * Verifies a FungibleAssetTransferMessage message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates a FungibleAssetTransferMessage message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns FungibleAssetTransferMessage
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.Aptos.Proto.FungibleAssetTransferMessage;
+
+                /**
+                 * Creates a plain object from a FungibleAssetTransferMessage message. Also converts values to other types if specified.
+                 * @param message FungibleAssetTransferMessage
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.Aptos.Proto.FungibleAssetTransferMessage, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this FungibleAssetTransferMessage to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+
             /** Properties of a ManagedTokensRegisterMessage. */
             interface IManagedTokensRegisterMessage {
 
@@ -2159,6 +2244,12 @@ export namespace TW {
 
                 /** SigningInput tokenTransferCoins */
                 tokenTransferCoins?: (TW.Aptos.Proto.ITokenTransferCoinsMessage|null);
+
+                /** SigningInput fungibleAssetTransfer */
+                fungibleAssetTransfer?: (TW.Aptos.Proto.IFungibleAssetTransferMessage|null);
+
+                /** SigningInput abi */
+                abi?: (string|null);
             }
 
             /** Represents a SigningInput. */
@@ -2215,8 +2306,14 @@ export namespace TW {
                 /** SigningInput tokenTransferCoins. */
                 public tokenTransferCoins?: (TW.Aptos.Proto.ITokenTransferCoinsMessage|null);
 
+                /** SigningInput fungibleAssetTransfer. */
+                public fungibleAssetTransfer?: (TW.Aptos.Proto.IFungibleAssetTransferMessage|null);
+
+                /** SigningInput abi. */
+                public abi: string;
+
                 /** SigningInput transactionPayload. */
-                public transactionPayload?: ("transfer"|"tokenTransfer"|"createAccount"|"nftMessage"|"registerToken"|"liquidStakingMessage"|"tokenTransferCoins");
+                public transactionPayload?: ("transfer"|"tokenTransfer"|"createAccount"|"nftMessage"|"registerToken"|"liquidStakingMessage"|"tokenTransferCoins"|"fungibleAssetTransfer");
 
                 /**
                  * Creates a new SigningInput instance using the specified properties.
@@ -2373,86 +2470,1030 @@ export namespace TW {
                 errorMessage?: (string|null);
             }
 
-            /** Represents a SigningOutput. */
-            class SigningOutput implements ISigningOutput {
+            /** Represents a SigningOutput. */
+            class SigningOutput implements ISigningOutput {
+
+                /**
+                 * Constructs a new SigningOutput.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.Aptos.Proto.ISigningOutput);
+
+                /** The raw transaction (bytes) */
+                public rawTxn: Uint8Array;
+
+                /** Public key and signature to authenticate */
+                public authenticator?: (TW.Aptos.Proto.ITransactionAuthenticator|null);
+
+                /** Signed and encoded transaction bytes. */
+                public encoded: Uint8Array;
+
+                /** SigningOutput json. */
+                public json: string;
+
+                /** SigningOutput error. */
+                public error: TW.Common.Proto.SigningError;
+
+                /** SigningOutput errorMessage. */
+                public errorMessage: string;
+
+                /**
+                 * Creates a new SigningOutput instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns SigningOutput instance
+                 */
+                public static create(properties?: TW.Aptos.Proto.ISigningOutput): TW.Aptos.Proto.SigningOutput;
+
+                /**
+                 * Encodes the specified SigningOutput message. Does not implicitly {@link TW.Aptos.Proto.SigningOutput.verify|verify} messages.
+                 * @param message SigningOutput message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.Aptos.Proto.ISigningOutput, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes a SigningOutput message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns SigningOutput
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.Aptos.Proto.SigningOutput;
+
+                /**
+                 * Verifies a SigningOutput message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates a SigningOutput message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns SigningOutput
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.Aptos.Proto.SigningOutput;
+
+                /**
+                 * Creates a plain object from a SigningOutput message. Also converts values to other types if specified.
+                 * @param message SigningOutput
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.Aptos.Proto.SigningOutput, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this SigningOutput to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+        }
+    }
+
+    /** Namespace BabylonStaking. */
+    namespace BabylonStaking {
+
+        /** Namespace Proto. */
+        namespace Proto {
+
+            /** Properties of a PublicKeySignature. */
+            interface IPublicKeySignature {
+
+                /** PublicKeySignature publicKey */
+                publicKey?: (Uint8Array|null);
+
+                /** PublicKeySignature signature */
+                signature?: (Uint8Array|null);
+            }
+
+            /** Represents a PublicKeySignature. */
+            class PublicKeySignature implements IPublicKeySignature {
+
+                /**
+                 * Constructs a new PublicKeySignature.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.BabylonStaking.Proto.IPublicKeySignature);
+
+                /** PublicKeySignature publicKey. */
+                public publicKey: Uint8Array;
+
+                /** PublicKeySignature signature. */
+                public signature: Uint8Array;
+
+                /**
+                 * Creates a new PublicKeySignature instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns PublicKeySignature instance
+                 */
+                public static create(properties?: TW.BabylonStaking.Proto.IPublicKeySignature): TW.BabylonStaking.Proto.PublicKeySignature;
+
+                /**
+                 * Encodes the specified PublicKeySignature message. Does not implicitly {@link TW.BabylonStaking.Proto.PublicKeySignature.verify|verify} messages.
+                 * @param message PublicKeySignature message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.BabylonStaking.Proto.IPublicKeySignature, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes a PublicKeySignature message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns PublicKeySignature
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.PublicKeySignature;
+
+                /**
+                 * Verifies a PublicKeySignature message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates a PublicKeySignature message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns PublicKeySignature
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.PublicKeySignature;
+
+                /**
+                 * Creates a plain object from a PublicKeySignature message. Also converts values to other types if specified.
+                 * @param message PublicKeySignature
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.BabylonStaking.Proto.PublicKeySignature, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this PublicKeySignature to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+
+            /** Properties of a StakingInfo. */
+            interface IStakingInfo {
+
+                /** StakingInfo stakerPublicKey */
+                stakerPublicKey?: (Uint8Array|null);
+
+                /** StakingInfo finalityProviderPublicKey */
+                finalityProviderPublicKey?: (Uint8Array|null);
+
+                /** StakingInfo stakingTime */
+                stakingTime?: (number|null);
+
+                /** StakingInfo covenantCommitteePublicKeys */
+                covenantCommitteePublicKeys?: (Uint8Array[]|null);
+
+                /** StakingInfo covenantQuorum */
+                covenantQuorum?: (number|null);
+            }
+
+            /** Represents a StakingInfo. */
+            class StakingInfo implements IStakingInfo {
+
+                /**
+                 * Constructs a new StakingInfo.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.BabylonStaking.Proto.IStakingInfo);
+
+                /** StakingInfo stakerPublicKey. */
+                public stakerPublicKey: Uint8Array;
+
+                /** StakingInfo finalityProviderPublicKey. */
+                public finalityProviderPublicKey: Uint8Array;
+
+                /** StakingInfo stakingTime. */
+                public stakingTime: number;
+
+                /** StakingInfo covenantCommitteePublicKeys. */
+                public covenantCommitteePublicKeys: Uint8Array[];
+
+                /** StakingInfo covenantQuorum. */
+                public covenantQuorum: number;
+
+                /**
+                 * Creates a new StakingInfo instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns StakingInfo instance
+                 */
+                public static create(properties?: TW.BabylonStaking.Proto.IStakingInfo): TW.BabylonStaking.Proto.StakingInfo;
+
+                /**
+                 * Encodes the specified StakingInfo message. Does not implicitly {@link TW.BabylonStaking.Proto.StakingInfo.verify|verify} messages.
+                 * @param message StakingInfo message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.BabylonStaking.Proto.IStakingInfo, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes a StakingInfo message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns StakingInfo
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.StakingInfo;
+
+                /**
+                 * Verifies a StakingInfo message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates a StakingInfo message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns StakingInfo
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.StakingInfo;
+
+                /**
+                 * Creates a plain object from a StakingInfo message. Also converts values to other types if specified.
+                 * @param message StakingInfo
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.BabylonStaking.Proto.StakingInfo, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this StakingInfo to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+
+            /** Properties of an InputBuilder. */
+            interface IInputBuilder {
+            }
+
+            /** Represents an InputBuilder. */
+            class InputBuilder implements IInputBuilder {
+
+                /**
+                 * Constructs a new InputBuilder.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.BabylonStaking.Proto.IInputBuilder);
+
+                /**
+                 * Creates a new InputBuilder instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns InputBuilder instance
+                 */
+                public static create(properties?: TW.BabylonStaking.Proto.IInputBuilder): TW.BabylonStaking.Proto.InputBuilder;
+
+                /**
+                 * Encodes the specified InputBuilder message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.verify|verify} messages.
+                 * @param message InputBuilder message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.BabylonStaking.Proto.IInputBuilder, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes an InputBuilder message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns InputBuilder
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.InputBuilder;
+
+                /**
+                 * Verifies an InputBuilder message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates an InputBuilder message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns InputBuilder
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.InputBuilder;
+
+                /**
+                 * Creates a plain object from an InputBuilder message. Also converts values to other types if specified.
+                 * @param message InputBuilder
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.BabylonStaking.Proto.InputBuilder, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this InputBuilder to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+
+            namespace InputBuilder {
+
+                /** Properties of a StakingTimelockPath. */
+                interface IStakingTimelockPath {
+
+                    /** StakingTimelockPath params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+                }
+
+                /** Represents a StakingTimelockPath. */
+                class StakingTimelockPath implements IStakingTimelockPath {
+
+                    /**
+                     * Constructs a new StakingTimelockPath.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath);
+
+                    /** StakingTimelockPath params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /**
+                     * Creates a new StakingTimelockPath instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns StakingTimelockPath instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath): TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath;
+
+                    /**
+                     * Encodes the specified StakingTimelockPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath.verify|verify} messages.
+                     * @param message StakingTimelockPath message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes a StakingTimelockPath message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns StakingTimelockPath
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath;
+
+                    /**
+                     * Verifies a StakingTimelockPath message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates a StakingTimelockPath message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns StakingTimelockPath
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath;
+
+                    /**
+                     * Creates a plain object from a StakingTimelockPath message. Also converts values to other types if specified.
+                     * @param message StakingTimelockPath
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.InputBuilder.StakingTimelockPath, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this StakingTimelockPath to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                /** Properties of a StakingUnbondingPath. */
+                interface IStakingUnbondingPath {
+
+                    /** StakingUnbondingPath params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /** StakingUnbondingPath covenantCommitteeSignatures */
+                    covenantCommitteeSignatures?: (TW.BabylonStaking.Proto.IPublicKeySignature[]|null);
+                }
+
+                /** Represents a StakingUnbondingPath. */
+                class StakingUnbondingPath implements IStakingUnbondingPath {
+
+                    /**
+                     * Constructs a new StakingUnbondingPath.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath);
+
+                    /** StakingUnbondingPath params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /** StakingUnbondingPath covenantCommitteeSignatures. */
+                    public covenantCommitteeSignatures: TW.BabylonStaking.Proto.IPublicKeySignature[];
+
+                    /**
+                     * Creates a new StakingUnbondingPath instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns StakingUnbondingPath instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath): TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath;
+
+                    /**
+                     * Encodes the specified StakingUnbondingPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath.verify|verify} messages.
+                     * @param message StakingUnbondingPath message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes a StakingUnbondingPath message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns StakingUnbondingPath
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath;
+
+                    /**
+                     * Verifies a StakingUnbondingPath message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates a StakingUnbondingPath message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns StakingUnbondingPath
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath;
+
+                    /**
+                     * Creates a plain object from a StakingUnbondingPath message. Also converts values to other types if specified.
+                     * @param message StakingUnbondingPath
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.InputBuilder.StakingUnbondingPath, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this StakingUnbondingPath to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                /** Properties of a StakingSlashingPath. */
+                interface IStakingSlashingPath {
+
+                    /** StakingSlashingPath params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /** StakingSlashingPath finalityProviderSignature */
+                    finalityProviderSignature?: (TW.BabylonStaking.Proto.IPublicKeySignature|null);
+                }
+
+                /** Represents a StakingSlashingPath. */
+                class StakingSlashingPath implements IStakingSlashingPath {
+
+                    /**
+                     * Constructs a new StakingSlashingPath.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath);
+
+                    /** StakingSlashingPath params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /** StakingSlashingPath finalityProviderSignature. */
+                    public finalityProviderSignature?: (TW.BabylonStaking.Proto.IPublicKeySignature|null);
+
+                    /**
+                     * Creates a new StakingSlashingPath instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns StakingSlashingPath instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath): TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath;
+
+                    /**
+                     * Encodes the specified StakingSlashingPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath.verify|verify} messages.
+                     * @param message StakingSlashingPath message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes a StakingSlashingPath message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns StakingSlashingPath
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath;
+
+                    /**
+                     * Verifies a StakingSlashingPath message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates a StakingSlashingPath message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns StakingSlashingPath
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath;
+
+                    /**
+                     * Creates a plain object from a StakingSlashingPath message. Also converts values to other types if specified.
+                     * @param message StakingSlashingPath
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.InputBuilder.StakingSlashingPath, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this StakingSlashingPath to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                /** Properties of an UnbondingTimelockPath. */
+                interface IUnbondingTimelockPath {
+
+                    /** UnbondingTimelockPath params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+                }
+
+                /** Represents an UnbondingTimelockPath. */
+                class UnbondingTimelockPath implements IUnbondingTimelockPath {
+
+                    /**
+                     * Constructs a new UnbondingTimelockPath.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath);
+
+                    /** UnbondingTimelockPath params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /**
+                     * Creates a new UnbondingTimelockPath instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns UnbondingTimelockPath instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath): TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath;
+
+                    /**
+                     * Encodes the specified UnbondingTimelockPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath.verify|verify} messages.
+                     * @param message UnbondingTimelockPath message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes an UnbondingTimelockPath message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns UnbondingTimelockPath
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath;
+
+                    /**
+                     * Verifies an UnbondingTimelockPath message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates an UnbondingTimelockPath message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns UnbondingTimelockPath
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath;
+
+                    /**
+                     * Creates a plain object from an UnbondingTimelockPath message. Also converts values to other types if specified.
+                     * @param message UnbondingTimelockPath
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.InputBuilder.UnbondingTimelockPath, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this UnbondingTimelockPath to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                /** Properties of an UnbondingSlashingPath. */
+                interface IUnbondingSlashingPath {
+
+                    /** UnbondingSlashingPath params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /** UnbondingSlashingPath finalityProviderSignature */
+                    finalityProviderSignature?: (TW.BabylonStaking.Proto.IPublicKeySignature|null);
+                }
+
+                /** Represents an UnbondingSlashingPath. */
+                class UnbondingSlashingPath implements IUnbondingSlashingPath {
+
+                    /**
+                     * Constructs a new UnbondingSlashingPath.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath);
+
+                    /** UnbondingSlashingPath params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /** UnbondingSlashingPath finalityProviderSignature. */
+                    public finalityProviderSignature?: (TW.BabylonStaking.Proto.IPublicKeySignature|null);
+
+                    /**
+                     * Creates a new UnbondingSlashingPath instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns UnbondingSlashingPath instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath): TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath;
+
+                    /**
+                     * Encodes the specified UnbondingSlashingPath message. Does not implicitly {@link TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath.verify|verify} messages.
+                     * @param message UnbondingSlashingPath message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes an UnbondingSlashingPath message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns UnbondingSlashingPath
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath;
+
+                    /**
+                     * Verifies an UnbondingSlashingPath message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates an UnbondingSlashingPath message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns UnbondingSlashingPath
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath;
+
+                    /**
+                     * Creates a plain object from an UnbondingSlashingPath message. Also converts values to other types if specified.
+                     * @param message UnbondingSlashingPath
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.InputBuilder.UnbondingSlashingPath, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this UnbondingSlashingPath to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+            }
+
+            /** Properties of an OutputBuilder. */
+            interface IOutputBuilder {
+            }
+
+            /** Represents an OutputBuilder. */
+            class OutputBuilder implements IOutputBuilder {
 
                 /**
-                 * Constructs a new SigningOutput.
+                 * Constructs a new OutputBuilder.
                  * @param [properties] Properties to set
                  */
-                constructor(properties?: TW.Aptos.Proto.ISigningOutput);
-
-                /** The raw transaction (bytes) */
-                public rawTxn: Uint8Array;
-
-                /** Public key and signature to authenticate */
-                public authenticator?: (TW.Aptos.Proto.ITransactionAuthenticator|null);
-
-                /** Signed and encoded transaction bytes. */
-                public encoded: Uint8Array;
-
-                /** SigningOutput json. */
-                public json: string;
-
-                /** SigningOutput error. */
-                public error: TW.Common.Proto.SigningError;
-
-                /** SigningOutput errorMessage. */
-                public errorMessage: string;
+                constructor(properties?: TW.BabylonStaking.Proto.IOutputBuilder);
 
                 /**
-                 * Creates a new SigningOutput instance using the specified properties.
+                 * Creates a new OutputBuilder instance using the specified properties.
                  * @param [properties] Properties to set
-                 * @returns SigningOutput instance
+                 * @returns OutputBuilder instance
                  */
-                public static create(properties?: TW.Aptos.Proto.ISigningOutput): TW.Aptos.Proto.SigningOutput;
+                public static create(properties?: TW.BabylonStaking.Proto.IOutputBuilder): TW.BabylonStaking.Proto.OutputBuilder;
 
                 /**
-                 * Encodes the specified SigningOutput message. Does not implicitly {@link TW.Aptos.Proto.SigningOutput.verify|verify} messages.
-                 * @param message SigningOutput message or plain object to encode
+                 * Encodes the specified OutputBuilder message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.verify|verify} messages.
+                 * @param message OutputBuilder message or plain object to encode
                  * @param [writer] Writer to encode to
                  * @returns Writer
                  */
-                public static encode(message: TW.Aptos.Proto.ISigningOutput, writer?: $protobuf.Writer): $protobuf.Writer;
+                public static encode(message: TW.BabylonStaking.Proto.IOutputBuilder, writer?: $protobuf.Writer): $protobuf.Writer;
 
                 /**
-                 * Decodes a SigningOutput message from the specified reader or buffer.
+                 * Decodes an OutputBuilder message from the specified reader or buffer.
                  * @param reader Reader or buffer to decode from
                  * @param [length] Message length if known beforehand
-                 * @returns SigningOutput
+                 * @returns OutputBuilder
                  * @throws {Error} If the payload is not a reader or valid buffer
                  * @throws {$protobuf.util.ProtocolError} If required fields are missing
                  */
-                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.Aptos.Proto.SigningOutput;
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.OutputBuilder;
 
                 /**
-                 * Verifies a SigningOutput message.
+                 * Verifies an OutputBuilder message.
                  * @param message Plain object to verify
                  * @returns `null` if valid, otherwise the reason why it is not
                  */
                 public static verify(message: { [k: string]: any }): (string|null);
 
                 /**
-                 * Creates a SigningOutput message from a plain object. Also converts values to their respective internal types.
+                 * Creates an OutputBuilder message from a plain object. Also converts values to their respective internal types.
                  * @param object Plain object
-                 * @returns SigningOutput
+                 * @returns OutputBuilder
                  */
-                public static fromObject(object: { [k: string]: any }): TW.Aptos.Proto.SigningOutput;
+                public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.OutputBuilder;
 
                 /**
-                 * Creates a plain object from a SigningOutput message. Also converts values to other types if specified.
-                 * @param message SigningOutput
+                 * Creates a plain object from an OutputBuilder message. Also converts values to other types if specified.
+                 * @param message OutputBuilder
                  * @param [options] Conversion options
                  * @returns Plain object
                  */
-                public static toObject(message: TW.Aptos.Proto.SigningOutput, options?: $protobuf.IConversionOptions): { [k: string]: any };
+                public static toObject(message: TW.BabylonStaking.Proto.OutputBuilder, options?: $protobuf.IConversionOptions): { [k: string]: any };
 
                 /**
-                 * Converts this SigningOutput to JSON.
+                 * Converts this OutputBuilder to JSON.
                  * @returns JSON object
                  */
                 public toJSON(): { [k: string]: any };
             }
+
+            namespace OutputBuilder {
+
+                /** Properties of a StakingOutput. */
+                interface IStakingOutput {
+
+                    /** StakingOutput params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+                }
+
+                /** Represents a StakingOutput. */
+                class StakingOutput implements IStakingOutput {
+
+                    /**
+                     * Constructs a new StakingOutput.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput);
+
+                    /** StakingOutput params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /**
+                     * Creates a new StakingOutput instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns StakingOutput instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput): TW.BabylonStaking.Proto.OutputBuilder.StakingOutput;
+
+                    /**
+                     * Encodes the specified StakingOutput message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.StakingOutput.verify|verify} messages.
+                     * @param message StakingOutput message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes a StakingOutput message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns StakingOutput
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.OutputBuilder.StakingOutput;
+
+                    /**
+                     * Verifies a StakingOutput message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates a StakingOutput message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns StakingOutput
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.OutputBuilder.StakingOutput;
+
+                    /**
+                     * Creates a plain object from a StakingOutput message. Also converts values to other types if specified.
+                     * @param message StakingOutput
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.OutputBuilder.StakingOutput, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this StakingOutput to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                /** Properties of an UnbondingOutput. */
+                interface IUnbondingOutput {
+
+                    /** UnbondingOutput params */
+                    params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+                }
+
+                /** Represents an UnbondingOutput. */
+                class UnbondingOutput implements IUnbondingOutput {
+
+                    /**
+                     * Constructs a new UnbondingOutput.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput);
+
+                    /** UnbondingOutput params. */
+                    public params?: (TW.BabylonStaking.Proto.IStakingInfo|null);
+
+                    /**
+                     * Creates a new UnbondingOutput instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns UnbondingOutput instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput): TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput;
+
+                    /**
+                     * Encodes the specified UnbondingOutput message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput.verify|verify} messages.
+                     * @param message UnbondingOutput message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes an UnbondingOutput message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns UnbondingOutput
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput;
+
+                    /**
+                     * Verifies an UnbondingOutput message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates an UnbondingOutput message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns UnbondingOutput
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput;
+
+                    /**
+                     * Creates a plain object from an UnbondingOutput message. Also converts values to other types if specified.
+                     * @param message UnbondingOutput
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.OutputBuilder.UnbondingOutput, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this UnbondingOutput to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                /** Properties of an OpReturn. */
+                interface IOpReturn {
+
+                    /** OpReturn tag */
+                    tag?: (Uint8Array|null);
+
+                    /** OpReturn stakerPublicKey */
+                    stakerPublicKey?: (Uint8Array|null);
+
+                    /** OpReturn finalityProviderPublicKey */
+                    finalityProviderPublicKey?: (Uint8Array|null);
+
+                    /** OpReturn stakingTime */
+                    stakingTime?: (number|null);
+                }
+
+                /** Represents an OpReturn. */
+                class OpReturn implements IOpReturn {
+
+                    /**
+                     * Constructs a new OpReturn.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.BabylonStaking.Proto.OutputBuilder.IOpReturn);
+
+                    /** OpReturn tag. */
+                    public tag: Uint8Array;
+
+                    /** OpReturn stakerPublicKey. */
+                    public stakerPublicKey: Uint8Array;
+
+                    /** OpReturn finalityProviderPublicKey. */
+                    public finalityProviderPublicKey: Uint8Array;
+
+                    /** OpReturn stakingTime. */
+                    public stakingTime: number;
+
+                    /**
+                     * Creates a new OpReturn instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns OpReturn instance
+                     */
+                    public static create(properties?: TW.BabylonStaking.Proto.OutputBuilder.IOpReturn): TW.BabylonStaking.Proto.OutputBuilder.OpReturn;
+
+                    /**
+                     * Encodes the specified OpReturn message. Does not implicitly {@link TW.BabylonStaking.Proto.OutputBuilder.OpReturn.verify|verify} messages.
+                     * @param message OpReturn message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.BabylonStaking.Proto.OutputBuilder.IOpReturn, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes an OpReturn message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns OpReturn
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BabylonStaking.Proto.OutputBuilder.OpReturn;
+
+                    /**
+                     * Verifies an OpReturn message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates an OpReturn message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns OpReturn
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.BabylonStaking.Proto.OutputBuilder.OpReturn;
+
+                    /**
+                     * Creates a plain object from an OpReturn message. Also converts values to other types if specified.
+                     * @param message OpReturn
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.BabylonStaking.Proto.OutputBuilder.OpReturn, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this OpReturn to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+            }
         }
     }
 
@@ -6020,6 +7061,9 @@ export namespace TW {
                 /** SigningInput time */
                 time?: (number|null);
 
+                /** SigningInput zip_0317 */
+                zip_0317?: (boolean|null);
+
                 /** SigningInput signingV2 */
                 signingV2?: (TW.BitcoinV2.Proto.ISigningInput|null);
 
@@ -6090,6 +7134,9 @@ export namespace TW {
                 /** SigningInput time. */
                 public time: number;
 
+                /** SigningInput zip_0317. */
+                public zip_0317: boolean;
+
                 /** SigningInput signingV2. */
                 public signingV2?: (TW.BitcoinV2.Proto.ISigningInput|null);
 
@@ -6663,6 +7710,85 @@ export namespace TW {
                 public toJSON(): { [k: string]: any };
             }
 
+            /** Properties of a PublicKeySignature. */
+            interface IPublicKeySignature {
+
+                /** PublicKeySignature publicKey */
+                publicKey?: (Uint8Array|null);
+
+                /** PublicKeySignature signature */
+                signature?: (Uint8Array|null);
+            }
+
+            /** Represents a PublicKeySignature. */
+            class PublicKeySignature implements IPublicKeySignature {
+
+                /**
+                 * Constructs a new PublicKeySignature.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.BitcoinV2.Proto.IPublicKeySignature);
+
+                /** PublicKeySignature publicKey. */
+                public publicKey: Uint8Array;
+
+                /** PublicKeySignature signature. */
+                public signature: Uint8Array;
+
+                /**
+                 * Creates a new PublicKeySignature instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns PublicKeySignature instance
+                 */
+                public static create(properties?: TW.BitcoinV2.Proto.IPublicKeySignature): TW.BitcoinV2.Proto.PublicKeySignature;
+
+                /**
+                 * Encodes the specified PublicKeySignature message. Does not implicitly {@link TW.BitcoinV2.Proto.PublicKeySignature.verify|verify} messages.
+                 * @param message PublicKeySignature message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.BitcoinV2.Proto.IPublicKeySignature, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes a PublicKeySignature message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns PublicKeySignature
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.BitcoinV2.Proto.PublicKeySignature;
+
+                /**
+                 * Verifies a PublicKeySignature message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates a PublicKeySignature message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns PublicKeySignature
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.BitcoinV2.Proto.PublicKeySignature;
+
+                /**
+                 * Creates a plain object from a PublicKeySignature message. Also converts values to other types if specified.
+                 * @param message PublicKeySignature
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.BitcoinV2.Proto.PublicKeySignature, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this PublicKeySignature to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+
             /** Properties of an OutPoint. */
             interface IOutPoint {
 
@@ -6946,6 +8072,21 @@ export namespace TW {
 
                     /** InputBuilder brc20Inscribe */
                     brc20Inscribe?: (TW.BitcoinV2.Proto.Input.IInputBrc20Inscription|null);
+
+                    /** InputBuilder babylonStakingTimelockPath */
+                    babylonStakingTimelockPath?: (TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath|null);
+
+                    /** InputBuilder babylonStakingUnbondingPath */
+                    babylonStakingUnbondingPath?: (TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath|null);
+
+                    /** InputBuilder babylonStakingSlashingPath */
+                    babylonStakingSlashingPath?: (TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath|null);
+
+                    /** InputBuilder babylonUnbondingTimelockPath */
+                    babylonUnbondingTimelockPath?: (TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath|null);
+
+                    /** InputBuilder babylonUnbondingSlashingPath */
+                    babylonUnbondingSlashingPath?: (TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath|null);
                 }
 
                 /** Represents an InputBuilder. */
@@ -6972,8 +8113,23 @@ export namespace TW {
                     /** InputBuilder brc20Inscribe. */
                     public brc20Inscribe?: (TW.BitcoinV2.Proto.Input.IInputBrc20Inscription|null);
 
+                    /** InputBuilder babylonStakingTimelockPath. */
+                    public babylonStakingTimelockPath?: (TW.BabylonStaking.Proto.InputBuilder.IStakingTimelockPath|null);
+
+                    /** InputBuilder babylonStakingUnbondingPath. */
+                    public babylonStakingUnbondingPath?: (TW.BabylonStaking.Proto.InputBuilder.IStakingUnbondingPath|null);
+
+                    /** InputBuilder babylonStakingSlashingPath. */
+                    public babylonStakingSlashingPath?: (TW.BabylonStaking.Proto.InputBuilder.IStakingSlashingPath|null);
+
+                    /** InputBuilder babylonUnbondingTimelockPath. */
+                    public babylonUnbondingTimelockPath?: (TW.BabylonStaking.Proto.InputBuilder.IUnbondingTimelockPath|null);
+
+                    /** InputBuilder babylonUnbondingSlashingPath. */
+                    public babylonUnbondingSlashingPath?: (TW.BabylonStaking.Proto.InputBuilder.IUnbondingSlashingPath|null);
+
                     /** InputBuilder variant. */
-                    public variant?: ("p2pk"|"p2pkh"|"p2wpkh"|"p2trKeyPath"|"brc20Inscribe");
+                    public variant?: ("p2pk"|"p2pkh"|"p2wpkh"|"p2trKeyPath"|"brc20Inscribe"|"babylonStakingTimelockPath"|"babylonStakingUnbondingPath"|"babylonStakingSlashingPath"|"babylonUnbondingTimelockPath"|"babylonUnbondingSlashingPath");
 
                     /**
                      * Creates a new InputBuilder instance using the specified properties.
@@ -7322,6 +8478,15 @@ export namespace TW {
 
                     /** OutputBuilder opReturn */
                     opReturn?: (Uint8Array|null);
+
+                    /** OutputBuilder babylonStaking */
+                    babylonStaking?: (TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput|null);
+
+                    /** OutputBuilder babylonUnbonding */
+                    babylonUnbonding?: (TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput|null);
+
+                    /** OutputBuilder babylonStakingOpReturn */
+                    babylonStakingOpReturn?: (TW.BabylonStaking.Proto.OutputBuilder.IOpReturn|null);
                 }
 
                 /** Represents an OutputBuilder. */
@@ -7363,8 +8528,17 @@ export namespace TW {
                     /** OutputBuilder opReturn. */
                     public opReturn?: (Uint8Array|null);
 
+                    /** OutputBuilder babylonStaking. */
+                    public babylonStaking?: (TW.BabylonStaking.Proto.OutputBuilder.IStakingOutput|null);
+
+                    /** OutputBuilder babylonUnbonding. */
+                    public babylonUnbonding?: (TW.BabylonStaking.Proto.OutputBuilder.IUnbondingOutput|null);
+
+                    /** OutputBuilder babylonStakingOpReturn. */
+                    public babylonStakingOpReturn?: (TW.BabylonStaking.Proto.OutputBuilder.IOpReturn|null);
+
                     /** OutputBuilder variant. */
-                    public variant?: ("p2sh"|"p2pk"|"p2pkh"|"p2wsh"|"p2wpkh"|"p2trKeyPath"|"p2trScriptPath"|"p2trDangerousAssumeTweaked"|"brc20Inscribe"|"opReturn");
+                    public variant?: ("p2sh"|"p2pk"|"p2pkh"|"p2wsh"|"p2wpkh"|"p2trKeyPath"|"p2trScriptPath"|"p2trDangerousAssumeTweaked"|"brc20Inscribe"|"opReturn"|"babylonStaking"|"babylonUnbonding"|"babylonStakingOpReturn");
 
                     /**
                      * Creates a new OutputBuilder instance using the specified properties.