@trustwallet/wallet-core 3.0.8 → 3.1.0

package/dist/generated/core_proto.js

@@ -40793,6 +40793,1361 @@
             return Harmony;
         })();
     
+        TW.Hedera = (function() {
+    
+            /**
+             * Namespace Hedera.
+             * @memberof TW
+             * @namespace
+             */
+            var Hedera = {};
+    
+            Hedera.Proto = (function() {
+    
+                /**
+                 * Namespace Proto.
+                 * @memberof TW.Hedera
+                 * @namespace
+                 */
+                var Proto = {};
+    
+                Proto.Timestamp = (function() {
+    
+                    /**
+                     * Properties of a Timestamp.
+                     * @memberof TW.Hedera.Proto
+                     * @interface ITimestamp
+                     * @property {Long|null} [seconds] Timestamp seconds
+                     * @property {number|null} [nanos] Timestamp nanos
+                     */
+    
+                    /**
+                     * Constructs a new Timestamp.
+                     * @memberof TW.Hedera.Proto
+                     * @classdesc Represents a Timestamp.
+                     * @implements ITimestamp
+                     * @constructor
+                     * @param {TW.Hedera.Proto.ITimestamp=} [properties] Properties to set
+                     */
+                    function Timestamp(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]];
+                    }
+    
+                    /**
+                     * Timestamp seconds.
+                     * @member {Long} seconds
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @instance
+                     */
+                    Timestamp.prototype.seconds = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+    
+                    /**
+                     * Timestamp nanos.
+                     * @member {number} nanos
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @instance
+                     */
+                    Timestamp.prototype.nanos = 0;
+    
+                    /**
+                     * Creates a new Timestamp instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @static
+                     * @param {TW.Hedera.Proto.ITimestamp=} [properties] Properties to set
+                     * @returns {TW.Hedera.Proto.Timestamp} Timestamp instance
+                     */
+                    Timestamp.create = function create(properties) {
+                        return new Timestamp(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified Timestamp message. Does not implicitly {@link TW.Hedera.Proto.Timestamp.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @static
+                     * @param {TW.Hedera.Proto.ITimestamp} message Timestamp message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    Timestamp.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.seconds != null && Object.hasOwnProperty.call(message, "seconds"))
+                            writer.uint32(/* id 1, wireType 0 =*/8).int64(message.seconds);
+                        if (message.nanos != null && Object.hasOwnProperty.call(message, "nanos"))
+                            writer.uint32(/* id 2, wireType 0 =*/16).int32(message.nanos);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a Timestamp message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Hedera.Proto.Timestamp} Timestamp
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    Timestamp.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.Hedera.Proto.Timestamp();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.seconds = reader.int64();
+                                break;
+                            case 2:
+                                message.nanos = reader.int32();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a Timestamp message.
+                     * @function verify
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    Timestamp.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.seconds != null && message.hasOwnProperty("seconds"))
+                            if (!$util.isInteger(message.seconds) && !(message.seconds && $util.isInteger(message.seconds.low) && $util.isInteger(message.seconds.high)))
+                                return "seconds: integer|Long expected";
+                        if (message.nanos != null && message.hasOwnProperty("nanos"))
+                            if (!$util.isInteger(message.nanos))
+                                return "nanos: integer expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a Timestamp message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Hedera.Proto.Timestamp} Timestamp
+                     */
+                    Timestamp.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Hedera.Proto.Timestamp)
+                            return object;
+                        var message = new $root.TW.Hedera.Proto.Timestamp();
+                        if (object.seconds != null)
+                            if ($util.Long)
+                                (message.seconds = $util.Long.fromValue(object.seconds)).unsigned = false;
+                            else if (typeof object.seconds === "string")
+                                message.seconds = parseInt(object.seconds, 10);
+                            else if (typeof object.seconds === "number")
+                                message.seconds = object.seconds;
+                            else if (typeof object.seconds === "object")
+                                message.seconds = new $util.LongBits(object.seconds.low >>> 0, object.seconds.high >>> 0).toNumber();
+                        if (object.nanos != null)
+                            message.nanos = object.nanos | 0;
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a Timestamp message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @static
+                     * @param {TW.Hedera.Proto.Timestamp} message Timestamp
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    Timestamp.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults) {
+                            if ($util.Long) {
+                                var long = new $util.Long(0, 0, false);
+                                object.seconds = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                            } else
+                                object.seconds = options.longs === String ? "0" : 0;
+                            object.nanos = 0;
+                        }
+                        if (message.seconds != null && message.hasOwnProperty("seconds"))
+                            if (typeof message.seconds === "number")
+                                object.seconds = options.longs === String ? String(message.seconds) : message.seconds;
+                            else
+                                object.seconds = options.longs === String ? $util.Long.prototype.toString.call(message.seconds) : options.longs === Number ? new $util.LongBits(message.seconds.low >>> 0, message.seconds.high >>> 0).toNumber() : message.seconds;
+                        if (message.nanos != null && message.hasOwnProperty("nanos"))
+                            object.nanos = message.nanos;
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this Timestamp to JSON.
+                     * @function toJSON
+                     * @memberof TW.Hedera.Proto.Timestamp
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    Timestamp.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return Timestamp;
+                })();
+    
+                Proto.TransactionID = (function() {
+    
+                    /**
+                     * Properties of a TransactionID.
+                     * @memberof TW.Hedera.Proto
+                     * @interface ITransactionID
+                     * @property {TW.Hedera.Proto.ITimestamp|null} [transactionValidStart] TransactionID transactionValidStart
+                     * @property {string|null} [accountID] TransactionID accountID
+                     * @property {boolean|null} [scheduled] TransactionID scheduled
+                     * @property {number|null} [nonce] TransactionID nonce
+                     */
+    
+                    /**
+                     * Constructs a new TransactionID.
+                     * @memberof TW.Hedera.Proto
+                     * @classdesc Represents a TransactionID.
+                     * @implements ITransactionID
+                     * @constructor
+                     * @param {TW.Hedera.Proto.ITransactionID=} [properties] Properties to set
+                     */
+                    function TransactionID(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]];
+                    }
+    
+                    /**
+                     * TransactionID transactionValidStart.
+                     * @member {TW.Hedera.Proto.ITimestamp|null|undefined} transactionValidStart
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @instance
+                     */
+                    TransactionID.prototype.transactionValidStart = null;
+    
+                    /**
+                     * TransactionID accountID.
+                     * @member {string} accountID
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @instance
+                     */
+                    TransactionID.prototype.accountID = "";
+    
+                    /**
+                     * TransactionID scheduled.
+                     * @member {boolean} scheduled
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @instance
+                     */
+                    TransactionID.prototype.scheduled = false;
+    
+                    /**
+                     * TransactionID nonce.
+                     * @member {number} nonce
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @instance
+                     */
+                    TransactionID.prototype.nonce = 0;
+    
+                    /**
+                     * Creates a new TransactionID instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @static
+                     * @param {TW.Hedera.Proto.ITransactionID=} [properties] Properties to set
+                     * @returns {TW.Hedera.Proto.TransactionID} TransactionID instance
+                     */
+                    TransactionID.create = function create(properties) {
+                        return new TransactionID(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified TransactionID message. Does not implicitly {@link TW.Hedera.Proto.TransactionID.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @static
+                     * @param {TW.Hedera.Proto.ITransactionID} message TransactionID message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    TransactionID.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.transactionValidStart != null && Object.hasOwnProperty.call(message, "transactionValidStart"))
+                            $root.TW.Hedera.Proto.Timestamp.encode(message.transactionValidStart, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                        if (message.accountID != null && Object.hasOwnProperty.call(message, "accountID"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).string(message.accountID);
+                        if (message.scheduled != null && Object.hasOwnProperty.call(message, "scheduled"))
+                            writer.uint32(/* id 3, wireType 0 =*/24).bool(message.scheduled);
+                        if (message.nonce != null && Object.hasOwnProperty.call(message, "nonce"))
+                            writer.uint32(/* id 4, wireType 0 =*/32).int32(message.nonce);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a TransactionID message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Hedera.Proto.TransactionID} TransactionID
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    TransactionID.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.Hedera.Proto.TransactionID();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.transactionValidStart = $root.TW.Hedera.Proto.Timestamp.decode(reader, reader.uint32());
+                                break;
+                            case 2:
+                                message.accountID = reader.string();
+                                break;
+                            case 3:
+                                message.scheduled = reader.bool();
+                                break;
+                            case 4:
+                                message.nonce = reader.int32();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a TransactionID message.
+                     * @function verify
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    TransactionID.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.transactionValidStart != null && message.hasOwnProperty("transactionValidStart")) {
+                            var error = $root.TW.Hedera.Proto.Timestamp.verify(message.transactionValidStart);
+                            if (error)
+                                return "transactionValidStart." + error;
+                        }
+                        if (message.accountID != null && message.hasOwnProperty("accountID"))
+                            if (!$util.isString(message.accountID))
+                                return "accountID: string expected";
+                        if (message.scheduled != null && message.hasOwnProperty("scheduled"))
+                            if (typeof message.scheduled !== "boolean")
+                                return "scheduled: boolean expected";
+                        if (message.nonce != null && message.hasOwnProperty("nonce"))
+                            if (!$util.isInteger(message.nonce))
+                                return "nonce: integer expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a TransactionID message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Hedera.Proto.TransactionID} TransactionID
+                     */
+                    TransactionID.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Hedera.Proto.TransactionID)
+                            return object;
+                        var message = new $root.TW.Hedera.Proto.TransactionID();
+                        if (object.transactionValidStart != null) {
+                            if (typeof object.transactionValidStart !== "object")
+                                throw TypeError(".TW.Hedera.Proto.TransactionID.transactionValidStart: object expected");
+                            message.transactionValidStart = $root.TW.Hedera.Proto.Timestamp.fromObject(object.transactionValidStart);
+                        }
+                        if (object.accountID != null)
+                            message.accountID = String(object.accountID);
+                        if (object.scheduled != null)
+                            message.scheduled = Boolean(object.scheduled);
+                        if (object.nonce != null)
+                            message.nonce = object.nonce | 0;
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a TransactionID message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @static
+                     * @param {TW.Hedera.Proto.TransactionID} message TransactionID
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    TransactionID.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults) {
+                            object.transactionValidStart = null;
+                            object.accountID = "";
+                            object.scheduled = false;
+                            object.nonce = 0;
+                        }
+                        if (message.transactionValidStart != null && message.hasOwnProperty("transactionValidStart"))
+                            object.transactionValidStart = $root.TW.Hedera.Proto.Timestamp.toObject(message.transactionValidStart, options);
+                        if (message.accountID != null && message.hasOwnProperty("accountID"))
+                            object.accountID = message.accountID;
+                        if (message.scheduled != null && message.hasOwnProperty("scheduled"))
+                            object.scheduled = message.scheduled;
+                        if (message.nonce != null && message.hasOwnProperty("nonce"))
+                            object.nonce = message.nonce;
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this TransactionID to JSON.
+                     * @function toJSON
+                     * @memberof TW.Hedera.Proto.TransactionID
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    TransactionID.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return TransactionID;
+                })();
+    
+                Proto.TransferMessage = (function() {
+    
+                    /**
+                     * Properties of a TransferMessage.
+                     * @memberof TW.Hedera.Proto
+                     * @interface ITransferMessage
+                     * @property {string|null} [from] TransferMessage from
+                     * @property {string|null} [to] TransferMessage to
+                     * @property {Long|null} [amount] TransferMessage amount
+                     */
+    
+                    /**
+                     * Constructs a new TransferMessage.
+                     * @memberof TW.Hedera.Proto
+                     * @classdesc Represents a TransferMessage.
+                     * @implements ITransferMessage
+                     * @constructor
+                     * @param {TW.Hedera.Proto.ITransferMessage=} [properties] Properties to set
+                     */
+                    function TransferMessage(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]];
+                    }
+    
+                    /**
+                     * TransferMessage from.
+                     * @member {string} from
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @instance
+                     */
+                    TransferMessage.prototype.from = "";
+    
+                    /**
+                     * TransferMessage to.
+                     * @member {string} to
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @instance
+                     */
+                    TransferMessage.prototype.to = "";
+    
+                    /**
+                     * TransferMessage amount.
+                     * @member {Long} amount
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @instance
+                     */
+                    TransferMessage.prototype.amount = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+    
+                    /**
+                     * Creates a new TransferMessage instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @static
+                     * @param {TW.Hedera.Proto.ITransferMessage=} [properties] Properties to set
+                     * @returns {TW.Hedera.Proto.TransferMessage} TransferMessage instance
+                     */
+                    TransferMessage.create = function create(properties) {
+                        return new TransferMessage(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified TransferMessage message. Does not implicitly {@link TW.Hedera.Proto.TransferMessage.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @static
+                     * @param {TW.Hedera.Proto.ITransferMessage} message TransferMessage message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    TransferMessage.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.from != null && Object.hasOwnProperty.call(message, "from"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).string(message.from);
+                        if (message.to != null && Object.hasOwnProperty.call(message, "to"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).string(message.to);
+                        if (message.amount != null && Object.hasOwnProperty.call(message, "amount"))
+                            writer.uint32(/* id 3, wireType 0 =*/24).sint64(message.amount);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a TransferMessage message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Hedera.Proto.TransferMessage} TransferMessage
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    TransferMessage.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.Hedera.Proto.TransferMessage();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.from = reader.string();
+                                break;
+                            case 2:
+                                message.to = reader.string();
+                                break;
+                            case 3:
+                                message.amount = reader.sint64();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a TransferMessage message.
+                     * @function verify
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    TransferMessage.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.from != null && message.hasOwnProperty("from"))
+                            if (!$util.isString(message.from))
+                                return "from: string expected";
+                        if (message.to != null && message.hasOwnProperty("to"))
+                            if (!$util.isString(message.to))
+                                return "to: string expected";
+                        if (message.amount != null && message.hasOwnProperty("amount"))
+                            if (!$util.isInteger(message.amount) && !(message.amount && $util.isInteger(message.amount.low) && $util.isInteger(message.amount.high)))
+                                return "amount: integer|Long expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a TransferMessage message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Hedera.Proto.TransferMessage} TransferMessage
+                     */
+                    TransferMessage.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Hedera.Proto.TransferMessage)
+                            return object;
+                        var message = new $root.TW.Hedera.Proto.TransferMessage();
+                        if (object.from != null)
+                            message.from = String(object.from);
+                        if (object.to != null)
+                            message.to = String(object.to);
+                        if (object.amount != null)
+                            if ($util.Long)
+                                (message.amount = $util.Long.fromValue(object.amount)).unsigned = false;
+                            else if (typeof object.amount === "string")
+                                message.amount = parseInt(object.amount, 10);
+                            else if (typeof object.amount === "number")
+                                message.amount = object.amount;
+                            else if (typeof object.amount === "object")
+                                message.amount = new $util.LongBits(object.amount.low >>> 0, object.amount.high >>> 0).toNumber();
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a TransferMessage message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @static
+                     * @param {TW.Hedera.Proto.TransferMessage} message TransferMessage
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    TransferMessage.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults) {
+                            object.from = "";
+                            object.to = "";
+                            if ($util.Long) {
+                                var long = new $util.Long(0, 0, false);
+                                object.amount = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                            } else
+                                object.amount = options.longs === String ? "0" : 0;
+                        }
+                        if (message.from != null && message.hasOwnProperty("from"))
+                            object.from = message.from;
+                        if (message.to != null && message.hasOwnProperty("to"))
+                            object.to = message.to;
+                        if (message.amount != null && message.hasOwnProperty("amount"))
+                            if (typeof message.amount === "number")
+                                object.amount = options.longs === String ? String(message.amount) : message.amount;
+                            else
+                                object.amount = options.longs === String ? $util.Long.prototype.toString.call(message.amount) : options.longs === Number ? new $util.LongBits(message.amount.low >>> 0, message.amount.high >>> 0).toNumber() : message.amount;
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this TransferMessage to JSON.
+                     * @function toJSON
+                     * @memberof TW.Hedera.Proto.TransferMessage
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    TransferMessage.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return TransferMessage;
+                })();
+    
+                Proto.TransactionBody = (function() {
+    
+                    /**
+                     * Properties of a TransactionBody.
+                     * @memberof TW.Hedera.Proto
+                     * @interface ITransactionBody
+                     * @property {TW.Hedera.Proto.ITransactionID|null} [transactionID] TransactionBody transactionID
+                     * @property {string|null} [nodeAccountID] TransactionBody nodeAccountID
+                     * @property {Long|null} [transactionFee] TransactionBody transactionFee
+                     * @property {Long|null} [transactionValidDuration] TransactionBody transactionValidDuration
+                     * @property {string|null} [memo] TransactionBody memo
+                     * @property {TW.Hedera.Proto.ITransferMessage|null} [transfer] TransactionBody transfer
+                     */
+    
+                    /**
+                     * Constructs a new TransactionBody.
+                     * @memberof TW.Hedera.Proto
+                     * @classdesc Represents a TransactionBody.
+                     * @implements ITransactionBody
+                     * @constructor
+                     * @param {TW.Hedera.Proto.ITransactionBody=} [properties] Properties to set
+                     */
+                    function TransactionBody(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]];
+                    }
+    
+                    /**
+                     * TransactionBody transactionID.
+                     * @member {TW.Hedera.Proto.ITransactionID|null|undefined} transactionID
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    TransactionBody.prototype.transactionID = null;
+    
+                    /**
+                     * TransactionBody nodeAccountID.
+                     * @member {string} nodeAccountID
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    TransactionBody.prototype.nodeAccountID = "";
+    
+                    /**
+                     * TransactionBody transactionFee.
+                     * @member {Long} transactionFee
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    TransactionBody.prototype.transactionFee = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
+    
+                    /**
+                     * TransactionBody transactionValidDuration.
+                     * @member {Long} transactionValidDuration
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    TransactionBody.prototype.transactionValidDuration = $util.Long ? $util.Long.fromBits(0,0,false) : 0;
+    
+                    /**
+                     * TransactionBody memo.
+                     * @member {string} memo
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    TransactionBody.prototype.memo = "";
+    
+                    /**
+                     * TransactionBody transfer.
+                     * @member {TW.Hedera.Proto.ITransferMessage|null|undefined} transfer
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    TransactionBody.prototype.transfer = null;
+    
+                    // OneOf field names bound to virtual getters and setters
+                    var $oneOfFields;
+    
+                    /**
+                     * TransactionBody data.
+                     * @member {"transfer"|undefined} data
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     */
+                    Object.defineProperty(TransactionBody.prototype, "data", {
+                        get: $util.oneOfGetter($oneOfFields = ["transfer"]),
+                        set: $util.oneOfSetter($oneOfFields)
+                    });
+    
+                    /**
+                     * Creates a new TransactionBody instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @static
+                     * @param {TW.Hedera.Proto.ITransactionBody=} [properties] Properties to set
+                     * @returns {TW.Hedera.Proto.TransactionBody} TransactionBody instance
+                     */
+                    TransactionBody.create = function create(properties) {
+                        return new TransactionBody(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified TransactionBody message. Does not implicitly {@link TW.Hedera.Proto.TransactionBody.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @static
+                     * @param {TW.Hedera.Proto.ITransactionBody} message TransactionBody message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    TransactionBody.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.transactionID != null && Object.hasOwnProperty.call(message, "transactionID"))
+                            $root.TW.Hedera.Proto.TransactionID.encode(message.transactionID, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                        if (message.nodeAccountID != null && Object.hasOwnProperty.call(message, "nodeAccountID"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).string(message.nodeAccountID);
+                        if (message.transactionFee != null && Object.hasOwnProperty.call(message, "transactionFee"))
+                            writer.uint32(/* id 3, wireType 0 =*/24).uint64(message.transactionFee);
+                        if (message.transactionValidDuration != null && Object.hasOwnProperty.call(message, "transactionValidDuration"))
+                            writer.uint32(/* id 4, wireType 0 =*/32).int64(message.transactionValidDuration);
+                        if (message.memo != null && Object.hasOwnProperty.call(message, "memo"))
+                            writer.uint32(/* id 5, wireType 2 =*/42).string(message.memo);
+                        if (message.transfer != null && Object.hasOwnProperty.call(message, "transfer"))
+                            $root.TW.Hedera.Proto.TransferMessage.encode(message.transfer, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a TransactionBody message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Hedera.Proto.TransactionBody} TransactionBody
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    TransactionBody.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.Hedera.Proto.TransactionBody();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.transactionID = $root.TW.Hedera.Proto.TransactionID.decode(reader, reader.uint32());
+                                break;
+                            case 2:
+                                message.nodeAccountID = reader.string();
+                                break;
+                            case 3:
+                                message.transactionFee = reader.uint64();
+                                break;
+                            case 4:
+                                message.transactionValidDuration = reader.int64();
+                                break;
+                            case 5:
+                                message.memo = reader.string();
+                                break;
+                            case 6:
+                                message.transfer = $root.TW.Hedera.Proto.TransferMessage.decode(reader, reader.uint32());
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a TransactionBody message.
+                     * @function verify
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    TransactionBody.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        var properties = {};
+                        if (message.transactionID != null && message.hasOwnProperty("transactionID")) {
+                            var error = $root.TW.Hedera.Proto.TransactionID.verify(message.transactionID);
+                            if (error)
+                                return "transactionID." + error;
+                        }
+                        if (message.nodeAccountID != null && message.hasOwnProperty("nodeAccountID"))
+                            if (!$util.isString(message.nodeAccountID))
+                                return "nodeAccountID: string expected";
+                        if (message.transactionFee != null && message.hasOwnProperty("transactionFee"))
+                            if (!$util.isInteger(message.transactionFee) && !(message.transactionFee && $util.isInteger(message.transactionFee.low) && $util.isInteger(message.transactionFee.high)))
+                                return "transactionFee: integer|Long expected";
+                        if (message.transactionValidDuration != null && message.hasOwnProperty("transactionValidDuration"))
+                            if (!$util.isInteger(message.transactionValidDuration) && !(message.transactionValidDuration && $util.isInteger(message.transactionValidDuration.low) && $util.isInteger(message.transactionValidDuration.high)))
+                                return "transactionValidDuration: integer|Long expected";
+                        if (message.memo != null && message.hasOwnProperty("memo"))
+                            if (!$util.isString(message.memo))
+                                return "memo: string expected";
+                        if (message.transfer != null && message.hasOwnProperty("transfer")) {
+                            properties.data = 1;
+                            {
+                                var error = $root.TW.Hedera.Proto.TransferMessage.verify(message.transfer);
+                                if (error)
+                                    return "transfer." + error;
+                            }
+                        }
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a TransactionBody message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Hedera.Proto.TransactionBody} TransactionBody
+                     */
+                    TransactionBody.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Hedera.Proto.TransactionBody)
+                            return object;
+                        var message = new $root.TW.Hedera.Proto.TransactionBody();
+                        if (object.transactionID != null) {
+                            if (typeof object.transactionID !== "object")
+                                throw TypeError(".TW.Hedera.Proto.TransactionBody.transactionID: object expected");
+                            message.transactionID = $root.TW.Hedera.Proto.TransactionID.fromObject(object.transactionID);
+                        }
+                        if (object.nodeAccountID != null)
+                            message.nodeAccountID = String(object.nodeAccountID);
+                        if (object.transactionFee != null)
+                            if ($util.Long)
+                                (message.transactionFee = $util.Long.fromValue(object.transactionFee)).unsigned = true;
+                            else if (typeof object.transactionFee === "string")
+                                message.transactionFee = parseInt(object.transactionFee, 10);
+                            else if (typeof object.transactionFee === "number")
+                                message.transactionFee = object.transactionFee;
+                            else if (typeof object.transactionFee === "object")
+                                message.transactionFee = new $util.LongBits(object.transactionFee.low >>> 0, object.transactionFee.high >>> 0).toNumber(true);
+                        if (object.transactionValidDuration != null)
+                            if ($util.Long)
+                                (message.transactionValidDuration = $util.Long.fromValue(object.transactionValidDuration)).unsigned = false;
+                            else if (typeof object.transactionValidDuration === "string")
+                                message.transactionValidDuration = parseInt(object.transactionValidDuration, 10);
+                            else if (typeof object.transactionValidDuration === "number")
+                                message.transactionValidDuration = object.transactionValidDuration;
+                            else if (typeof object.transactionValidDuration === "object")
+                                message.transactionValidDuration = new $util.LongBits(object.transactionValidDuration.low >>> 0, object.transactionValidDuration.high >>> 0).toNumber();
+                        if (object.memo != null)
+                            message.memo = String(object.memo);
+                        if (object.transfer != null) {
+                            if (typeof object.transfer !== "object")
+                                throw TypeError(".TW.Hedera.Proto.TransactionBody.transfer: object expected");
+                            message.transfer = $root.TW.Hedera.Proto.TransferMessage.fromObject(object.transfer);
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a TransactionBody message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @static
+                     * @param {TW.Hedera.Proto.TransactionBody} message TransactionBody
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    TransactionBody.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults) {
+                            object.transactionID = null;
+                            object.nodeAccountID = "";
+                            if ($util.Long) {
+                                var long = new $util.Long(0, 0, true);
+                                object.transactionFee = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                            } else
+                                object.transactionFee = options.longs === String ? "0" : 0;
+                            if ($util.Long) {
+                                var long = new $util.Long(0, 0, false);
+                                object.transactionValidDuration = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                            } else
+                                object.transactionValidDuration = options.longs === String ? "0" : 0;
+                            object.memo = "";
+                        }
+                        if (message.transactionID != null && message.hasOwnProperty("transactionID"))
+                            object.transactionID = $root.TW.Hedera.Proto.TransactionID.toObject(message.transactionID, options);
+                        if (message.nodeAccountID != null && message.hasOwnProperty("nodeAccountID"))
+                            object.nodeAccountID = message.nodeAccountID;
+                        if (message.transactionFee != null && message.hasOwnProperty("transactionFee"))
+                            if (typeof message.transactionFee === "number")
+                                object.transactionFee = options.longs === String ? String(message.transactionFee) : message.transactionFee;
+                            else
+                                object.transactionFee = options.longs === String ? $util.Long.prototype.toString.call(message.transactionFee) : options.longs === Number ? new $util.LongBits(message.transactionFee.low >>> 0, message.transactionFee.high >>> 0).toNumber(true) : message.transactionFee;
+                        if (message.transactionValidDuration != null && message.hasOwnProperty("transactionValidDuration"))
+                            if (typeof message.transactionValidDuration === "number")
+                                object.transactionValidDuration = options.longs === String ? String(message.transactionValidDuration) : message.transactionValidDuration;
+                            else
+                                object.transactionValidDuration = options.longs === String ? $util.Long.prototype.toString.call(message.transactionValidDuration) : options.longs === Number ? new $util.LongBits(message.transactionValidDuration.low >>> 0, message.transactionValidDuration.high >>> 0).toNumber() : message.transactionValidDuration;
+                        if (message.memo != null && message.hasOwnProperty("memo"))
+                            object.memo = message.memo;
+                        if (message.transfer != null && message.hasOwnProperty("transfer")) {
+                            object.transfer = $root.TW.Hedera.Proto.TransferMessage.toObject(message.transfer, options);
+                            if (options.oneofs)
+                                object.data = "transfer";
+                        }
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this TransactionBody to JSON.
+                     * @function toJSON
+                     * @memberof TW.Hedera.Proto.TransactionBody
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    TransactionBody.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return TransactionBody;
+                })();
+    
+                Proto.SigningInput = (function() {
+    
+                    /**
+                     * Properties of a SigningInput.
+                     * @memberof TW.Hedera.Proto
+                     * @interface ISigningInput
+                     * @property {Uint8Array|null} [privateKey] SigningInput privateKey
+                     * @property {TW.Hedera.Proto.ITransactionBody|null} [body] SigningInput body
+                     */
+    
+                    /**
+                     * Constructs a new SigningInput.
+                     * @memberof TW.Hedera.Proto
+                     * @classdesc Represents a SigningInput.
+                     * @implements ISigningInput
+                     * @constructor
+                     * @param {TW.Hedera.Proto.ISigningInput=} [properties] Properties to set
+                     */
+                    function SigningInput(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]];
+                    }
+    
+                    /**
+                     * SigningInput privateKey.
+                     * @member {Uint8Array} privateKey
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @instance
+                     */
+                    SigningInput.prototype.privateKey = $util.newBuffer([]);
+    
+                    /**
+                     * SigningInput body.
+                     * @member {TW.Hedera.Proto.ITransactionBody|null|undefined} body
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @instance
+                     */
+                    SigningInput.prototype.body = null;
+    
+                    /**
+                     * Creates a new SigningInput instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @static
+                     * @param {TW.Hedera.Proto.ISigningInput=} [properties] Properties to set
+                     * @returns {TW.Hedera.Proto.SigningInput} SigningInput instance
+                     */
+                    SigningInput.create = function create(properties) {
+                        return new SigningInput(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified SigningInput message. Does not implicitly {@link TW.Hedera.Proto.SigningInput.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @static
+                     * @param {TW.Hedera.Proto.ISigningInput} message SigningInput message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    SigningInput.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.privateKey != null && Object.hasOwnProperty.call(message, "privateKey"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.privateKey);
+                        if (message.body != null && Object.hasOwnProperty.call(message, "body"))
+                            $root.TW.Hedera.Proto.TransactionBody.encode(message.body, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a SigningInput message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Hedera.Proto.SigningInput} SigningInput
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    SigningInput.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.Hedera.Proto.SigningInput();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.privateKey = reader.bytes();
+                                break;
+                            case 2:
+                                message.body = $root.TW.Hedera.Proto.TransactionBody.decode(reader, reader.uint32());
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a SigningInput message.
+                     * @function verify
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    SigningInput.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.privateKey != null && message.hasOwnProperty("privateKey"))
+                            if (!(message.privateKey && typeof message.privateKey.length === "number" || $util.isString(message.privateKey)))
+                                return "privateKey: buffer expected";
+                        if (message.body != null && message.hasOwnProperty("body")) {
+                            var error = $root.TW.Hedera.Proto.TransactionBody.verify(message.body);
+                            if (error)
+                                return "body." + error;
+                        }
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a SigningInput message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Hedera.Proto.SigningInput} SigningInput
+                     */
+                    SigningInput.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Hedera.Proto.SigningInput)
+                            return object;
+                        var message = new $root.TW.Hedera.Proto.SigningInput();
+                        if (object.privateKey != null)
+                            if (typeof object.privateKey === "string")
+                                $util.base64.decode(object.privateKey, message.privateKey = $util.newBuffer($util.base64.length(object.privateKey)), 0);
+                            else if (object.privateKey.length)
+                                message.privateKey = object.privateKey;
+                        if (object.body != null) {
+                            if (typeof object.body !== "object")
+                                throw TypeError(".TW.Hedera.Proto.SigningInput.body: object expected");
+                            message.body = $root.TW.Hedera.Proto.TransactionBody.fromObject(object.body);
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a SigningInput message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @static
+                     * @param {TW.Hedera.Proto.SigningInput} message SigningInput
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    SigningInput.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults) {
+                            if (options.bytes === String)
+                                object.privateKey = "";
+                            else {
+                                object.privateKey = [];
+                                if (options.bytes !== Array)
+                                    object.privateKey = $util.newBuffer(object.privateKey);
+                            }
+                            object.body = null;
+                        }
+                        if (message.privateKey != null && message.hasOwnProperty("privateKey"))
+                            object.privateKey = options.bytes === String ? $util.base64.encode(message.privateKey, 0, message.privateKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.privateKey) : message.privateKey;
+                        if (message.body != null && message.hasOwnProperty("body"))
+                            object.body = $root.TW.Hedera.Proto.TransactionBody.toObject(message.body, options);
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this SigningInput to JSON.
+                     * @function toJSON
+                     * @memberof TW.Hedera.Proto.SigningInput
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    SigningInput.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return SigningInput;
+                })();
+    
+                Proto.SigningOutput = (function() {
+    
+                    /**
+                     * Properties of a SigningOutput.
+                     * @memberof TW.Hedera.Proto
+                     * @interface ISigningOutput
+                     * @property {Uint8Array|null} [encoded] SigningOutput encoded
+                     */
+    
+                    /**
+                     * Constructs a new SigningOutput.
+                     * @memberof TW.Hedera.Proto
+                     * @classdesc Represents a SigningOutput.
+                     * @implements ISigningOutput
+                     * @constructor
+                     * @param {TW.Hedera.Proto.ISigningOutput=} [properties] Properties to set
+                     */
+                    function SigningOutput(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]];
+                    }
+    
+                    /**
+                     * SigningOutput encoded.
+                     * @member {Uint8Array} encoded
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @instance
+                     */
+                    SigningOutput.prototype.encoded = $util.newBuffer([]);
+    
+                    /**
+                     * Creates a new SigningOutput instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @static
+                     * @param {TW.Hedera.Proto.ISigningOutput=} [properties] Properties to set
+                     * @returns {TW.Hedera.Proto.SigningOutput} SigningOutput instance
+                     */
+                    SigningOutput.create = function create(properties) {
+                        return new SigningOutput(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified SigningOutput message. Does not implicitly {@link TW.Hedera.Proto.SigningOutput.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @static
+                     * @param {TW.Hedera.Proto.ISigningOutput} message SigningOutput message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    SigningOutput.encode = function encode(message, writer) {
+                        if (!writer)
+                            writer = $Writer.create();
+                        if (message.encoded != null && Object.hasOwnProperty.call(message, "encoded"))
+                            writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.encoded);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes a SigningOutput message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Hedera.Proto.SigningOutput} SigningOutput
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    SigningOutput.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.Hedera.Proto.SigningOutput();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.encoded = reader.bytes();
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies a SigningOutput message.
+                     * @function verify
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    SigningOutput.verify = function verify(message) {
+                        if (typeof message !== "object" || message === null)
+                            return "object expected";
+                        if (message.encoded != null && message.hasOwnProperty("encoded"))
+                            if (!(message.encoded && typeof message.encoded.length === "number" || $util.isString(message.encoded)))
+                                return "encoded: buffer expected";
+                        return null;
+                    };
+    
+                    /**
+                     * Creates a SigningOutput message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Hedera.Proto.SigningOutput} SigningOutput
+                     */
+                    SigningOutput.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Hedera.Proto.SigningOutput)
+                            return object;
+                        var message = new $root.TW.Hedera.Proto.SigningOutput();
+                        if (object.encoded != null)
+                            if (typeof object.encoded === "string")
+                                $util.base64.decode(object.encoded, message.encoded = $util.newBuffer($util.base64.length(object.encoded)), 0);
+                            else if (object.encoded.length)
+                                message.encoded = object.encoded;
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from a SigningOutput message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @static
+                     * @param {TW.Hedera.Proto.SigningOutput} message SigningOutput
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    SigningOutput.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.defaults)
+                            if (options.bytes === String)
+                                object.encoded = "";
+                            else {
+                                object.encoded = [];
+                                if (options.bytes !== Array)
+                                    object.encoded = $util.newBuffer(object.encoded);
+                            }
+                        if (message.encoded != null && message.hasOwnProperty("encoded"))
+                            object.encoded = options.bytes === String ? $util.base64.encode(message.encoded, 0, message.encoded.length) : options.bytes === Array ? Array.prototype.slice.call(message.encoded) : message.encoded;
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this SigningOutput to JSON.
+                     * @function toJSON
+                     * @memberof TW.Hedera.Proto.SigningOutput
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    SigningOutput.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return SigningOutput;
+                })();
+    
+                return Proto;
+            })();
+    
+            return Hedera;
+        })();
+    
         TW.Icon = (function() {
     
             /**
@@ -60138,20 +61493,6 @@
                  */
                 var Proto = {};
     
-                /**
-                 * Network enum.
-                 * @name TW.Polkadot.Proto.Network
-                 * @enum {number}
-                 * @property {number} POLKADOT=0 POLKADOT value
-                 * @property {number} KUSAMA=2 KUSAMA value
-                 */
-                Proto.Network = (function() {
-                    var valuesById = {}, values = Object.create(valuesById);
-                    values[valuesById[0] = "POLKADOT"] = 0;
-                    values[valuesById[2] = "KUSAMA"] = 2;
-                    return values;
-                })();
-    
                 /**
                  * RewardDestination enum.
                  * @name TW.Polkadot.Proto.RewardDestination
@@ -62646,7 +63987,7 @@
                      * @property {Uint8Array|null} [tip] SigningInput tip
                      * @property {TW.Polkadot.Proto.IEra|null} [era] SigningInput era
                      * @property {Uint8Array|null} [privateKey] SigningInput privateKey
-                     * @property {TW.Polkadot.Proto.Network|null} [network] SigningInput network
+                     * @property {number|null} [network] SigningInput network
                      * @property {TW.Polkadot.Proto.IBalance|null} [balanceCall] SigningInput balanceCall
                      * @property {TW.Polkadot.Proto.IStaking|null} [stakingCall] SigningInput stakingCall
                      */
@@ -62732,7 +64073,7 @@
     
                     /**
                      * SigningInput network.
-                     * @member {TW.Polkadot.Proto.Network} network
+                     * @member {number} network
                      * @memberof TW.Polkadot.Proto.SigningInput
                      * @instance
                      */
@@ -62809,7 +64150,7 @@
                         if (message.privateKey != null && Object.hasOwnProperty.call(message, "privateKey"))
                             writer.uint32(/* id 8, wireType 2 =*/66).bytes(message.privateKey);
                         if (message.network != null && Object.hasOwnProperty.call(message, "network"))
-                            writer.uint32(/* id 9, wireType 0 =*/72).int32(message.network);
+                            writer.uint32(/* id 9, wireType 0 =*/72).uint32(message.network);
                         if (message.balanceCall != null && Object.hasOwnProperty.call(message, "balanceCall"))
                             $root.TW.Polkadot.Proto.Balance.encode(message.balanceCall, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
                         if (message.stakingCall != null && Object.hasOwnProperty.call(message, "stakingCall"))
@@ -62860,7 +64201,7 @@
                                 message.privateKey = reader.bytes();
                                 break;
                             case 9:
-                                message.network = reader.int32();
+                                message.network = reader.uint32();
                                 break;
                             case 10:
                                 message.balanceCall = $root.TW.Polkadot.Proto.Balance.decode(reader, reader.uint32());
@@ -62915,13 +64256,8 @@
                             if (!(message.privateKey && typeof message.privateKey.length === "number" || $util.isString(message.privateKey)))
                                 return "privateKey: buffer expected";
                         if (message.network != null && message.hasOwnProperty("network"))
-                            switch (message.network) {
-                            default:
-                                return "network: enum value expected";
-                            case 0:
-                            case 2:
-                                break;
-                            }
+                            if (!$util.isInteger(message.network))
+                                return "network: integer expected";
                         if (message.balanceCall != null && message.hasOwnProperty("balanceCall")) {
                             properties.messageOneof = 1;
                             {
@@ -62993,16 +64329,8 @@
                                 $util.base64.decode(object.privateKey, message.privateKey = $util.newBuffer($util.base64.length(object.privateKey)), 0);
                             else if (object.privateKey.length)
                                 message.privateKey = object.privateKey;
-                        switch (object.network) {
-                        case "POLKADOT":
-                        case 0:
-                            message.network = 0;
-                            break;
-                        case "KUSAMA":
-                        case 2:
-                            message.network = 2;
-                            break;
-                        }
+                        if (object.network != null)
+                            message.network = object.network >>> 0;
                         if (object.balanceCall != null) {
                             if (typeof object.balanceCall !== "object")
                                 throw TypeError(".TW.Polkadot.Proto.SigningInput.balanceCall: object expected");
@@ -63066,7 +64394,7 @@
                                 if (options.bytes !== Array)
                                     object.privateKey = $util.newBuffer(object.privateKey);
                             }
-                            object.network = options.enums === String ? "POLKADOT" : 0;
+                            object.network = 0;
                         }
                         if (message.blockHash != null && message.hasOwnProperty("blockHash"))
                             object.blockHash = options.bytes === String ? $util.base64.encode(message.blockHash, 0, message.blockHash.length) : options.bytes === Array ? Array.prototype.slice.call(message.blockHash) : message.blockHash;
@@ -63088,7 +64416,7 @@
                         if (message.privateKey != null && message.hasOwnProperty("privateKey"))
                             object.privateKey = options.bytes === String ? $util.base64.encode(message.privateKey, 0, message.privateKey.length) : options.bytes === Array ? Array.prototype.slice.call(message.privateKey) : message.privateKey;
                         if (message.network != null && message.hasOwnProperty("network"))
-                            object.network = options.enums === String ? $root.TW.Polkadot.Proto.Network[message.network] : message.network;
+                            object.network = message.network;
                         if (message.balanceCall != null && message.hasOwnProperty("balanceCall")) {
                             object.balanceCall = $root.TW.Polkadot.Proto.Balance.toObject(message.balanceCall, options);
                             if (options.oneofs)
@@ -66803,6 +68131,7 @@
                      * @memberof TW.Solana.Proto
                      * @interface ISigningOutput
                      * @property {string|null} [encoded] SigningOutput encoded
+                     * @property {string|null} [unsignedTx] SigningOutput unsignedTx
                      */
     
                     /**
@@ -66828,6 +68157,14 @@
                      */
                     SigningOutput.prototype.encoded = "";
     
+                    /**
+                     * SigningOutput unsignedTx.
+                     * @member {string} unsignedTx
+                     * @memberof TW.Solana.Proto.SigningOutput
+                     * @instance
+                     */
+                    SigningOutput.prototype.unsignedTx = "";
+    
                     /**
                      * Creates a new SigningOutput instance using the specified properties.
                      * @function create
@@ -66854,6 +68191,8 @@
                             writer = $Writer.create();
                         if (message.encoded != null && Object.hasOwnProperty.call(message, "encoded"))
                             writer.uint32(/* id 1, wireType 2 =*/10).string(message.encoded);
+                        if (message.unsignedTx != null && Object.hasOwnProperty.call(message, "unsignedTx"))
+                            writer.uint32(/* id 2, wireType 2 =*/18).string(message.unsignedTx);
                         return writer;
                     };
     
@@ -66878,6 +68217,9 @@
                             case 1:
                                 message.encoded = reader.string();
                                 break;
+                            case 2:
+                                message.unsignedTx = reader.string();
+                                break;
                             default:
                                 reader.skipType(tag & 7);
                                 break;
@@ -66900,6 +68242,9 @@
                         if (message.encoded != null && message.hasOwnProperty("encoded"))
                             if (!$util.isString(message.encoded))
                                 return "encoded: string expected";
+                        if (message.unsignedTx != null && message.hasOwnProperty("unsignedTx"))
+                            if (!$util.isString(message.unsignedTx))
+                                return "unsignedTx: string expected";
                         return null;
                     };
     
@@ -66917,6 +68262,8 @@
                         var message = new $root.TW.Solana.Proto.SigningOutput();
                         if (object.encoded != null)
                             message.encoded = String(object.encoded);
+                        if (object.unsignedTx != null)
+                            message.unsignedTx = String(object.unsignedTx);
                         return message;
                     };
     
@@ -66933,10 +68280,14 @@
                         if (!options)
                             options = {};
                         var object = {};
-                        if (options.defaults)
+                        if (options.defaults) {
                             object.encoded = "";
+                            object.unsignedTx = "";
+                        }
                         if (message.encoded != null && message.hasOwnProperty("encoded"))
                             object.encoded = message.encoded;
+                        if (message.unsignedTx != null && message.hasOwnProperty("unsignedTx"))
+                            object.unsignedTx = message.unsignedTx;
                         return object;
                     };
     
