blocktrail / blocktrail-sdk-nodejs

            identifier,

            options.walletVersion,

            result.primary_mnemonic,

            result.encrypted_primary_seed,

            result.encrypted_secret,

            primaryPublicKeys,

            backupPublicKey,

            blocktrailPublicKeys,

            keyIndex,

            result.segwit || 0,

            self.testnet,

            result.checksum,

            result.upgrade_key_index,

            options.useCashAddress,

            options.bypassNewAddressCheck

        );

        wallet.recoverySecret = result.recovery_secret;

        if (!options.readOnly) {

            return wallet.unlock(options).then(function() {

                return wallet;

            });

        } else {

            return wallet;

        }

    }));

    return deferred.promise;

};

APIClient.CREATE_WALLET_PROGRESS_START = 0;

APIClient.CREATE_WALLET_PROGRESS_ENCRYPT_SECRET = 4;

APIClient.CREATE_WALLET_PROGRESS_ENCRYPT_PRIMARY = 5;

APIClient.CREATE_WALLET_PROGRESS_ENCRYPT_RECOVERY = 6;

APIClient.CREATE_WALLET_PROGRESS_PRIMARY = 10;

APIClient.CREATE_WALLET_PROGRESS_BACKUP = 20;

APIClient.CREATE_WALLET_PROGRESS_SUBMIT = 30;

APIClient.CREATE_WALLET_PROGRESS_INIT = 40;

APIClient.CREATE_WALLET_PROGRESS_DONE = 100;

/**

 * create a new wallet

 *   - will generate a new primary seed and backup seed

 *

 * Either takes two argument:

 * @param options       object      {}

 * @param [cb]          function    callback(err, wallet, primaryMnemonic, backupMnemonic, blocktrailPubKeys) // nocommit @TODO

 *

 * For v1 wallets (explicitly specify options.walletVersion=v1):

 * @param options       object      {}

 * @param [cb]          function    callback(err, wallet, primaryMnemonic, backupMnemonic, blocktrailPubKeys)

 *

 * Or takes four arguments (old, deprecated syntax):

 * @param identifier    string      the wallet identifier to be initialized

 * @param passphrase    string      the password to decrypt the mnemonic with

 * @param keyIndex      int         override for the blocktrail cosign key to use (for development purposes)

 * @param [cb]          function    callback(err, wallet, primaryMnemonic, backupMnemonic, blocktrailPubKeys)

 * @returns {q.Promise}

 */

APIClient.prototype.createNewWallet = function(options, cb) {

    /* jshint -W071, -W074 */

    var self = this;

    if (typeof options !== "object") {

        // get the old-style arguments

        var identifier = arguments[0];

        var passphrase = arguments[1];

        var keyIndex = arguments[2];

        cb = arguments[3];

        // keyIndex is optional

        if (typeof keyIndex === "function") {

            cb = keyIndex;

            keyIndex = null;

        }

        options = {

            identifier: identifier,

            passphrase: passphrase,

            keyIndex: keyIndex

        };

    }

    // default to v3

    options.walletVersion = options.walletVersion || Wallet.WALLET_VERSION_V3;

    var deferred = q.defer();

    deferred.promise.spreadNodeify(cb);

    q.nextTick(function() {

        deferred.notify(APIClient.CREATE_WALLET_PROGRESS_START);

        options.keyIndex = options.keyIndex || 0;

        options.passphrase = options.passphrase || options.password;

        delete options.password;

        if (!options.identifier) {

            deferred.reject(new blocktrail.WalletCreateError("Identifier is required"));

            return deferred.promise;

        }

        if (options.walletVersion === Wallet.WALLET_VERSION_V1) {

            self._createNewWalletV1(options)

                .progress(function(p) { deferred.notify(p); })

                .then(function(r) { deferred.resolve(r); }, function(e) { deferred.reject(e); })

            ;

        } else if (options.walletVersion === Wallet.WALLET_VERSION_V2) {

            self._createNewWalletV2(options)

                .progress(function(p) { deferred.notify(p); })

                .then(function(r) { deferred.resolve(r); }, function(e) { deferred.reject(e); })

            ;

        } else if (options.walletVersion === Wallet.WALLET_VERSION_V3) {

            self._createNewWalletV2(options)

                .progress(function(p) { deferred.notify(p); })

                .then(function(r) { deferred.resolve(r); }, function(e) { deferred.reject(e); })

            ;

        } else if (options.walletVersion === Wallet.WALLET_VERSION_V3) {

            self._createNewWalletV3(options)

                .progress(function(p) { deferred.notify(p); })

                .then(function(r) { deferred.resolve(r); }, function(e) { deferred.reject(e); })

            ;

        } else {

            deferred.reject(new blocktrail.WalletCreateError("Invalid wallet version!"));

        }

    });

    return deferred.promise;

};

