0

Nous travaillons avec un projet ICO basé sur NEO Blockchain. Nous avons besoin d'obtenir des paiements via NEO, ETH et BTC. Nous utilisons le concept d'adresse de dépôt pour obtenir des paiements de la part des utilisateurs, et pour cela nous avons utilisé certains nœuds js pour créer l'adresse BTC comme ci-dessous:

var express = require ('express');
var app = express ();
var fs = require ("fs");
var bitcoin = require ('bitcoinjs-lib');
var lightwallet = require ('eth-lightwallet');

function generateBitcoinAddress () {
    console.log ("generateBitcoinAddress");
    const crypto = require ('crypto');
    const EC = require ('elliptique'). ec;
    const RIPEMD160 = require ('ripemd160');
    const bs58 = require ('bs58');
    const buffer = require ('buffer');
    const ec = new EC ('secp256k1');

    function hasha256 (données) {
        return crypto.createHash ('sha256'). mise à jour (données) .digest ();
    } // Une petite fonction que j'ai créée car il y a beaucoup de hachage sha256.

    const addrVer = Buffer.alloc (1, 0x00); // 0x00 P2PKH Mainnet, 0x6f P2PKH Testnet
    const wifByte = Buffer.alloc (1, 0x80); // 0x80 Mainnet, 0xEF Testnet

    var key = ec.genKeyPair ();
    var privKey = key.getPrivate (). toString ('hex');
    var pubPoint = key.getPublic ();
    var x = pubPoint.getX (); // elliptique x
    var y = pubPoint.getY (); // elliptique

    // Hashing de clés privées
    var bufPrivKey = Buffer.from (privKey, 'hex');
    var wifBufPriv = Buffer.concat ([wifByte, bufPrivKey]wifByte.length + bufPrivKey.length);
    var wifHashFirst = hasha256 (wifBufPriv);
    var wifHashSecond = hasha256 (wifHashFirst);
    var wifHashSig = wifHashSecond.slice (0, 4);
    var wifBuf = Buffer.concat ([wifBufPriv, wifHashSig]wifBufPriv.length + wifHashSig.length);
    var wifFinal = bs58.encode (wifBuf);

    // Hashing de clé publique
    var publicKey = pubPoint.encode ('hex');
    var publicKeyInitialHash = hasha256 (Buffer.from (publicKey, 'hex'));
    var publicKeyRIPEHash = nouveau RIPEMD160 (). update (Buffer.from (publicKeyInitialHash, 'hex')). digest ('hex');
    var hashBuffer = Buffer.from (publicKeyRIPEHash, 'hex');
    var concatHash = Buffer.concat ([addrVer, hashBuffer]addrVer.length + hashBuffer.length);
    var hashExtRipe = hasha256 (concatHash);
    var hashExtRipe2 = hasha256 (hashExtRipe);
    var hashSig = hashExtRipe2.slice (0, 4);
    var bitcoinBinaryStr = Buffer.concat ([concatHash, hashSig]concatHash.length + hashSig.length);

    var bitcoinWifAddress = wifFinal.toString ('hex');
    var bitcoinAddress = bs58.encode (Buffer.from (bitcoinBinaryStr));
    données = {};
    data.WIFPrivateKey = bitcoinWifAddress.toString ('hex');
    data.BitcoinAddress = bitcoinAddress.toString ('hex');
    renvoyer des données;
}

app.get ('/ generateBTCAddress', fonction (req, res) {
      res.send (generateBitcoinAddress ());
})

app.get ('/', function (req, res) {
    console.log ("bienvenue");
    var wifkey = bitcoin.ECPair.makeRandom (). toWIF ();
    var keyPair = bitcoin.ECPair.fromWIF ('L22fA7nJgiig78A8nubSAQPwYp4Fnqk4W6FUen7GWsQxp2H4UD2V');
    var data = {};
    data.address = keyPair.getAddress ();
    data.wifkey = wifkey;
    data.message = "Bienvenue à la maison";
    res.send (données);
});

app.get ('/ generateETHAddress', fonction (req, res) {
    var mot de passe = Math.random (). toString ();
    var seed = lightwallet.keystore.generateRandomSeed ();

    lightwallet.keystore.createVault ({
        mot de passe: mot de passe,
        seedPhrase: graine,
        hdPathString: "m / 0 '/ 0' / 0 '"
    }, function (err, ks) {

    ks.keyFromPassword (mot de passe, function (err, pwDerivedKey) {
        if (! ks.isDerivedKeyCorrect (pwDerivedKey)) {
            throw new Error ("Clé dérivée incorrecte!");
        }

        essayez {
            ks.generateNewAddress (pwDerivedKey, 1);
        } catch (err) {
            console.log (err);
            console.trace ();
        }
        var résultat = {};
        result.address = ks.getAddresses () [0];
        result.prv_key = ks.exportPrivateKey (result.address, pwDerivedKey);
        res.send (résultat);
        });
    });
})

var server = app.listen (8081, function () {
var host = adresse_serveur (). adresse
var port = server.address (). port
      console.log ("Exemple d'application écoutant sur http: //% s:% s", hôte, port)
    })

retourne bitcoin.ECPair.makeRandom (). toWIF ()

Cette adresse de retour du portefeuille et la clé privée.

{
    "WIFPrivateKey": "5XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXa",
    "BitcoinAddress": "12zyHTgqfm3XT5KXXXXXHk"
}

Pour obtenir ces BTC déposés par l'utilisateur, nous devons nous connecter au portefeuille.

Le flux est très simple dans NEO et Ethereum, l'utilisateur peut se connecter au portefeuille en utilisant la clé privée, mais dans Bitcoin je ne suis pas en mesure de trouver un moyen de se connecter au portefeuille.

Y a-t-il quelque chose que j'ai manqué?