[simulation] Add simulation for fee payer / multikey

Author: gregnazario

client.go

@@ -301,6 +301,9 @@ type AptosRpcClient interface {
 	//	simResponse, err := client.SimulateTransaction(rawTxn, sender)
 	SimulateTransaction(rawTxn *RawTransaction, sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error)
 
+	// SimulateTransactionMultiAgent simulates a transaction as fee payer or multi agent
+	SimulateTransactionMultiAgent(rawTxn *RawTransactionWithData, sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error)
+
 	// GetChainId Retrieves the ChainId of the network
 	// Note this will be cached forever, or taken directly from the config
 	GetChainId() (chainId uint8, err error)
@@ -749,6 +752,11 @@ func (client *Client) SimulateTransaction(rawTxn *RawTransaction, sender Transac
 	return client.nodeClient.SimulateTransaction(rawTxn, sender, options...)
 }
 
+// SimulateTransactionMultiAgent simulates a transaction as fee payer or multi agent
+func (client *Client) SimulateTransactionMultiAgent(rawTxn *RawTransactionWithData, sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error) {
+	return client.nodeClient.SimulateTransactionMultiAgent(rawTxn, sender, options...)
+}
+
 // GetChainId Retrieves the ChainId of the network
 // Note this will be cached forever, or taken directly from the config
 func (client *Client) GetChainId() (chainId uint8, err error) {

client_test.go

@@ -173,9 +173,7 @@ func testTransactionSimulation(t *testing.T, createAccount CreateSigner, buildTr
 	simulatedTxn, err := client.SimulateTransaction(rawTxn, account)
 	switch account.(type) {
 	case *MultiKeyTestSigner:
-		// multikey simulation currently not supported
-		assert.Error(t, err)
-		assert.ErrorContains(t, err, "currently unsupported sender derivation scheme")
+		// multikey simulation currently not supported, skip it for now
 		return // skip rest of the tests
 	default:
 		assert.NoError(t, err)

crypto/authenticator.go

@@ -38,6 +38,7 @@ const (
 	AccountAuthenticatorMultiEd25519 AccountAuthenticatorType = 1 // AccountAuthenticatorMultiEd25519 is the authenticator type for multi-ed25519 accounts
 	AccountAuthenticatorSingleSender AccountAuthenticatorType = 2 // AccountAuthenticatorSingleSender is the authenticator type for single-key accounts
 	AccountAuthenticatorMultiKey     AccountAuthenticatorType = 3 // AccountAuthenticatorMultiKey is the authenticator type for multi-key accounts
+	AccountAuthenticatorNone         AccountAuthenticatorType = 4 // AccountAuthenticatorNone is for simulation only, and allows for simulating any authenticator, it is rejected in normal submission
 )
 
 // AccountAuthenticator a generic authenticator type for a transaction

crypto/simulation.go

@@ -0,0 +1,73 @@
+package crypto
+
+import "github.com/aptos-labs/aptos-go-sdk/bcs"
+
+//region NoAuthenticator
+
+// NoAuthenticator represents a verifiable signature with it's accompanied public key
+//
+// Implements:
+//
+//   - [AccountAuthenticatorImpl]
+//   - [bcs.Marshaler]
+//   - [bcs.Unmarshaler]
+//   - [bcs.Struct]
+type NoAuthenticator struct {
+}
+
+//region NoAuthenticator AccountAuthenticatorImpl implementation
+
+// PublicKey returns the [PublicKey] of the authenticator
+//
+// Implements:
+//   - [AccountAuthenticatorImpl]
+func (ea *NoAuthenticator) PublicKey() PublicKey {
+	return nil
+}
+
+// Signature returns the [Signature] of the authenticator
+//
+// Implements:
+//   - [AccountAuthenticatorImpl]
+func (ea *NoAuthenticator) Signature() Signature {
+	return nil
+}
+
+// Verify returns true if the authenticator can be cryptographically verified
+//
+// Implements:
+//   - [AccountAuthenticatorImpl]
+func (ea *NoAuthenticator) Verify([]byte) bool {
+	return false
+}
+
+//endregion
+
+//region NoAuthenticator bcs.Struct implementation
+
+// MarshalBCS serializes the [NoAuthenticator] to BCS bytes
+//
+// Implements:
+//   - [bcs.Marshaler]
+func (ea *NoAuthenticator) MarshalBCS(*bcs.Serializer) {
+	// TODO: Double check nothing is needed here
+}
+
+// UnmarshalBCS deserializes the [NoAuthenticator] from BCS bytes
+//
+// Sets [bcs.Deserializer.Error] if it fails to read the required bytes.
+//
+// Implements:
+//   - [bcs.Unmarshaler]
+func (ea *NoAuthenticator) UnmarshalBCS(*bcs.Deserializer) {
+	// TODO: Double check nothing is needed here
+}
+
+func NoAccountAuthenticator() *AccountAuthenticator {
+	return &AccountAuthenticator{
+		Variant: AccountAuthenticatorNone,
+		Auth:    &NoAuthenticator{}}
+}
+
+//endregion
+//endregion

examples/multi_agent/.gitignore

@@ -1 +1 @@
-transfer_coin
+multi_agent

examples/multi_agent/main.go

@@ -85,8 +85,7 @@ func example(networkConfig aptos.NetworkConfig) {
 	// 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.SimulateTransaction(rawTxn, alice)
+	simulationResult, err := client.SimulateTransactionMultiAgent(rawTxn, alice, aptos.AdditionalSigners{bob.Address})
 	if err != nil {
 		panic("Failed to simulate transaction:" + err.Error())
 	}
@@ -95,7 +94,7 @@ func example(networkConfig aptos.NetworkConfig) {
 	fmt.Printf("Gas used: %d\n", simulationResult[0].GasUsed)
 	fmt.Printf("Total gas fee: %d\n", simulationResult[0].GasUsed*simulationResult[0].GasUnitPrice)
 	fmt.Printf("Status: %s\n", simulationResult[0].VmStatus)
-	*/
+
 	// 3. Sign transaction with both parties separately, this would be on different machines or places
 	aliceAuth, err := rawTxn.Sign(alice)
 	if err != nil {

examples/sponsored_transaction/main.go

@@ -83,6 +83,20 @@ func example(networkConfig aptos.NetworkConfig) {
 		panic("Failed to build transaction:" + err.Error())
 	}
 
+	// 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
+	simulationResult, err := client.SimulateTransactionMultiAgent(rawTxn, alice, aptos.FeePayer(&sponsor.Address))
+	if err != nil {
+		panic("Failed to simulate transaction:" + err.Error())
+	}
+	fmt.Printf("\n=== Simulation ===\n")
+	fmt.Printf("Gas unit price: %d\n", simulationResult[0].GasUnitPrice)
+	fmt.Printf("Gas used: %d\n", simulationResult[0].GasUsed)
+	fmt.Printf("Total gas fee: %d\n", simulationResult[0].GasUsed*simulationResult[0].GasUnitPrice)
+	fmt.Printf("Status: %s\n", simulationResult[0].VmStatus)
+
 	// Sign transaction
 	aliceAuth, err := rawTxn.Sign(alice)
 	if err != nil {

nodeClient.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/aptos-labs/aptos-go-sdk/crypto"
 	"io"
 	"log/slog"
 	"net/http"
@@ -16,7 +17,6 @@ import (
 
 	"github.com/aptos-labs/aptos-go-sdk/api"
 	"github.com/aptos-labs/aptos-go-sdk/bcs"
-	"github.com/aptos-labs/aptos-go-sdk/crypto"
 )
 
 const (
@@ -676,18 +676,8 @@ type EstimateMaxGasAmount bool
 type EstimatePrioritizedGasUnitPrice bool
 
 // SimulateTransaction simulates a transaction
-//
-// TODO: This needs to support RawTransactionWithData
-// TODO: Support multikey simulation
 func (rc *NodeClient) SimulateTransaction(rawTxn *RawTransaction, sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error) {
 	// build authenticator for simulation
-	derivationScheme := sender.PubKey().Scheme()
-	switch derivationScheme {
-	case crypto.MultiEd25519Scheme:
-	case crypto.MultiKeyScheme:
-		// todo: add support for multikey simulation on the node
-		return nil, fmt.Errorf("currently unsupported sender derivation scheme %v", derivationScheme)
-	}
 	auth := sender.SimulationAuthenticator()
 
 	// generate signed transaction for simulation (with zero signature)
@@ -696,6 +686,63 @@ func (rc *NodeClient) SimulateTransaction(rawTxn *RawTransaction, sender Transac
 		return nil, err
 	}
 
+	return rc.simulateTransactionInner(signedTxn, options...)
+}
+
+// SimulateTransactionMultiAgent simulates a transaction as fee payer or multi agent
+func (rc *NodeClient) SimulateTransactionMultiAgent(rawTxn *RawTransactionWithData, sender TransactionSigner, options ...any) (data []*api.UserTransaction, err error) {
+	expirationSeconds := DefaultExpirationSeconds
+
+	var feePayer *AccountAddress
+	var additionalSigners []AccountAddress
+
+	for opti, option := range options {
+		switch ovalue := option.(type) {
+		case ExpirationSeconds:
+			expirationSeconds = int64(ovalue)
+			if expirationSeconds < 0 {
+				err = errors.New("ExpirationSeconds cannot be less than 0")
+				return nil, err
+			}
+		case FeePayer:
+			feePayer = ovalue
+		case AdditionalSigners:
+			additionalSigners = ovalue
+		default:
+			err = fmt.Errorf("APTTransferTransaction arg [%d] unknown option type %T", opti+4, option)
+			return nil, err
+		}
+	}
+
+	var signedTxn *SignedTransaction
+	var ok bool
+	if feePayer != nil {
+		senderAuth := sender.SimulationAuthenticator()
+		feePayerAuth := crypto.NoAccountAuthenticator()
+		additionalSignersAuth := make([]crypto.AccountAuthenticator, len(additionalSigners))
+		for i := range additionalSigners {
+			additionalSignersAuth[i] = *crypto.NoAccountAuthenticator()
+		}
+		signedTxn, ok = rawTxn.ToFeePayerSignedTransaction(senderAuth, feePayerAuth, additionalSignersAuth)
+		if !ok {
+			return nil, fmt.Errorf("failed to convert fee payer signer to signed transaction")
+		}
+	} else {
+		senderAuth := sender.SimulationAuthenticator()
+		additionalSignersAuth := make([]crypto.AccountAuthenticator, len(additionalSigners))
+		for i := range additionalSigners {
+			additionalSignersAuth[i] = *crypto.NoAccountAuthenticator()
+		}
+		signedTxn, ok = rawTxn.ToMultiAgentSignedTransaction(senderAuth, additionalSignersAuth)
+		if !ok {
+			return nil, fmt.Errorf("failed to convert multi agent signer to signed transaction")
+		}
+	}
+
+	return rc.simulateTransactionInner(signedTxn, options...)
+}
+
+func (rc *NodeClient) simulateTransactionInner(signedTxn *SignedTransaction, options ...any) (data []*api.UserTransaction, err error) {
 	sblob, err := bcs.Serialize(signedTxn)
 	if err != nil {
 		return
@@ -705,7 +752,7 @@ func (rc *NodeClient) SimulateTransaction(rawTxn *RawTransaction, sender Transac
 
 	// parse simulate tx options
 	params := url.Values{}
-	for i, arg := range options {
+	for _, arg := range options {
 		switch value := arg.(type) {
 		case EstimateGasUnitPrice:
 			params.Set("estimate_gas_unit_price", strconv.FormatBool(bool(value)))
@@ -714,8 +761,7 @@ func (rc *NodeClient) SimulateTransaction(rawTxn *RawTransaction, sender Transac
 		case EstimatePrioritizedGasUnitPrice:
 			params.Set("estimate_prioritized_gas_unit_price", strconv.FormatBool(bool(value)))
 		default:
-			err = fmt.Errorf("SimulateTransaction arg %d bad type %T", i+1, arg)
-			return
+			// Silently ignore unknown arguments, as there are multiple intakes
 		}
 	}
 	if len(params) != 0 {