@trustwallet/wallet-core 4.1.8-rc1 → 4.1.8-rc2

package/dist/generated/core_proto.d.ts

@@ -14634,6 +14634,85 @@ export namespace TW {
                 public toJSON(): { [k: string]: any };
             }
 
+            /** Properties of an Access. */
+            interface IAccess {
+
+                /** Access address */
+                address?: (string|null);
+
+                /** Access storedKeys */
+                storedKeys?: (Uint8Array[]|null);
+            }
+
+            /** Represents an Access. */
+            class Access implements IAccess {
+
+                /**
+                 * Constructs a new Access.
+                 * @param [properties] Properties to set
+                 */
+                constructor(properties?: TW.Ethereum.Proto.IAccess);
+
+                /** Access address. */
+                public address: string;
+
+                /** Access storedKeys. */
+                public storedKeys: Uint8Array[];
+
+                /**
+                 * Creates a new Access instance using the specified properties.
+                 * @param [properties] Properties to set
+                 * @returns Access instance
+                 */
+                public static create(properties?: TW.Ethereum.Proto.IAccess): TW.Ethereum.Proto.Access;
+
+                /**
+                 * Encodes the specified Access message. Does not implicitly {@link TW.Ethereum.Proto.Access.verify|verify} messages.
+                 * @param message Access message or plain object to encode
+                 * @param [writer] Writer to encode to
+                 * @returns Writer
+                 */
+                public static encode(message: TW.Ethereum.Proto.IAccess, writer?: $protobuf.Writer): $protobuf.Writer;
+
+                /**
+                 * Decodes an Access message from the specified reader or buffer.
+                 * @param reader Reader or buffer to decode from
+                 * @param [length] Message length if known beforehand
+                 * @returns Access
+                 * @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.Access;
+
+                /**
+                 * Verifies an Access message.
+                 * @param message Plain object to verify
+                 * @returns `null` if valid, otherwise the reason why it is not
+                 */
+                public static verify(message: { [k: string]: any }): (string|null);
+
+                /**
+                 * Creates an Access message from a plain object. Also converts values to their respective internal types.
+                 * @param object Plain object
+                 * @returns Access
+                 */
+                public static fromObject(object: { [k: string]: any }): TW.Ethereum.Proto.Access;
+
+                /**
+                 * Creates a plain object from an Access message. Also converts values to other types if specified.
+                 * @param message Access
+                 * @param [options] Conversion options
+                 * @returns Plain object
+                 */
+                public static toObject(message: TW.Ethereum.Proto.Access, options?: $protobuf.IConversionOptions): { [k: string]: any };
+
+                /**
+                 * Converts this Access to JSON.
+                 * @returns JSON object
+                 */
+                public toJSON(): { [k: string]: any };
+            }
+
             /** Properties of a SigningInput. */
             interface ISigningInput {
 
@@ -14669,6 +14748,9 @@ export namespace TW {
 
                 /** SigningInput userOperation */
                 userOperation?: (TW.Ethereum.Proto.IUserOperation|null);
+
+                /** SigningInput accessList */
+                accessList?: (TW.Ethereum.Proto.IAccess[]|null);
             }
 
             /** Represents a SigningInput. */
@@ -14713,6 +14795,9 @@ export namespace TW {
                 /** SigningInput userOperation. */
                 public userOperation?: (TW.Ethereum.Proto.IUserOperation|null);
 
+                /** SigningInput accessList. */
+                public accessList: TW.Ethereum.Proto.IAccess[];
+
                 /**
                  * Creates a new SigningInput instance using the specified properties.
                  * @param [properties] Properties to set

package/dist/generated/core_proto.js

@@ -43975,6 +43975,206 @@
                     return UserOperation;
                 })();
     
+                Proto.Access = (function() {
+    
+                    /**
+                     * Properties of an Access.
+                     * @memberof TW.Ethereum.Proto
+                     * @interface IAccess
+                     * @property {string|null} [address] Access address
+                     * @property {Array.<Uint8Array>|null} [storedKeys] Access storedKeys
+                     */
+    
+                    /**
+                     * Constructs a new Access.
+                     * @memberof TW.Ethereum.Proto
+                     * @classdesc Represents an Access.
+                     * @implements IAccess
+                     * @constructor
+                     * @param {TW.Ethereum.Proto.IAccess=} [properties] Properties to set
+                     */
+                    function Access(properties) {
+                        this.storedKeys = [];
+                        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]];
+                    }
+    
+                    /**
+                     * Access address.
+                     * @member {string} address
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @instance
+                     */
+                    Access.prototype.address = "";
+    
+                    /**
+                     * Access storedKeys.
+                     * @member {Array.<Uint8Array>} storedKeys
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @instance
+                     */
+                    Access.prototype.storedKeys = $util.emptyArray;
+    
+                    /**
+                     * Creates a new Access instance using the specified properties.
+                     * @function create
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @static
+                     * @param {TW.Ethereum.Proto.IAccess=} [properties] Properties to set
+                     * @returns {TW.Ethereum.Proto.Access} Access instance
+                     */
+                    Access.create = function create(properties) {
+                        return new Access(properties);
+                    };
+    
+                    /**
+                     * Encodes the specified Access message. Does not implicitly {@link TW.Ethereum.Proto.Access.verify|verify} messages.
+                     * @function encode
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @static
+                     * @param {TW.Ethereum.Proto.IAccess} message Access message or plain object to encode
+                     * @param {$protobuf.Writer} [writer] Writer to encode to
+                     * @returns {$protobuf.Writer} Writer
+                     */
+                    Access.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.storedKeys != null && message.storedKeys.length)
+                            for (var i = 0; i < message.storedKeys.length; ++i)
+                                writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.storedKeys[i]);
+                        return writer;
+                    };
+    
+                    /**
+                     * Decodes an Access message from the specified reader or buffer.
+                     * @function decode
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @static
+                     * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                     * @param {number} [length] Message length if known beforehand
+                     * @returns {TW.Ethereum.Proto.Access} Access
+                     * @throws {Error} If the payload is not a reader or valid buffer
+                     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                     */
+                    Access.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.Access();
+                        while (reader.pos < end) {
+                            var tag = reader.uint32();
+                            switch (tag >>> 3) {
+                            case 1:
+                                message.address = reader.string();
+                                break;
+                            case 2:
+                                if (!(message.storedKeys && message.storedKeys.length))
+                                    message.storedKeys = [];
+                                message.storedKeys.push(reader.bytes());
+                                break;
+                            default:
+                                reader.skipType(tag & 7);
+                                break;
+                            }
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Verifies an Access message.
+                     * @function verify
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @static
+                     * @param {Object.<string,*>} message Plain object to verify
+                     * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                     */
+                    Access.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.storedKeys != null && message.hasOwnProperty("storedKeys")) {
+                            if (!Array.isArray(message.storedKeys))
+                                return "storedKeys: array expected";
+                            for (var i = 0; i < message.storedKeys.length; ++i)
+                                if (!(message.storedKeys[i] && typeof message.storedKeys[i].length === "number" || $util.isString(message.storedKeys[i])))
+                                    return "storedKeys: buffer[] expected";
+                        }
+                        return null;
+                    };
+    
+                    /**
+                     * Creates an Access message from a plain object. Also converts values to their respective internal types.
+                     * @function fromObject
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @static
+                     * @param {Object.<string,*>} object Plain object
+                     * @returns {TW.Ethereum.Proto.Access} Access
+                     */
+                    Access.fromObject = function fromObject(object) {
+                        if (object instanceof $root.TW.Ethereum.Proto.Access)
+                            return object;
+                        var message = new $root.TW.Ethereum.Proto.Access();
+                        if (object.address != null)
+                            message.address = String(object.address);
+                        if (object.storedKeys) {
+                            if (!Array.isArray(object.storedKeys))
+                                throw TypeError(".TW.Ethereum.Proto.Access.storedKeys: array expected");
+                            message.storedKeys = [];
+                            for (var i = 0; i < object.storedKeys.length; ++i)
+                                if (typeof object.storedKeys[i] === "string")
+                                    $util.base64.decode(object.storedKeys[i], message.storedKeys[i] = $util.newBuffer($util.base64.length(object.storedKeys[i])), 0);
+                                else if (object.storedKeys[i].length)
+                                    message.storedKeys[i] = object.storedKeys[i];
+                        }
+                        return message;
+                    };
+    
+                    /**
+                     * Creates a plain object from an Access message. Also converts values to other types if specified.
+                     * @function toObject
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @static
+                     * @param {TW.Ethereum.Proto.Access} message Access
+                     * @param {$protobuf.IConversionOptions} [options] Conversion options
+                     * @returns {Object.<string,*>} Plain object
+                     */
+                    Access.toObject = function toObject(message, options) {
+                        if (!options)
+                            options = {};
+                        var object = {};
+                        if (options.arrays || options.defaults)
+                            object.storedKeys = [];
+                        if (options.defaults)
+                            object.address = "";
+                        if (message.address != null && message.hasOwnProperty("address"))
+                            object.address = message.address;
+                        if (message.storedKeys && message.storedKeys.length) {
+                            object.storedKeys = [];
+                            for (var j = 0; j < message.storedKeys.length; ++j)
+                                object.storedKeys[j] = options.bytes === String ? $util.base64.encode(message.storedKeys[j], 0, message.storedKeys[j].length) : options.bytes === Array ? Array.prototype.slice.call(message.storedKeys[j]) : message.storedKeys[j];
+                        }
+                        return object;
+                    };
+    
+                    /**
+                     * Converts this Access to JSON.
+                     * @function toJSON
+                     * @memberof TW.Ethereum.Proto.Access
+                     * @instance
+                     * @returns {Object.<string,*>} JSON object
+                     */
+                    Access.prototype.toJSON = function toJSON() {
+                        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                    };
+    
+                    return Access;
+                })();
+    
                 Proto.SigningInput = (function() {
     
                     /**
@@ -43992,6 +44192,7 @@
                      * @property {Uint8Array|null} [privateKey] SigningInput privateKey
                      * @property {TW.Ethereum.Proto.ITransaction|null} [transaction] SigningInput transaction
                      * @property {TW.Ethereum.Proto.IUserOperation|null} [userOperation] SigningInput userOperation
+                     * @property {Array.<TW.Ethereum.Proto.IAccess>|null} [accessList] SigningInput accessList
                      */
     
                     /**
@@ -44003,6 +44204,7 @@
                      * @param {TW.Ethereum.Proto.ISigningInput=} [properties] Properties to set
                      */
                     function SigningInput(properties) {
+                        this.accessList = [];
                         if (properties)
                             for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                                 if (properties[keys[i]] != null)
@@ -44097,6 +44299,14 @@
                      */
                     SigningInput.prototype.userOperation = null;
     
+                    /**
+                     * SigningInput accessList.
+                     * @member {Array.<TW.Ethereum.Proto.IAccess>} accessList
+                     * @memberof TW.Ethereum.Proto.SigningInput
+                     * @instance
+                     */
+                    SigningInput.prototype.accessList = $util.emptyArray;
+    
                     /**
                      * Creates a new SigningInput instance using the specified properties.
                      * @function create
@@ -44143,6 +44353,9 @@
                             $root.TW.Ethereum.Proto.Transaction.encode(message.transaction, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
                         if (message.userOperation != null && Object.hasOwnProperty.call(message, "userOperation"))
                             $root.TW.Ethereum.Proto.UserOperation.encode(message.userOperation, writer.uint32(/* id 11, wireType 2 =*/90).fork()).ldelim();
+                        if (message.accessList != null && message.accessList.length)
+                            for (var i = 0; i < message.accessList.length; ++i)
+                                $root.TW.Ethereum.Proto.Access.encode(message.accessList[i], writer.uint32(/* id 12, wireType 2 =*/98).fork()).ldelim();
                         return writer;
                     };
     
