Verwendung von Trezor (Hardware Wallet) mit Web3js auf Truffle oder Ropsten

Wir versuchen, web3js mit Trezor in ein Truffle -Dev-Netzwerk zu integrieren oder das Ropsten-Testnetzwerk zu verwenden .

Die Idee ist, die Transaktionen mit der Hardware-Wallet zu signieren und dann eine Rohtransaktion mit web3js zu senden

Wir bekommen, dass wir kein Guthaben haben, um die Transaktion durchzuführen, wahrscheinlich weil web3js keines der 10 Trüffelkonten belegt und die Trezor-Adresse verwendet, die nicht in meinem lokalen Netzwerk ist .

Auf ropsten habe ich einige Ether und bekomme "ungültige Adresse"

Gibt es eine Möglichkeit, signierte Transaktionen (mit Trezor) mit web3js in ein Truffle-Entwicklungsnetzwerk zu senden? Ich meine, gibt es eine Möglichkeit, die Trezor-Adresse in das Trüffelnetzwerk aufzunehmen?

Die Situation bei Truffle wird hier ausführlicher erklärt, aber die Frage könnte verallgemeinert werden zu " Gibt es eine Möglichkeit, Hardware-Wallets in das Truffle-Entwicklungsnetzwerk einzubeziehen? ": https://github.com/trufflesuite/truffle/issues/973

Mit ropsten haben wir es geschafft, eine Transaktion zu senden und einen Transaktions-Hash im Rückruf zu erhalten, aber wenn wir nach dieser Transaktion fragen, erhalten wir, dass die Transaktion nicht existiert ... also ... wie ist das möglich?

Wir haben auch versucht, einen Vertrag in Ropsten bereitzustellen, und jetzt erhalten wir „Ungültige Adresse“, wenn wir eine intelligente Vertragsfunktion aufrufen. Vielleicht ist die Signierfunktion falsch? jeder könnte die Trezor-Transaktionssignierung mit web3js integrieren?

Seht ihr irgendetwas falsch im Signier- und Sendeprozess, den wir befolgt haben? Vielleicht ist bei der Handhabung der R-, V- und S-Parameter etwas falsch ..

Eine weitere wichtige Sache ist, dass wir https://github.com/ethereumjs/ethereumjs-tx zum Erstellen der Rohtransaktionen verwenden

In web3js, truffle und trezzor veröffentlichte Ausgaben mit weiteren Informationen:

• https://github.com/trufflesuite/truffle/issues/973
• https://github.com/ethereum/web3.js/issues/1669
• https://github.com/trezor/connect/issues/130

mit freundlichen Grüßen

 trezorLogin = async()=> {
        let trezor=  await this.getTrezor();

        // site icon, optional. at least 48x48px
        var hosticon = 'https://doc.satoshilabs.com/trezor-apps/_images/copay_logo.png';
        // server-side generated and randomized challenges
        var challenge_hidden = '';
        var challenge_visual = '';
        //use anonimous functions on callback otherwise returns cross origin errors
        trezor.requestLogin(hosticon, challenge_hidden, challenge_visual, function (result){
            if (result.success) {
                console.log('Public key:', result.public_key); // pubkey in hex
                console.log('Signature:', result.signature); // signature in hex
                console.log('Version 2:', result.version === 2); // version field
                console.log(result);
            }else {
                console.error('Error:', result.error);
            }
        });}


    trezorSignTx= async(transaction)=> {
        let trezor=  await this.getTrezor();
        // spend one change output
        var address_n = "m/44'/60'/0'/0/0"
        // var address_n = [44 | 0x80000000,
        //                  60 | 0x80000000,
        //                  0  | 0x80000000 ,
        //                  0 ]; // same, in raw form
        var nonce = transaction.nonce.substring(2); // note - it is hex, not number!!!
        var gas_price = transaction.gasPrice.substring(2);
        var gas_limit = transaction.gasLimit.substring(2);
        var to = transaction.to.substring(2);
        // var value = '01'; // in hexadecimal, in wei - this is 1 wei
        var value = transaction.value.substring(2); // in hexadecimal, in wei - this is about 18 ETC
        var data = transaction.data.substring(2); // some contract data
        // var data = null  // for no data
        var chain_id = 5777; // 1 for ETH, 61 for ETC
        return new Promise (function (resolve,reject) {
            trezor.ethereumSignTx(
                address_n,
                nonce,
                gas_price,
                gas_limit,
                to,
                value,
                data,
                chain_id,
                function (response) {
                    if (response.success) {

                        console.log('Signature V (recovery parameter):', response.v); // number
                        console.log('Signature R component:', response.r); // bytes
                        console.log('Signature S component:', response.s); // bytes
                        resolve(response);

                    } else {
                        console.error('Error:', response.error); // error message
                        resolve(null);
                    }

                });
        })
    }

    getTrezorAddress = async() => {
        let trezor=  await this.getTrezor();
        // spend one change output
        var address_n = "m/44'/60'/0'/0/0";
        trezor.ethereumGetAddress(address_n, function (result) {
            if (result.success) { // success
                console.log('Address: ', result.address);
            } else {
                console.error('Error:', result.error); // error message
            }
        });
    }


    getTrezor = async() => {
        let trezorC;
        await getTrezorConnect
            .then(trezorConnect => {
                trezorC= trezorConnect;
            })
            .catch((error) => {
                console.log(error)
            })
        return trezorC;

    }

 sendTransaction= async(address, amount, id)=>{
        let tokenInstance = this.props.smartContractInstance;

        var getData = tokenInstance.mint.getData(address, amount);

        var tx = {
            nonce: '0x00',
            gasPrice: '0x09184e72a000',
            gasLimit: '0x2710',
            to: CONTRACT_ADDRESS,
            value: '0x00',
            from:CONTRACT_OWNER_ADDRESS,
            data: getData
        };
        let response = await this.trezorSignTx(tx);

        let web3;
        let _this = this;
        if (response!=null){
            getWeb3
                .then(results => {
                    web3= results.web3;
                    let v = response.v.toString();
                    if (v.length % 2 != 0){
                        v="0"+v;
                    }
                    tx.r=Buffer.from(response.r,'hex');
                    tx.v=Buffer.from(v,'hex');
                    tx.s=Buffer.from(response.s,'hex');
                    let ethtx = new ethereumjs(tx);
                    console.dir(ethtx.getSenderAddress().toString('hex'), );
                    const serializedTx = ethtx.serialize();
                    const rawTx = '0x' + serializedTx.toString('hex');
                    console.log(rawTx);
                    //finally pass this data parameter to send Transaction
                    web3.eth.sendRawTransaction(rawTx, function (error, result) {
                        if(!error){
                            _this.props.addTokens(id)
                                .then(()=>{
                                        _this.setState({modalOpen: true});
                                        _this.props.getAllTransactions();
                                    }
                                );
                        }else{
                            alert(error)
                        }
                    });
                })
                .catch((error) => {
                    console.log(error)
                })
        }else{
            alert("There was an error signing with trezor hardware wallet")
        }


    }

Die getTrezorConnect-Funktion ist einfach get window.trezorConnect asynchron, da das Objekt als Skript injiziert wird

<script src="https://connect.trezor.io/4/connect.js"></script>