feat: aggregator should check if gas is enough before respondToTask

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}

aggregator/internal/pkg/aggregator.go

@@ -277,7 +277,7 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 	agg.logger.Info("Sending aggregated response onchain", "taskIndex", blsAggServiceResp.TaskIndex,
  "batchIdentifierHash", "0x"+hex.EncodeToString(batchIdentifierHash[:]))
 	for i := 0; i < MaxSentTxRetries; i++ {
- _, err = agg.sendAggregatedResponse(batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
+ _, err = agg.sendAggregatedResponse(batchIdentifierHash, batchData.BatchMerkleRoot, batchData.SenderAddress, nonSignerStakesAndSignature)
  if err == nil {
  agg.logger.Info("Aggregator successfully responded to task",
  "taskIndex", blsAggServiceResp.TaskIndex,
@@ -300,17 +300,15 @@ func (agg *Aggregator) handleBlsAggServiceResponse(blsAggServiceResp blsagg.BlsA
 
 // / Sends response to contract and waits for transaction receipt
 // / Returns error if it fails to send tx or receipt is not found
-func (agg *Aggregator) sendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
-	batchIdentifier := append(batchMerkleRoot[:], senderAddress[:]...)
-	var batchIdentifierHash = *(*[32]byte)(crypto.Keccak256(batchIdentifier))
+func (agg *Aggregator) sendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*gethtypes.Receipt, error) {
 
 	agg.walletMutex.Lock()
 	agg.logger.Infof("- Locked Wallet Resources: Sending aggregated response for batch",
  "merkleRoot", hex.EncodeToString(batchMerkleRoot[:]),
  "senderAddress", hex.EncodeToString(senderAddress[:]),
  "batchIdentifierHash", hex.EncodeToString(batchIdentifierHash[:]))
 
-	txHash, err := agg.avsWriter.SendAggregatedResponse(batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
+	txHash, err := agg.avsWriter.SendAggregatedResponse(batchIdentifierHash, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  agg.walletMutex.Unlock()
  agg.logger.Infof("- Unlocked Wallet Resources: Error sending aggregated response for batch %s. Error: %s", hex.EncodeToString(batchIdentifierHash[:]), err)

contracts/src/core/AlignedLayerServiceManagerStorage.sol

@@ -12,7 +12,7 @@ abstract contract AlignedLayerServiceManagerStorage {
  mapping(bytes32 => BatchState) public batchesState;
 
  // Storage for batchers balances. Used by aggregator to pay for respondToTask
- mapping(address => uint256) internal batchersBalances;
+ mapping(address => uint256) public batchersBalances;
 
  address public alignedAggregator;
 

core/chainio/avs_writer.go

@@ -1,13 +1,19 @@
 package chainio
 
 import (
+	"context"
+	"fmt"
+	"math/big"
+	"time"
 
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/avsregistry"
 	"github.com/Layr-Labs/eigensdk-go/chainio/clients/eth"
 	"github.com/Layr-Labs/eigensdk-go/logging"
 	"github.com/Layr-Labs/eigensdk-go/signer"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
 	servicemanager "github.com/yetanotherco/aligned_layer/contracts/bindings/AlignedLayerServiceManager"
 	"github.com/yetanotherco/aligned_layer/core/config"
 )
@@ -18,6 +24,7 @@ type AvsWriter struct {
 	logger logging.Logger
 	Signer signer.Signer
 	Client eth.Client
+	ClientFallback eth.Client
 }
 
 func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.EcdsaConfig) (*AvsWriter, error) {
@@ -59,22 +66,27 @@ func NewAvsWriterFromConfig(baseConfig *config.BaseConfig, ecdsaConfig *config.E
  logger: baseConfig.Logger,
  Signer: privateKeySigner,
  Client: baseConfig.EthRpcClient,
+ ClientFallback: baseConfig.EthRpcClientFallback,
 	}, nil
 }
 
-
-func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
+func (w *AvsWriter) SendAggregatedResponse(batchIdentifierHash [32]byte, batchMerkleRoot [32]byte, senderAddress [20]byte, nonSignerStakesAndSignature servicemanager.IBLSSignatureCheckerNonSignerStakesAndSignature) (*common.Hash, error) {
 	txOpts := *w.Signer.GetTxOpts()
 	txOpts.NoSend = true // simulate the transaction
 	tx, err := w.AvsContractBindings.ServiceManager.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
 	if err != nil {
  // Retry with fallback
  tx, err = w.AvsContractBindings.ServiceManagerFallback.RespondToTaskV2(&txOpts, batchMerkleRoot, senderAddress, nonSignerStakesAndSignature)
  if err != nil {
- return nil, err
+ return nil, fmt.Errorf("transaction simulation failed: %v", err)
  }
 	}
 
+	err = w.checkRespondToTaskFeeLimit(tx, txOpts, batchIdentifierHash, senderAddress)
+	if err != nil {
+ return nil, err
+	}
+
 	// Send the transaction
 	txOpts.NoSend = false
 	txOpts.GasLimit = tx.Gas() * 110 / 100 // Add 10% to the gas limit
@@ -91,3 +103,82 @@ func (w *AvsWriter) SendAggregatedResponse(batchMerkleRoot [32]byte, senderAddre
 
 	return &txHash, nil
 }
+
+func (w *AvsWriter) checkRespondToTaskFeeLimit(tx *types.Transaction, txOpts bind.TransactOpts, batchIdentifierHash [32]byte, senderAddress [20]byte) error {
+	aggregatorAddress := txOpts.From
+	simulatedCost := new(big.Int).Mul(new(big.Int).SetUint64(tx.Gas()), tx.GasPrice())
+	w.logger.Info("Simulated cost", "cost", simulatedCost)
+
+	// Get RespondToTaskFeeLimit
+	batchState, err := w.AvsContractBindings.ServiceManager.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+	if err != nil {
+ // Retry with fallback
+ batchState, err = w.AvsContractBindings.ServiceManagerFallback.BatchesState(&bind.CallOpts{}, batchIdentifierHash)
+ if err != nil {
+ // Fallback also failed
+ // Proceed to check values against simulated costs
+ w.logger.Error("Failed to get batch state", "error", err)
+ w.logger.Info("Proceeding with simulated cost checks")
+
+ return w.compareBalances(simulatedCost, aggregatorAddress, senderAddress)
+ }
+	}
+	// At this point, batchState was successfully retrieved
+	// Proceed to check values against RespondToTaskFeeLimit
+	respondToTaskFeeLimit := batchState.RespondToTaskFeeLimit
+	w.logger.Info("Batch RespondToTaskFeeLimit", "RespondToTaskFeeLimit", respondToTaskFeeLimit)
+
+	if respondToTaskFeeLimit.Cmp(simulatedCost) < 0 {
+ return fmt.Errorf("cost of transaction is higher than Batch.RespondToTaskFeeLimit")
+	}
+
+	return w.compareBalances(respondToTaskFeeLimit, aggregatorAddress, senderAddress)
+}
+
+func (w *AvsWriter) compareBalances(amount *big.Int, aggregatorAddress common.Address, senderAddress [20]byte) error {
+	if err := w.compareAggregatorBalance(amount, aggregatorAddress); err != nil {
+ return err
+	}
+	if err := w.compareBatcherBalance(amount, senderAddress); err != nil {
+ return err
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareAggregatorBalance(amount *big.Int, aggregatorAddress common.Address) error {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	// Get Agg wallet balance
+	aggregatorBalance, err := w.Client.BalanceAt(ctx, aggregatorAddress, nil)
+	if err != nil {
+ aggregatorBalance, err = w.ClientFallback.BalanceAt(ctx, aggregatorAddress, nil)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("failed to get aggregator balance: %v", err)
+ return nil
+ }
+	}
+	w.logger.Info("Aggregator balance", "balance", aggregatorBalance)
+	if aggregatorBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Aggregator balance")
+	}
+	return nil
+}
+
+func (w *AvsWriter) compareBatcherBalance(amount *big.Int, senderAddress [20]byte) error {
+	// Get batcher balance
+	batcherBalance, err := w.AvsContractBindings.ServiceManager.BatchersBalances(&bind.CallOpts{}, senderAddress)
+	if err != nil {
+ batcherBalance, err = w.AvsContractBindings.ServiceManagerFallback.BatchersBalances(&bind.CallOpts{}, senderAddress)
+ if err != nil {
+ // Ignore and continue.
+ w.logger.Error("Failed to get batcherBalance", "error", err)
+ return nil
+ }
+	}
+	w.logger.Info("Batcher balance", "balance", batcherBalance)
+	if batcherBalance.Cmp(amount) < 0 {
+ return fmt.Errorf("cost is higher than Batcher balance")
+	}
+	return nil
+}