APIClient.prototype._createNewWalletV1 = function(options) {

    var self = this;

    var deferred = q.defer();

    q.nextTick(function() {

        if (!options.primaryMnemonic && !options.primarySeed) {

            if (!options.passphrase && !options.password) {

                deferred.reject(new blocktrail.WalletCreateError("Can't generate Primary Mnemonic without a passphrase"));

                return deferred.promise;

            } else {

                options.primaryMnemonic = bip39.generateMnemonic(Wallet.WALLET_ENTROPY_BITS);

                if (options.storePrimaryMnemonic !== false) {

                    options.storePrimaryMnemonic = true;

                }

            }

        }

        if (!options.backupMnemonic && !options.backupPublicKey) {

            options.backupMnemonic = bip39.generateMnemonic(Wallet.WALLET_ENTROPY_BITS);

        }

        deferred.notify(APIClient.CREATE_WALLET_PROGRESS_PRIMARY);

        self.resolvePrimaryPrivateKeyFromOptions(options)

            .then(function(options) {

                deferred.notify(APIClient.CREATE_WALLET_PROGRESS_BACKUP);

                return self.resolveBackupPublicKeyFromOptions(options)

                    .then(function(options) {

                        deferred.notify(APIClient.CREATE_WALLET_PROGRESS_SUBMIT);

                        // create a checksum of our private key which we'll later use to verify we used the right password

                        var pubKeyHash = bitcoin.crypto.hash160(options.primaryPrivateKey.getPublicKeyBuffer());

                        var checksum = bitcoin.address.toBase58Check(pubKeyHash, self.network.pubKeyHash);

                        var keyIndex = options.keyIndex;

                        var primaryPublicKey = options.primaryPrivateKey.deriveHardened(keyIndex).neutered();

                        // send the public keys to the server to store them

                        //  and the mnemonic, which is safe because it's useless without the password

                        return self.storeNewWalletV1(

                            options.identifier,

                            [primaryPublicKey.toBase58(), "M/" + keyIndex + "'"],

                            [options.backupPublicKey.toBase58(), "M"],

                            options.storePrimaryMnemonic ? options.primaryMnemonic : false,

                            checksum,

                            keyIndex,

                            options.segwit || null

                        )

                            .then(function(result) {

                                deferred.notify(APIClient.CREATE_WALLET_PROGRESS_INIT);

                                var blocktrailPublicKeys = _.mapValues(result.blocktrail_public_keys, function(blocktrailPublicKey) {

                                    return bitcoin.HDNode.fromBase58(blocktrailPublicKey[0], self.network);

                                });

                                var wallet = new Wallet(

                                    self,

                                    options.identifier,

                                    Wallet.WALLET_VERSION_V1,

                                    options.primaryMnemonic,

                                    null,

                                    null,

                                    {keyIndex: primaryPublicKey},

                                    options.backupPublicKey,

                                    blocktrailPublicKeys,

                                    keyIndex,

                                    result.segwit || 0,

                                    self.testnet,

                                    checksum,

                                    result.upgrade_key_index,

                                    options.useCashAddress,

                                    options.bypassNewAddressCheck

                                );

                                return wallet.unlock({

                                    walletVersion: Wallet.WALLET_VERSION_V1,

                                    passphrase: options.passphrase,

                                    primarySeed: options.primarySeed,

                                    primaryMnemonic: null // explicit null

                                }).then(function() {

                                    deferred.notify(APIClient.CREATE_WALLET_PROGRESS_DONE);

                                    return [

                                        wallet,

                                        {

                                            walletVersion: wallet.walletVersion,

                                            primaryMnemonic: options.primaryMnemonic,

                                            backupMnemonic: options.backupMnemonic,

                                            blocktrailPublicKeys: blocktrailPublicKeys

                                        }

                                    ];