@trustwallet/wallet-core 3.2.0 → 3.2.2

package/dist/generated/core_proto.d.ts

@@ -10897,6 +10897,9 @@ export namespace TW {
 
                 /** Transaction contractGeneric */
                 contractGeneric?: (TW.Ethereum.Proto.Transaction.IContractGeneric|null);
+
+                /** Transaction batch */
+                batch?: (TW.Ethereum.Proto.Transaction.IBatch|null);
             }
 
             /** Represents a Transaction. */
@@ -10926,8 +10929,11 @@ export namespace TW {
                 /** Transaction contractGeneric. */
                 public contractGeneric?: (TW.Ethereum.Proto.Transaction.IContractGeneric|null);
 
+                /** Transaction batch. */
+                public batch?: (TW.Ethereum.Proto.Transaction.IBatch|null);
+
                 /** Transaction transactionOneof. */
-                public transactionOneof?: ("transfer"|"erc20Transfer"|"erc20Approve"|"erc721Transfer"|"erc1155Transfer"|"contractGeneric");
+                public transactionOneof?: ("transfer"|"erc20Transfer"|"erc20Approve"|"erc721Transfer"|"erc1155Transfer"|"contractGeneric"|"batch");
 
                 /**
                  * Creates a new Transaction instance using the specified properties.
@@ -11482,6 +11488,167 @@ export namespace TW {
                      */
                     public toJSON(): { [k: string]: any };
                 }
