jcc_wallet 3.0.1 → 4.0.0

package/lib/index.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * MIT License
+ * Copyright (c) 2018 JCC Dex
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * @author https://github.com/GinMu
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HDWallet = exports.hdWallet = exports.JingchangWallet = void 0;
+const jingchangWallet_1 = __importDefault(require("./jingchangWallet"));
+exports.JingchangWallet = jingchangWallet_1.default;
+const hdWallet = __importStar(require("./hd"));
+exports.hdWallet = hdWallet;
+const hd_1 = require("./hd");
+Object.defineProperty(exports, "HDWallet", { enumerable: true, get: function () { return hd_1.HDWallet; } });
+__exportStar(require("./hd/plugins"), exports);
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,wEAAgD;AAIvC,0BAJF,yBAAe,CAIE;AAHxB,+CAAiC;AAGP,4BAAQ;AAFlC,6BAAgC;AAEI,yFAF3B,aAAQ,OAE2B;AAD5C,+CAA6B"}

package/lib/jingchangWallet.d.ts

@@ -0,0 +1,273 @@
+import { IEncrypt, IJingchangWalletModel, IKeypairsModel, IKeystoreModel, IKeyPair } from "./types";
+/**
+ * api of jingchang wallet
+ *
+ * @export
+ * @class JingchangWallet
+ */
+export default class JingchangWallet {
+    static readonly version = "1.0";
+    private static readonly _name;
+    private static readonly _walletID;
+    private _jingchangWallet;
+    /**
+     * if the value is true, support save multiple wallet keystore for each type, otherwise only support one.
+     *
+     * @private
+     * @type {boolean}
+     * @memberof JingchangWallet
+     */
+    private _multiple;
+    /**
+     * if the value is true, use the default swt keystore's password which be generated in the beginning as password for other type.
+     *
+     * @private
+     * @type {boolean}
+     * @memberof JingchangWallet
+     */
+    private _samePassword;
+    /**
+     * Creates an instance of JingchangWallet.
+     * @param {IJingchangWalletModel} wallet
+     * @param {boolean} [multiple=false] if the value is true, support save multiple wallet keystore for each type, otherwise only support one.
+     * @param {boolean} [samePassword=true] if the value is true, use the default swt keystore's password which be generated
+     * in the beginning as password for other type.
+     * @memberof JingchangWallet
+     */
+    constructor(wallet: IJingchangWalletModel, multiple?: boolean, samePassword?: boolean);
+    /**
+     * check jingchang wallet is valid or not
+     *
+     * @static
+     * @param {*} wallet
+     * @returns {boolean} return true if valid.
+     * @memberof JingchangWallet
+     */
+    static isValid(wallet: any): boolean;
+    /**
+     * create a jingchang wallet
+     *
+     * @static
+     * @param {string} password password for keystore
+     * @param {string} [secret] swtc chain's secret
+     * @param {string} [alias] wallet name
+     * @returns {Promise<IJingchangWalletModel>} resolve jingchang wallet if success.
+     * @memberof JingchangWallet
+     */
+    static generate(password: string, secret?: string, alias?: string): Promise<IJingchangWalletModel>;
+    /**
+     * get jingchang wallet from local storage
+     *
+     * @static
+     * @returns {(IJingchangWalletModel | null)} return jingchang wallet or null
+     * @memberof JingchangWallet
+     */
+    static get(): IJingchangWalletModel | null;
+    /**
+     * clear jingchang wallet from local storage
+     *
+     * @static
+     * @memberof JingchangWallet
+     */
+    static clear(): void;
+    /**
+     * save jingchang wallet to local storage.
+     *
+     * @static
+     * @param {IJingchangWalletModel} wallet
+     * @memberof JingchangWallet
+     */
+    static save(wallet: IJingchangWalletModel): void;
+    /**
+     * derive key pair with secret
+     *
+     * @static
+     * @param {string} secret
+     * @param {string} [chain="swt"]
+     * @returns {IKeyPair} for privateKey, it's length should be 64 when call `decryptWithPrivateKey`, but the origin derived
+     * privateKey's length is 66 that contains prefix `00` for `secp256k1` or `ED` for `ed25519`, so removed it.
+     * @memberof JingchangWallet
+     */
+    static deriveKeyPair(secret: string, chain?: string): IKeyPair;
+    /**
+     * encrypt data with public key
+     *
+     * @static
+     * @param {string} message
+     * @param {string} publicKey
+     * @returns {Promise<IEncrypt>}
+     * @memberof JingchangWallet
+     */
+    static encryptWithPublicKey(message: string, publicKey: string): Promise<IEncrypt>;
+    /**
+     * decrypt data with private key
+     *
+     * @static
+     * @param {IEncrypt} message
+     * @param {string} privateKey the privateKey's length should be 64
+     * @returns {Promise<string>}
+     * @memberof JingchangWallet
+     */
+    static decryptWithPrivateKey(message: IEncrypt, privateKey: string): Promise<string>;
+    /**
+     * get wallets from jingchang wallet
+     *
+     * @static
+     * @param {IJingchangWalletModel} jcWallet
+     * @returns {Array<IKeystoreModel>} return wallets if valid, otherwise return empty array.
+     * @memberof JingchangWallet
+     */
+    static getWallets(keystore: IJingchangWalletModel): Array<IKeystoreModel>;
+    /**
+     * set property of _jingchangWallet
+     *
+     * @param {IJingchangWalletModel} wallet
+     * @memberof JingchangWallet
+     */
+    setJingchangWallet(wallet: IJingchangWalletModel): void;
+    /**
+     * get default wallet's keystore address for each type
+     *
+     * @param {string} [type="swt"]
+     * @returns {Promise<string>} resolve address if success
+     * @memberof JingchangWallet
+     */
+    getAddress(type?: string): Promise<string>;
+    /**
+     * get default wallet keystore with type
+     *
+     * @param {string} [type="swt"]
+     * @returns {Promise<IKeystoreModel>} resolve default wallet keystore if success.
+     * @memberof JingchangWallet
+     */
+    getWalletWithType(type?: string): Promise<IKeystoreModel>;
+    /**
+     * get wallet keystore with address
+     *
+     * @param {string} address
+     * @returns {Promise<IKeystoreModel>} resolve wallet keystore if success.
+     * @memberof JingchangWallet
+     */
+    getWalletWithAddress(address: string): Promise<IKeystoreModel>;
+    /**
+     * check if has default wallet for each type
+     *
+     * @param {string} [type="swt"]
+     * @returns {boolean} return true if has default
+     * @memberof JingchangWallet
+     */
+    hasDefault(type?: string): boolean;
+    /**
+     * get the default wallet keystore's secret with type.
+     *
+     * @param {string} password
+     * @param {string} [type="swt"]
+     * @returns {Promise<string>}
+     * @memberof JingchangWallet
+     */
+    getSecretWithType(password: string, type?: string): Promise<string>;
+    /**
+     * get the wallet keystore's secret with address.
+     *
+     * @param {string} password
+     * @param {string} address
+     * @returns {Promise<string>}
+     * @memberof JingchangWallet resolve secret if success.
+     */
+    getSecretWithAddress(password: string, address: string): Promise<string>;
+    /**
+     * change the whole jingchang wallet password, if you set property of _samePassword is false, will throw an error
+     *
+     * @param {string} oldPassword
+     * @param {string} newPassword
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    changeWholePassword(oldPassword: string, newPassword: string): Promise<IJingchangWalletModel>;
+    /**
+     * change the keystore password with address, if you set the property of _samePassword is true, will throw an error
+     *
+     * @param {string} address
+     * @param {string} oldPassword
+     * @param {string} newPassword
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    changePasswordWithAddress(address: string, oldPassword: string, newPassword: string): Promise<IJingchangWalletModel>;
+    /**
+     * replace keystore, if forget password
+     *
+     * @param {string} secret
+     * @param {string} password
+     * @param {(secret: string) => string} retriveSecret
+     * @returns {Promise<IJingchangWalletModel>}
+     * @memberof JingchangWallet
+     */
+    replaceKeystore(secret: string, password: string, retriveSecret: (secret: string) => string): Promise<IJingchangWalletModel>;
+    /**
+     * remove default wallet keystore of the given type
+     *
+     * @param {string} [type="swt"]
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    removeWalletWithType(type?: string): Promise<IJingchangWalletModel>;
+    /**
+     * remove wallet keystore of the given address
+     *
+     * @param {string} address
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    removeWalletWithAddress(address: string): Promise<IJingchangWalletModel>;
+    /**
+     * set defalut wallet keystore for each type
+     *
+     * @param {string} address
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    setDefaultWallet(address: string): Promise<IJingchangWalletModel>;
+    /**
+     * import secret
+     *
+     * @param {string} secret
+     * @param {string} password
+     * @param {string} type
+     * @param {(secret: string) => string} retriveSecret
+     * @param {string} [alias] wallet name
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    importSecret(secret: string, password: string, type: string, retriveSecret: (secret: string) => string, alias?: string): Promise<IJingchangWalletModel>;
+    /**
+     * find wallet keystore according to filter function
+     *
+     * @protected
+     * @param {(wallet: IKeystoreModel) => boolean} filter
+     * @returns {IKeystoreModel} return wallet keystore if existent, otherwise throw `keystore is invalid` if the jingchang wallet is invalid
+     * or throw `wallet is empty` if the wallet isn't existent
+     * @memberof JingchangWallet
+     */
+    protected findWallet(filter: (wallet: IKeystoreModel) => boolean): IKeystoreModel;
+    /**
+     * encrypt data
+     *
+     * @protected
+     * @param {string} password
+     * @param {IKeypairsModel} keypairs
+     * @returns {IKeystoreModel}
+     * @memberof JingchangWallet
+     */
+    protected getEncryptData(password: string, keypairs: IKeypairsModel): IKeystoreModel;
+    /**
+     * save wallet keystore to jingchang wallet
+     *
+     * @private
+     * @param {string} password
+     * @param {IKeypairsModel} keypairs
+     * @returns {Promise<IJingchangWalletModel>} resolve new jingchang wallet if success
+     * @memberof JingchangWallet
+     */
+    private saveWallet;
+}