@@ -44197,6 +44410,11 @@
                             case 11:
                                 message.userOperation = $root.TW.Ethereum.Proto.UserOperation.decode(reader, reader.uint32());
                                 break;
+                            case 12:
+                                if (!(message.accessList && message.accessList.length))
+                                    message.accessList = [];
+                                message.accessList.push($root.TW.Ethereum.Proto.Access.decode(reader, reader.uint32()));
+                                break;
                             default:
                                 reader.skipType(tag & 7);
                                 break;
@@ -44259,6 +44477,15 @@
                             if (error)
                                 return "userOperation." + error;
                         }
+                        if (message.accessList != null && message.hasOwnProperty("accessList")) {
+                            if (!Array.isArray(message.accessList))
+                                return "accessList: array expected";
+                            for (var i = 0; i < message.accessList.length; ++i) {
+                                var error = $root.TW.Ethereum.Proto.Access.verify(message.accessList[i]);
+                                if (error)
+                                    return "accessList." + error;
+                            }
+                        }
                         return null;
                     };
     
@@ -44335,6 +44562,16 @@
                                 throw TypeError(".TW.Ethereum.Proto.SigningInput.userOperation: object expected");
                             message.userOperation = $root.TW.Ethereum.Proto.UserOperation.fromObject(object.userOperation);
                         }
