Parität, Web3, Nodejs - Fehler: Die Transaktion wurde nicht innerhalb von 750 Sekunden abgebaut. Bitte stellen Sie sicher, dass Ihre Transaktion ordnungsgemäß gesendet wurde

Ich verwende Parity ("ropsten" test net), Nodejs und web3js, um Smart Contracts von meinem System bereitzustellen. Die Parität wird im Testmodus synchronisiert, aber wenn ich den folgenden Code mit Nodejs ausführe, hat er mir eine Transaktions-ID " https://ropsten.etherscan.io/tx/0xa229e52224e7200337aa7893fea71c83e79cd5b2b37234a1559d9e6a7512385d " gegeben, aber als ich diese Transaktion auf etherscan.ropsten testnet überprüft habe, dann Ich habe festgestellt, dass diese Transaktion nicht von Etherscan abgebaut wurde. Ich bin mir nicht sicher, warum die Transaktion nicht von meinem lokalen "Parity" -Knoten nach Etherscan verschoben wurde.

Jede Hilfe wäre willkommen.

var Web3 = require('web3');
let fs = require("fs");
var solc = require('solc');

if( typeof Web3.currentProvider !== 'undefined'){
    web3 = new Web3( Web3.currentProvider );
}else{
    web3 = new Web3( new Web3.providers.HttpProvider("http://localhost:8545"));
}

async function deployContract(){

    var address = await web3.eth.getAccounts()
    var contractAdminAddrs = address[2]
    console.log("Contract deployed from: "+contractAdminAddrs);

    var input = {
        //'IERC20.sol': fs.readFileSync('IERC20.sol', 'utf8'),
        //'SafeMath.sol': fs.readFileSync('SafeMath.sol', 'utf8'),
        'Distribution.sol': fs.readFileSync('Distribution.sol', 'utf8')
    };
    let compiledContract = await solc.compile({sources: input}, 1);

    //console.log(compiledContract);
    //return false;

    let abi = compiledContract.contracts['Distribution.sol:Distribution'].interface;
    let bytecode = '0x'+compiledContract.contracts['Distribution.sol:Distribution'].bytecode;

    console.log("Contract Deployment Gas Estimate=")
    var gasEstimate = web3.eth.estimateGas({
        to: contractAdminAddrs,
        data: bytecode
    }).then(console.log)

    let Token = new web3.eth.Contract(JSON.parse(abi)); 

    console.log("ABI");
    console.log(abi);
    //return false;

    //var gasEstimate = 4500000; //Default gas
    var gas_Estimate = 4500000    //Calculated from above function,used static
    var gasPrice = 30000000000;

    var lms = Token.deploy(
        {data:bytecode,arguments:[contractAdminAddrs]})
        .send({
            from: contractAdminAddrs,
            gas: gas_Estimate,
            gasPrice: gasPrice
        }, 
        function(error, transactionHash){ 
            console.log("send function error=")
            console.log(error)

            console.log("transactionHash=")
            console.log(transactionHash)
        })
        .on('error', function(error){ 
            console.log("contract deploy error=")
            console.log(error)
        })
        .on('transactionHash', function(transactionHash){ 
            console.log("transactionHash 2nd function=")
            console.log(transactionHash)
        })
        .on('receipt', function(receipt){
            console.log("Receipt=")
            console.log(receipt.contractAddress) // contains the new contract address
        })
        .on('confirmation', function(confirmationNumber, receipt){ 
            console.log("Confirmation Number=")
            console.log(confirmationNumber)
        })
        .then(function(newContractInstance){
            console.log("New Contract address=")
            console.log(newContractInstance.options.address) // instance with the new contract address
        });


}

//Call function to deploy contract
deployContract()

Antworten (1)

Sie können das folgende NodeJS-Skript verwenden, um zu testen, ob Ihr Parity-Knoten synchronisiert und bereit ist, Anfragen zu empfangen.

Führen Sie es als Prozess neben Ihrem Paritätsprozess aus (dh auf derselben Maschine).

Dieser Prozess ist im Wesentlichen ein HTTP-Server, der auf einem Port mit dem Parity-Prozess und auf einem anderen Port mit Ihrem HTTP-Client (z. B. Browser) kommuniziert.

Ausführung: ausführen node check.js SERVER_PORT NODE_ADDRESS ETHERSCAN_KEY SYNC_THRESHOLD.

ETHERSCAN_KEYSie können Ihre wie folgt generieren :

Übrigens ist dieser Schlüssel sowohl für Ropsten (Testnetz) als auch für Homestead (Hauptnetz) gut.

Für SYNC_THRESHOLDkönnen Sie zunächst 10 verwenden und später den besten Wert ermitteln. Dieser Parameter gibt die zulässige Differenz zwischen dem aktuellen Block des Paritätsknotens und dem höchsten Block in der Kette an (den wir von etherscan.io erhalten). Wenn der Unterschied zwischen diesen beiden Werten SYNC_THRESHOLDkleiner oder gleich ist, ist der Parity-Knoten bereit, Anfragen zu empfangen, und der Server gibt 200 zurück. Andernfalls ist der Parity-Knoten nicht bereit, Anfragen zu empfangen, und der Server gibt 500 zurück.

let Web3    = require("web3");
let http    = require("http");
let request = require("request");

let SERVER_PORT    = process.argv[2];
let NODE_ADDRESS   = process.argv[3];
let ETHERSCAN_KEY  = process.argv[4];
let SYNC_THRESHOLD = process.argv[5];

let server = http.createServer(async function(externalRequest, externalResponse) {
    request.get("https://api-ropsten.etherscan.io/api?module=proxy&action=eth_blockNumber&apikey=" + ETHERSCAN_KEY, async function (error, response, body) {
        let externalResponseCode;
        let externalResponseBody;
        if (error) {
            externalResponseCode = 500;
            externalResponseBody = "error: " + error;
        }
        else if (!response) {
            externalResponseCode = 500;
            externalResponseBody = "no response";
        }
        else if (response.statusCode != 200) {
            externalResponseCode = 500;
            externalResponseBody = "bad response";
        }
        else {
            let web3 = new Web3(NODE_ADDRESS);
            let currentBlock = await web3.eth.getBlockNumber();
            let highestBlock = parseInt(JSON.parse(body).result);
            if (web3.currentProvider.constructor.name == "WebsocketProvider")
                web3.currentProvider.connection.close();
            externalResponseCode = highestBlock - currentBlock > parseInt(SYNC_THRESHOLD) ? 500 : 200;
            externalResponseBody = `currentBlock = ${currentBlock}, highestBlock = ${highestBlock}`;
        }
        console.log(externalResponseCode, externalResponseBody);
        externalResponse.statusCode = externalResponseCode;
        externalResponse.end(externalResponseBody);
    });
});

server.listen(SERVER_PORT, async function(error) {
    if (error)
        return console.log(error);
    console.log(`server is listening on port ${SERVER_PORT}`);
});
Danke @goodvibration für deinen detaillierten Code, lass mich prüfen, ob mir das hilft, das Problem mit dem Paritätsknoten zu lösen.
Ich führe Ihren Code aus und erhalte "currentBlock = 3788976, höchstBlock = 3788976", was bedeutet, dass mein Paritäts-Ropsten-Testnet-Knoten synchronisiert ist. Ihr Code ist sehr nützlich, um den Knotenstatus zu validieren. Ich verwende "Parity-ui", um die Paritätssyn. Status. Vielen Dank für Ihre Hilfe.