Gibt es eine technische Obergrenze für Transaktions-Nonces?

Wenn ich ein sehr ausgelastetes Konto habe, sagen wir, ich bin eine Börse und verwende ein Relay-Konto oder so / eine Hot Wallet, vielleicht um Abhebungen zu verarbeiten, die Millionen von Transaktionen verarbeitet und erstellt, wird es ein Problem mit einer stetig steigenden Transaktion geben ?

Gibt es eine technische Obergrenze für Transaktions-Nonces, zB in den verwendeten zugrunde liegenden Datentypen?

Antworten (1)

Von github - Go Ethereum - core/types/transaction.go, Zeilen 46-54 :

type txdata struct {
    AccountNonce    uint64
    Price, GasLimit *big.Int
    Recipient       *common.Address `rlp:"nil"` // nil means contract creation
    Amount          *big.Int
    Payload         []byte
    V               byte     // signature
    R, S            *big.Int // signature
}

AccountNonceist eine 64-Bit-Ganzzahl ohne Vorzeichen mit einem Bereich von 0 bis 2^64-1 (was 18.446.744.073.709.551.616 von Unsigned and Signed Integers entspricht ).

Nach Durchsicht des Quellcodes von Go Ethereum scheint es keine weiteren Einschränkungen für die Reichweite der Nonce zu geben.

So können Sie sicher Millionen (x Millionen x Millionen) Transaktionen von demselben Konto erstellen.

Und falls Sie interessiert sind, hier ist die Ausgabe für meine Überprüfungen der Vergleichsoperatoren auf der Nonce-Variablen.

user@Kumquat:~/EthereumSource/go-ethereum$ find . -type f -exec grep -H Nonce {} \; | grep "<"
./core/chain_pow.go:func verifyNoncesFromHeaders(checker pow.PoW, headers []*types.Header) (chan<- struct{}, <-chan nonceCheckResult) {
./core/chain_pow.go:func verifyNoncesFromBlocks(checker pow.PoW, blocks []*types.Block) (chan<- struct{}, <-chan nonceCheckResult) {
./core/chain_pow.go:func verifyNonces(checker pow.PoW, items []pow.Block) (chan<- struct{}, <-chan nonceCheckResult) {
./core/types/transaction_test.go:               t.Errorf("invalid nonce ordering: tx #%d (A=%x N=%v) < tx #%d (A=%x N=%v)", i, fromi[:4], txi.Nonce(), i+j, fromj[:4], txj.Nonce())
./core/types/transaction.go:func (s TxByNonce) Less(i, j int) bool { return s[i].data.AccountNonce < s[j].data.AccountNonce }
./core/tx_pool.go:          if pool.pendingState.GetNonce(addr) <= tx.Nonce() {
./core/tx_pool.go:          if tx.Nonce() < trueNonce || balance.Cmp(tx.Cost()) < 0 {
./core/tx_pool.go:      if past := state.GetNonce(sender) > tx.Nonce(); past || balance.Cmp(tx.Cost()) < 0 {
./core/tx_pool.go:              if prev, ok := gaps[sender]; !ok || tx.Nonce() < prev {
./core/tx_pool.go:func (q txQueue) Less(i, j int) bool { return q[i].Nonce() < q[j].Nonce() }
user@Kumquat:~/EthereumSource/go-ethereum$ find . -type f -exec grep -H Nonce {} \; | grep ">"
./core/types/transaction_test.go:           if fromi == fromj && txi.Nonce() > txj.Nonce() {
./core/types/transaction.go:        if accTxs, ok := byNonce[acc]; ok && len(accTxs) > 0 {
./core/tx_pool.go:  if currentState.GetNonce(from) > tx.Nonce() {
./core/tx_pool.go:          if entry.Nonce() > guessedNonce {
./core/tx_pool.go:      if past := state.GetNonce(sender) > tx.Nonce(); past || balance.Cmp(tx.Cost()) < 0 {
./core/tx_pool.go:          if gap, ok := gaps[sender]; ok && tx.Nonce() >= gap {

Es scheint keine Überprüfungen für eine Obergrenze der Nonce zu geben.

Gibt es eine technische Obergrenze für Transaktions-Nonces?
AntwortenHierDatenschutz-Bestimmungen1y, 0v