You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
628 lines
22 KiB
628 lines
22 KiB
package services
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/ecdsa"
|
|
"encoding/json"
|
|
"fmt"
|
|
"math/big"
|
|
"strings"
|
|
"testing"
|
|
|
|
common2 "github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/harmony-one/harmony/crypto/bls"
|
|
"github.com/harmony-one/harmony/internal/common"
|
|
"github.com/harmony-one/harmony/numeric"
|
|
|
|
"github.com/coinbase/rosetta-sdk-go/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
hmytypes "github.com/harmony-one/harmony/core/types"
|
|
stakingTypes "github.com/harmony-one/harmony/staking/types"
|
|
"github.com/harmony-one/harmony/test/helpers"
|
|
)
|
|
|
|
func TestUnpackWrappedTransactionFromString(t *testing.T) {
|
|
refKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
refAddr := crypto.PubkeyToAddress(refKey.PublicKey)
|
|
refAddrID, rosettaError := newAccountIdentifier(refAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
refEstGasUsed := big.NewInt(100000)
|
|
signer := hmytypes.NewEIP155Signer(big.NewInt(0))
|
|
|
|
// Test plain transactions
|
|
tx, err := helpers.CreateTestTransaction(
|
|
signer, 0, 1, 2, refEstGasUsed.Uint64(), gasPrice, big.NewInt(1e10), []byte{0x01, 0x02},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
buf := &bytes.Buffer{}
|
|
if err := tx.EncodeRLP(buf); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wrappedTransaction := WrappedTransaction{
|
|
RLPBytes: buf.Bytes(),
|
|
From: refAddrID,
|
|
IsStaking: false,
|
|
}
|
|
marshalledBytes, err := json.Marshal(wrappedTransaction)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
testWrappedTx, testTx, rosettaError := unpackWrappedTransactionFromString(string(marshalledBytes), true)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if types.Hash(tx) != types.Hash(testTx) {
|
|
t.Error("unwrapped tx does not match reference tx")
|
|
}
|
|
if types.Hash(testWrappedTx) != types.Hash(wrappedTransaction) {
|
|
t.Error("unwrapped tx struct does not matched reference tx struct")
|
|
}
|
|
|
|
// Test staking transactions
|
|
receiverKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatalf(err.Error())
|
|
}
|
|
stx, err := helpers.CreateTestStakingTransaction(func() (stakingTypes.Directive, interface{}) {
|
|
return stakingTypes.DirectiveDelegate, stakingTypes.Delegate{
|
|
DelegatorAddress: refAddr,
|
|
ValidatorAddress: crypto.PubkeyToAddress(receiverKey.PublicKey),
|
|
Amount: tenOnes,
|
|
}
|
|
}, refKey, 10, refEstGasUsed.Uint64(), gasPrice)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
buf = &bytes.Buffer{}
|
|
if err := stx.EncodeRLP(buf); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wrappedTransaction.RLPBytes = buf.Bytes()
|
|
wrappedTransaction.IsStaking = true
|
|
marshalledBytes, err = json.Marshal(wrappedTransaction)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
testWrappedTx, testStx, rosettaError := unpackWrappedTransactionFromString(string(marshalledBytes), true)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if types.Hash(testStx) != types.Hash(stx) {
|
|
t.Error("unwrapped tx does not match reference tx")
|
|
}
|
|
if types.Hash(testWrappedTx) != types.Hash(wrappedTransaction) {
|
|
t.Error("unwrapped tx struct does not matched reference tx struct")
|
|
}
|
|
|
|
// Test invalid marshall
|
|
marshalledBytesFail := marshalledBytes[:]
|
|
marshalledBytesFail[0] = 0x0
|
|
_, _, rosettaError = unpackWrappedTransactionFromString(string(marshalledBytesFail), true)
|
|
if rosettaError == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
|
|
// test invalid RLP encoding for staking
|
|
wrappedTransaction.RLPBytes = []byte{0x0}
|
|
marshalledBytesFail, err = json.Marshal(wrappedTransaction)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _, rosettaError = unpackWrappedTransactionFromString(string(marshalledBytesFail), true)
|
|
if rosettaError == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
|
|
// test invalid RLP encoding for plain
|
|
wrappedTransaction.IsStaking = false
|
|
marshalledBytesFail, err = json.Marshal(wrappedTransaction)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _, rosettaError = unpackWrappedTransactionFromString(string(marshalledBytesFail), true)
|
|
if rosettaError == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
|
|
// test invalid nil RLP
|
|
wrappedTransaction.RLPBytes = nil
|
|
marshalledBytesFail, err = json.Marshal(wrappedTransaction)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _, rosettaError = unpackWrappedTransactionFromString(string(marshalledBytesFail), true)
|
|
if rosettaError == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
|
|
// test invalid from address
|
|
wrappedTransaction.RLPBytes = buf.Bytes()
|
|
wrappedTransaction.From = nil
|
|
marshalledBytesFail, err = json.Marshal(wrappedTransaction)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, _, rosettaError = unpackWrappedTransactionFromString(string(marshalledBytesFail), true)
|
|
if rosettaError == nil {
|
|
t.Fatal("expected error")
|
|
}
|
|
}
|
|
|
|
func TestRecoverSenderAddressFromCreateValidatorString(t *testing.T) {
|
|
key, err := crypto.HexToECDSA("4edef2c24995d15b0e25cbd152fb0e2c05d3b79b9c2afd134e6f59f91bf99e48")
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
stakingTransaction, expectedPayload, err := stakingCreateValidatorTransaction(key)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
address, err := stakingTransaction.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
|
|
_, tx, rosettaError := unpackWrappedTransactionFromString("{\"rlp_bytes\":\"+QExgPkBIJQLWF+NrvvGijEfvUyyDZF0rRdAFvg4hUFsaWNlhWFsaWNlkWFsaWNlLmhhcm1vbnkub25lg0JvYpVEb24ndCBtZXNzIHdpdGggbWUhISHdyYgBY0V4XYoAAMmIDH1xO0naAADIh7GivC7FAACIiscjBInoAACJoqFdCVGb4AAA8bAwssOLExbakeBorDvYdRwJAe9sAqHVi8cSEEkYMCxu0D1YlGcdDIFtrStNMDMg8gL4YrhgaPgAtq32V7Z0kD4EcIBgkSuJO3x7UAeIgIJHVQqz4YblakTr88pIj47RpC9s7zoEvV0rK361p2eEjTE1s2LmaM5rukLHudVmbY46g75we1cI5yLFiTn+mwfBcPO3BiQUiQVrx14tYxAAAICEdzWUAIOhvkCAgIA=\",\"is_staking\":true,\"contract_code\":\"0x\",\"from\":{\"address\":\"one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9\",\"metadata\":{\"hex_address\":\"0xeBCD16e8c1D8f493bA04E99a56474122D81A9c58\"}}}", false)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
stakingTx, ok := tx.(*stakingTypes.StakingTransaction)
|
|
|
|
if !ok {
|
|
t.Fatal()
|
|
}
|
|
sig, err := hexutil.Decode("0x5ee37d4f19016a7ba6eef5dad74f0214ecfb73feda46dd263c3dd0ed54f9d4f60d78033196f148b2a005fe0c1af9afbb0e6f087075f1c9addb3ec8d7d2b6b16600")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
stakingTx, err = stakingTx.WithSignature(signer, sig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
v, r, s := stakingTransaction.RawSignatureValues()
|
|
v1, r1, s1 := stakingTx.RawSignatureValues()
|
|
if v.String() != v1.String() || r.String() != r1.String() || s.String() != s1.String() {
|
|
t.Log(stakingTransaction.RawSignatureValues())
|
|
t.Log(stakingTx.RawSignatureValues())
|
|
t.Fatal("signature error")
|
|
}
|
|
|
|
if expectedPayload != signer.Hash(stakingTx) {
|
|
t.Error("payload error")
|
|
}
|
|
|
|
address, err = stakingTx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
}
|
|
|
|
func TestRecoverSenderAddressFromEditValidatorString(t *testing.T) {
|
|
key, err := crypto.HexToECDSA("4edef2c24995d15b0e25cbd152fb0e2c05d3b79b9c2afd134e6f59f91bf99e48")
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
stakingTransaction, expectedPayload, err := stakingEditValidatorTransaction(key)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
address, err := stakingTransaction.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
|
|
// todo to correct rlp bytes
|
|
_, tx, rosettaError := unpackWrappedTransactionFromString("{\"rlp_bytes\":\"+QFBAfkBMZTrzRbowdj0k7oE6ZpWR0Ei2BqcWPg4hUFsaWNlhWFsaWNlkWFsaWNlLmhhcm1vbnkub25lg0JvYpVEb24ndCBtZXNzIHdpdGggbWUhISHJiAFjRXhdigAAiIrHIwSJ6AAAiaKhXQlRm+AAALAwssOLExbakeBorDvYdRwJAe9sAqHVi8cSEEkYMCxu0D1YlGcdDIFtrStNMDMg8gKwMLLDixMW2pHgaKw72HUcCQHvbAKh1YvHEhBJGDAsbtA9WJRnHQyBba0rTTAzIPICuGBo+AC2rfZXtnSQPgRwgGCRK4k7fHtQB4iAgkdVCrPhhuVqROvzykiPjtGkL2zvOgS9XSsrfrWnZ4SNMTWzYuZozmu6Qse51WZtjjqDvnB7VwjnIsWJOf6bB8Fw87cGJBSAgIR3NZQAgqQQgICA\",\"is_staking\":true,\"contract_code\":\"0x\",\"from\":{\"address\":\"one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9\",\"metadata\":{\"hex_address\":\"0xeBCD16e8c1D8f493bA04E99a56474122D81A9c58\"}}}", false)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
stakingTx, ok := tx.(*stakingTypes.StakingTransaction)
|
|
if !ok {
|
|
t.Fatal()
|
|
}
|
|
sig, err := hexutil.Decode("0xe7d6edf1fc99806533bb2c5c5ece5873ddbf391c58ab2b839afb0770d86d70df6ccb4727afa97b0f26bec18dbb6bf287ef93867b2129af2d2a9bcced735d79f400")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
stakingTx, err = stakingTx.WithSignature(signer, sig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v, r, s := stakingTransaction.RawSignatureValues()
|
|
v1, r1, s1 := stakingTx.RawSignatureValues()
|
|
if v.String() != v1.String() || r.String() != r1.String() || s.String() != s1.String() {
|
|
t.Log(stakingTransaction.RawSignatureValues())
|
|
t.Log(stakingTx.RawSignatureValues())
|
|
t.Fatal("signature error")
|
|
}
|
|
|
|
if expectedPayload != signer.Hash(stakingTx) {
|
|
t.Error("payload error")
|
|
}
|
|
|
|
address, err = stakingTx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
}
|
|
|
|
func TestRecoverSenderAddressFromDelegateString(t *testing.T) {
|
|
key, err := crypto.HexToECDSA("4edef2c24995d15b0e25cbd152fb0e2c05d3b79b9c2afd134e6f59f91bf99e48")
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
stakingTransaction, expectedPayload, err := stakingDelegateTransaction(key)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
address, err := stakingTransaction.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
|
|
_, tx, rosettaError := unpackWrappedTransactionFromString("{\"rlp_bytes\":\"+EEC85TrzRbowdj0k7oE6ZpWR0Ei2BqcWJTrzRbowdj0k7oE6ZpWR0Ei2BqcWIiKxyMEiegAAICEdzWUAIKkEICAgA==\",\"is_staking\":true,\"contract_code\":\"0x\",\"from\":{\"address\":\"one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9\",\"metadata\":{\"hex_address\":\"0xeBCD16e8c1D8f493bA04E99a56474122D81A9c58\"}}}", false)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
stakingTx, ok := tx.(*stakingTypes.StakingTransaction)
|
|
if !ok {
|
|
t.Fatal()
|
|
}
|
|
sig, err := hexutil.Decode("0xfcfdda6ac52e81c5a4f53628588cd7fb2b0da40fb42f26472329698522230ca759fd3ba51b4078cc2b2370253688f1cc7f16706e897bf9fee0c1e7369f22dbf500")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
stakingTx, err = stakingTx.WithSignature(signer, sig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v, r, s := stakingTransaction.RawSignatureValues()
|
|
v1, r1, s1 := stakingTx.RawSignatureValues()
|
|
if v.String() != v1.String() || r.String() != r1.String() || s.String() != s1.String() {
|
|
t.Log(stakingTransaction.RawSignatureValues())
|
|
t.Log(stakingTx.RawSignatureValues())
|
|
t.Fatal("signature error")
|
|
}
|
|
|
|
if expectedPayload != signer.Hash(stakingTx) {
|
|
t.Error("payload error")
|
|
}
|
|
|
|
address, err = stakingTx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
}
|
|
|
|
func TestRecoverSenderAddressFromUndelegateString(t *testing.T) {
|
|
key, err := crypto.HexToECDSA("4edef2c24995d15b0e25cbd152fb0e2c05d3b79b9c2afd134e6f59f91bf99e48")
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
stakingTransaction, expectedPayload, err := stakingUndelegateTransaction(key)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
address, err := stakingTransaction.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
_, tx, rosettaError := unpackWrappedTransactionFromString("{\"rlp_bytes\":\"+EED85TrzRbowdj0k7oE6ZpWR0Ei2BqcWJTrzRbowdj0k7oE6ZpWR0Ei2BqcWIiKxyMEiegAAICEdzWUAIJSCICAgA==\",\"is_staking\":true,\"contract_code\":\"0x\",\"from\":{\"address\":\"one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9\",\"metadata\":{\"hex_address\":\"0xeBCD16e8c1D8f493bA04E99a56474122D81A9c58\"}}}", false)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
stakingTx, ok := tx.(*stakingTypes.StakingTransaction)
|
|
if !ok {
|
|
t.Fatal()
|
|
}
|
|
sig, err := hexutil.Decode("0xb24e011d4013f0101a68ee0a6181e311fab6f65b768623f4ef8c6d5e429b507e3ce5dd52f3e85ae969854f7ac36a2ac74fe2d779ac9a9d8f38a64f683565980e00")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
stakingTx, err = stakingTx.WithSignature(signer, sig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v, r, s := stakingTransaction.RawSignatureValues()
|
|
v1, r1, s1 := stakingTx.RawSignatureValues()
|
|
if v.String() != v1.String() || r.String() != r1.String() || s.String() != s1.String() {
|
|
t.Log(stakingTransaction.RawSignatureValues())
|
|
t.Log(stakingTx.RawSignatureValues())
|
|
t.Fatal("signature error")
|
|
}
|
|
|
|
if expectedPayload != signer.Hash(stakingTx) {
|
|
t.Error("payload error")
|
|
}
|
|
|
|
address, err = stakingTx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
}
|
|
|
|
func TestRecoverSenderAddressFromCollectRewardsString(t *testing.T) {
|
|
key, err := crypto.HexToECDSA("4edef2c24995d15b0e25cbd152fb0e2c05d3b79b9c2afd134e6f59f91bf99e48")
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
stakingTransaction, expectedPayload, err := stakingCollectRewardsTransaction(key)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
address, err := stakingTransaction.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
|
|
_, tx, rosettaError := unpackWrappedTransactionFromString("{\"rlp_bytes\":\"4wTVlOvNFujB2PSTugTpmlZHQSLYGpxYgIR3NZQAglIIgICA\",\"is_staking\":true,\"contract_code\":\"0x\",\"from\":{\"address\":\"one13lx3exmpfc446vsguc5d0mtgha2ff7h5uz85pk\",\"metadata\":{\"hex_address\":\"0x8fCD1C9B614E2b5D3208E628d7eD68bF5494faF4\"}}}", false)
|
|
if rosettaError != nil {
|
|
a, _ := json.Marshal(rosettaError)
|
|
fmt.Println(string(a))
|
|
t.Fatal(rosettaError)
|
|
}
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
stakingTx, ok := tx.(*stakingTypes.StakingTransaction)
|
|
if !ok {
|
|
t.Fatal()
|
|
}
|
|
sig, err := hexutil.Decode("0x13f25e40cf5cadf9ae68a318b216de52dc97ec423f581a36defccbdd31870cc26c66872f9f543246d0da7ee6b48d7e11e5034227795e80a5c1e95ac68a2a024500")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
stakingTx, err = stakingTx.WithSignature(signer, sig)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
v, r, s := stakingTransaction.RawSignatureValues()
|
|
v1, r1, s1 := stakingTx.RawSignatureValues()
|
|
if v.String() != v1.String() || r.String() != r1.String() || s.String() != s1.String() {
|
|
t.Log(stakingTransaction.RawSignatureValues())
|
|
t.Log(stakingTx.RawSignatureValues())
|
|
t.Fatal("signature error")
|
|
}
|
|
|
|
if expectedPayload != signer.Hash(stakingTx) {
|
|
t.Error("payload error")
|
|
}
|
|
|
|
address, err = stakingTx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
|
|
if strings.ToLower(hexutil.Encode(address[:])) != "0xebcd16e8c1d8f493ba04e99a56474122d81a9c58" {
|
|
t.Fatal("address error")
|
|
}
|
|
}
|
|
|
|
func stakingCreateValidatorTransaction(key *ecdsa.PrivateKey) (*stakingTypes.StakingTransaction, common2.Hash, error) {
|
|
var pub bls.SerializedPublicKey
|
|
pubb, err := hexutil.Decode("0x30b2c38b1316da91e068ac3bd8751c0901ef6c02a1d58bc712104918302c6ed03d5894671d0c816dad2b4d303320f202")
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
copy(pub[:], pubb)
|
|
|
|
var sig bls.SerializedSignature
|
|
sigg, err := hexutil.Decode("0x68f800b6adf657b674903e04708060912b893b7c7b500788808247550ab3e186e56a44ebf3ca488f8ed1a42f6cef3a04bd5d2b2b7eb5a767848d3135b362e668ce6bba42c7b9d5666d8e3a83be707b5708e722c58939fe9b07c170f3b7062414")
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
copy(sig[:], sigg)
|
|
validator, _ := common.Bech32ToAddress("one1pdv9lrdwl0rg5vglh4xtyrv3wjk3wsqket7zxy")
|
|
stakePayloadMaker := func() (stakingTypes.Directive, interface{}) {
|
|
return stakingTypes.DirectiveCreateValidator, stakingTypes.CreateValidator{
|
|
Description: stakingTypes.Description{
|
|
Name: "Alice",
|
|
Identity: "alice",
|
|
Website: "alice.harmony.one",
|
|
SecurityContact: "Bob",
|
|
Details: "Don't mess with me!!!",
|
|
},
|
|
CommissionRates: stakingTypes.CommissionRates{
|
|
Rate: numeric.Dec{Int: new(big.Int).SetUint64(100000000000000000)},
|
|
MaxRate: numeric.Dec{Int: new(big.Int).SetUint64(900000000000000000)},
|
|
MaxChangeRate: numeric.Dec{Int: new(big.Int).SetUint64(50000000000000000)},
|
|
},
|
|
MinSelfDelegation: new(big.Int).Mul(new(big.Int).SetInt64(10), big.NewInt(1e18)),
|
|
MaxTotalDelegation: new(big.Int).Mul(new(big.Int).SetInt64(3000), big.NewInt(1e18)),
|
|
ValidatorAddress: validator,
|
|
SlotPubKeys: []bls.SerializedPublicKey{pub},
|
|
SlotKeySigs: []bls.SerializedSignature{sig},
|
|
Amount: new(big.Int).Mul(new(big.Int).SetInt64(100), big.NewInt(1e18)),
|
|
}
|
|
}
|
|
|
|
gasPrice := big.NewInt(2000000000)
|
|
tx, _ := stakingTypes.NewStakingTransaction(0, 10600000, gasPrice, stakePayloadMaker)
|
|
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
signingPayload := signer.Hash(tx)
|
|
|
|
stakingTransaction, err := stakingTypes.Sign(tx, signer, key)
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
|
|
return stakingTransaction, signingPayload, nil
|
|
}
|
|
|
|
func stakingEditValidatorTransaction(key *ecdsa.PrivateKey) (*stakingTypes.StakingTransaction, common2.Hash, error) {
|
|
stakePayloadMaker := func() (stakingTypes.Directive, interface{}) {
|
|
var slotKeyToRemove bls.SerializedPublicKey
|
|
removeBytes, _ := hexutil.Decode("0x30b2c38b1316da91e068ac3bd8751c0901ef6c02a1d58bc712104918302c6ed03d5894671d0c816dad2b4d303320f202")
|
|
copy(slotKeyToRemove[:], removeBytes)
|
|
|
|
var slotKeyToAdd bls.SerializedPublicKey
|
|
addBytes, _ := hexutil.Decode("0x30b2c38b1316da91e068ac3bd8751c0901ef6c02a1d58bc712104918302c6ed03d5894671d0c816dad2b4d303320f202")
|
|
copy(slotKeyToAdd[:], addBytes)
|
|
|
|
var slotKeyToAddSig bls.SerializedSignature
|
|
sigBytes, _ := hexutil.Decode("0x68f800b6adf657b674903e04708060912b893b7c7b500788808247550ab3e186e56a44ebf3ca488f8ed1a42f6cef3a04bd5d2b2b7eb5a767848d3135b362e668ce6bba42c7b9d5666d8e3a83be707b5708e722c58939fe9b07c170f3b7062414")
|
|
copy(slotKeyToAddSig[:], sigBytes)
|
|
|
|
validator, _ := common.Bech32ToAddress("one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9")
|
|
|
|
return stakingTypes.DirectiveEditValidator, stakingTypes.EditValidator{
|
|
Description: stakingTypes.Description{
|
|
Name: "Alice",
|
|
Identity: "alice",
|
|
Website: "alice.harmony.one",
|
|
SecurityContact: "Bob",
|
|
Details: "Don't mess with me!!!",
|
|
},
|
|
CommissionRate: &numeric.Dec{Int: new(big.Int).SetUint64(100000000000000000)},
|
|
MinSelfDelegation: new(big.Int).Mul(new(big.Int).SetInt64(10), big.NewInt(1e18)),
|
|
MaxTotalDelegation: new(big.Int).Mul(new(big.Int).SetInt64(3000), big.NewInt(1e18)),
|
|
SlotKeyToRemove: &slotKeyToRemove,
|
|
SlotKeyToAdd: &slotKeyToAdd,
|
|
SlotKeyToAddSig: &slotKeyToAddSig,
|
|
ValidatorAddress: validator,
|
|
}
|
|
}
|
|
|
|
gasPrice := big.NewInt(2000000000)
|
|
tx, _ := stakingTypes.NewStakingTransaction(0, 42000, gasPrice, stakePayloadMaker)
|
|
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
signingPayload := signer.Hash(tx)
|
|
|
|
stakingTransaction, err := stakingTypes.Sign(tx, signer, key)
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
|
|
return stakingTransaction, signingPayload, nil
|
|
}
|
|
|
|
func stakingDelegateTransaction(key *ecdsa.PrivateKey) (*stakingTypes.StakingTransaction, common2.Hash, error) {
|
|
stakePayloadMaker := func() (stakingTypes.Directive, interface{}) {
|
|
|
|
validator, _ := common.Bech32ToAddress("one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9")
|
|
delegator, _ := common.Bech32ToAddress("one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9")
|
|
return stakingTypes.DirectiveDelegate, stakingTypes.Delegate{
|
|
ValidatorAddress: validator,
|
|
DelegatorAddress: delegator,
|
|
Amount: new(big.Int).Mul(new(big.Int).SetInt64(10), big.NewInt(1e18)),
|
|
}
|
|
}
|
|
|
|
gasPrice := big.NewInt(2000000000)
|
|
tx, _ := stakingTypes.NewStakingTransaction(0, 42000, gasPrice, stakePayloadMaker)
|
|
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
signingPayload := signer.Hash(tx)
|
|
|
|
stakingTransaction, err := stakingTypes.Sign(tx, signer, key)
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
return stakingTransaction, signingPayload, nil
|
|
}
|
|
|
|
func stakingUndelegateTransaction(key *ecdsa.PrivateKey) (*stakingTypes.StakingTransaction, common2.Hash, error) {
|
|
stakePayloadMaker := func() (stakingTypes.Directive, interface{}) {
|
|
|
|
validator, _ := common.Bech32ToAddress("one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9")
|
|
delegator, _ := common.Bech32ToAddress("one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9")
|
|
return stakingTypes.DirectiveUndelegate, stakingTypes.Undelegate{
|
|
ValidatorAddress: validator,
|
|
DelegatorAddress: delegator,
|
|
Amount: new(big.Int).Mul(new(big.Int).SetInt64(10), big.NewInt(1e18)),
|
|
}
|
|
}
|
|
|
|
gasPrice := big.NewInt(2000000000)
|
|
tx, _ := stakingTypes.NewStakingTransaction(0, 21000, gasPrice, stakePayloadMaker)
|
|
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
signingPayload := signer.Hash(tx)
|
|
|
|
stakingTransaction, err := stakingTypes.Sign(tx, signer, key)
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
return stakingTransaction, signingPayload, nil
|
|
}
|
|
|
|
func stakingCollectRewardsTransaction(key *ecdsa.PrivateKey) (*stakingTypes.StakingTransaction, common2.Hash, error) {
|
|
stakePayloadMaker := func() (stakingTypes.Directive, interface{}) {
|
|
|
|
delegator, _ := common.Bech32ToAddress("one1a0x3d6xpmr6f8wsyaxd9v36pytvp48zckswvv9")
|
|
return stakingTypes.DirectiveCollectRewards, stakingTypes.CollectRewards{
|
|
DelegatorAddress: delegator,
|
|
}
|
|
}
|
|
|
|
gasPrice := big.NewInt(2000000000)
|
|
tx, _ := stakingTypes.NewStakingTransaction(0, 21000, gasPrice, stakePayloadMaker)
|
|
|
|
signer := stakingTypes.NewEIP155Signer(new(big.Int).SetUint64(1))
|
|
signingPayload := signer.Hash(tx)
|
|
|
|
stakingTransaction, err := stakingTypes.Sign(tx, signer, key)
|
|
if err != nil {
|
|
return nil, common2.Hash{}, err
|
|
}
|
|
return stakingTransaction, signingPayload, nil
|
|
}
|
|
|