chaingate/build/InitializeWallet.js

A complete TypeScript library for connecting to and making transactions on different blockchains

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.create = create;
exports.fromPhrase = fromPhrase;
exports.checkPhrase = checkPhrase;
exports.fromSeed = fromSeed;
exports.checkSeed = checkSeed;
exports.fromPrivateKey = fromPrivateKey;
exports.checkPrivateKey = checkPrivateKey;
exports.fromKeystore = fromKeystore;
exports.checkKeystore = checkKeystore;
exports.deserialize = deserialize;
exports.checkSerialized = checkSerialized;
const PhraseGenerator_1 = require("./Wallet/implementations/PhraseWallet/PhraseGenerator");
const Phrase_1 = require("./Wallet/entities/Secret/implementations/Phrase");
const PhraseWallet_1 = require("./Wallet/implementations/PhraseWallet/PhraseWallet");
const Wallet_1 = require("./Wallet/Wallet");
const SeedWallet_1 = require("./Wallet/implementations/SeedWallet/SeedWallet");
const PrivateKeyWallet_1 = require("./Wallet/implementations/PrivateKeyWallet/PrivateKeyWallet");
const LegacyKeystore_1 = require("./Wallet/entities/Keystore/LegacyKeystore");
const Web3Keystore_1 = require("./Wallet/entities/Keystore/Web3Keystore");
const errors_1 = require("./Wallet/entities/Keystore/errors");
const WalletEncryption_1 = require("./Wallet/entities/WalletEncryption/WalletEncryption");
const Seed_1 = require("./Wallet/entities/Secret/implementations/Seed");
const PrivateKey_1 = require("./Wallet/entities/Secret/implementations/PrivateKey");
async function create({ apiKey = '', phraseLanguage = 'english', phraseNumOfWords = 12, encrypt, warnAboutUnencrypted = true } = {}) {
    const phrase = (0, PhraseGenerator_1.generateNewPhrase)(phraseLanguage, phraseNumOfWords);
    let wallet;
    if (encrypt)
        wallet = await PhraseWallet_1.PhraseWallet.new(apiKey, (0, PhraseGenerator_1.generateNewPhrase)(phraseLanguage, phraseNumOfWords), warnAboutUnencrypted, encrypt);
    else
        wallet = await PhraseWallet_1.PhraseWallet.new(apiKey, phrase, warnAboutUnencrypted);
    return { phrase, wallet };
}
async function fromPhrase({ apiKey = '', phrase, encrypt, warnAboutUnencrypted = true }) {
    return PhraseWallet_1.PhraseWallet.new(apiKey, phrase, warnAboutUnencrypted, encrypt);
}
async function checkPhrase(phrase) {
    try {
        Phrase_1.Phrase.isValidPhrase(phrase);
        return true;
    }
    catch (_ex) {
        return false;
    }
}
async function fromSeed({ apiKey = '', seed, encrypt, warnAboutUnencrypted = true }) {
    return SeedWallet_1.SeedWallet.new(apiKey, seed, warnAboutUnencrypted, encrypt);
}
async function checkSeed(seed) {
    try {
        new Seed_1.Seed(seed);
        return true;
    }
    catch (_ex) {
        return false;
    }
}
async function fromPrivateKey({ apiKey = '', privateKey, encrypt, warnAboutUnencrypted = true }) {
    return await PrivateKeyWallet_1.PrivateKeyWallet.new(apiKey, privateKey, warnAboutUnencrypted, encrypt);
}
async function checkPrivateKey(privateKey) {
    try {
        new PrivateKey_1.PrivateKey(privateKey);
        return true;
    }
    catch (_ex) {
        return false;
    }
}
async function fromKeystore({ apiKey = '', keystore, password, encrypt, warnAboutUnencrypted = true }) {
    try {
        const obj = JSON.parse(keystore);
        let decrypted;
        if (LegacyKeystore_1.LegacyKeystore.isKeystore(obj))
            decrypted = await new LegacyKeystore_1.LegacyKeystore(obj).decrypt(password);
        else if (Web3Keystore_1.Web3Keystore.isKeystore(obj))
            decrypted = await new Web3Keystore_1.Web3Keystore(obj).decrypt(password);
        else
            throw new WalletEncryption_1.EncodingError('Invalid json');
        try {
            const phraseText = new TextDecoder().decode(decrypted);
            if (!Phrase_1.Phrase.isValidPhrase(phraseText))
                return PrivateKeyWallet_1.PrivateKeyWallet.new(apiKey, decrypted, warnAboutUnencrypted, encrypt);
            return PhraseWallet_1.PhraseWallet.new(apiKey, phraseText, warnAboutUnencrypted, encrypt);
        }
        catch (_ex) {
            return PrivateKeyWallet_1.PrivateKeyWallet.new(apiKey, decrypted, warnAboutUnencrypted, encrypt);
        }
    }
    catch (ex) {
        if (ex instanceof errors_1.IncorrectPassword)
            throw ex;
        throw new WalletEncryption_1.EncodingError('Invalid json');
    }
}
async function checkKeystore(keystore) {
    try {
        const keystoreObj = JSON.parse(keystore);
        return LegacyKeystore_1.LegacyKeystore.isKeystore(keystoreObj) || Web3Keystore_1.Web3Keystore.isKeystore(keystoreObj);
    }
    catch (_ex) {
        return false;
    }
}
async function deserialize({ apiKey = '', serialized, askForPassword }) {
    try {
        const serializedParsed = JSON.parse(serialized);
        if (!Wallet_1.Wallet.isSerializedWallet(serializedParsed))
            throw new WalletEncryption_1.EncodingError('Invalid serialized');
        const client = apiKey;
        const serializedWallet = serializedParsed;
        switch (serializedWallet.walletType) {
            case 'privateKey': return await PrivateKeyWallet_1.PrivateKeyWallet.import(client, serializedWallet, askForPassword);
            case 'phrase': return await PhraseWallet_1.PhraseWallet.import(client, serializedWallet, askForPassword);
            case 'seed': return await SeedWallet_1.SeedWallet.import(client, serializedWallet, askForPassword);
        }
        throw new WalletEncryption_1.EncodingError('Invalid serialized');
    }
    catch (ex) {
        throw new WalletEncryption_1.EncodingError('Invalid serialized');
    }
}
async function checkSerialized(serialized) {
    try {
        await deserialize({ serialized, askForPassword: async () => { return ''; } });
        return true;
    }
    catch (_ex) {
        return false;
    }
}
//# sourceMappingURL=InitializeWallet.js.map