+
+                /** Properties of a Batch. */
+                interface IBatch {
+
+                    /** Batch calls */
+                    calls?: (TW.Ethereum.Proto.Transaction.Batch.IBatchedCall[]|null);
+                }
+
+                /** Represents a Batch. */
+                class Batch implements IBatch {
+
+                    /**
+                     * Constructs a new Batch.
+                     * @param [properties] Properties to set
+                     */
+                    constructor(properties?: TW.Ethereum.Proto.Transaction.IBatch);
+
+                    /** Batch calls. */
+                    public calls: TW.Ethereum.Proto.Transaction.Batch.IBatchedCall[];
+
+                    /**
+                     * Creates a new Batch instance using the specified properties.
+                     * @param [properties] Properties to set
+                     * @returns Batch instance
+                     */
+                    public static create(properties?: TW.Ethereum.Proto.Transaction.IBatch): TW.Ethereum.Proto.Transaction.Batch;
+
+                    /**
+                     * Encodes the specified Batch message. Does not implicitly {@link TW.Ethereum.Proto.Transaction.Batch.verify|verify} messages.
+                     * @param message Batch message or plain object to encode
+                     * @param [writer] Writer to encode to
+                     * @returns Writer
+                     */
+                    public static encode(message: TW.Ethereum.Proto.Transaction.IBatch, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                    /**
+                     * Decodes a Batch message from the specified reader or buffer.
+                     * @param reader Reader or buffer to decode from
+                     * @param [length] Message length if known beforehand
+                     * @returns Batch
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.Ethereum.Proto.Transaction.Batch;
+
+                    /**
+                     * Verifies a Batch message.
+                     * @param message Plain object to verify
+                     * @returns `null` if valid, otherwise the reason why it is not
+                     */
+                    public static verify(message: { [k: string]: any }): (string|null);
+
+                    /**
+                     * Creates a Batch message from a plain object. Also converts values to their respective internal types.
+                     * @param object Plain object
+                     * @returns Batch
+                     */
+                    public static fromObject(object: { [k: string]: any }): TW.Ethereum.Proto.Transaction.Batch;
+
+                    /**
+                     * Creates a plain object from a Batch message. Also converts values to other types if specified.
+                     * @param message Batch
+                     * @param [options] Conversion options
+                     * @returns Plain object
+                     */
+                    public static toObject(message: TW.Ethereum.Proto.Transaction.Batch, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                    /**
+                     * Converts this Batch to JSON.
+                     * @returns JSON object
+                     */
+                    public toJSON(): { [k: string]: any };
+                }
+
+                namespace Batch {
+
+                    /** Properties of a BatchedCall. */
+                    interface IBatchedCall {
+
+                        /** BatchedCall address */
+                        address?: (string|null);
+
+                        /** BatchedCall amount */
+                        amount?: (Uint8Array|null);
+
+                        /** BatchedCall payload */
+                        payload?: (Uint8Array|null);
+                    }
+
+                    /** Represents a BatchedCall. */
+                    class BatchedCall implements IBatchedCall {
+
+                        /**
+                         * Constructs a new BatchedCall.
+                         * @param [properties] Properties to set
+                         */
+                        constructor(properties?: TW.Ethereum.Proto.Transaction.Batch.IBatchedCall);
+
+                        /** BatchedCall address. */
+                        public address: string;
+
+                        /** BatchedCall amount. */
+                        public amount: Uint8Array;
+
+                        /** BatchedCall payload. */
+                        public payload: Uint8Array;
+
+                        /**
+                         * Creates a new BatchedCall instance using the specified properties.
+                         * @param [properties] Properties to set
+                         * @returns BatchedCall instance
+                         */
+                        public static create(properties?: TW.Ethereum.Proto.Transaction.Batch.IBatchedCall): TW.Ethereum.Proto.Transaction.Batch.BatchedCall;
+
+                        /**
+                         * Encodes the specified BatchedCall message. Does not implicitly {@link TW.Ethereum.Proto.Transaction.Batch.BatchedCall.verify|verify} messages.
+                         * @param message BatchedCall message or plain object to encode
+                         * @param [writer] Writer to encode to
+                         * @returns Writer
+                         */
+                        public static encode(message: TW.Ethereum.Proto.Transaction.Batch.IBatchedCall, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                        /**
+                         * Decodes a BatchedCall message from the specified reader or buffer.
+                         * @param reader Reader or buffer to decode from
+                         * @param [length] Message length if known beforehand
+                         * @returns BatchedCall
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        public static decode(reader: ($protobuf.Reader|Uint8Array), length?: number): TW.Ethereum.Proto.Transaction.Batch.BatchedCall;
+
+                        /**
+                         * Verifies a BatchedCall message.
+                         * @param message Plain object to verify
+                         * @returns `null` if valid, otherwise the reason why it is not
+                         */
+                        public static verify(message: { [k: string]: any }): (string|null);
+
+                        /**
+                         * Creates a BatchedCall message from a plain object. Also converts values to their respective internal types.
+                         * @param object Plain object
+                         * @returns BatchedCall
+                         */
+                        public static fromObject(object: { [k: string]: any }): TW.Ethereum.Proto.Transaction.Batch.BatchedCall;
+
+                        /**
+                         * Creates a plain object from a BatchedCall message. Also converts values to other types if specified.
+                         * @param message BatchedCall
+                         * @param [options] Conversion options
+                         * @returns Plain object
+                         */
+                        public static toObject(message: TW.Ethereum.Proto.Transaction.Batch.BatchedCall, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                        /**
+                         * Converts this BatchedCall to JSON.
+                         * @returns JSON object
+                         */
+                        public toJSON(): { [k: string]: any };
+                    }
+                }
             }
 
             /** TransactionMode enum. */

package/dist/generated/core_proto.js

@@ -32644,6 +32644,7 @@
                      * @property {TW.Ethereum.Proto.Transaction.IERC721Transfer|null} [erc721Transfer] Transaction erc721Transfer
                      * @property {TW.Ethereum.Proto.Transaction.IERC1155Transfer|null} [erc1155Transfer] Transaction erc1155Transfer
                      * @property {TW.Ethereum.Proto.Transaction.IContractGeneric|null} [contractGeneric] Transaction contractGeneric
+                     * @property {TW.Ethereum.Proto.Transaction.IBatch|null} [batch] Transaction batch
                      */
     
                     /**
@@ -32709,17 +32710,25 @@
                      */
                     Transaction.prototype.contractGeneric = null;
     
+                    /**
+                     * Transaction batch.
+                     * @member {TW.Ethereum.Proto.Transaction.IBatch|null|undefined} batch
+                     * @memberof TW.Ethereum.Proto.Transaction
+                     * @instance
+                     */
+                    Transaction.prototype.batch = null;
+    
                     // OneOf field names bound to virtual getters and setters
                     var $oneOfFields;
     
                     /**
                      * Transaction transactionOneof.
-                     * @member {"transfer"|"erc20Transfer"|"erc20Approve"|"erc721Transfer"|"erc1155Transfer"|"contractGeneric"|undefined} transactionOneof
+                     * @member {"transfer"|"erc20Transfer"|"erc20Approve"|"erc721Transfer"|"erc1155Transfer"|"contractGeneric"|"batch"|undefined} transactionOneof
                      * @memberof TW.Ethereum.Proto.Transaction
                      * @instance
                      */
                     Object.defineProperty(Transaction.prototype, "transactionOneof", {
-                        get: $util.oneOfGetter($oneOfFields = ["transfer", "erc20Transfer", "erc20Approve", "erc721Transfer", "erc1155Transfer", "contractGeneric"]),
+                        get: $util.oneOfGetter($oneOfFields = ["transfer", "erc20Transfer", "erc20Approve", "erc721Transfer", "erc1155Transfer", "contractGeneric", "batch"]),
                         set: $util.oneOfSetter($oneOfFields)
                     });
     
@@ -32759,6 +32768,8 @@
                             $root.TW.Ethereum.Proto.Transaction.ERC1155Transfer.encode(message.erc1155Transfer, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
                         if (message.contractGeneric != null && Object.hasOwnProperty.call(message, "contractGeneric"))
                             $root.TW.Ethereum.Proto.Transaction.ContractGeneric.encode(message.contractGeneric, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
+                        if (message.batch != null && Object.hasOwnProperty.call(message, "batch"))
+                            $root.TW.Ethereum.Proto.Transaction.Batch.encode(message.batch, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
                         return writer;
                     };
     
@@ -32798,6 +32809,9 @@
                             case 6:
                                 message.contractGeneric = $root.TW.Ethereum.Proto.Transaction.ContractGeneric.decode(reader, reader.uint32());
                                 break;
+                            case 7:
+                                message.batch = $root.TW.Ethereum.Proto.Transaction.Batch.decode(reader, reader.uint32());
+                                break;
                             default:
                                 reader.skipType(tag & 7);
                                 break;
@@ -32876,6 +32890,16 @@
                                     return "contractGeneric." + error;
                             }
                         }
+                        if (message.batch != null && message.hasOwnProperty("batch")) {
+                            if (properties.transactionOneof === 1)
+                                return "transactionOneof: multiple values";
+                            properties.transactionOneof = 1;
+                            {
+                                var error = $root.TW.Ethereum.Proto.Transaction.Batch.verify(message.batch);
+                                if (error)
+                                    return "batch." + error;
+                            }
+                        }
                         return null;
                     };
     
@@ -32921,6 +32945,11 @@
                                 throw TypeError(".TW.Ethereum.Proto.Transaction.contractGeneric: object expected");
                             message.contractGeneric = $root.TW.Ethereum.Proto.Transaction.ContractGeneric.fromObject(object.contractGeneric);
                         }
+                        if (object.batch != null) {
+                            if (typeof object.batch !== "object")
+                                throw TypeError(".TW.Ethereum.Proto.Transaction.batch: object expected");
+                            message.batch = $root.TW.Ethereum.Proto.Transaction.Batch.fromObject(object.batch);
+                        }
                         return message;
                     };
     
