common.BigToHash stores absolute value of big int

[DenyVeyten]

System information

Geth version: v1.16.3

Expected behaviour

"0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd0abc"

Actual behaviour

"0x000000000000000000000000000000000000000000000000000000000002f544"

Steps to reproduce the behaviour

common.BigToHash(big.NewInt(-193860)).String()

[DenyVeyten]

Should be good enough fix?

func BigToHash(b *big.Int) Hash { return BytesToHash(math.U256Bytes(new(big.Int).Set(b))) }

[cuiweixie]

This is not a bug in Geth.
common.BigToHash uses Go’s big.Int.FillBytes, which always writes the absolute value of the number into the byte slice. Negative numbers are not stored in two’s complement form.

If you need a two’s complement representation for a negative value, you’ll have to convert it manually, e.g. by computing (2^256 + n) before calling FillBytes.

[DenyVeyten]

@cuiweixie I'm trying to manually create event logs (mainly for unit testing purposes). I use anABI.Events["EventName"].Inputs.NonIndexed().Pack(data...) for types.Log.Data, but for types.Log.Topics that is []common.Hash I create each hash value one by one:

[]common.Hash{
	anABI.Events["EventName"].ID,
	common.HexToHash("0xabcd"),
	common.BigToHash(big.NewInt(-1000)),
	common.BigToHash(big.NewInt(1000)),
}

If common.BigToHash is not supposed to convert exact value of *big.Int, does it mean common.BigToHash is not supposed to be used for the purpose of hashes creation for log topics? Not sure if there is a way to utilise abi package for convenient creation of types.Log.Topics similar to creation of types.Log.Data

N.B.:
I can find the current usage of common.BigToHash here

go-ethereum/internal/ethapi/logtracer.go

Line 139 in 1e4b39e

t.captureLog(transferAddress, topics, common.BigToHash(value).Bytes())

go-ethereum/eth/protocols/snap/sync.go

Line 862 in 1e4b39e

last := common.BigToHash(new(big.Int).Add(next.Big(), step))

it might have the same issue if negative values are possible there.

[cuiweixie]

@DenyVeyten May be you can try this.

package main

import (
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
)

// BigToHashSigned converts a big.Int to a 256-bit two's complement common.Hash
func BigToHashSigned(n *big.Int) common.Hash {
    // Create the modulus 2^256
    two256 := new(big.Int).Lsh(big.NewInt(1), 256)

    // If the number is negative, add 2^256 to get its two's complement representation
    if n.Sign() < 0 {
        n = new(big.Int).Add(n, two256)
    }

    // Convert to bytes
    b := n.Bytes()
    if len(b) > 32 {
        panic("number too large for 256-bit")
    }

    // Left-pad with zeros to make it exactly 32 bytes
    padded := make([]byte, 32)
    copy(padded[32-len(b):], b)

    return common.BytesToHash(padded)
}

func main() {
    // Example: -193860
    num := big.NewInt(-193860)
    h := BigToHashSigned(num)
    fmt.Println(h.Hex()) // 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd0abc
}

[DenyVeyten]

@cuiweixie thanks, I've got what you meant in your initial reply, I can achieve the same output with math.U256Bytes shared above (I slightly modified it to prevent original value destructuring). But I suppose the issues shared in my previous comment are still valid.

I also found a correct method that allows to conveniently create log topics, correctly converting *big.Int values:

abi.MakeTopics([]any{anABI.Events["EventName"].ID, "0xabcd", big.NewInt(-1000), big.NewInt(1000)})