@tronlink/core/dist/esm/tron_wallet/TronWallet.js

The library serves as a core module within TronLink Extension, which provides low-level wallet functionality for both Tron and Ethereum networks, primary features includes account generation and transaction signing

// @ts-ignore
import * as bip32 from 'bip32';
// @ts-ignore
import bip39 from 'bip39';
// @ts-ignore
import { TronWeb } from 'tronweb';
import { BaseWallet } from '../base_wallet';
import { CoinType } from '../base_wallet/constants';
import { InvalidParameterError, SignError, VerifySignError } from '../base_wallet/error';
import { defaultTronWeb, generateTronWeb } from './generateTronWeb';
import { checkSignParams } from '../utils';
export class TronWallet extends BaseWallet {
    getCoinType() {
        return CoinType.TRON;
    }
    derivePrivateKey(params) {
        const seed = bip39.mnemonicToSeed(params.mnemonic);
        // @ts-ignore
        const node = bip32.fromSeed(seed);
        const child = node.derivePath(params.path);
        const privateKey = child.privateKey.toString('hex');
        return privateKey;
    }
    getAddressBy(params) {
        // @ts-ignore
        const address = TronWeb.address.fromPrivateKey(params.privateKey);
        return address;
    }
    validateAddress(params) {
        if (!params.address) {
            return false;
        }
        // @ts-ignore
        return TronWeb.isAddress(params.address);
    }
    async sign(params) {
        try {
            checkSignParams(params);
            const { data, options } = params;
            const { isMultiSign, isSignMessageV2 } = options || {
                isMultiSign: false,
                isSignMessageV2: false,
            };
            if (typeof data === 'string' ||
                (data && data.constructor && data.constructor.name === 'String')) {
                if (isSignMessageV2) {
                    return this.signMessageV2(params);
                }
                else {
                    return this.signMessage(params);
                }
            }
            else if (typeof data === 'object' && data.txID) {
                if (isMultiSign) {
                    return this.multiSign(params);
                }
                else {
                    return this.signTransaction(params);
                }
            }
            else if (typeof data === 'object' && data.domain && data.types && data.message) {
                return this.signTypedData(params);
            }
            else {
                throw new InvalidParameterError();
            }
        }
        catch (error) {
            throw new SignError(error.message);
        }
    }
    async signMessage(params) {
        try {
            checkSignParams(params);
            const { privateKey, data: message } = params;
            return defaultTronWeb.trx.sign(message, privateKey);
        }
        catch (error) {
            throw new SignError(error.message);
        }
    }
    async verifyMessage(params) {
        try {
            const { data: message, signature, address } = params;
            if (!message || !signature) {
                throw new InvalidParameterError();
            }
            return defaultTronWeb.trx.verifyMessage(message, signature, address);
        }
        catch (error) {
            throw new VerifySignError(error.message);
        }
    }
    async signTransaction(params) {
        try {
            checkSignParams(params);
            const { privateKey, data: transaction } = params;
            return defaultTronWeb.trx.sign(transaction, privateKey);
        }
        catch (error) {
            throw new SignError(error.message);
        }
    }
    async signTypedData(params) {
        try {
            checkSignParams(params);
            const { privateKey, data } = params;
            if (typeof data !== 'object') {
                throw new InvalidParameterError();
            }
            const { domain, types, message } = data;
            return defaultTronWeb.trx._signTypedData(domain, types, message, privateKey);
        }
        catch (error) {
            throw new SignError(error.message);
        }
    }
    async verifyTypedData(params) {
        try {
            const { data, signature, address } = params;
            if (!data || !signature || !address || typeof data !== 'object') {
                throw new InvalidParameterError();
            }
            const { domain, types, message } = data;
            return defaultTronWeb.trx.verifyTypedData(domain, types, message, signature, address);
        }
        catch (error) {
            throw new VerifySignError(error.message);
        }
    }
    async multiSign(params) {
        try {
            checkSignParams(params);
            const { privateKey, data: transaction, options } = params;
            if (!options) {
                throw new InvalidParameterError();
            }
            const { permissionId, nodeInfo } = options;
            const tronWeb = generateTronWeb(nodeInfo);
            return await tronWeb.trx.multiSign(transaction, privateKey, permissionId);
        }
        catch (error) {
            throw new SignError(error.message);
        }
    }
    async signMessageV2(params) {
        try {
            checkSignParams(params);
            const { privateKey, data: message } = params;
            return defaultTronWeb.trx.signMessageV2(message, privateKey);
        }
        catch (error) {
            throw new SignError(error.message);
        }
    }
    async verifyMessageV2(params) {
        try {
            const { data: message, signature } = params;
            if (!message || !signature) {
                throw new InvalidParameterError();
            }
            return defaultTronWeb.trx.verifyMessageV2(message, signature);
        }
        catch (error) {
            throw new VerifySignError(error.message);
        }
    }
}
//# sourceMappingURL=TronWallet.js.map