@@ -32967,6 +32996,11 @@
                             if (options.oneofs)
                                 object.transactionOneof = "contractGeneric";
                         }
+                        if (message.batch != null && message.hasOwnProperty("batch")) {
+                            object.batch = $root.TW.Ethereum.Proto.Transaction.Batch.toObject(message.batch, options);
+                            if (options.oneofs)
+                                object.transactionOneof = "batch";
+                        }
                         return object;
                     };
     
@@ -34245,6 +34279,406 @@
                         return ContractGeneric;
                     })();
     
+                    Transaction.Batch = (function() {
+    
+                        /**
+                         * Properties of a Batch.
+                         * @memberof TW.Ethereum.Proto.Transaction
+                         * @interface IBatch
+                         * @property {Array.<TW.Ethereum.Proto.Transaction.Batch.IBatchedCall>|null} [calls] Batch calls
+                         */
+    
+                        /**
+                         * Constructs a new Batch.
+                         * @memberof TW.Ethereum.Proto.Transaction
+                         * @classdesc Represents a Batch.
+                         * @implements IBatch
+                         * @constructor
+                         * @param {TW.Ethereum.Proto.Transaction.IBatch=} [properties] Properties to set
+                         */
+                        function Batch(properties) {
+                            this.calls = [];
+                            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]];
+                        }
+    
+                        /**
+                         * Batch calls.
+                         * @member {Array.<TW.Ethereum.Proto.Transaction.Batch.IBatchedCall>} calls
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @instance
+                         */
+                        Batch.prototype.calls = $util.emptyArray;
+    
+                        /**
+                         * Creates a new Batch instance using the specified properties.
+                         * @function create
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @static
+                         * @param {TW.Ethereum.Proto.Transaction.IBatch=} [properties] Properties to set
+                         * @returns {TW.Ethereum.Proto.Transaction.Batch} Batch instance
+                         */
+                        Batch.create = function create(properties) {
+                            return new Batch(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified Batch message. Does not implicitly {@link TW.Ethereum.Proto.Transaction.Batch.verify|verify} messages.
+                         * @function encode
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @static
+                         * @param {TW.Ethereum.Proto.Transaction.IBatch} message Batch message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        Batch.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.calls != null && message.calls.length)
+                                for (var i = 0; i < message.calls.length; ++i)
+                                    $root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall.encode(message.calls[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Decodes a Batch message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {TW.Ethereum.Proto.Transaction.Batch} Batch
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        Batch.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.Ethereum.Proto.Transaction.Batch();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    if (!(message.calls && message.calls.length))
+                                        message.calls = [];
+                                    message.calls.push($root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall.decode(reader, reader.uint32()));
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Verifies a Batch message.
+                         * @function verify
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        Batch.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.calls != null && message.hasOwnProperty("calls")) {
+                                if (!Array.isArray(message.calls))
+                                    return "calls: array expected";
+                                for (var i = 0; i < message.calls.length; ++i) {
+                                    var error = $root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall.verify(message.calls[i]);
+                                    if (error)
+                                        return "calls." + error;
+                                }
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a Batch message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {TW.Ethereum.Proto.Transaction.Batch} Batch
+                         */
+                        Batch.fromObject = function fromObject(object) {
+                            if (object instanceof $root.TW.Ethereum.Proto.Transaction.Batch)
+                                return object;
+                            var message = new $root.TW.Ethereum.Proto.Transaction.Batch();
+                            if (object.calls) {
+                                if (!Array.isArray(object.calls))
+                                    throw TypeError(".TW.Ethereum.Proto.Transaction.Batch.calls: array expected");
+                                message.calls = [];
+                                for (var i = 0; i < object.calls.length; ++i) {
+                                    if (typeof object.calls[i] !== "object")
+                                        throw TypeError(".TW.Ethereum.Proto.Transaction.Batch.calls: object expected");
+                                    message.calls[i] = $root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall.fromObject(object.calls[i]);
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a Batch message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @static
+                         * @param {TW.Ethereum.Proto.Transaction.Batch} message Batch
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        Batch.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.arrays || options.defaults)
+                                object.calls = [];
+                            if (message.calls && message.calls.length) {
+                                object.calls = [];
+                                for (var j = 0; j < message.calls.length; ++j)
+                                    object.calls[j] = $root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall.toObject(message.calls[j], options);
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this Batch to JSON.
+                         * @function toJSON
+                         * @memberof TW.Ethereum.Proto.Transaction.Batch
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        Batch.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        Batch.BatchedCall = (function() {
+    
+                            /**
+                             * Properties of a BatchedCall.
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch
+                             * @interface IBatchedCall
+                             * @property {string|null} [address] BatchedCall address
+                             * @property {Uint8Array|null} [amount] BatchedCall amount
+                             * @property {Uint8Array|null} [payload] BatchedCall payload
+                             */
+    
+                            /**
+                             * Constructs a new BatchedCall.
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch
+                             * @classdesc Represents a BatchedCall.
+                             * @implements IBatchedCall
+                             * @constructor
+                             * @param {TW.Ethereum.Proto.Transaction.Batch.IBatchedCall=} [properties] Properties to set
+                             */
+                            function BatchedCall(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]];
+                            }
+    
+                            /**
+                             * BatchedCall address.
+                             * @member {string} address
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @instance
+                             */
+                            BatchedCall.prototype.address = "";
+    
+                            /**
+                             * BatchedCall amount.
+                             * @member {Uint8Array} amount
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @instance
+                             */
+                            BatchedCall.prototype.amount = $util.newBuffer([]);
+    
+                            /**
+                             * BatchedCall payload.
+                             * @member {Uint8Array} payload
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @instance
+                             */
+                            BatchedCall.prototype.payload = $util.newBuffer([]);
+    
+                            /**
+                             * Creates a new BatchedCall instance using the specified properties.
+                             * @function create
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @static
+                             * @param {TW.Ethereum.Proto.Transaction.Batch.IBatchedCall=} [properties] Properties to set
+                             * @returns {TW.Ethereum.Proto.Transaction.Batch.BatchedCall} BatchedCall instance
+                             */
+                            BatchedCall.create = function create(properties) {
+                                return new BatchedCall(properties);
+                            };
+    
+                            /**
+                             * Encodes the specified BatchedCall message. Does not implicitly {@link TW.Ethereum.Proto.Transaction.Batch.BatchedCall.verify|verify} messages.
+                             * @function encode
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @static
+                             * @param {TW.Ethereum.Proto.Transaction.Batch.IBatchedCall} message BatchedCall message or plain object to encode
+                             * @param {$protobuf.Writer} [writer] Writer to encode to
+                             * @returns {$protobuf.Writer} Writer
+                             */
+                            BatchedCall.encode = function encode(message, writer) {
+                                if (!writer)
+                                    writer = $Writer.create();
+                                if (message.address != null && Object.hasOwnProperty.call(message, "address"))
+                                    writer.uint32(/* id 1, wireType 2 =*/10).string(message.address);
+                                if (message.amount != null && Object.hasOwnProperty.call(message, "amount"))
+                                    writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.amount);
+                                if (message.payload != null && Object.hasOwnProperty.call(message, "payload"))
+                                    writer.uint32(/* id 3, wireType 2 =*/26).bytes(message.payload);
+                                return writer;
+                            };
+    
+                            /**
+                             * Decodes a BatchedCall message from the specified reader or buffer.
+                             * @function decode
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @static
+                             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                             * @param {number} [length] Message length if known beforehand
+                             * @returns {TW.Ethereum.Proto.Transaction.Batch.BatchedCall} BatchedCall
+                             * @throws {Error} If the payload is not a reader or valid buffer
+                             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                             */
+                            BatchedCall.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.Ethereum.Proto.Transaction.Batch.BatchedCall();
+                                while (reader.pos < end) {
+                                    var tag = reader.uint32();
+                                    switch (tag >>> 3) {
+                                    case 1:
+                                        message.address = reader.string();
+                                        break;
+                                    case 2:
+                                        message.amount = reader.bytes();
+                                        break;
+                                    case 3:
+                                        message.payload = reader.bytes();
+                                        break;
+                                    default:
+                                        reader.skipType(tag & 7);
+                                        break;
+                                    }
+                                }
+                                return message;
+                            };
+    
+                            /**
+                             * Verifies a BatchedCall message.
+                             * @function verify
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @static
+                             * @param {Object.<string,*>} message Plain object to verify
+                             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                             */
+                            BatchedCall.verify = function verify(message) {
+                                if (typeof message !== "object" || message === null)
+                                    return "object expected";
+                                if (message.address != null && message.hasOwnProperty("address"))
+                                    if (!$util.isString(message.address))
+                                        return "address: string expected";
+                                if (message.amount != null && message.hasOwnProperty("amount"))
+                                    if (!(message.amount && typeof message.amount.length === "number" || $util.isString(message.amount)))
+                                        return "amount: buffer expected";
+                                if (message.payload != null && message.hasOwnProperty("payload"))
+                                    if (!(message.payload && typeof message.payload.length === "number" || $util.isString(message.payload)))
+                                        return "payload: buffer expected";
+                                return null;
+                            };
+    
+                            /**
+                             * Creates a BatchedCall message from a plain object. Also converts values to their respective internal types.
+                             * @function fromObject
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @static
+                             * @param {Object.<string,*>} object Plain object
+                             * @returns {TW.Ethereum.Proto.Transaction.Batch.BatchedCall} BatchedCall
+                             */
+                            BatchedCall.fromObject = function fromObject(object) {
+                                if (object instanceof $root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall)
+                                    return object;
+                                var message = new $root.TW.Ethereum.Proto.Transaction.Batch.BatchedCall();
+                                if (object.address != null)
+                                    message.address = String(object.address);
+                                if (object.amount != null)
+                                    if (typeof object.amount === "string")
+                                        $util.base64.decode(object.amount, message.amount = $util.newBuffer($util.base64.length(object.amount)), 0);
+                                    else if (object.amount.length)
+                                        message.amount = object.amount;
+                                if (object.payload != null)
+                                    if (typeof object.payload === "string")
+                                        $util.base64.decode(object.payload, message.payload = $util.newBuffer($util.base64.length(object.payload)), 0);
+                                    else if (object.payload.length)
+                                        message.payload = object.payload;
+                                return message;
+                            };
+    
+                            /**
+                             * Creates a plain object from a BatchedCall message. Also converts values to other types if specified.
+                             * @function toObject
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @static
+                             * @param {TW.Ethereum.Proto.Transaction.Batch.BatchedCall} message BatchedCall
+                             * @param {$protobuf.IConversionOptions} [options] Conversion options
+                             * @returns {Object.<string,*>} Plain object
+                             */
+                            BatchedCall.toObject = function toObject(message, options) {
+                                if (!options)
+                                    options = {};
+                                var object = {};
+                                if (options.defaults) {
+                                    object.address = "";
+                                    if (options.bytes === String)
+                                        object.amount = "";
+                                    else {
+                                        object.amount = [];
+                                        if (options.bytes !== Array)
+                                            object.amount = $util.newBuffer(object.amount);
+                                    }
+                                    if (options.bytes === String)
+                                        object.payload = "";
+                                    else {
+                                        object.payload = [];
+                                        if (options.bytes !== Array)
+                                            object.payload = $util.newBuffer(object.payload);
+                                    }
+                                }
+                                if (message.address != null && message.hasOwnProperty("address"))
+                                    object.address = message.address;
+                                if (message.amount != null && message.hasOwnProperty("amount"))
+                                    object.amount = options.bytes === String ? $util.base64.encode(message.amount, 0, message.amount.length) : options.bytes === Array ? Array.prototype.slice.call(message.amount) : message.amount;
+                                if (message.payload != null && message.hasOwnProperty("payload"))
+                                    object.payload = options.bytes === String ? $util.base64.encode(message.payload, 0, message.payload.length) : options.bytes === Array ? Array.prototype.slice.call(message.payload) : message.payload;
+                                return object;
+                            };
+    
+                            /**
+                             * Converts this BatchedCall to JSON.
+                             * @function toJSON
+                             * @memberof TW.Ethereum.Proto.Transaction.Batch.BatchedCall
+                             * @instance
+                             * @returns {Object.<string,*>} JSON object
+                             */
+                            BatchedCall.prototype.toJSON = function toJSON() {
+                                return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                            };
+    
+                            return BatchedCall;
+                        })();
+    
+                        return Batch;
+                    })();
+    
                     return Transaction;
                 })();
     

