@machinomy/hdwallet-provider/dist/mnemonic.subprovider.js

HD Wallet-enabled Web3 provider

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MnemonicSubprovider = void 0;
const hooked_wallet_1 = __importDefault(require("web3-provider-engine/subproviders/hooked-wallet"));
const eth_hd_keyring_1 = __importDefault(require("eth-hd-keyring"));
const util_1 = require("./util");
const transaction_util_1 = require("./util/transaction.util");
class MnemonicSubprovider extends hooked_wallet_1.default {
    constructor(hdPath, mnemonic, numberOfAccounts) {
        const keyring = new eth_hd_keyring_1.default({
            hdPath: hdPath,
            mnemonic: mnemonic,
            numberOfAccounts: numberOfAccounts || 1
        });
        const options = {
            getAccounts: (callback) => {
                keyring
                    .getAccounts()
                    .then(accounts => {
                    callback(null, accounts);
                })
                    .catch(e => {
                    callback(e);
                });
            },
            signMessage: (msgParams, callback) => {
                let address = msgParams.from;
                keyring
                    .signPersonalMessage(address, msgParams.data)
                    .then(result => {
                    callback(null, result);
                })
                    .catch(e => {
                    callback(e);
                });
            },
            signPersonalMessage: (msgParams, callback) => {
                let address = msgParams.from;
                keyring
                    .signPersonalMessage(address, msgParams.data)
                    .then(result => {
                    callback(null, result);
                })
                    .catch(e => {
                    callback(e);
                });
            },
            signTypedMessage: (msgParams, callback) => {
                let address = msgParams.from;
                keyring
                    .signTypedData(address, msgParams.data)
                    .then(result => {
                    callback(null, result);
                })
                    .catch(e => {
                    callback(e);
                });
            },
            signTransaction: (txParams, callback) => {
                this.engine.sendAsync(util_1.createPayload({
                    method: "net_version"
                }), (err, result) => {
                    if (err) {
                        return callback(err);
                    }
                    else {
                        const networkId = Number(result.result);
                        const tx = transaction_util_1.buildTransaction(txParams, networkId);
                        keyring
                            .signTransaction(txParams.from, tx)
                            .then(signedTx => {
                            const hexTx = "0x" + signedTx.serialize().toString("hex");
                            callback(null, hexTx);
                        })
                            .catch(e => {
                            callback(e);
                        });
                    }
                });
            }
        };
        super(options);
        this.keyring = keyring;
    }
}
exports.MnemonicSubprovider = MnemonicSubprovider;
//# sourceMappingURL=mnemonic.subprovider.js.map