@@ -73573,6 +74924,9 @@
                      * @property {string|null} [routerAddress] SwapInput routerAddress
                      * @property {string|null} [fromAmount] SwapInput fromAmount
                      * @property {string|null} [toAmountLimit] SwapInput toAmountLimit
+                     * @property {string|null} [affiliateFeeAddress] SwapInput affiliateFeeAddress
+                     * @property {string|null} [affiliateFeeRateBp] SwapInput affiliateFeeRateBp
+                     * @property {string|null} [extraMemo] SwapInput extraMemo
                      */
     
                     /**
@@ -73654,6 +75008,30 @@
                      */
                     SwapInput.prototype.toAmountLimit = "";
     
+                    /**
+                     * SwapInput affiliateFeeAddress.
+                     * @member {string} affiliateFeeAddress
+                     * @memberof TW.THORChainSwap.Proto.SwapInput
+                     * @instance
+                     */
+                    SwapInput.prototype.affiliateFeeAddress = "";
+    
+                    /**
+                     * SwapInput affiliateFeeRateBp.
+                     * @member {string} affiliateFeeRateBp
+                     * @memberof TW.THORChainSwap.Proto.SwapInput
+                     * @instance
+                     */
+                    SwapInput.prototype.affiliateFeeRateBp = "";
+    
+                    /**
+                     * SwapInput extraMemo.
+                     * @member {string} extraMemo
+                     * @memberof TW.THORChainSwap.Proto.SwapInput
+                     * @instance
+                     */
+                    SwapInput.prototype.extraMemo = "";
+    
                     /**
                      * Creates a new SwapInput instance using the specified properties.
                      * @function create
@@ -73694,6 +75072,12 @@
                             writer.uint32(/* id 7, wireType 2 =*/58).string(message.fromAmount);
                         if (message.toAmountLimit != null && Object.hasOwnProperty.call(message, "toAmountLimit"))
                             writer.uint32(/* id 8, wireType 2 =*/66).string(message.toAmountLimit);
