package dasigners_test import ( "math/big" "strings" "testing" "github.com/0glabs/0g-chain/crypto/bn254util" dasignersprecompile "github.com/0glabs/0g-chain/precompiles/dasigners" "github.com/0glabs/0g-chain/precompiles/testutil" "github.com/0glabs/0g-chain/x/dasigners/v1" "github.com/0glabs/0g-chain/x/dasigners/v1/keeper" dasignerskeeper "github.com/0glabs/0g-chain/x/dasigners/v1/keeper" "github.com/0glabs/0g-chain/x/dasigners/v1/types" abci "github.com/cometbft/cometbft/abci/types" "github.com/consensys/gnark-crypto/ecc/bn254" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" evmtypes "github.com/evmos/ethermint/x/evm/types" "github.com/stretchr/testify/suite" "cosmossdk.io/math" stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/evmos/ethermint/crypto/ethsecp256k1" ) type DASignersTestSuite struct { testutil.PrecompileTestSuite abi abi.ABI addr common.Address dasigners *dasignersprecompile.DASignersPrecompile dasignerskeeper dasignerskeeper.Keeper signerOne *testutil.TestSigner signerTwo *testutil.TestSigner } func (suite *DASignersTestSuite) AddDelegation(from string, to string, amount math.Int) { accAddr, err := sdk.AccAddressFromHexUnsafe(from) suite.Require().NoError(err) valAddr, err := sdk.ValAddressFromHex(to) suite.Require().NoError(err) validator, found := suite.StakingKeeper.GetValidator(suite.Ctx, valAddr) if !found { consPriv, err := ethsecp256k1.GenerateKey() suite.Require().NoError(err) newValidator, err := stakingtypes.NewValidator(valAddr, consPriv.PubKey(), stakingtypes.Description{}) suite.Require().NoError(err) validator = newValidator } validator.Tokens = validator.Tokens.Add(amount) validator.DelegatorShares = validator.DelegatorShares.Add(amount.ToLegacyDec()) suite.StakingKeeper.SetValidator(suite.Ctx, validator) bonded := suite.dasignerskeeper.GetDelegatorBonded(suite.Ctx, accAddr) suite.StakingKeeper.SetDelegation(suite.Ctx, stakingtypes.Delegation{ DelegatorAddress: accAddr.String(), ValidatorAddress: valAddr.String(), Shares: bonded.Add(amount).ToLegacyDec(), }) } func (suite *DASignersTestSuite) SetupTest() { suite.PrecompileTestSuite.SetupTest() suite.dasignerskeeper = suite.App.GetDASignersKeeper() suite.addr = common.HexToAddress(dasignersprecompile.PrecompileAddress) precompiles := suite.EvmKeeper.GetPrecompiles() precompile, ok := precompiles[suite.addr] suite.Assert().EqualValues(ok, true) suite.dasigners = precompile.(*dasignersprecompile.DASignersPrecompile) suite.signerOne = testutil.GenSigner() suite.signerTwo = testutil.GenSigner() abi, err := abi.JSON(strings.NewReader(dasignersprecompile.DASignersABI)) suite.Assert().NoError(err) suite.abi = abi } func (suite *DASignersTestSuite) runTx(input []byte, signer *testutil.TestSigner, gas uint64) ([]byte, error) { contract := vm.NewPrecompile(vm.AccountRef(signer.Addr), vm.AccountRef(suite.addr), big.NewInt(0), gas) contract.Input = input msgEthereumTx := evmtypes.NewTx(suite.EvmKeeper.ChainID(), 0, &suite.addr, big.NewInt(0), gas, big.NewInt(0), big.NewInt(0), big.NewInt(0), input, nil) msgEthereumTx.From = signer.HexAddr err := msgEthereumTx.Sign(suite.EthSigner, signer.Signer) suite.Assert().NoError(err, "failed to sign Ethereum message") proposerAddress := suite.Ctx.BlockHeader().ProposerAddress cfg, err := suite.EvmKeeper.EVMConfig(suite.Ctx, proposerAddress, suite.EvmKeeper.ChainID()) suite.Assert().NoError(err, "failed to instantiate EVM config") msg, err := msgEthereumTx.AsMessage(suite.EthSigner, big.NewInt(0)) suite.Assert().NoError(err, "failed to instantiate Ethereum message") evm := suite.EvmKeeper.NewEVM(suite.Ctx, msg, cfg, nil, suite.Statedb) precompiles := suite.EvmKeeper.GetPrecompiles() evm.WithPrecompiles(precompiles, []common.Address{suite.addr}) return suite.dasigners.Run(evm, contract, false) } func (suite *DASignersTestSuite) registerSigner(testSigner *testutil.TestSigner, sk *big.Int) *types.Signer { pkG1 := new(bn254.G1Affine).ScalarMultiplication(bn254util.GetG1Generator(), sk) pkG2 := new(bn254.G2Affine).ScalarMultiplication(bn254util.GetG2Generator(), sk) hash := types.PubkeyRegistrationHash(testSigner.Addr, big.NewInt(8888)) signature := new(bn254.G1Affine).ScalarMultiplication(hash, sk) signer := &types.Signer{ Account: testSigner.HexAddr, Socket: "0.0.0.0:1234", PubkeyG1: bn254util.SerializeG1(pkG1), PubkeyG2: bn254util.SerializeG2(pkG2), } input, err := suite.abi.Pack( "registerSigner", dasignersprecompile.NewIDASignersSignerDetail(signer), dasignersprecompile.NewBN254G1Point(bn254util.SerializeG1(signature)), ) suite.Assert().NoError(err) oldLogs := suite.Statedb.Logs() _, err = suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) logs := suite.Statedb.Logs() suite.Assert().EqualValues(len(logs), len(oldLogs)+2) _, err = suite.abi.Unpack("SocketUpdated", logs[len(logs)-1].Data) suite.Assert().NoError(err) _, err = suite.abi.Unpack("NewSigner", logs[len(logs)-2].Data) suite.Assert().NoError(err) return signer } func (suite *DASignersTestSuite) updateSocket(testSigner *testutil.TestSigner, signer *types.Signer) { input, err := suite.abi.Pack( "updateSocket", "0.0.0.0:2345", ) suite.Assert().NoError(err) oldLogs := suite.Statedb.Logs() _, err = suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) logs := suite.Statedb.Logs() suite.Assert().EqualValues(len(logs), len(oldLogs)+1) _, err = suite.abi.Unpack("SocketUpdated", logs[len(logs)-1].Data) suite.Assert().NoError(err) signer.Socket = "0.0.0.0:2345" } func (suite *DASignersTestSuite) registerEpoch(testSigner *testutil.TestSigner, sk *big.Int) { hash := types.EpochRegistrationHash(common.HexToAddress(testSigner.HexAddr), 1, big.NewInt(8888)) signature := new(bn254.G1Affine).ScalarMultiplication(hash, sk) input, err := suite.abi.Pack( "registerNextEpoch", dasignersprecompile.NewBN254G1Point(bn254util.SerializeG1(signature)), ) suite.Assert().NoError(err) _, err = suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) } func (suite *DASignersTestSuite) queryEpochNumber(testSigner *testutil.TestSigner) { input, err := suite.abi.Pack( "epochNumber", ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["epochNumber"].Outputs.Unpack(bz) suite.Assert().NoError(err) suite.Assert().EqualValues(out[0], big.NewInt(1)) } func (suite *DASignersTestSuite) queryQuorumCount(testSigner *testutil.TestSigner) { input, err := suite.abi.Pack( "quorumCount", big.NewInt(1), ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["quorumCount"].Outputs.Unpack(bz) suite.Assert().NoError(err) suite.Assert().EqualValues(out[0], big.NewInt(1)) } func (suite *DASignersTestSuite) queryGetSigner(testSigner *testutil.TestSigner, answer []*types.Signer) { input, err := suite.abi.Pack( "getSigner", []common.Address{suite.signerOne.Addr, suite.signerTwo.Addr}, ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["getSigner"].Outputs.Unpack(bz) suite.Assert().NoError(err) res := make([]dasignersprecompile.IDASignersSignerDetail, 0) for _, s := range answer { res = append(res, dasignersprecompile.NewIDASignersSignerDetail(s)) } suite.Assert().EqualValues(out[0], res) } func (suite *DASignersTestSuite) queryIsSigner(testSigner *testutil.TestSigner) { input, err := suite.abi.Pack( "isSigner", suite.signerOne.Addr, ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["isSigner"].Outputs.Unpack(bz) suite.Assert().NoError(err) suite.Assert().EqualValues(out[0], true) } func (suite *DASignersTestSuite) queryRegisteredEpoch(testSigner *testutil.TestSigner, account common.Address, epoch *big.Int) bool { input, err := suite.abi.Pack( "registeredEpoch", account, epoch, ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["registeredEpoch"].Outputs.Unpack(bz) suite.Assert().NoError(err) return out[0].(bool) } func (suite *DASignersTestSuite) queryGetQuorum(testSigner *testutil.TestSigner) []common.Address { input, err := suite.abi.Pack( "getQuorum", big.NewInt(1), big.NewInt(0), ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["getQuorum"].Outputs.Unpack(bz) suite.Assert().NoError(err) return out[0].([]common.Address) } func (suite *DASignersTestSuite) queryGetQuorumRow(testSigner *testutil.TestSigner, row uint32) common.Address { input, err := suite.abi.Pack( "getQuorumRow", big.NewInt(1), big.NewInt(0), row, ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["getQuorumRow"].Outputs.Unpack(bz) suite.Assert().NoError(err) return out[0].(common.Address) } func (suite *DASignersTestSuite) queryGetAggPkG1(testSigner *testutil.TestSigner, bitmap []byte) struct { AggPkG1 dasignersprecompile.BN254G1Point Total *big.Int Hit *big.Int } { input, err := suite.abi.Pack( "getAggPkG1", big.NewInt(1), big.NewInt(0), bitmap, ) suite.Assert().NoError(err) bz, err := suite.runTx(input, testSigner, 10000000) suite.Assert().NoError(err) out, err := suite.abi.Methods["getAggPkG1"].Outputs.Unpack(bz) suite.Assert().NoError(err) return struct { AggPkG1 dasignersprecompile.BN254G1Point Total *big.Int Hit *big.Int }{ AggPkG1: out[0].(dasignersprecompile.BN254G1Point), Total: out[1].(*big.Int), Hit: out[2].(*big.Int), } } func (suite *DASignersTestSuite) Test_DASigners() { // suite.App.InitializeFromGenesisStates() dasigners.InitGenesis(suite.Ctx, suite.dasignerskeeper, *types.DefaultGenesisState()) // add delegation params := suite.dasignerskeeper.GetParams(suite.Ctx) suite.AddDelegation(suite.signerOne.HexAddr, suite.signerOne.HexAddr, keeper.BondedConversionRate.Mul(sdk.NewIntFromUint64(params.TokensPerVote))) suite.AddDelegation(suite.signerTwo.HexAddr, suite.signerOne.HexAddr, keeper.BondedConversionRate.Mul(sdk.NewIntFromUint64(params.TokensPerVote)).Mul(sdk.NewIntFromUint64(2))) // tx test signer1 := suite.registerSigner(suite.signerOne, big.NewInt(1)) signer2 := suite.registerSigner(suite.signerTwo, big.NewInt(11)) suite.updateSocket(suite.signerOne, signer1) suite.updateSocket(suite.signerTwo, signer2) suite.registerEpoch(suite.signerOne, big.NewInt(1)) suite.registerEpoch(suite.signerTwo, big.NewInt(11)) // move to next epoch suite.Ctx = suite.Ctx.WithBlockHeight(int64(params.EpochBlocks) * 1) suite.dasignerskeeper.BeginBlock(suite.Ctx, abci.RequestBeginBlock{}) // query test suite.queryEpochNumber(suite.signerOne) suite.queryQuorumCount(suite.signerOne) suite.queryGetSigner(suite.signerOne, []*types.Signer{signer1, signer2}) suite.queryIsSigner(suite.signerOne) suite.Assert().EqualValues(suite.queryRegisteredEpoch(suite.signerOne, suite.signerOne.Addr, big.NewInt(1)), true) suite.Assert().EqualValues(suite.queryRegisteredEpoch(suite.signerOne, suite.signerTwo.Addr, big.NewInt(1)), true) suite.Assert().EqualValues(suite.queryRegisteredEpoch(suite.signerOne, suite.signerOne.Addr, big.NewInt(2)), false) suite.Assert().EqualValues(suite.queryRegisteredEpoch(suite.signerOne, suite.signerTwo.Addr, big.NewInt(0)), false) quorum := suite.queryGetQuorum(suite.signerOne) suite.Assert().EqualValues(len(quorum), params.EncodedSlices) cnt := map[common.Address]int{suite.signerOne.Addr: 0, suite.signerTwo.Addr: 0} onePos := len(quorum) twoPos := len(quorum) for i, v := range quorum { suite.Assert().EqualValues(suite.queryGetQuorumRow(suite.signerOne, uint32(i)), v) cnt[v] += 1 if v == suite.signerOne.Addr { onePos = min(onePos, i) } else { twoPos = min(twoPos, i) } } suite.Assert().EqualValues(cnt[suite.signerOne.Addr], len(quorum)/3) suite.Assert().EqualValues(cnt[suite.signerTwo.Addr], len(quorum)*2/3) bitMap := make([]byte, len(quorum)/8) bitMap[onePos/8] |= 1 << (onePos % 8) suite.Assert().EqualValues(suite.queryGetAggPkG1(suite.signerOne, bitMap), struct { AggPkG1 dasignersprecompile.BN254G1Point Total *big.Int Hit *big.Int }{ AggPkG1: dasignersprecompile.NewBN254G1Point(bn254util.SerializeG1(new(bn254.G1Affine).ScalarMultiplication(bn254util.GetG1Generator(), big.NewInt(1)))), Total: big.NewInt(int64(len(quorum))), Hit: big.NewInt(int64(len(quorum) / 3)), }) bitMap[twoPos/8] |= 1 << (twoPos % 8) suite.Assert().EqualValues(suite.queryGetAggPkG1(suite.signerOne, bitMap), struct { AggPkG1 dasignersprecompile.BN254G1Point Total *big.Int Hit *big.Int }{ AggPkG1: dasignersprecompile.NewBN254G1Point(bn254util.SerializeG1(new(bn254.G1Affine).ScalarMultiplication(bn254util.GetG1Generator(), big.NewInt(1+11)))), Total: big.NewInt(int64(len(quorum))), Hit: big.NewInt(int64(len(quorum))), }) } func TestKeeperSuite(t *testing.T) { suite.Run(t, new(DASignersTestSuite)) }