package/dist/lib/wallet-core.js

@@ -34,7 +34,7 @@ function Ua(){Qa++;g.monitorRunDependencies&&g.monitorRunDependencies(Qa);assert
 function Va(){return G.startsWith("data:application/octet-stream;base64,")}function ma(a){return a.startsWith("file://")}function H(a){return function(){var b=g.asm;assert(Oa,"native function `"+a+"` called before runtime initialization");b[a]||assert(b[a],"exported native function `"+a+"` not found");return b[a].apply(null,arguments)}}var G;G="wallet-core.wasm";if(!Va()){var Wa=G;G=g.locateFile?g.locateFile(Wa,w):w+Wa}
 function Xa(){var a=G;try{if(a==G&&qa)return new Uint8Array(qa);if(ka)return ka(a);throw"both async and sync fetching of the wasm failed";}catch(b){n(b)}}
 function Ya(){if(!qa&&(ea||fa)){if("function"==typeof fetch&&!ma(G))return fetch(G,{credentials:"same-origin"}).then(function(a){if(!a.ok)throw"failed to load wasm binary file at '"+G+"'";return a.arrayBuffer()}).catch(function(){return Xa()});if(ja)return new Promise(function(a,b){ja(G,function(c){a(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return Xa()})}
-var Za,$a,ab={1790052:()=>{if(void 0===g.ea)try{var a="object"===typeof window?window:self,b="undefined"!==typeof a.crypto?a.crypto:a.msCrypto;a=function(){var d=new Uint32Array(1);b.getRandomValues(d);return d[0]>>>0};a();g.ea=a}catch(d){try{var c=require("crypto");a=function(){var e=c.randomBytes(4);return(e[0]<<24|e[1]<<16|e[2]<<8|e[3])>>>0};a();g.ea=a}catch(e){throw"No secure random number generator found";}}},1790774:()=>g.ea()};function bb(a){for(;0<a.length;)a.shift()(g)}
+var Za,$a,ab={1789908:()=>{if(void 0===g.ea)try{var a="object"===typeof window?window:self,b="undefined"!==typeof a.crypto?a.crypto:a.msCrypto;a=function(){var d=new Uint32Array(1);b.getRandomValues(d);return d[0]>>>0};a();g.ea=a}catch(d){try{var c=require("crypto");a=function(){var e=c.randomBytes(4);return(e[0]<<24|e[1]<<16|e[2]<<8|e[3])>>>0};a();g.ea=a}catch(e){throw"No secure random number generator found";}}},1790630:()=>g.ea()};function bb(a){for(;0<a.length;)a.shift()(g)}
 function va(a){assert("number"===typeof a);return"0x"+a.toString(16).padStart(8,"0")}function pa(a){cb||(cb={});cb[a]||(cb[a]=1,v&&(a="warning: "+a),y(a))}var cb,db=0;
 function eb(a){this.l=a-24;this.Ta=function(b){F[this.l+4>>2]=b};this.Da=function(){return F[this.l+4>>2]};this.Ja=function(b){F[this.l+8>>2]=b};this.Ka=function(){E[this.l>>2]=0};this.Ia=function(){C[this.l+12>>0]=0};this.Na=function(){C[this.l+13>>0]=0};this.Ea=function(b,c){this.F(0);this.Ta(b);this.Ja(c);this.Ka();this.Ia();this.Na()};this.F=function(b){F[this.l+16>>2]=b}}
 var fb=0,gb=(a,b)=>{for(var c=0,d=a.length-1;0<=d;d--){var e=a[d];"."===e?a.splice(d,1):".."===e?(a.splice(d,1),c++):c&&(a.splice(d,1),c--)}if(b)for(;c;c--)a.unshift("..");return a},hb=a=>{var b="/"===a.charAt(0),c="/"===a.substr(-1);(a=gb(a.split("/").filter(d=>!!d),!b).join("/"))||b||(a=".");a&&c&&(a+="/");return(b?"/":"")+a},ib=a=>{var b=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/.exec(a).slice(1);a=b[0];b=b[1];if(!a&&!b)return".";b&&(b=b.substr(0,b.length-1));return a+b},jb=

package/dist/src/wallet-core.d.ts

@@ -364,6 +364,7 @@ export class CoinType {
     static scroll: CoinType;
     static rootstock: CoinType;
     static thetaFuel: CoinType;
+    static confluxeSpace: CoinType;
 }
 export class CoinTypeConfiguration {
     static getSymbol(type: CoinType): string;
@@ -506,6 +507,7 @@ export class EthereumChainID {
     static polygon: EthereumChainID;
     static okc: EthereumChainID;
     static thundertoken: EthereumChainID;
+    static cfxevm: EthereumChainID;
     static gochain: EthereumChainID;
     static meter: EthereumChainID;
     static celo: EthereumChainID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustwallet/wallet-core",
-  "version": "3.2.0",
+  "version": "3.2.2",
   "description": "wallet core wasm and protobuf models",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",