+                        if (message.affiliateFeeAddress != null && Object.hasOwnProperty.call(message, "affiliateFeeAddress"))
+                            writer.uint32(/* id 9, wireType 2 =*/74).string(message.affiliateFeeAddress);
+                        if (message.affiliateFeeRateBp != null && Object.hasOwnProperty.call(message, "affiliateFeeRateBp"))
+                            writer.uint32(/* id 10, wireType 2 =*/82).string(message.affiliateFeeRateBp);
+                        if (message.extraMemo != null && Object.hasOwnProperty.call(message, "extraMemo"))
+                            writer.uint32(/* id 11, wireType 2 =*/90).string(message.extraMemo);
                         return writer;
                     };
     
@@ -73739,6 +75123,15 @@
                             case 8:
                                 message.toAmountLimit = reader.string();
                                 break;
+                            case 9:
+                                message.affiliateFeeAddress = reader.string();
+                                break;
+                            case 10:
+                                message.affiliateFeeRateBp = reader.string();
+                                break;
+                            case 11:
+                                message.extraMemo = reader.string();
+                                break;
                             default:
                                 reader.skipType(tag & 7);
                                 break;
@@ -73791,6 +75184,15 @@
                         if (message.toAmountLimit != null && message.hasOwnProperty("toAmountLimit"))
                             if (!$util.isString(message.toAmountLimit))
                                 return "toAmountLimit: string expected";
