fix: Transaction.AddSignature fixes, added AddSignature tests

account_create_transaction.go

@@ -287,6 +287,9 @@ func (transaction *AccountCreateTransaction) Freeze() (*AccountCreateTransaction
 }
 
 func (transaction *AccountCreateTransaction) FreezeWith(client *Client) (*AccountCreateTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -355,3 +358,12 @@ func (transaction *AccountCreateTransaction) SetMaxRetry(count int) *AccountCrea
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *AccountCreateTransaction) AddSignature(publicKey PublicKey, signature []byte) *AccountCreateTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

account_create_transaction_test.go

@@ -98,3 +98,43 @@ func Test_AccountCreate_NoKey(t *testing.T) {
 		assert.Equal(t, fmt.Sprintf("exceptional precheck status KEY_REQUIRED received for transaction %s", resp.TransactionID), err.Error())
 	}
 }
+
+func TestAccountCreateTransactionAddSignature(t *testing.T) {
+	client := newTestClient(t)
+
+	newKey, err := GeneratePrivateKey()
+	assert.NoError(t, err)
+
+	resp, err := NewAccountCreateTransaction().
+		SetKey(newKey.PublicKey()).
+		Execute(client)
+	assert.NoError(t, err)
+
+	receipt, err := resp.GetReceipt(client)
+	assert.NoError(t, err)
+
+	tx, err := NewAccountDeleteTransaction().
+		SetNodeAccountIDs([]AccountID{resp.NodeID}).
+		SetAccountID(*receipt.AccountID).
+		SetTransferAccountID(client.GetOperatorAccountID()).
+		FreezeWith(client)
+	assert.NoError(t, err)
+
+	updateBytes, err := tx.ToBytes()
+	assert.NoError(t, err)
+
+	sig1, err := newKey.SignTransaction(&tx.Transaction)
+	assert.NoError(t, err)
+
+	tx2, err := TransactionFromBytes(updateBytes)
+	assert.NoError(t, err)
+
+	switch newTx := tx2.(type) {
+	case AccountDeleteTransaction:
+		resp, err = newTx.AddSignature(newKey.PublicKey(), sig1).Execute(client)
+		assert.NoError(t, err)
+	}
+
+	_, err = resp.GetReceipt(client)
+	assert.NoError(t, err)
+}

account_delete_transaction.go

@@ -205,6 +205,9 @@ func (transaction *AccountDeleteTransaction) Freeze() (*AccountDeleteTransaction
 }
 
 func (transaction *AccountDeleteTransaction) FreezeWith(client *Client) (*AccountDeleteTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -273,3 +276,12 @@ func (transaction *AccountDeleteTransaction) SetMaxRetry(count int) *AccountDele
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *AccountDeleteTransaction) AddSignature(publicKey PublicKey, signature []byte) *AccountDeleteTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

account_update_transaction.go

