@trustwallet/wallet-core 3.0.3 → 3.0.5

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

@@ -0,0 +1,19 @@
+import { WalletCore, CoinType, PrivateKey, StoredKey } from "../wallet-core";
+import * as Types from "./types";
+export declare class Default implements Types.IKeyStore {
+    private readonly core;
+    private readonly storage;
+    constructor(core: WalletCore, storage: Types.IStorage);
+    hasWallet(id: string): Promise<boolean>;
+    load(id: string): Promise<Types.Wallet>;
+    loadAll(): Promise<Types.Wallet[]>;
+    delete(id: string, password: string): Promise<void>;
+    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>;
+    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

@@ -0,0 +1,127 @@
+"use strict";
+// Copyright © 2017-2022 Trust Wallet.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Default = void 0;
+var Types = require("./types");
+var Default = /** @class */ (function () {
+    function Default(core, storage) {
+        this.core = core;
+        this.storage = storage;
+    }
+    Default.prototype.hasWallet = function (id) {
+        return this.storage
+            .get(id)
+            .then(function (wallet) { return true; })
+            .catch(function (error) { return false; });
+    };
+    Default.prototype.load = function (id) {
+        return this.storage.get(id);
+    };
+    Default.prototype.loadAll = function () {
+        return this.storage.loadAll();
+    };
+    Default.prototype.delete = function (id, password) {
+        return this.storage.delete(id, password);
+    };
+    Default.prototype.mapWallet = function (storedKey) {
+        var json = storedKey.exportJSON();
+        return JSON.parse(Buffer.from(json).toString());
+    };
+    Default.prototype.mapStoredKey = function (wallet) {
+        var json = Buffer.from(JSON.stringify(wallet));
+        return this.core.StoredKey.importJSON(json);
+    };
+    Default.prototype.importWallet = function (wallet) {
+        return this.storage.set(wallet.id, wallet);
+    };
+    Default.prototype.import = function (mnemonic, name, password, coins) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var _a = _this.core, Mnemonic = _a.Mnemonic, StoredKey = _a.StoredKey, HDWallet = _a.HDWallet;
+            if (!Mnemonic.isValid(mnemonic)) {
+                throw Types.Error.InvalidMnemonic;
+            }
+            var pass = Buffer.from(password);
+            var storedKey = StoredKey.importHDWallet(mnemonic, name, pass, coins[0]);
+            var hdWallet = HDWallet.createWithMnemonic(mnemonic, "");
+            coins.forEach(function (coin) {
+                storedKey.accountForCoin(coin, hdWallet);
+            });
+            var wallet = _this.mapWallet(storedKey);
+            storedKey.delete();
+            hdWallet.delete();
+            _this.importWallet(wallet)
+                .then(function () { return resolve(wallet); })
+                .catch(function (error) { return reject(error); });
+        });
+    };
+    Default.prototype.importKey = function (key, name, password, coin) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var _a = _this.core, StoredKey = _a.StoredKey, PrivateKey = _a.PrivateKey, Curve = _a.Curve;
+            // 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 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) {
+            var storedKey = _this.mapStoredKey(wallet);
+            var hdWallet = storedKey.wallet(Buffer.from(password));
+            coins.forEach(function (coin) {
+                storedKey.accountForCoin(coin, hdWallet);
+            });
+            var newWallet = _this.mapWallet(storedKey);
+            storedKey.delete();
+            hdWallet.delete();
+            return _this.importWallet(newWallet).then(function () { return newWallet; });
+        });
+    };
+    Default.prototype.getKey = function (id, password, account) {
+        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 = hdWallet.getKey(coin, account.derivationPath);
+            storedKey.delete();
+            hdWallet.delete();
+            return privateKey;
+        });
+    };
+    Default.prototype.export = function (id, password) {
+        var _this = this;
+        return this.load(id).then(function (wallet) {
+            var storedKey = _this.mapStoredKey(wallet);
+            var value;
+            switch (wallet.type) {
+                case Types.WalletType.Mnemonic:
+                    value = storedKey.decryptMnemonic(Buffer.from(password));
+                    break;
+                case Types.WalletType.PrivateKey:
+                    value = storedKey.decryptPrivateKey(Buffer.from(password));
+                    break;
+                default:
+                    throw Types.Error.InvalidJSON;
+            }
+            storedKey.delete();
+            return value;
+        });
+    };
+    return Default;
+}());
+exports.Default = Default;

