@kadena/kadena-cli/lib/services/wallet/wallet.service.js

Kadena CLI tool to interact with the Kadena blockchain (manage keys, transactions, etc.)

import { kadenaDecrypt, kadenaEncrypt, kadenaGenKeypairFromSeed, kadenaGenMnemonic, kadenaMnemonicToSeed, } from '@kadena/hd-wallet';
import { kadenaChangePassword, kadenaGenKeypair, kadenaGenMnemonic as legacyKadenaGenMnemonic, kadenaMnemonicToRootKeypair as legacykadenaMnemonicToRootKeypair, } from '@kadena/hd-wallet/chainweaver';
import { toHexStr } from '../../commands/keys/utils/keysHelpers.js';
import { log } from '../../utils/logger.js';
import { decryptMessage } from '../../utils/wrappers.js';
import { WALLET_SCHEMA_VERSION } from './wallet.schemas.js';
export class WalletService {
    // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/parameter-properties
    constructor(services) {
        this.services = services;
    }
    async create({ alias, legacy, password, }) {
        const { words, seed } = await this._generateMnemonic(password, legacy);
        const wallet = await this._createFromSeed({
            alias,
            legacy,
            seed,
        });
        return { words, wallet };
    }
    async import({ alias, legacy, password, mnemonic, }) {
        const seed = await this._mnemonicToSeed(mnemonic, password, legacy);
        return this._createFromSeed({ alias, legacy, seed });
    }
    async get(filepath) {
        return this.services.config.getWallet(filepath);
    }
    async getByAlias(alias) {
        const wallets = await this.services.config.getWallets();
        const match = wallets.filter((wallet) => wallet.alias === alias);
        if (match.length === 1) {
            return match[0];
        }
        else if (match.length > 1) {
            log.warning(`Multiple wallets found with alias "${alias}", it is recommended to use unique aliases`);
            return match[0];
        }
        return null;
    }
    async list() {
        return this.services.config.getWallets();
    }
    async delete(filepath) {
        return this.services.config.deleteWallet(filepath);
    }
    async generateKey({ seed, legacy, password, index, alias, }) {
        const { publicKey } = await this._generateKey({
            seed,
            legacy,
            password,
            index,
        });
        return { publicKey, index, alias };
    }
    async storeKey(wallet, key) {
        const keys = [...wallet.keys, key];
        const newWallet = { ...wallet, keys };
        await this.services.config.setWallet(newWallet, true);
        return newWallet;
    }
    async getKeyPair(wallet, key, password) {
        const keypair = await this._generateKey({
            seed: wallet.seed,
            legacy: wallet.legacy,
            password,
            index: key.index,
        });
        return {
            publicKey: keypair.publicKey,
            secretKey: toHexStr(await decryptMessage(password, keypair.secretKey)),
        };
    }
    async changePassword(wallet, currentPassword, newPassword) {
        const encryptedSeed = await (async () => {
            if (wallet.legacy === true) {
                return await kadenaChangePassword(wallet.seed, currentPassword, newPassword);
            }
            else {
                const decryptedSeed = await decryptMessage(currentPassword, wallet.seed);
                return await kadenaEncrypt(newPassword, decryptedSeed);
            }
        })();
        const newWallet = { ...wallet, seed: encryptedSeed };
        await this.services.config.setWallet(newWallet, true);
        return newWallet;
    }
    async _createFromSeed({ alias, legacy, seed, }) {
        const walletCreate = {
            alias,
            legacy,
            seed,
            keys: [],
        };
        const filepath = await this.services.config.setWallet(walletCreate);
        return {
            filepath,
            version: WALLET_SCHEMA_VERSION,
            ...walletCreate,
        };
    }
    async _generateMnemonic(password, legacy) {
        const words = legacy ? legacyKadenaGenMnemonic() : kadenaGenMnemonic();
        return { words, seed: await this._mnemonicToSeed(words, password, legacy) };
    }
    async _mnemonicToSeed(words, password, legacy) {
        if (legacy === true) {
            return await legacykadenaMnemonicToRootKeypair(password, words);
        }
        return await kadenaMnemonicToSeed(password, words);
    }
    async testPassword(wallet, password) {
        const result = await kadenaDecrypt(password, wallet.seed).catch(() => null);
        return result !== null;
    }
    async _generateKey({ seed, legacy, password, index, }) {
        if (legacy === true) {
            const { publicKey, secretKey } = await kadenaGenKeypair(password, seed, index);
            return { publicKey, secretKey };
        }
        else {
            const [publicKey, secretKey] = await kadenaGenKeypairFromSeed(password, seed, index);
            return { publicKey, secretKey };
        }
    }
}
//# sourceMappingURL=wallet.service.js.map