@trustwallet/wallet-core 3.0.9 → 3.1.1

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

@@ -1,4 +1,4 @@
-import { WalletCore, CoinType, PrivateKey, StoredKey } from "../wallet-core";
+import { WalletCore, CoinType, PrivateKey, StoredKey, StoredKeyEncryption } from "../wallet-core";
 import * as Types from "./types";
 export declare class Default implements Types.IKeyStore {
     private readonly core;
@@ -11,8 +11,8 @@ export declare class Default implements Types.IKeyStore {
     mapWallet(storedKey: StoredKey): Types.Wallet;
     mapStoredKey(wallet: Types.Wallet): StoredKey;
     importWallet(wallet: Types.Wallet): Promise<void>;
-    import(mnemonic: string, name: string, password: string, coins: CoinType[]): Promise<Types.Wallet>;
-    importKey(key: Uint8Array, name: string, password: string, coin: CoinType): Promise<Types.Wallet>;
+    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>;
     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

@@ -38,15 +38,15 @@ var Default = /** @class */ (function () {
     Default.prototype.importWallet = function (wallet) {
         return this.storage.set(wallet.id, wallet);
     };
-    Default.prototype.import = function (mnemonic, name, password, coins) {
+    Default.prototype.import = function (mnemonic, name, password, coins, encryption) {
         var _this = this;
         return new Promise(function (resolve, reject) {
-            var _a = _this.core, Mnemonic = _a.Mnemonic, StoredKey = _a.StoredKey, HDWallet = _a.HDWallet;
+            var _a = _this.core, Mnemonic = _a.Mnemonic, StoredKey = _a.StoredKey, HDWallet = _a.HDWallet, StoredKeyEncryption = _a.StoredKeyEncryption;
             if (!Mnemonic.isValid(mnemonic)) {
                 throw Types.Error.InvalidMnemonic;
             }
             var pass = Buffer.from(password);
-            var storedKey = StoredKey.importHDWallet(mnemonic, name, pass, coins[0]);
+            var storedKey = StoredKey.importHDWalletWithEncryption(mnemonic, name, pass, coins[0], encryption);
             var hdWallet = HDWallet.createWithMnemonic(mnemonic, "");
             coins.forEach(function (coin) {
                 storedKey.accountForCoin(coin, hdWallet);
@@ -59,17 +59,17 @@ var Default = /** @class */ (function () {
                 .catch(function (error) { return reject(error); });
         });
     };
-    Default.prototype.importKey = function (key, name, password, coin) {
+    Default.prototype.importKey = function (key, name, password, coin, encryption) {
         var _this = this;
         return new Promise(function (resolve, reject) {
-            var _a = _this.core, StoredKey = _a.StoredKey, PrivateKey = _a.PrivateKey, Curve = _a.Curve;
+            var _a = _this.core, StoredKey = _a.StoredKey, PrivateKey = _a.PrivateKey, Curve = _a.Curve, StoredKeyEncryption = _a.StoredKeyEncryption;
             // FIXME: get curve from coin
             if (!PrivateKey.isValid(key, Curve.secp256k1) ||
                 !PrivateKey.isValid(key, Curve.ed25519)) {
                 throw Types.Error.InvalidKey;
             }
             var pass = Buffer.from(password);
-            var storedKey = StoredKey.importPrivateKey(key, name, pass, coin);
+            var storedKey = StoredKey.importPrivateKeyWithEncryption(key, name, pass, coin, encryption);
             var wallet = _this.mapWallet(storedKey);
             storedKey.delete();
             _this.importWallet(wallet)

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

@@ -1,4 +1,4 @@
-import { CoinType, PrivateKey } from "../wallet-core";
+import { CoinType, PrivateKey, StoredKeyEncryption } from "../wallet-core";
 export declare enum WalletType {
     Mnemonic = "mnemonic",
     PrivateKey = "privateKey",
@@ -31,8 +31,8 @@ export interface IKeyStore {
     hasWallet(id: string): Promise<boolean>;
     load(id: string): Promise<Wallet>;
     loadAll(): Promise<Wallet[]>;
-    import(mnemonic: string, name: string, password: string, coins: CoinType[]): Promise<Wallet>;
-    importKey(key: Uint8Array, name: string, password: string, coin: CoinType): Promise<Wallet>;
+    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>;
     addAccounts(id: string, password: string, coins: CoinType[]): Promise<Wallet>;
     getKey(id: string, password: string, account: ActiveAccount): Promise<PrivateKey>;

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

@@ -255,6 +255,13 @@ export class SS58AddressType {
     static polkadot: SS58AddressType;
     static kusama: SS58AddressType;
 }
+export class StoredKeyEncryption {
+    value: number;
+    static aes128Ctr: StoredKeyEncryption;
+    static aes128Cbc: StoredKeyEncryption;
+    static aes192Ctr: StoredKeyEncryption;
+    static aes256Ctr: StoredKeyEncryption;
+}
 export class Base64 {
     static decode(string: string): Uint8Array;
     static decodeUrl(string: string): Uint8Array;
@@ -442,6 +449,7 @@ export class Blockchain {
     static nervos: Blockchain;
     static everscale: Blockchain;
     static aptos: Blockchain;
+    static hedera: Blockchain;
 }
 export class HDVersion {
     value: number;
@@ -575,6 +583,7 @@ export class CoinType {
     static nervos: CoinType;
     static everscale: CoinType;
     static aptos: CoinType;
+    static hedera: CoinType;
 }
 export class RippleXAddress {
     static equal(lhs: RippleXAddress, rhs: RippleXAddress): boolean;
@@ -597,10 +606,14 @@ export class BitcoinMessageSigner {
 export class StoredKey {
     static load(path: string): StoredKey;
     static importPrivateKey(privateKey: Uint8Array | Buffer, name: string, password: Uint8Array | Buffer, coin: CoinType): 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 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;
     static create(name: string, password: Uint8Array | Buffer): StoredKey;
+    static createEncryption(name: string, password: Uint8Array | Buffer, encryption: StoredKeyEncryption): StoredKey;
     identifier(): string;
     name(): string;
     isMnemonic(): boolean;
@@ -746,6 +759,7 @@ export interface WalletCore {
     NEARAccount: typeof NEARAccount;
     Base58: typeof Base58;
     SS58AddressType: typeof SS58AddressType;
+    StoredKeyEncryption: typeof StoredKeyEncryption;
     Base64: typeof Base64;
     HDWallet: typeof HDWallet;
     SegwitAddress: typeof SegwitAddress;

package/package.json

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