package/dist/src/keystore/extension-storage.d.ts

@@ -0,0 +1,12 @@
+import { Storage } from "webextension-polyfill";
+import * as Types from "./types";
+export declare class ExtensionStorage implements Types.IStorage {
+    readonly storage: Storage.StorageArea;
+    readonly walletIdsKey: string;
+    constructor(walletIdsKey: string, storage: Storage.StorageArea);
+    get(id: string): Promise<Types.Wallet>;
+    set(id: string, wallet: Types.Wallet): Promise<void>;
+    loadAll(): Promise<Types.Wallet[]>;
+    delete(id: string, password: string): Promise<void>;
+    private getWalletIds;
+}

package/dist/src/keystore/extension-storage.js

@@ -0,0 +1,74 @@
+"use strict";
+// Copyright © 2017-2022 Trust Wallet.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionStorage = void 0;
+var Types = require("./types");
+// Extension KeyStore
+var ExtensionStorage = /** @class */ (function () {
+    function ExtensionStorage(walletIdsKey, storage) {
+        this.walletIdsKey = walletIdsKey;
+        this.storage = storage;
+    }
+    ExtensionStorage.prototype.get = function (id) {
+        return this.storage.get(id).then(function (object) {
+            var wallet = object[id];
+            if (wallet === undefined) {
+                throw Types.Error.WalletNotFound;
+            }
+            return wallet;
+        });
+    };
+    ExtensionStorage.prototype.set = function (id, wallet) {
+        var _this = this;
+        return this.getWalletIds().then(function (ids) {
+            var _a;
+            if (ids.indexOf(id) === -1) {
+                ids.push(id);
+            }
+            return _this.storage.set((_a = {},
+                _a[id] = wallet,
+                _a[_this.walletIdsKey] = ids,
+                _a));
+        });
+    };
+    ExtensionStorage.prototype.loadAll = function () {
+        var _this = this;
+        return this.getWalletIds().then(function (ids) {
+            if (ids.length === 0) {
+                return [];
+            }
+            return _this.storage
+                .get(ids)
+                .then(function (wallets) { return Object.keys(wallets).map(function (key) { return wallets[key]; }); });
+        });
+    };
+    ExtensionStorage.prototype.delete = function (id, password) {
+        var _this = this;
+        return this.getWalletIds().then(function (ids) {
+            var index = ids.indexOf(id);
+            if (index === -1) {
+                return;
+            }
+            ids.splice(index, 1);
+            return _this.storage
+                .remove(id)
+                .then(function () {
+                var _a;
+                return _this.storage.set((_a = {}, _a[_this.walletIdsKey] = ids, _a));
+            });
+        });
+    };
+    ExtensionStorage.prototype.getWalletIds = function () {
+        var _this = this;
+        return this.storage.get(this.walletIdsKey).then(function (object) {
+            var ids = object[_this.walletIdsKey];
+            return ids === undefined ? [] : ids;
+        });
+    };
+    return ExtensionStorage;
+}());
+exports.ExtensionStorage = ExtensionStorage;

package/dist/src/keystore/fs-storage.d.ts

@@ -0,0 +1,10 @@
+import * as Types from "./types";
+export declare class FileSystemStorage implements Types.IStorage {
+    private readonly directory;
+    constructor(directory: string);
+    getFilename(id: any): string;
+    get(id: string): Promise<Types.Wallet>;
+    set(id: string, wallet: Types.Wallet): Promise<void>;
+    loadAll(): Promise<Types.Wallet[]>;
+    delete(id: string, password: string): Promise<void>;
+}

package/dist/src/keystore/fs-storage.js