+                        if (object.accessList) {
+                            if (!Array.isArray(object.accessList))
+                                throw TypeError(".TW.Ethereum.Proto.SigningInput.accessList: array expected");
+                            message.accessList = [];
+                            for (var i = 0; i < object.accessList.length; ++i) {
+                                if (typeof object.accessList[i] !== "object")
+                                    throw TypeError(".TW.Ethereum.Proto.SigningInput.accessList: object expected");
+                                message.accessList[i] = $root.TW.Ethereum.Proto.Access.fromObject(object.accessList[i]);
+                            }
+                        }
                         return message;
                     };
     
@@ -44351,6 +44588,8 @@
                         if (!options)
                             options = {};
                         var object = {};
+                        if (options.arrays || options.defaults)
+                            object.accessList = [];
                         if (options.defaults) {
                             if (options.bytes === String)
                                 object.chainId = "";
@@ -44428,6 +44667,11 @@
                             object.transaction = $root.TW.Ethereum.Proto.Transaction.toObject(message.transaction, options);
                         if (message.userOperation != null && message.hasOwnProperty("userOperation"))
                             object.userOperation = $root.TW.Ethereum.Proto.UserOperation.toObject(message.userOperation, options);
+                        if (message.accessList && message.accessList.length) {
+                            object.accessList = [];
+                            for (var j = 0; j < message.accessList.length; ++j)
+                                object.accessList[j] = $root.TW.Ethereum.Proto.Access.toObject(message.accessList[j], options);
+                        }
                         return object;
                     };
     

