Enhance SimulateMultiTransaction method to support additional signers and update related documentation

Author: Ellenp2p

client.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/aptos-labs/aptos-go-sdk/api"
+	"github.com/aptos-labs/aptos-go-sdk/crypto"
 	"github.com/hasura/go-graphql-client"
 )
 
@@ -749,8 +750,48 @@ func (client *Client) SimulateTransaction(rawTxn *RawTransaction, sender Transac
 	return client.nodeClient.SimulateTransaction(rawTxn, sender, options...)
 }
 
-func (client *Client) SimulateMultiTransaction(rawTxnWithData *RawTransactionWithData, sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error) {
-	return client.nodeClient.SimulateMultiTransaction(rawTxnWithData, sender, options...)
+// SimulateMultiTransaction simulates a multi-transaction on the Aptos blockchain.
+// It takes a raw transaction with data, a transaction signer, and optional parameters.
+// It returns a slice of UserTransaction and an error if the simulation fails.
+//
+// Parameters:
+// - rawTxnWithData: A pointer to RawTransactionWithData containing the transaction details.
+// - sender: A TransactionSigner that signs the transaction.
+// - options: Optional parameters for the simulation.
+//
+// Returns:
+// - data: A slice of UserTransaction containing the simulated transaction results.
+// - err: An error if the simulation fails.
+// SimulateMultiTransaction simulates a multi-signature transaction without broadcasting it to the network.
+// This function takes a raw transaction with data, a sender transaction signer, and additional signers.
+// It returns the simulated user transactions or an error if the simulation fails.
+//
+// Parameters:
+//   - rawTxnWithData: A pointer to the raw transaction data to be simulated.
+//   - sender: The primary transaction signer.
+//   - additionalSigners: A slice of additional signers' account authenticators.
+//   - options: Additional options for the simulation.
+//
+// Returns:
+//   - data: A slice of pointers to the simulated user transactions.
+//   - err: An error if the simulation fails.
+func (client *Client) SimulateMultiTransaction(rawTxnWithData *RawTransactionWithData, sender TransactionSigner, additionalSigners []crypto.AccountAuthenticator, options ...any) (data []*api.UserTransaction, err error) {
+	return client.nodeClient.SimulateMultiTransaction(rawTxnWithData, sender, additionalSigners , options...)
+}
+
+// SimulateTransactionWithSignedTxn simulates a transaction using a signed transaction.
+// This function sends the signed transaction to the node client for simulation and returns
+// the resulting user transactions and any error encountered during the simulation.
+//
+// Parameters:
+// - signedTxn: A pointer to the SignedTransaction struct representing the signed transaction to be simulated.
+// - options: Additional optional parameters that can be passed to the simulation.
+//
+// Returns:
+// - data: A slice of pointers to api.UserTransaction structs representing the simulated user transactions.
+// - err: An error object if an error occurred during the simulation, otherwise nil.
+func (client *Client) SimulateTransactionWithSignedTxn(signedTxn *SignedTransaction, options ...any) (data []*api.UserTransaction, err error) {
+	return client.nodeClient.SimulateTransactionWithSignedTxn(signedTxn, options...)
 }
 
 // GetChainId Retrieves the ChainId of the network

examples/simulate_mult_transaction/main.go

@@ -82,6 +82,7 @@ func example(networkConfig aptos.NetworkConfig) {
 		panic("Failed to serialize transfer amount:" + err.Error())
 	}
 
+	
 	rawTxn, err := client.BuildTransactionMultiAgent(alice.AccountAddress(), aptos.TransactionPayload{
 		Payload: &aptos.EntryFunction{
 			Module: aptos.ModuleId{
@@ -102,9 +103,7 @@ func example(networkConfig aptos.NetworkConfig) {
 	// 2. Simulate transaction (optional)
 	// This is useful for understanding how much the transaction will cost
 	// and to ensure that the transaction is valid before sending it to the network
-	// This is optional, but recommended
-	// TODO: Support simulate transaction with multi-agent / fee payer
-	simulationResult, err := client.SimulateMultiTransaction(rawTxn, alice)
+	simulationResult, err := client.SimulateMultiTransaction(rawTxn, alice, []crypto.AccountAuthenticator{})
 	if err != nil {
 		panic("Failed to simulate transaction:" + err.Error())
 	}
@@ -124,20 +123,20 @@ func example(networkConfig aptos.NetworkConfig) {
 		panic("Failed to sign multiagent transaction with bob:" + err.Error())
 	}
 
-	// 3.a. merge the signatures together into a single transaction
-	signedTxn, ok := rawTxn.ToMultiAgentSignedTransaction(aliceAuth, []crypto.AccountAuthenticator{*bobAuth})
+	// 4.a. merge the signatures together into a single transaction
+	signedTxn, ok := rawTxn.ToFeePayerSignedTransaction(aliceAuth,bobAuth ,[]crypto.AccountAuthenticator{})
 	if !ok {
 		panic("Failed to build a signed multiagent transaction")
 	}
 
-	// 4. Submit transaction
+	// 5. Submit transaction
 	submitResult, err := client.SubmitTransaction(signedTxn)
 	if err != nil {
 		panic("Failed to submit transaction:" + err.Error())
 	}
 	txnHash := submitResult.Hash
 
-	// 5. Wait for the transaction to complete
+	// 6. Wait for the transaction to complete
 	_, err = client.WaitForTransaction(txnHash)
 	if err != nil {
 		panic("Failed to wait for transaction:" + err.Error())

nodeClient.go

@@ -733,7 +733,7 @@ func (rc *NodeClient) SimulateTransaction(rawTxn *RawTransaction, sender Transac
 // SimulateMultiTransaction simulates a transaction with optional fee payer and secondary signers
 // If feePayerAddress is nil, no fee payer will be used
 // If secondarySignerAddresses is nil or empty, no secondary signers will be used
-func (rc *NodeClient) SimulateMultiTransaction(rawTxnWithData *RawTransactionWithData,  sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error) {
+func (rc *NodeClient) SimulateMultiTransaction(rawTxnWithData *RawTransactionWithData, sender TransactionSigner, additionalSigners []crypto.AccountAuthenticator, options ...any) (data []*api.UserTransaction, err error) {
 	if( rawTxnWithData == nil ) {
 		return nil, fmt.Errorf("rawTxnWithData is nil")
 	}
@@ -745,28 +745,28 @@ func (rc *NodeClient) SimulateMultiTransaction(rawTxnWithData *RawTransactionWit
 				Variant: crypto.AccountAuthenticatorNoAccount,
 				Auth: &crypto.AccountAuthenticatorNoAccountAuthenticator{},
 			},
-			[]crypto.AccountAuthenticator{},
+			additionalSigners,
 		);
 		if !ok {
-			return nil, fmt.Errorf("failed to sign agent transaction")
+			return nil, fmt.Errorf("failed to sign fee payer transaction")
 		}
-		return rc.simulateTransactionWithSignedTxn(signedFeePayerTxn, options...)
+		return rc.SimulateTransactionWithSignedTxn(signedFeePayerTxn, options...)
 	case MultiAgentRawTransactionWithDataVariant:
 		signedAgentTxn, ok := rawTxnWithData.ToMultiAgentSignedTransaction(
 			sender.SimulationAuthenticator(),
-			[]crypto.AccountAuthenticator{},
+			additionalSigners,
 		)
 		if !ok {
-			return nil, fmt.Errorf("failed to sign agent transaction")
+			return nil, fmt.Errorf("failed to sign multi agent transaction")
 		}
-		return rc.simulateTransactionWithSignedTxn(signedAgentTxn, options...)
+		return rc.SimulateTransactionWithSignedTxn(signedAgentTxn, options...)
 	default:
 		return nil, fmt.Errorf("unsupported raw transaction with data variant %v", rawTxnWithData.Variant)
 	}
 }
 
 // Helper method to avoid code duplication
-func (rc *NodeClient) simulateTransactionWithSignedTxn(signedTxn *SignedTransaction, options ...any) ([]*api.UserTransaction, error) {
+func (rc *NodeClient) SimulateTransactionWithSignedTxn(signedTxn *SignedTransaction, options ...any) ([]*api.UserTransaction, error) {
 	sblob, err := bcs.Serialize(signedTxn)
 	if err != nil {
 		return nil, err