@@ -120,6 +120,7 @@ func (transaction *AccountUpdateTransaction) Sign(
 func (transaction *AccountUpdateTransaction) SignWithOperator(
 	client *Client,
 ) (*AccountUpdateTransaction, error) {
+
 	// If the transaction is not signed by the operator, we need
 	// to sign the transaction with the operator
 
@@ -239,6 +240,9 @@ func (transaction *AccountUpdateTransaction) Freeze() (*AccountUpdateTransaction
 }
 
 func (transaction *AccountUpdateTransaction) FreezeWith(client *Client) (*AccountUpdateTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -307,3 +311,12 @@ func (transaction *AccountUpdateTransaction) SetMaxRetry(count int) *AccountUpda
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *AccountUpdateTransaction) AddSignature(publicKey PublicKey, signature []byte) *AccountUpdateTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

account_update_transaction_test.go

@@ -153,3 +153,86 @@ func Test_AccountUpdate_AccoundIDNotSet(t *testing.T) {
 		assert.Equal(t, fmt.Sprintf("exceptional precheck status INVALID_ACCOUNT_ID"), err.Error())
 	}
 }
+
+func TestAccountUpdateTransactionAddSignature_Execute(t *testing.T) {
+	client := newTestClient(t)
+
+	newKey, err := GeneratePrivateKey()
+	assert.NoError(t, err)
+
+	newKey2, err := GeneratePrivateKey()
+	assert.NoError(t, err)
+
+	newBalance := NewHbar(2)
+
+	assert.Equal(t, 2*HbarUnits.Hbar.numberOfTinybar(), newBalance.tinybar)
+
+	resp, err := NewAccountCreateTransaction().
+		SetKey(newKey.PublicKey()).
+		SetInitialBalance(newBalance).
+		Execute(client)
+
+	assert.NoError(t, err)
+
+	receipt, err := resp.GetReceipt(client)
+	assert.NoError(t, err)
+
+	accountID := *receipt.AccountID
+	assert.NoError(t, err)
+
+	tx, err := NewAccountUpdateTransaction().
+		SetAccountID(accountID).
+		SetNodeAccountIDs([]AccountID{resp.NodeID}).
+		SetExpirationTime(time.Now().Local().Add(time.Second * 5)).
+		SetTransactionID(TransactionIDGenerate(accountID)).
+		SetKey(newKey2.PublicKey()).
+		FreezeWith(client)
+	assert.NoError(t, err)
+
+	updateBytes, err := tx.ToBytes()
+	assert.NoError(t, err)
+
+	sig1, err := newKey.SignTransaction(&tx.Transaction)
+	assert.NoError(t, err)
+	sig2, err := newKey2.SignTransaction(&tx.Transaction)
+	assert.NoError(t, err)
+
+	tx2, err := TransactionFromBytes(updateBytes)
+	assert.NoError(t, err)
+
+	switch newTx := tx2.(type) {
+	case AccountUpdateTransaction:
+		resp, err = newTx.AddSignature(newKey.PublicKey(), sig1).AddSignature(newKey2.PublicKey(), sig2).Execute(client)
+		assert.NoError(t, err)
+	}
+
+	_, err = resp.GetReceipt(client)
+	assert.NoError(t, err)
+
+	info, err := NewAccountInfoQuery().
+		SetAccountID(accountID).
+		SetNodeAccountIDs([]AccountID{resp.NodeID}).
+		SetMaxQueryPayment(NewHbar(1)).
+		Execute(client)
+	assert.NoError(t, err)
+
+	assert.Equal(t, newKey2.PublicKey().String(), info.Key.String())
+
+	txDelete, err := NewAccountDeleteTransaction().
+		SetAccountID(accountID).
+		SetTransferAccountID(client.GetOperatorAccountID()).
+		SetNodeAccountIDs([]AccountID{resp.NodeID}).
+		FreezeWith(client)
+
+	assert.NoError(t, err)
+
+	txDelete.Sign(newKey2)
+
+	resp, err = txDelete.Execute(client)
+	assert.NoError(t, err)
+
+	_, err = resp.GetReceipt(client)
+
+	assert.NoError(t, err)
+
+}

contract_create_transaction.go

@@ -285,6 +285,9 @@ func (transaction *ContractCreateTransaction) Freeze() (*ContractCreateTransacti
 }
 
 func (transaction *ContractCreateTransaction) FreezeWith(client *Client) (*ContractCreateTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -353,3 +356,12 @@ func (transaction *ContractCreateTransaction) SetMaxRetry(count int) *ContractCr
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *ContractCreateTransaction) AddSignature(publicKey PublicKey, signature []byte) *ContractCreateTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

contract_delete_transaction.go

@@ -213,6 +213,9 @@ func (transaction *ContractDeleteTransaction) Freeze() (*ContractDeleteTransacti
 }
 
 func (transaction *ContractDeleteTransaction) FreezeWith(client *Client) (*ContractDeleteTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -281,3 +284,12 @@ func (transaction *ContractDeleteTransaction) SetMaxRetry(count int) *ContractDe
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *ContractDeleteTransaction) AddSignature(publicKey PublicKey, signature []byte) *ContractDeleteTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

contract_execute_transaction.go

@@ -238,6 +238,9 @@ func (transaction *ContractExecuteTransaction) Freeze() (*ContractExecuteTransac
 }
 
 func (transaction *ContractExecuteTransaction) FreezeWith(client *Client) (*ContractExecuteTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -306,3 +309,12 @@ func (transaction *ContractExecuteTransaction) SetMaxRetry(count int) *ContractE
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *ContractExecuteTransaction) AddSignature(publicKey PublicKey, signature []byte) *ContractExecuteTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

contract_update_transaction.go

@@ -273,6 +273,9 @@ func (transaction *ContractUpdateTransaction) Freeze() (*ContractUpdateTransacti
 }
 
 func (transaction *ContractUpdateTransaction) FreezeWith(client *Client) (*ContractUpdateTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -341,3 +344,12 @@ func (transaction *ContractUpdateTransaction) SetMaxRetry(count int) *ContractUp
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *ContractUpdateTransaction) AddSignature(publicKey PublicKey, signature []byte) *ContractUpdateTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

crypto.go

@@ -352,14 +352,14 @@ func (pk PublicKey) toSignaturePairProtobuf(signature []byte) *proto.SignaturePa
 	}
 }
 