+                        if (message.affiliateFeeAddress != null && message.hasOwnProperty("affiliateFeeAddress"))
+                            if (!$util.isString(message.affiliateFeeAddress))
+                                return "affiliateFeeAddress: string expected";
+                        if (message.affiliateFeeRateBp != null && message.hasOwnProperty("affiliateFeeRateBp"))
+                            if (!$util.isString(message.affiliateFeeRateBp))
+                                return "affiliateFeeRateBp: string expected";
+                        if (message.extraMemo != null && message.hasOwnProperty("extraMemo"))
+                            if (!$util.isString(message.extraMemo))
+                                return "extraMemo: string expected";
                         return null;
                     };
     
@@ -73841,6 +75243,12 @@
                             message.fromAmount = String(object.fromAmount);
                         if (object.toAmountLimit != null)
                             message.toAmountLimit = String(object.toAmountLimit);
+                        if (object.affiliateFeeAddress != null)
+                            message.affiliateFeeAddress = String(object.affiliateFeeAddress);
+                        if (object.affiliateFeeRateBp != null)
+                            message.affiliateFeeRateBp = String(object.affiliateFeeRateBp);
+                        if (object.extraMemo != null)
+                            message.extraMemo = String(object.extraMemo);
                         return message;
                     };
     
@@ -73866,6 +75274,9 @@
                             object.routerAddress = "";
                             object.fromAmount = "";
                             object.toAmountLimit = "";
+                            object.affiliateFeeAddress = "";
+                            object.affiliateFeeRateBp = "";
+                            object.extraMemo = "";
                         }
                         if (message.fromChain != null && message.hasOwnProperty("fromChain"))
                             object.fromChain = options.enums === String ? $root.TW.THORChainSwap.Proto.Chain[message.fromChain] : message.fromChain;
@@ -73883,6 +75294,12 @@
                             object.fromAmount = message.fromAmount;
                         if (message.toAmountLimit != null && message.hasOwnProperty("toAmountLimit"))
                             object.toAmountLimit = message.toAmountLimit;
+                        if (message.affiliateFeeAddress != null && message.hasOwnProperty("affiliateFeeAddress"))
+                            object.affiliateFeeAddress = message.affiliateFeeAddress;
+                        if (message.affiliateFeeRateBp != null && message.hasOwnProperty("affiliateFeeRateBp"))
+                            object.affiliateFeeRateBp = message.affiliateFeeRateBp;
+                        if (message.extraMemo != null && message.hasOwnProperty("extraMemo"))
+                            object.extraMemo = message.extraMemo;
                         return object;
                     };