From e63a11fa8acc30fc2bc2db863c4f1a89c091f901 Mon Sep 17 00:00:00 2001 From: Antonio Mindov Date: Tue, 26 Sep 2023 14:12:16 +0300 Subject: [PATCH] Fix serialization issues - fix auto renew on token create tx - fix return type on system delete tx Signed-off-by: Antonio Mindov --- file_append_transaction.go | 2 +- file_append_transaction_unit_test.go | 29 +++++++++++++++ token_create_transaction.go | 2 +- token_create_transaction_unit_test.go | 11 ++++++ topic_create_transaction.go | 2 +- topic_create_transaction_unit_test.go | 35 +++++++++++++++++++ topic_message_submit_transaction.go | 2 +- topic_message_submit_transaction_unit_test.go | 31 ++++++++++++++++ 8 files changed, 110 insertions(+), 4 deletions(-) diff --git a/file_append_transaction.go b/file_append_transaction.go index 4121e7cc2..a6b1b6a7c 100644 --- a/file_append_transaction.go +++ b/file_append_transaction.go @@ -58,7 +58,7 @@ func _FileAppendTransactionFromProtobuf(transaction Transaction, pb *services.Tr return &FileAppendTransaction{ Transaction: transaction, maxChunks: 20, - contents: make([]byte, 0), + contents: pb.GetFileAppend().GetContents(), chunkSize: 2048, fileID: _FileIDFromProtobuf(pb.GetFileAppend().GetFileID()), } diff --git a/file_append_transaction_unit_test.go b/file_append_transaction_unit_test.go index 073ed822c..b14237d19 100644 --- a/file_append_transaction_unit_test.go +++ b/file_append_transaction_unit_test.go @@ -363,3 +363,32 @@ func TestUnitFileAppendTransactionCoverage(t *testing.T) { b.AddSignature(newKey.PublicKey(), sig) } } + +func TestUnitFileAppendTransactionSerialization(t *testing.T) { + t.Parallel() + + fileID := FileID{File: 7} + nodeAccountID := []AccountID{{Account: 10}} + transactionID := TransactionIDGenerate(AccountID{Account: 324}) + + transaction, err := NewFileAppendTransaction(). + SetTransactionID(transactionID). + SetNodeAccountIDs(nodeAccountID). + SetFileID(fileID). + SetContents([]byte("Hello, World")). + Freeze() + require.NoError(t, err) + + txBytes, err := transaction.ToBytes() + require.NoError(t, err) + + txParsed, err := TransactionFromBytes(txBytes) + require.NoError(t, err) + + result, ok := txParsed.(FileAppendTransaction) + require.True(t, ok) + + require.Equal(t, transactionID.AccountID, result.GetTransactionID().AccountID) + require.Equal(t, fileID, result.GetFileID()) + require.Equal(t, transaction.GetContents(), result.GetContents()) +} diff --git a/token_create_transaction.go b/token_create_transaction.go index 382099377..7aca4f82b 100644 --- a/token_create_transaction.go +++ b/token_create_transaction.go @@ -774,7 +774,7 @@ func (transaction *TokenCreateTransaction) Freeze() (*TokenCreateTransaction, er } func (transaction *TokenCreateTransaction) FreezeWith(client *Client) (*TokenCreateTransaction, error) { - if transaction.autoRenewPeriod != nil && client != nil && !client.GetOperatorAccountID()._IsZero() { + if transaction.autoRenewAccountID == nil && transaction.autoRenewPeriod != nil && client != nil && !client.GetOperatorAccountID()._IsZero() { transaction.SetAutoRenewAccount(client.GetOperatorAccountID()) } diff --git a/token_create_transaction_unit_test.go b/token_create_transaction_unit_test.go index 6bd7b9a71..a410b7076 100644 --- a/token_create_transaction_unit_test.go +++ b/token_create_transaction_unit_test.go @@ -330,3 +330,14 @@ func TestUnitTokenCreateTransactionMock(t *testing.T) { _, err = freez.Sign(newKey).Execute(client) require.NoError(t, err) } + +func TestUnitTokenCreateAutoRenewAccountSetting(t *testing.T) { + client, err := _NewMockClient() + autoRenewAccount := AccountID{Account: 3} + frozenTx, err := NewTokenCreateTransaction(). + SetAutoRenewAccount(autoRenewAccount). + SetAutoRenewPeriod(24 * time.Hour). + FreezeWith(client) + require.NoError(t, err) + require.Equal(t, autoRenewAccount, frozenTx.GetAutoRenewAccount()) +} diff --git a/topic_create_transaction.go b/topic_create_transaction.go index 5e8f53923..d298378fd 100644 --- a/topic_create_transaction.go +++ b/topic_create_transaction.go @@ -66,7 +66,7 @@ func _TopicCreateTransactionFromProtobuf(transaction Transaction, pb *services.T autoRenewAccountID: _AccountIDFromProtobuf(pb.GetConsensusCreateTopic().GetAutoRenewAccount()), adminKey: adminKey, submitKey: submitKey, - memo: pb.GetContractCreateInstance().GetMemo(), + memo: pb.GetConsensusCreateTopic().GetMemo(), autoRenewPeriod: &autoRenew, } } diff --git a/topic_create_transaction_unit_test.go b/topic_create_transaction_unit_test.go index 27cf1dc3d..957659722 100644 --- a/topic_create_transaction_unit_test.go +++ b/topic_create_transaction_unit_test.go @@ -302,3 +302,38 @@ func TestUnitTopicCreateTransactionMock(t *testing.T) { _, err = freez.Sign(newKey).Execute(client) require.NoError(t, err) } + +func TestUnitTopicCreateTransactionSerialization(t *testing.T) { + t.Parallel() + + nodeAccountID := []AccountID{{Account: 10}} + transactionID := TransactionIDGenerate(AccountID{Account: 324}) + newKey, err := PrivateKeyGenerateEd25519() + require.NoError(t, err) + + topicCreate, err := NewTopicCreateTransaction(). + SetTransactionID(transactionID). + SetAdminKey(newKey). + SetNodeAccountIDs(nodeAccountID). + SetSubmitKey(newKey). + SetTopicMemo("ad"). + SetAutoRenewPeriod(time.Second * 30). + Freeze() + require.NoError(t, err) + + transactionBytes, err := topicCreate.ToBytes() + require.NoError(t, err) + + txParsed, err := TransactionFromBytes(transactionBytes) + require.NoError(t, err) + + result, ok := txParsed.(TopicCreateTransaction) + require.True(t, ok) + + require.Equal(t, topicCreate.GetTopicMemo(), result.GetTopicMemo()) + require.Equal(t, topicCreate.GetAutoRenewPeriod(), result.GetAutoRenewPeriod()) + adminKey, _ := result.GetAdminKey() + require.Equal(t, newKey.PublicKey(), adminKey) + submitKey, _ := result.GetSubmitKey() + require.Equal(t, newKey.PublicKey(), submitKey) +} diff --git a/topic_message_submit_transaction.go b/topic_message_submit_transaction.go index 48ebe256c..fd2389f67 100644 --- a/topic_message_submit_transaction.go +++ b/topic_message_submit_transaction.go @@ -58,7 +58,7 @@ func _TopicMessageSubmitTransactionFromProtobuf(transaction Transaction, pb *ser tx := &TopicMessageSubmitTransaction{ Transaction: transaction, maxChunks: 20, - message: make([]byte, 0), + message: pb.GetConsensusSubmitMessage().GetMessage(), topicID: _TopicIDFromProtobuf(pb.GetConsensusSubmitMessage().GetTopicID()), } diff --git a/topic_message_submit_transaction_unit_test.go b/topic_message_submit_transaction_unit_test.go index fecbdfa8d..5510937b4 100644 --- a/topic_message_submit_transaction_unit_test.go +++ b/topic_message_submit_transaction_unit_test.go @@ -291,3 +291,34 @@ func TestUnitTopicMessageSubmitTransactionCoverage(t *testing.T) { b.AddSignature(newKey.PublicKey(), sig) } } + +func TestUnitTopicMessageSubmitTransactionSerialization(t *testing.T) { + t.Parallel() + + topic := TopicID{Topic: 3} + nodeAccountID := []AccountID{{Account: 10}} + transactionID := TransactionIDGenerate(AccountID{Account: 324}) + + transaction, err := NewTopicMessageSubmitTransaction(). + SetTransactionID(transactionID). + SetNodeAccountIDs(nodeAccountID). + SetTopicID(topic). + SetMessage([]byte("nothing to see here")). + SetMaxChunks(30). + SetTransactionMemo("no"). + Freeze() + require.NoError(t, err) + + txBytes, err := transaction.ToBytes() + require.NoError(t, err) + + txParsed, err := TransactionFromBytes(txBytes) + require.NoError(t, err) + + result, ok := txParsed.(TopicMessageSubmitTransaction) + require.True(t, ok) + + require.Equal(t, transactionID.AccountID, result.GetTransactionID().AccountID) + require.Equal(t, transaction.GetMessage(), result.GetMessage()) + require.Equal(t, transaction.GetTransactionMemo(), result.GetTransactionMemo()) +}