github.com/SmartMeshFoundation/Spectrum@v0.0.0-20220621030607-452a266fee1e/consensus/tribe/tribe_test.go

package tribe

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"encoding/hex"
	"math/big"
	mrand "math/rand"
	"testing"
	"time"

	"github.com/SmartMeshFoundation/Spectrum/core/types"

	"github.com/SmartMeshFoundation/Spectrum/core/state"
	"github.com/SmartMeshFoundation/Spectrum/params"

	"github.com/SmartMeshFoundation/Spectrum/accounts/keystore"
	"github.com/SmartMeshFoundation/Spectrum/common"
	"github.com/SmartMeshFoundation/Spectrum/crypto"
	"github.com/SmartMeshFoundation/Spectrum/ethdb"
)

func TestNormal(t *testing.T) {
	prv, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
	t.Log(prv)
	t.Log(prv.PublicKey)
	pub := prv.PublicKey
	pk := crypto.PubkeyToAddress(prv.PublicKey)
	t.Log(pk.Hex())
	m := elliptic.Marshal(crypto.S256(), pub.X, pub.Y)
	t.Log("m=", m)
	x, y := elliptic.Unmarshal(crypto.S256(), m)
	t.Log("x,y=", x, y)

}

func TestDelay(t *testing.T) {
	for signerLen := 1; signerLen < 11; signerLen += 1 {
		wiggle := time.Duration(signerLen/2+1) * wiggleTime
		delay := time.Duration(mrand.Int63n(int64(wiggle)))
		t.Log(signerLen, wiggle, "\t", delay)
	}
	for signerLen := 10; signerLen < 110; signerLen += 10 {
		wiggle := time.Duration(signerLen/2+1) * wiggleTime
		delay := time.Duration(mrand.Int63n(int64(wiggle)))
		t.Log(signerLen, wiggle, "\t", delay)
	}
}

func TestNodekey(t *testing.T) {
	prv, _ := ecdsa.GenerateKey(crypto.S256(), rand.Reader)
	k := hex.EncodeToString(crypto.FromECDSA(prv))
	t.Log(k)

	json := `{"address":"4110bd1ff0b73fa12c259acf39c950277f266787","crypto":{"cipher":"aes-128-ctr","ciphertext":"3c12a4bb0048503ea6874c9357b046f3585cdb3af3219618e56220e69d01e5f8","cipherparams":{"iv":"e3e516858fa657437ab53aca9bd48b30"},"kdf":"scrypt","kdfparams":{"dklen":32,"n":262144,"p":1,"r":8,"salt":"63795963bf80c8acff4c4c7f2f33f83b2ebf8f82747c057992cab92ba80beca6"},"mac":"12672d255fbbf0ef9374d9f37da7d25b39ea65b9dec3e63ff6055950dbb48103"},"id":"d541af26-402e-4cdb-841d-8bb700c09887","version":3}`
	key, _ := keystore.DecryptKey([]byte(json), "123456")
	prv2 := key.PrivateKey
	t.Log(crypto.SaveECDSA("/tmp/nodekey", prv2))

	prv3, _ := crypto.HexToECDSA("4755839cb237126c4317a858d85d3837745615b1f67eb20de260416658c43b19")
	t.Log(&prv2)
	t.Log(&prv3)

}

func TestHexToPrv(t *testing.T) {
	h := "4755839cb237126c4317a858d85d3837745615b1f67eb20de260416658c43b19"
	prv, e := crypto.HexToECDSA(h)
	t.Log(e)
	pub := prv.PublicKey
	pbytes := elliptic.Marshal(pub.Curve, pub.X, pub.Y)
	nodeid := pbytes[1:]
	t.Log(crypto.PubkeyToAddress(pub).Hex())
	t.Log(h)
	t.Log(hex.EncodeToString(nodeid))
	//f9cf4fdc53ce5ecf84e7c26fbe262bddd7cbf3d17593328f74816a1c646a0ccfac9a85d81f7d51b59bc02dc8f0e8c5dada4db081efd79698a820faf9384773c0
}

func TestKeyAddressExange(t *testing.T) {
	nodekey := "6188edbba7ba30e7c29f314fea016937816598c8d43a903dabea58bef189d09a"
	prv, _ := crypto.HexToECDSA(nodekey)
	target := "bff277e91e8adeff5c39bb5969f7c8d9be27db76cb61080dc1f1b98601029eb69912731717580dfc140fe331a7953fcba211d59b1d2b086fb669dbdedbf1f717"
	pub := prv.PublicKey
	pbytes := elliptic.Marshal(pub.Curve, pub.X, pub.Y)
	t.Log(pbytes)
	nodeid := pbytes[1:]
	t.Log("---------------")
	t.Log(target)
	t.Log(hex.EncodeToString(nodeid))
	t.Logf("%x\n", nodeid)
	t.Log(hex.EncodeToString(nodeid) == target)
	pub2 := new(ecdsa.PublicKey)
	pub2.Curve = pub.Curve
	tb, _ := hex.DecodeString(target)
	tb = append([]byte{4}, tb...)
	t.Log(tb)
	pub2.X, pub2.Y = elliptic.Unmarshal(pub.Curve, tb)
	t.Log(pub)
	t.Log(pub2)
}