-func (sk PrivateKey) SignTransaction(transaction Transaction) ([]byte, error) {
+func (sk PrivateKey) SignTransaction(transaction *Transaction) ([]byte, error) {
 	transaction.requireOneNodeAccountID()
 
-	if len(transaction.transactions) == 0 {
+	if len(transaction.signedTransactions) == 0 {
 		return make([]byte, 0), errTransactionRequiresSingleNodeAccountID
 	}
 
-	signature := sk.Sign(transaction.transactions[0].GetBodyBytes())
+	signature := sk.Sign(transaction.signedTransactions[0].GetBodyBytes())
 	transaction.AddSignature(sk.PublicKey(), signature)
 
 	return signature, nil

file_append_transaction.go

@@ -231,6 +231,10 @@ func (transaction *FileAppendTransaction) Freeze() (*FileAppendTransaction, erro
 }
 
 func (transaction *FileAppendTransaction) FreezeWith(client *Client) (*FileAppendTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
+
 	if len(transaction.nodeIDs) == 0 {
 		if client == nil {
 			return transaction, errNoClientOrTransactionIDOrNodeId
@@ -352,3 +356,12 @@ func (transaction *FileAppendTransaction) SetMaxRetry(count int) *FileAppendTran
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *FileAppendTransaction) AddSignature(publicKey PublicKey, signature []byte) *FileAppendTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

file_append_transaction_test.go

@@ -28,7 +28,6 @@ func TestFileAppendTransaction_Execute(t *testing.T) {
 		SetNodeAccountIDs([]AccountID{resp.NodeID}).
 		SetContents([]byte(" world!")).
 		Execute(client)
-
 	assert.NoError(t, err)
 
 	_, err = resp.GetReceipt(client)

file_create_transaction.go

@@ -250,6 +250,9 @@ func (transaction *FileCreateTransaction) Freeze() (*FileCreateTransaction, erro
 }
 
 func (transaction *FileCreateTransaction) FreezeWith(client *Client) (*FileCreateTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -318,3 +321,12 @@ func (transaction *FileCreateTransaction) SetMaxRetry(count int) *FileCreateTran
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *FileCreateTransaction) AddSignature(publicKey PublicKey, signature []byte) *FileCreateTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}

file_delete_transaction.go

@@ -184,6 +184,10 @@ func (transaction *FileDeleteTransaction) Freeze() (*FileDeleteTransaction, erro
 }
 
 func (transaction *FileDeleteTransaction) FreezeWith(client *Client) (*FileDeleteTransaction, error) {
+	if transaction.IsFrozen() {
+		return transaction, nil
+	}
+
 	transaction.initFee(client)
 	if err := transaction.initTransactionID(client); err != nil {
 		return transaction, err
@@ -252,3 +256,12 @@ func (transaction *FileDeleteTransaction) SetMaxRetry(count int) *FileDeleteTran
 	transaction.Transaction.SetMaxRetry(count)
 	return transaction
 }
+
+func (transaction *FileDeleteTransaction) AddSignature(publicKey PublicKey, signature []byte) *FileDeleteTransaction {
+	if !transaction.IsFrozen() {
+		transaction.Freeze()
+	}
+
+	transaction.Transaction.AddSignature(publicKey, signature)
+	return transaction
+}