blocktrail / blocktrail-sdk-nodejs

                checksum,

                keyIndex,

                options.support_secret || null,

                options.segwit || null

            )

                .then(

                    // result, deferred, self(apiclient)

                    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_V3,

                            null,

                            options.storeDataOnServer ? options.encryptedPrimarySeed : null,

                            options.storeDataOnServer ? options.encryptedSecret : null,

                            {keyIndex: options.primaryPublicKey},

                            options.backupPublicKey,

                            blocktrailPublicKeys,

                            keyIndex,

                            result.segwit || 0,

                            self.testnet,

                            checksum,

                            result.upgrade_key_index,

                            options.useCashAddress,

                            options.bypassNewAddressCheck

                        );

                        // pass along decrypted data to avoid extra work

                        return wallet.unlock({

                            walletVersion: Wallet.WALLET_VERSION_V3,

                            passphrase: options.passphrase,

                            primarySeed: options.primarySeed,

                            secret: options.secret

                        }).then(function() {

                            deferred.notify(APIClient.CREATE_WALLET_PROGRESS_DONE);

                            return [

                                wallet,

                                {

                                    walletVersion: wallet.walletVersion,

                                    encryptedPrimarySeed: options.encryptedPrimarySeed ? EncryptionMnemonic.encode(options.encryptedPrimarySeed) : null,

                                    backupSeed: options.backupSeed ? bip39.entropyToMnemonic(options.backupSeed) : null,

                                    recoveryEncryptedSecret: options.recoveryEncryptedSecret ?

                                        EncryptionMnemonic.encode(options.recoveryEncryptedSecret) : null,

                                    encryptedSecret: options.encryptedSecret ? EncryptionMnemonic.encode(options.encryptedSecret) : null,

                                    blocktrailPublicKeys: blocktrailPublicKeys

                                }

                            ];

                        });

                    }

                );

        })

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

    return deferred.promise;

};

function verifyPublicBip32Key(bip32Key, network) {

    var hk = bitcoin.HDNode.fromBase58(bip32Key[0], network);

    if (typeof hk.keyPair.d !== "undefined") {

        throw new Error('BIP32Key contained private key material - abort');

    }

    if (bip32Key[1].slice(0, 1) !== "M") {

        throw new Error("BIP32Key contained non-public path - abort");

    }

}

function verifyPublicOnly(walletData, network) {

    verifyPublicBip32Key(walletData.primary_public_key, network);

    verifyPublicBip32Key(walletData.backup_public_key, network);

}

/**

 * create wallet using the API

 *

/**

 * create wallet using the API

 *

 * @param identifier            string      the wallet identifier to create

 * @param primaryPublicKey      array       the primary public key - [key, path] should be M/<keyIndex>'

 * @param backupPublicKey       array       the backup public key - [key, path] should be M/<keyIndex>'

 * @param encryptedPrimarySeed  string      openssl format

 * @param encryptedSecret       string      openssl format

 * @param recoverySecret        string      openssl format

 * @param checksum              string      checksum to store

 * @param keyIndex              int         keyIndex that was used to create wallet

 * @param supportSecret         string

 * @param segwit                bool

 * @returns {q.Promise}

 */

APIClient.prototype.storeNewWalletV2 = function(identifier, primaryPublicKey, backupPublicKey, encryptedPrimarySeed, encryptedSecret,

                                                recoverySecret, checksum, keyIndex, supportSecret, segwit) {

    var self = this;

    var postData = {

        identifier: identifier,

        wallet_version: Wallet.WALLET_VERSION_V2,

        primary_public_key: primaryPublicKey,

        backup_public_key: backupPublicKey,

        encrypted_primary_seed: encryptedPrimarySeed,

        encrypted_secret: encryptedSecret,

        recovery_secret: recoverySecret,

        checksum: checksum,

        key_index: keyIndex,

        support_secret: supportSecret || null,

        segwit: segwit

    };

    verifyPublicOnly(postData, self.network);

    return self.client.post("/wallet", null, postData);

};

/**

 * create wallet using the API

 *

 * @param identifier            string      the wallet identifier to create

 * @param primaryPublicKey      array       the primary public key - [key, path] should be M/<keyIndex>'

 * @param backupPublicKey       array       the backup public key - [key, path] should be M/<keyIndex>'

 * @param encryptedPrimarySeed  Buffer      buffer of ciphertext

 * @param encryptedSecret       Buffer      buffer of ciphertext

 * @param recoverySecret        Buffer      buffer of recovery secret

 * @param checksum              string      checksum to store

 * @param keyIndex              int         keyIndex that was used to create wallet

 * @param supportSecret         string

 * @param segwit                bool

 * @returns {q.Promise}

 */

APIClient.prototype.storeNewWalletV3 = function(identifier, primaryPublicKey, backupPublicKey, encryptedPrimarySeed, encryptedSecret,

                                                recoverySecret, checksum, keyIndex, supportSecret, segwit) {

    var self = this;

    var postData = {

        identifier: identifier,

        wallet_version: Wallet.WALLET_VERSION_V3,

        primary_public_key: primaryPublicKey,

        backup_public_key: backupPublicKey,

        encrypted_primary_seed: encryptedPrimarySeed.toString('base64'),

        encrypted_secret: encryptedSecret.toString('base64'),

        recovery_secret: recoverySecret.toString('hex'),

        checksum: checksum,

        key_index: keyIndex,

        support_secret: supportSecret || null,

        segwit: segwit

    };

    verifyPublicOnly(postData, self.network);

    return self.client.post("/wallet", null, postData);

};