func TestExtra(t *testing.T) {
	extra := []byte("0xd68301000083736d6386676f312e31328664617277696e00000000000000000009b5bd71d0cababfc178e89f63210d322675d53d16bdb58ce5741e06d78f60bd4e2e517089c35d9e278bd6bbf52b6f77746ff314c6cf3237a27209a3e922035300")
	t.Log(len(extra))
}

func TestAccumulateRewards(t *testing.T) {
	db, _ := ethdb.NewMemDatabase()
	state, _ := state.New(common.Hash{}, state.NewDatabase(db))
	config := params.DevnetChainConfig
	header := &types.Header{
		Coinbase: common.HexToAddress("0x01"),
	}
	//noreward
	expectReward := big.NewInt(0)
	header.Number = new(big.Int).Set(config.Chief100Block)
	header.Number.Sub(header.Number, big.NewInt(1))
	accumulateRewards(config, state, header)
	if state.GetBalance(header.Coinbase).Cmp(expectReward) != 0 {
		t.Error("should no reward before chief100Block")
		return
	}

	//full reward
	expectReward.Add(expectReward, Chief100BlockReward)
	header.Number = new(big.Int).Set(config.Chief100Block)
	accumulateRewards(config, state, header)
	if state.GetBalance(header.Coinbase).Cmp(expectReward) != 0 {
		t.Errorf("should get total reward=%s,but got=%s", expectReward, state.GetBalance(header.Coinbase))
		return
	}

	//half reward
	currentReward := new(big.Int).Set(Chief100BlockReward)
	currentReward = currentReward.Div(currentReward, big.NewInt(2))
	expectReward = expectReward.Add(expectReward, currentReward)
	header.Number = new(big.Int).Set(config.Chief100Block)
	header.Number = header.Number.Add(header.Number, big.NewInt(int64(BlockRewardReducedInterval)))
	accumulateRewards(config, state, header)
	if state.GetBalance(header.Coinbase).Cmp(expectReward) != 0 {
		t.Errorf("should get total reward=%s,but got=%s", expectReward, state.GetBalance(header.Coinbase))
		return
	}

	//1/4 reward
	currentReward = new(big.Int).Set(Chief100BlockReward)
	currentReward.Div(currentReward, big.NewInt(4))
	expectReward.Add(expectReward, currentReward)
	header.Number = new(big.Int).Set(config.Chief100Block)
	header.Number = header.Number.Add(header.Number, big.NewInt(int64(BlockRewardReducedInterval*2)))
	accumulateRewards(config, state, header)
	if state.GetBalance(header.Coinbase).Cmp(expectReward) != 0 {
		t.Errorf("should get total reward=%s,but got=%s", expectReward, state.GetBalance(header.Coinbase))
		return
	}
}

func TestTribeStatus_destroySmartMeshFoundation12Balance(t *testing.T) {
	db, _ := ethdb.NewMemDatabase()
	state, _ := state.New(common.Hash{}, state.NewDatabase(db))
	config := params.MainnetChainConfig
	header := &types.Header{
		Coinbase: common.HexToAddress("0x01"),
		Number:   config.Chief100Block,
	}
	b := new(big.Int).Set(SmartMeshFoundationAccountDestroyBalance)
	curBalance := b.Mul(b, big.NewInt(2))

	config.Chief100Block = big.NewInt(300000)
	header.Number = config.Chief100Block
	state.AddBalance(SmartMeshFoundationAccount, big.NewInt(3000))
	destroySmartMeshFoundation12Balance(config, state, header)
	nb := state.GetBalance(SmartMeshFoundationAccount)
	if nb.Cmp(big.NewInt(0)) != 0 {
		t.Error("destroy all inf not enough")
		return
	}

	state.AddBalance(SmartMeshFoundationAccount, curBalance)
	destroySmartMeshFoundation12Balance(config, state, header)
	nb = state.GetBalance(SmartMeshFoundationAccount)
	left := curBalance.Div(curBalance, big.NewInt(2))
	if nb.Cmp(left) != 0 {
		t.Error("should only half left")
		return
	}
}