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.
431 lines
14 KiB
431 lines
14 KiB
package services
|
|
|
|
import (
|
|
"crypto/ecdsa"
|
|
"fmt"
|
|
"math/big"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/coinbase/rosetta-sdk-go/types"
|
|
ethcommon "github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
|
|
hmytypes "github.com/harmony-one/harmony/core/types"
|
|
"github.com/harmony-one/harmony/hmy"
|
|
"github.com/harmony-one/harmony/internal/params"
|
|
"github.com/harmony-one/harmony/rosetta/common"
|
|
stakingTypes "github.com/harmony-one/harmony/staking/types"
|
|
"github.com/harmony-one/harmony/test/helpers"
|
|
)
|
|
|
|
// Invariant: A transaction can only contain 1 type of native operation(s) other than gas expenditure.
|
|
func assertNativeOperationTypeUniquenessInvariant(operations []*types.Operation) error {
|
|
foundType := ""
|
|
for _, op := range operations {
|
|
if op.Type == common.ExpendGasOperation {
|
|
continue
|
|
}
|
|
if foundType == "" {
|
|
foundType = op.Type
|
|
}
|
|
if op.Type != foundType {
|
|
return fmt.Errorf("found more than 1 type in given set of operations")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Note that this test only checks the general format of each type transaction on Harmony.
|
|
// The detailed operation checks for each type of transaction is done in separate unit tests.
|
|
func TestFormatTransactionIntegration(t *testing.T) {
|
|
gasLimit := uint64(1e18)
|
|
gasUsed := uint64(1e5)
|
|
senderKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatalf(err.Error())
|
|
}
|
|
receiverKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatalf(err.Error())
|
|
}
|
|
|
|
testFormatStakingTransaction(t, gasLimit, gasUsed, senderKey, receiverKey)
|
|
testFormatPlainTransaction(t, gasLimit, gasUsed, senderKey, receiverKey)
|
|
// Note that cross-shard receiver operations/transactions are formatted via
|
|
// FormatCrossShardReceiverTransaction, thus, it is not tested here -- but tested on its own.
|
|
testFormatCrossShardSenderTransaction(t, gasLimit, gasUsed, senderKey, receiverKey)
|
|
}
|
|
|
|
func testFormatStakingTransaction(
|
|
t *testing.T, gasLimit, gasUsed uint64, senderKey, receiverKey *ecdsa.PrivateKey,
|
|
) {
|
|
senderAddr := crypto.PubkeyToAddress(senderKey.PublicKey)
|
|
receiverAddr := crypto.PubkeyToAddress(receiverKey.PublicKey)
|
|
tx, err := helpers.CreateTestStakingTransaction(func() (stakingTypes.Directive, interface{}) {
|
|
return stakingTypes.DirectiveDelegate, stakingTypes.Delegate{
|
|
DelegatorAddress: senderAddr,
|
|
ValidatorAddress: receiverAddr,
|
|
Amount: tenOnes,
|
|
}
|
|
}, senderKey, 0, gasLimit, gasPrice)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAccID, rosettaError := newAccountIdentifier(senderAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
|
|
receipt := &hmytypes.Receipt{
|
|
Status: hmytypes.ReceiptStatusSuccessful,
|
|
GasUsed: gasUsed,
|
|
}
|
|
rosettaTx, rosettaError := FormatTransaction(tx, receipt)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
|
|
if len(rosettaTx.Operations) != 2 {
|
|
t.Error("Expected 2 operations")
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(rosettaTx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rosettaTx.TransactionIdentifier.Hash != tx.Hash().String() {
|
|
t.Error("Invalid transaction")
|
|
}
|
|
if rosettaTx.Operations[0].Type != common.ExpendGasOperation {
|
|
t.Error("Expected 1st operation to be gas type")
|
|
}
|
|
if rosettaTx.Operations[1].Type != tx.StakingType().String() {
|
|
t.Error("Expected 2nd operation to be staking type")
|
|
}
|
|
if reflect.DeepEqual(rosettaTx.Operations[1].Metadata, map[string]interface{}{}) {
|
|
t.Error("Expected staking operation to have some metadata")
|
|
}
|
|
if !reflect.DeepEqual(rosettaTx.Metadata, map[string]interface{}{}) {
|
|
t.Error("Expected transaction to have no metadata")
|
|
}
|
|
if !reflect.DeepEqual(rosettaTx.Operations[0].Account, senderAccID) {
|
|
t.Error("Expected sender to pay gas fee")
|
|
}
|
|
}
|
|
|
|
func testFormatPlainTransaction(
|
|
t *testing.T, gasLimit, gasUsed uint64, senderKey, receiverKey *ecdsa.PrivateKey,
|
|
) {
|
|
// Note that post EIP-155 epoch singer is tested in detailed tests.
|
|
signer := hmytypes.HomesteadSigner{}
|
|
tx, err := helpers.CreateTestTransaction(
|
|
signer, 0, 0, 0, 1e18, gasPrice, big.NewInt(1), []byte("test"),
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAddr, err := tx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAccID, rosettaError := newAccountIdentifier(senderAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
|
|
receipt := &hmytypes.Receipt{
|
|
Status: hmytypes.ReceiptStatusSuccessful,
|
|
GasUsed: gasUsed,
|
|
}
|
|
rosettaTx, rosettaError := FormatTransaction(tx, receipt)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if len(rosettaTx.Operations) != 3 {
|
|
t.Error("Expected 3 operations")
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(rosettaTx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rosettaTx.TransactionIdentifier.Hash != tx.Hash().String() {
|
|
t.Error("Invalid transaction")
|
|
}
|
|
if rosettaTx.Operations[0].Type != common.ExpendGasOperation {
|
|
t.Error("Expected 1st operation to be gas")
|
|
}
|
|
if rosettaTx.Operations[1].Type != common.TransferNativeOperation {
|
|
t.Error("Expected 2nd operation to transfer related")
|
|
}
|
|
if rosettaTx.Operations[1].Metadata != nil {
|
|
t.Error("Expected 1st operation to have no metadata")
|
|
}
|
|
if rosettaTx.Operations[2].Metadata != nil {
|
|
t.Error("Expected 2nd operation to have no metadata")
|
|
}
|
|
if reflect.DeepEqual(rosettaTx.Metadata, map[string]interface{}{}) {
|
|
t.Error("Expected transaction to have some metadata")
|
|
}
|
|
if !reflect.DeepEqual(rosettaTx.Operations[0].Account, senderAccID) {
|
|
t.Error("Expected sender to pay gas fee")
|
|
}
|
|
}
|
|
|
|
func TestFormatGenesisTransaction(t *testing.T) {
|
|
genesisSpec := getGenesisSpec(0)
|
|
testBlkHash := ethcommon.HexToHash("0x1a06b0378d63bf589282c032f0c85b32827e3a2317c2f992f45d8f07d0caa238")
|
|
for acc := range genesisSpec.Alloc {
|
|
txID := getSpecialCaseTransactionIdentifier(testBlkHash, acc, SpecialGenesisTxID)
|
|
tx, rosettaError := FormatGenesisTransaction(txID, acc, 0)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if !reflect.DeepEqual(txID, tx.TransactionIdentifier) {
|
|
t.Error("expected transaction ID of formatted tx to be same as requested")
|
|
}
|
|
if len(tx.Operations) != 1 {
|
|
t.Error("expected exactly 1 operation")
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(tx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if tx.Operations[0].OperationIdentifier.Index != 0 {
|
|
t.Error("expected operational ID to be 0")
|
|
}
|
|
if tx.Operations[0].Type != common.GenesisFundsOperation {
|
|
t.Error("expected operation to be genesis funds operations")
|
|
}
|
|
if tx.Operations[0].Status != common.SuccessOperationStatus.Status {
|
|
t.Error("expected successful operation status")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFormatPreStakingRewardTransactionSuccess(t *testing.T) {
|
|
testKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
|
|
testBlkHash := ethcommon.HexToHash("0x1a06b0378d63bf589282c032f0c85b32827e3a2317c2f992f45d8f07d0caa238")
|
|
testRewards := hmy.PreStakingBlockRewards{
|
|
testAddr: big.NewInt(1),
|
|
}
|
|
refTxID := getSpecialCaseTransactionIdentifier(testBlkHash, testAddr, SpecialPreStakingRewardTxID)
|
|
tx, rosettaError := FormatPreStakingRewardTransaction(refTxID, testRewards, testAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
|
|
if !reflect.DeepEqual(tx.TransactionIdentifier, refTxID) {
|
|
t.Errorf("Expected TxID %v got %v", refTxID, tx.TransactionIdentifier)
|
|
}
|
|
if len(tx.Operations) != 1 {
|
|
t.Fatal("Expected exactly 1 operation")
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(tx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if tx.Operations[0].OperationIdentifier.Index != 0 {
|
|
t.Error("expected operational ID to be 0")
|
|
}
|
|
if tx.Operations[0].Type != common.PreStakingBlockRewardOperation {
|
|
t.Error("expected operation type to be pre-staking era block rewards")
|
|
}
|
|
if tx.Operations[0].Status != common.SuccessOperationStatus.Status {
|
|
t.Error("expected successful operation status")
|
|
}
|
|
}
|
|
|
|
func TestFormatPreStakingRewardTransactionFail(t *testing.T) {
|
|
testKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
|
|
testBlkHash := ethcommon.HexToHash("0x1a06b0378d63bf589282c032f0c85b32827e3a2317c2f992f45d8f07d0caa238")
|
|
testRewards := hmy.PreStakingBlockRewards{
|
|
FormatDefaultSenderAddress: big.NewInt(1),
|
|
}
|
|
testTxID := getSpecialCaseTransactionIdentifier(testBlkHash, testAddr, SpecialPreStakingRewardTxID)
|
|
_, rosettaError := FormatPreStakingRewardTransaction(testTxID, testRewards, testAddr)
|
|
if rosettaError == nil {
|
|
t.Fatal("expected rosetta error")
|
|
}
|
|
if common.TransactionNotFoundError.Code != rosettaError.Code {
|
|
t.Error("expected transaction not found error")
|
|
}
|
|
}
|
|
|
|
func TestFormatUndelegationPayoutTransaction(t *testing.T) {
|
|
testKey, err := crypto.GenerateKey()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
testAddr := crypto.PubkeyToAddress(testKey.PublicKey)
|
|
testPayout := big.NewInt(1e10)
|
|
testDelegatorPayouts := hmy.UndelegationPayouts{
|
|
testAddr: testPayout,
|
|
}
|
|
testBlockHash := ethcommon.HexToHash("0x1a06b0378d63bf589282c032f0c85b32827e3a2317c2f992f45d8f07d0caa238")
|
|
testTxID := getSpecialCaseTransactionIdentifier(testBlockHash, testAddr, SpecialUndelegationPayoutTxID)
|
|
|
|
tx, rosettaError := FormatUndelegationPayoutTransaction(testTxID, testDelegatorPayouts, testAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if len(tx.Operations) != 1 {
|
|
t.Fatal("expected tx operations to be of length 1")
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(tx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if tx.Operations[0].OperationIdentifier.Index != 0 {
|
|
t.Error("Expect first operation to be index 0")
|
|
}
|
|
if tx.Operations[0].Type != common.UndelegationPayoutOperation {
|
|
t.Errorf("Expect operation type to be: %v", common.UndelegationPayoutOperation)
|
|
}
|
|
if tx.Operations[0].Status != common.SuccessOperationStatus.Status {
|
|
t.Error("expected successful operation status")
|
|
}
|
|
if tx.Operations[0].Amount.Value != fmt.Sprintf("%v", testPayout) {
|
|
t.Errorf("expect payout to be %v", testPayout)
|
|
}
|
|
|
|
_, rosettaError = FormatUndelegationPayoutTransaction(testTxID, hmy.UndelegationPayouts{}, testAddr)
|
|
if rosettaError == nil {
|
|
t.Fatal("Expect error for no payouts found")
|
|
}
|
|
if rosettaError.Code != common.TransactionNotFoundError.Code {
|
|
t.Errorf("expect error code %v", common.TransactionNotFoundError.Code)
|
|
}
|
|
}
|
|
|
|
func testFormatCrossShardSenderTransaction(
|
|
t *testing.T, gasLimit, gasUsed uint64, senderKey, receiverKey *ecdsa.PrivateKey,
|
|
) {
|
|
// Note that post EIP-155 epoch singer is tested in detailed tests.
|
|
signer := hmytypes.HomesteadSigner{}
|
|
tx, err := helpers.CreateTestTransaction(
|
|
signer, 0, 1, 0, 1e18, gasPrice, big.NewInt(1), []byte("test"),
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAddr, err := tx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAccID, rosettaError := newAccountIdentifier(senderAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
|
|
receipt := &hmytypes.Receipt{
|
|
Status: hmytypes.ReceiptStatusSuccessful,
|
|
GasUsed: gasUsed,
|
|
}
|
|
rosettaTx, rosettaError := FormatTransaction(tx, receipt)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if len(rosettaTx.Operations) != 2 {
|
|
t.Error("Expected 2 operations")
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(rosettaTx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
if rosettaTx.TransactionIdentifier.Hash != tx.Hash().String() {
|
|
t.Error("Invalid transaction")
|
|
}
|
|
if rosettaTx.Operations[0].Type != common.ExpendGasOperation {
|
|
t.Error("Expected 1st operation to be gas")
|
|
}
|
|
if rosettaTx.Operations[1].Type != common.CrossShardTransferNativeOperation {
|
|
t.Error("Expected 2nd operation to cross-shard transfer related")
|
|
}
|
|
if reflect.DeepEqual(rosettaTx.Operations[1].Metadata, map[string]interface{}{}) {
|
|
t.Error("Expected 1st operation to have metadata")
|
|
}
|
|
if reflect.DeepEqual(rosettaTx.Metadata, map[string]interface{}{}) {
|
|
t.Error("Expected transaction to have some metadata")
|
|
}
|
|
if !reflect.DeepEqual(rosettaTx.Operations[0].Account, senderAccID) {
|
|
t.Error("Expected sender to pay gas fee")
|
|
}
|
|
}
|
|
|
|
func TestFormatCrossShardReceiverTransaction(t *testing.T) {
|
|
signer := hmytypes.NewEIP155Signer(params.TestChainConfig.ChainID)
|
|
tx, err := helpers.CreateTestTransaction(
|
|
signer, 0, 1, 0, 1e18, gasPrice, big.NewInt(1), []byte{},
|
|
)
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAddr, err := tx.SenderAddress()
|
|
if err != nil {
|
|
t.Fatal(err.Error())
|
|
}
|
|
senderAccID, rosettaError := newAccountIdentifier(senderAddr)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
receiverAccID, rosettaError := newAccountIdentifier(*tx.To())
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
cxReceipt := &hmytypes.CXReceipt{
|
|
TxHash: tx.Hash(),
|
|
From: senderAddr,
|
|
To: tx.To(),
|
|
ShardID: 0,
|
|
ToShardID: 1,
|
|
Amount: tx.Value(),
|
|
}
|
|
opMetadata, err := types.MarshalMap(common.CrossShardTransactionOperationMetadata{
|
|
From: senderAccID,
|
|
To: receiverAccID,
|
|
})
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
refCxID := &types.TransactionIdentifier{Hash: tx.Hash().String()}
|
|
refOperations := []*types.Operation{
|
|
{
|
|
OperationIdentifier: &types.OperationIdentifier{
|
|
Index: 0, // There is no gas expenditure for cross-shard payout
|
|
},
|
|
Type: common.CrossShardTransferNativeOperation,
|
|
Status: common.SuccessOperationStatus.Status,
|
|
Account: receiverAccID,
|
|
Amount: &types.Amount{
|
|
Value: fmt.Sprintf("%v", tx.Value().Uint64()),
|
|
Currency: &common.NativeCurrency,
|
|
},
|
|
Metadata: opMetadata,
|
|
},
|
|
}
|
|
to := tx.ToShardID()
|
|
from := tx.ShardID()
|
|
refMetadata, err := types.MarshalMap(TransactionMetadata{
|
|
CrossShardIdentifier: refCxID,
|
|
ToShardID: &to,
|
|
FromShardID: &from,
|
|
})
|
|
refRosettaTx := &types.Transaction{
|
|
TransactionIdentifier: refCxID,
|
|
Operations: refOperations,
|
|
Metadata: refMetadata,
|
|
}
|
|
rosettaTx, rosettaError := FormatCrossShardReceiverTransaction(cxReceipt)
|
|
if rosettaError != nil {
|
|
t.Fatal(rosettaError)
|
|
}
|
|
if !reflect.DeepEqual(rosettaTx, refRosettaTx) {
|
|
t.Errorf("Expected transaction to be %v not %v", refRosettaTx, rosettaTx)
|
|
}
|
|
if err := assertNativeOperationTypeUniquenessInvariant(rosettaTx.Operations); err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|