package/dist/lib/wallet-core.js

@@ -34,7 +34,7 @@ function Ra(){H++;g.monitorRunDependencies&&g.monitorRunDependencies(H);assert(!
 function Sa(){return K.startsWith("data:application/octet-stream;base64,")}function ma(a){return a.startsWith("file://")}function M(a){return function(){var b=g.asm;assert(Na,"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 K;K="wallet-core.wasm";if(!Sa()){var Ta=K;K=g.locateFile?g.locateFile(Ta,x):x+Ta}
 function Ua(){var a=K;try{if(a==K&&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 Va(){if(!qa&&(ea||fa)){if("function"==typeof fetch&&!ma(K))return fetch(K,{credentials:"same-origin"}).then(function(a){if(!a.ok)throw"failed to load wasm binary file at '"+K+"'";return a.arrayBuffer()}).catch(function(){return Ua()});if(ja)return new Promise(function(a,b){ja(K,function(c){a(new Uint8Array(c))},b)})}return Promise.resolve().then(function(){return Ua()})}
-var Wa,Xa,Ya={2106900:()=>{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";}}},2107622:()=>g.ea()};function Za(a){for(;0<a.length;)a.shift()(g)}
+var Wa,Xa,Ya={2078740:()=>{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";}}},2079462:()=>g.ea()};function Za(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){$a||($a={});$a[a]||($a[a]=1,v&&(a="warning: "+a),y(a))}var $a;function ab(a){this.l=a-24;this.Na=function(b){G[this.l+4>>2]=b};this.Ia=function(b){G[this.l+8>>2]=b};this.Ja=function(){F[this.l>>2]=0};this.Ea=function(){D[this.l+12>>0]=0};this.Ka=function(){D[this.l+13>>0]=0};this.I=function(b,c){this.Da();this.Na(b);this.Ia(c);this.Ja();this.Ea();this.Ka()};this.Da=function(){G[this.l+16>>2]=0}}
 var bb=0,cb=(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},db=a=>{var b="/"===a.charAt(0),c="/"===a.substr(-1);(a=cb(a.split("/").filter(d=>!!d),!b).join("/"))||b||(a=".");a&&c&&(a+="/");return(b?"/":"")+a},eb=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},fb=
 a=>{if("/"===a)return"/";a=db(a);a=a.replace(/\/$/,"");var b=a.lastIndexOf("/");return-1===b?a:a.substr(b+1)};

package/dist/src/keystore/default-impl.d.ts

@@ -13,7 +13,6 @@ export declare class Default implements Types.IKeyStore {
     importWallet(wallet: Types.Wallet): Promise<void>;
     import(mnemonic: string, name: string, password: string, coins: CoinType[], encryption: StoredKeyEncryption): Promise<Types.Wallet>;
     importKey(key: Uint8Array, name: string, password: string, coin: CoinType, encryption: StoredKeyEncryption): Promise<Types.Wallet>;
-    importTON(tonMnemonic: string, name: string, password: string, coin: CoinType, encryption: StoredKeyEncryption): Promise<Types.Wallet>;
     addAccounts(id: string, password: string, coins: CoinType[]): Promise<Types.Wallet>;
     getKey(id: string, password: string, account: Types.ActiveAccount): Promise<PrivateKey>;
     export(id: string, password: string): Promise<string | Uint8Array>;

package/dist/src/keystore/default-impl.js

@@ -75,23 +75,6 @@ var Default = /** @class */ (function () {
                 .catch(function (error) { return reject(error); });
         });
     };
-    Default.prototype.importTON = function (tonMnemonic, name, password, coin, encryption) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var _a = _this.core, StoredKey = _a.StoredKey, TONWallet = _a.TONWallet;
-            var passphrase = "";
-            if (!TONWallet.isValidMnemonic(tonMnemonic, passphrase)) {
-                throw Types.Error.InvalidMnemonic;
-            }
-            var pass = Buffer.from(password);
-            var storedKey = StoredKey.importTONWalletWithEncryption(tonMnemonic, name, pass, coin, encryption);
-            var wallet = _this.mapWallet(storedKey);
-            storedKey.delete();
-            _this.importWallet(wallet)
-                .then(function () { return resolve(wallet); })
-                .catch(function (error) { return reject(error); });
-        });
-    };
     Default.prototype.addAccounts = function (id, password, coins) {
         var _this = this;
         return this.load(id).then(function (wallet) {
@@ -110,21 +93,11 @@ var Default = /** @class */ (function () {
         var _this = this;
         return this.load(id).then(function (wallet) {
             var storedKey = _this.mapStoredKey(wallet);
+            var hdWallet = storedKey.wallet(Buffer.from(password));
             var coin = _this.core.CoinType.values["" + account.coin];
-            var privateKey;
-            switch (wallet.type) {
-                // In case of BIP39 mnemonic, we should use the custom derivation path.
-                case Types.WalletType.Mnemonic:
-                    var hdWallet = storedKey.wallet(Buffer.from(password));
-                    privateKey = hdWallet.getKey(coin, account.derivationPath);
-                    hdWallet.delete();
-                    break;
-                // Otherwise, use the default implementation.
-                default:
-                    privateKey = storedKey.privateKey(coin, Buffer.from(password));
-                    break;
-            }
+            var privateKey = hdWallet.getKey(coin, account.derivationPath);
             storedKey.delete();
+            hdWallet.delete();
             return privateKey;
         });
     };
@@ -140,9 +113,6 @@ var Default = /** @class */ (function () {
                 case Types.WalletType.PrivateKey:
                     value = storedKey.decryptPrivateKey(Buffer.from(password));
                     break;
-                case Types.WalletType.TonMnemonic:
-                    value = storedKey.decryptTONMnemonic(Buffer.from(password));
-                    break;
                 default:
                     throw Types.Error.InvalidJSON;
             }

package/dist/src/keystore/types.d.ts

@@ -3,8 +3,7 @@ export declare enum WalletType {
     Mnemonic = "mnemonic",
     PrivateKey = "privateKey",
     WatchOnly = "watchOnly",
-    Hardware = "hardware",
-    TonMnemonic = "ton-mnemonic"
+    Hardware = "hardware"
 }
 export declare enum Error {
     WalletNotFound = "wallet not found",
@@ -35,7 +34,6 @@ export interface IKeyStore {
     import(mnemonic: string, name: string, password: string, coins: CoinType[], encryption: StoredKeyEncryption): Promise<Wallet>;
     importKey(key: Uint8Array, name: string, password: string, coin: CoinType, encryption: StoredKeyEncryption): Promise<Wallet>;
     importWallet(wallet: Wallet): Promise<void>;
-    importTON(tonMnemonic: string, name: string, password: string, coin: CoinType, encryption: StoredKeyEncryption): Promise<Wallet>;
     addAccounts(id: string, password: string, coins: CoinType[]): Promise<Wallet>;
     getKey(id: string, password: string, account: ActiveAccount): Promise<PrivateKey>;
     delete(id: string, password: string): Promise<void>;

package/dist/src/keystore/types.js

@@ -10,7 +10,6 @@ var WalletType;
     WalletType["PrivateKey"] = "privateKey";
     WalletType["WatchOnly"] = "watchOnly";
     WalletType["Hardware"] = "hardware";
-    WalletType["TonMnemonic"] = "ton-mnemonic";
 })(WalletType = exports.WalletType || (exports.WalletType = {}));
 var Error;
 (function (Error) {

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

@@ -928,8 +928,6 @@ export class StoredKey {
     static importPrivateKeyWithEncryption(privateKey: Uint8Array | Buffer, name: string, password: Uint8Array | Buffer, coin: CoinType, encryption: StoredKeyEncryption): StoredKey;
     static importHDWallet(mnemonic: string, name: string, password: Uint8Array | Buffer, coin: CoinType): StoredKey;
     static importHDWalletWithEncryption(mnemonic: string, name: string, password: Uint8Array | Buffer, coin: CoinType, encryption: StoredKeyEncryption): StoredKey;
-    static importTONWallet(tonMnemonic: string, name: string, password: Uint8Array | Buffer, coin: CoinType): StoredKey;
-    static importTONWalletWithEncryption(tonMnemonic: string, name: string, password: Uint8Array | Buffer, coin: CoinType, encryption: StoredKeyEncryption): StoredKey;
     static importJSON(json: Uint8Array | Buffer): StoredKey;
     static createLevel(name: string, password: Uint8Array | Buffer, encryptionLevel: StoredKeyEncryptionLevel): StoredKey;
     static createLevelAndEncryption(name: string, password: Uint8Array | Buffer, encryptionLevel: StoredKeyEncryptionLevel, encryption: StoredKeyEncryption): StoredKey;
@@ -938,7 +936,6 @@ export class StoredKey {
     identifier(): string;
     name(): string;
     isMnemonic(): boolean;
-    isTONMnemonic(): boolean;
     accountCount(): number;
     encryptionParameters(): string;
     account(index: number): Account;
@@ -952,7 +949,6 @@ export class StoredKey {
     store(path: string): boolean;
     decryptPrivateKey(password: Uint8Array | Buffer): Uint8Array;
     decryptMnemonic(password: Uint8Array | Buffer): string;
-    decryptTONMnemonic(password: Uint8Array | Buffer): string;
     privateKey(coin: CoinType, password: Uint8Array | Buffer): PrivateKey;
     wallet(password: Uint8Array | Buffer): HDWallet;
     exportJSON(): Uint8Array;
@@ -986,11 +982,7 @@ export class TONMessageSigner {
     static signMessage(privateKey: PrivateKey, message: string): string;
 }
 export class TONWallet {
-    static isValidMnemonic(mnemonic: string, passphrase: string): boolean;
     static buildV4R2StateInit(publicKey: PublicKey, workchain: number, walletId: number): string;
-    static createWithMnemonic(mnemonic: string, passphrase: string): TONWallet;
-    getKey(): PrivateKey;
-    delete(): void;
 }
 export class TezosMessageSigner {
     static formatMessage(message: string, url: string): string;

package/package.json

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