@@ -0,0 +1,39 @@
+"use strict";
+// Copyright © 2017-2022 Trust Wallet.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemStorage = void 0;
+var fs = require("fs/promises");
+// FileSystem Storage
+var FileSystemStorage = /** @class */ (function () {
+    function FileSystemStorage(directory) {
+        this.directory = directory.endsWith("/") ? directory : directory + "/";
+    }
+    FileSystemStorage.prototype.getFilename = function (id) {
+        return this.directory + id + ".json";
+    };
+    FileSystemStorage.prototype.get = function (id) {
+        return fs
+            .readFile(this.getFilename(id))
+            .then(function (data) { return JSON.parse(data.toString()); });
+    };
+    FileSystemStorage.prototype.set = function (id, wallet) {
+        return fs.writeFile(this.getFilename(id), JSON.stringify(wallet));
+    };
+    FileSystemStorage.prototype.loadAll = function () {
+        var _this = this;
+        return fs.readdir(this.directory).then(function (files) {
+            return Promise.all(files
+                .filter(function (file) { return file.endsWith(".json"); })
+                .map(function (file) { return _this.get(file.replace(".json", "")); }));
+        });
+    };
+    FileSystemStorage.prototype.delete = function (id, password) {
+        return fs.unlink(this.getFilename(id));
+    };
+    return FileSystemStorage;
+}());
+exports.FileSystemStorage = FileSystemStorage;

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

@@ -0,0 +1,4 @@
+export { Default } from "./default-impl";
+export * from "./types";
+export { FileSystemStorage } from "./fs-storage";
+export { ExtensionStorage } from "./extension-storage";

package/dist/src/keystore/index.js

@@ -0,0 +1,29 @@
+"use strict";
+// Copyright © 2017-2022 Trust Wallet.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionStorage = exports.FileSystemStorage = exports.Default = void 0;
+var default_impl_1 = require("./default-impl");
+Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return default_impl_1.Default; } });
+__exportStar(require("./types"), exports);
+var fs_storage_1 = require("./fs-storage");
+Object.defineProperty(exports, "FileSystemStorage", { enumerable: true, get: function () { return fs_storage_1.FileSystemStorage; } });
+var extension_storage_1 = require("./extension-storage");
+Object.defineProperty(exports, "ExtensionStorage", { enumerable: true, get: function () { return extension_storage_1.ExtensionStorage; } });

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

@@ -0,0 +1,47 @@
+import { CoinType, PrivateKey } from "../wallet-core";
+export declare enum WalletType {
+    Mnemonic = "mnemonic",
+    PrivateKey = "privateKey",
+    WatchOnly = "watchOnly",
+    Hardware = "hardware"
+}
+export declare enum Error {
+    WalletNotFound = "wallet not found",
+    AccountNotFound = "account not found",
+    InvalidPassword = "invalid password",
+    InvalidMnemonic = "invalid mnemonic",
+    InvalidJSON = "invalid JSON",
+    InvalidKey = "invalid key"
+}
+export interface ActiveAccount {
+    address: string;
+    coin: number;
+    publicKey: string;
+    derivationPath: string;
+    extendedPublicKey?: string;
+}
+export interface Wallet {
+    id: string;
+    type: WalletType;
+    name: string;
+    version: number;
+    activeAccounts: ActiveAccount[];
+}
+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>;
+    importWallet(wallet: Wallet): Promise<void>;
+    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>;
+    export(id: string, password: string): Promise<string | Uint8Array>;
+}
+export interface IStorage {
+    get(id: string): Promise<Wallet>;
+    set(id: string, wallet: Wallet): Promise<void>;
+    loadAll(): Promise<Wallet[]>;
+    delete(id: string, password: string): Promise<void>;
+}

package/dist/src/keystore/types.js

@@ -0,0 +1,24 @@
+"use strict";
+// Copyright © 2017-2022 Trust Wallet.
+//
+// This file is part of Trust. The full Trust copyright notice, including
+// terms governing use, modification, and redistribution, is contained in the
+// file LICENSE at the root of the source code distribution tree.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Error = exports.WalletType = void 0;
+var WalletType;
+(function (WalletType) {
+    WalletType["Mnemonic"] = "mnemonic";
+    WalletType["PrivateKey"] = "privateKey";
+    WalletType["WatchOnly"] = "watchOnly";
+    WalletType["Hardware"] = "hardware";
+})(WalletType = exports.WalletType || (exports.WalletType = {}));
+var Error;
+(function (Error) {
+    Error["WalletNotFound"] = "wallet not found";
+    Error["AccountNotFound"] = "account not found";
+    Error["InvalidPassword"] = "invalid password";
+    Error["InvalidMnemonic"] = "invalid mnemonic";
+    Error["InvalidJSON"] = "invalid JSON";
+    Error["InvalidKey"] = "invalid key";
+})(Error = exports.Error || (exports.Error = {}));