Autostaker uses fixed gas limit and nonce on stake/unstake, wait bugfix (#3237)

- Set a fixed gas limit in autostaker when doing stake/unstake
transactions, because `estimateGas` on `stake` transactions will
otherwise fail (with not enough balance) until `unstake` transactions
have been mined.
- Control nonce manually to prevent overlaps
- Fix wait bug

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Autostaker switches stake/unstake to fixed gas limit with explicit
nonces and longer timeouts, while SDK exposes TransactionOpts and
updates staking helpers to accept tx options with improved receipt
handling/logging.
> 
> - **Node (`autostaker`)**:
> - Use fixed `gasLimit` (`500000n`) and explicit `nonce` per action;
increase `TRANSACTION_TIMEOUT` to `180s`.
> - Change action submission to return `{ txResponse, txReceiptPromise
}`; broadcast all, then await receipts with `Promise.allSettled` and
summary logging.
> - Pass `TransactionOpts` to stake/unstake; remove gas estimation/bump
logic.
> - **SDK**:
> - Add and export `TransactionOpts` type; update
`_operatorContractUtils.stake/unstake` to accept tx opts and forward to
contract calls.
> - Remove gas estimation/bump; add nonce-aware logging and error
handling around `tx.wait`.
> - **Changelog**:
>   - Note autostaker fixes and optimizations.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
3fe01a8. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Teo Gebhard <[email protected]>

Author: hpihkala

CHANGELOG.md

@@ -15,6 +15,7 @@ Changes before Tatum release are not documented in this file.
 Autostaker changes:
 - transaction timeouts (https://github.com/streamr-dev/network/pull/3236)
 - queries filter by required block number (https://github.com/streamr-dev/network/pull/3238)
+- autostaker fixes and optimizations (https://github.com/streamr-dev/network/pull/3237)
 
 #### Changed
 

packages/node/src/plugins/autostaker/AutostakerPlugin.ts

@@ -1,4 +1,4 @@
-import { _operatorContractUtils, SignerWithProvider, SponsorshipCreatedEvent, StreamrClient } from '@streamr/sdk'
+import { _operatorContractUtils, SignerWithProvider, SponsorshipCreatedEvent, StreamrClient, TransactionOpts } from '@streamr/sdk'
 import { collect, Logger, retry, scheduleAtApproximateInterval, TheGraphClient, toEthereumAddress, WeiAmount } from '@streamr/utils'
 import { Schema } from 'ajv'
 import { ContractTransactionReceipt, ContractTransactionResponse, formatEther, parseEther } from 'ethers'
@@ -52,8 +52,13 @@ const logger = new Logger(module)
 const MIN_SPONSORSHIP_TOTAL_PAYOUT_PER_SECOND = 1000000000000n
 const ACTION_SUBMIT_RETRY_COUNT = 5
 const ACTION_SUBMIT_RETRY_DELAY_MS = 5000
-const ACTION_GAS_LIMIT_BUMP_PCT = 20
-const TRANSACTION_TIMEOUT = 60 * 1000
+const ACTION_GAS_LIMIT = 500000n
+const TRANSACTION_TIMEOUT = 180 * 1000
+
+interface SubmitActionResult {
+    txResponse: ContractTransactionResponse
+    txReceiptPromise: Promise<ContractTransactionReceipt | null>
+}
 
 const fetchMinStakePerSponsorship = async (theGraphClient: TheGraphClient): Promise<bigint> => {
     const queryResult = await theGraphClient.queryEntity<{ network: { minimumStakeWei: string } }>({
@@ -73,7 +78,7 @@ const getStakeOrUnstakeFunction = (action: Action): (
     operatorContractAddress: string,
     sponsorshipContractAddress: string,
     amount: WeiAmount,
-    bumpGasLimitPct: number,
+    txOpts: TransactionOpts,
     onSubmit: (tx: ContractTransactionResponse) => void,
     transactionTimeout?: number
 ) => Promise<ContractTransactionReceipt | null> => {
@@ -138,28 +143,28 @@ export class AutostakerPlugin extends Plugin<AutostakerPluginConfig> {
     }
 
     // Broadcasts a transaction corresponding to the action without waiting for it to be mined
-    private async submitAction(action: Action, signer: SignerWithProvider): Promise<ContractTransactionResponse> {
+    private async submitAction(action: Action, signer: SignerWithProvider, txOpts: TransactionOpts): Promise<SubmitActionResult> {
         logger.info(`Execute action: ${action.type} ${formatEther(action.amount)} ${action.sponsorshipId}`)
         const stakeOrUnstakeFunction = getStakeOrUnstakeFunction(action)
         return new Promise((resolve, reject) => {
-            stakeOrUnstakeFunction(signer,
+            const txReceiptPromise = stakeOrUnstakeFunction(signer,
                 this.pluginConfig.operatorContractAddress,
                 action.sponsorshipId,
                 action.amount,
-                // Gas limit needed for staking/unstaking is a little unstable because others might 
-                // be staking/unstaking at the same time, so we bump the gas limit to be safe
-                ACTION_GAS_LIMIT_BUMP_PCT,
+                txOpts,
                 // resolve on the onSubmit callback (=tx is broadcasted) instead of when the stakeOrUnstakeFunction resolves (=tx is mined)
-                (tx) => resolve(tx),
+                (txResponse) => resolve({ txResponse, txReceiptPromise }),
                 TRANSACTION_TIMEOUT 
-            ).catch(reject)
+            )
+            // Propagate errors that occur before onSubmit is called
+            txReceiptPromise.catch(reject)
         })
     }
 
     // This will retry the transaction preflight checks, defends against various transient errors
-    private async submitActionWithRetry(action: Action, signer: SignerWithProvider): Promise<ContractTransactionResponse> {
+    private async submitActionWithRetry(action: Action, signer: SignerWithProvider, txOpts: TransactionOpts): Promise<SubmitActionResult> {
         return await retry(
-            () => this.submitAction(action, signer),
+            () => this.submitAction(action, signer, txOpts),
             (message, error) => {
                 logger.error(message, { error })
             },
@@ -218,18 +223,36 @@ export class AutostakerPlugin extends Plugin<AutostakerPluginConfig> {
             ...actions.filter((a) => a.type === 'unstake'), 
             ...actions.filter((a) => a.type === 'stake')
         ]
-        const allTxs: ContractTransactionResponse[] = []
+        const allSubmitActionPromises: Promise<SubmitActionResult>[] = []
+
+        // Set nonce explicitly, because ethers tends to mess up nonce if we submit 
+        // multiple transactions in quick succession
+        const address = await signer.getAddress()
+        let nonce = await signer.provider.getTransactionCount(address)
 
-        // Broadcast each action sequentially (to avoid nonce overlap) but without waiting for each one to be mined
+        // Broadcast each action but don't wait for them to be mined
         for (const action of orderedActions) {
-            const tx = await this.submitActionWithRetry(action, signer)
-            allTxs.push(tx)
+            const submitActionPromise = this.submitActionWithRetry(action, signer, {
+                // Use a fixed gas limit - gas estimation of stake transactions would fails 
+                // with "not enough balance", because we first need to unstake before we stake
+                gasLimit: ACTION_GAS_LIMIT,
+                // Explicit nonce
+                nonce: nonce++,
+            })
+            allSubmitActionPromises.push(submitActionPromise)
         }
 
+        const allReceiptPromises = allSubmitActionPromises.map(async (p) => (await p).txReceiptPromise)
+
         // Wait for all transactions to be mined (don't stop waiting if some of them fail)
         // Note that if the actual submitted transaction errors, it won't get retried. This should be rare.
-        await Promise.allSettled(allTxs.map((tx) => tx.wait()))
-        logger.info('All actions executed')
+        const settledResults = await Promise.allSettled(allReceiptPromises)
+        const successfulResults = settledResults.filter((r) => r.status === 'fulfilled')
+        const failedResults = settledResults.filter((r) => r.status === 'rejected')
+        logger.info(`All actions finished. Successful actions: ${successfulResults.length}, Failed actions: ${failedResults.length}`)
+        if (failedResults.length > 0) {
+            logger.error('Failed to execute some actions:', { failedResults })
+        }
     }
 
     private async getStakeableSponsorships(

packages/sdk/src/contracts/operatorContractUtils.ts

@@ -13,6 +13,7 @@ import {
 import { Logger, multiplyWeiAmount, WeiAmount } from '@streamr/utils'
 import {
     AbiCoder,
+    BigNumberish,
     Contract,
     ContractTransactionReceipt,
     ContractTransactionResponse,
@@ -42,6 +43,16 @@ export interface DeployOperatorContractOpts {
     transactionTimeout?: number
 }
 
+/**
+ * @deprecated
+ * @hidden
+ */
+export interface TransactionOpts {
+    gasLimit?: BigNumberish
+    gasPrice?: BigNumberish
+    nonce?: number
+}
+
 /**
  * @param opts.deployer should be the operator's Wallet
  * @returns Operator
@@ -170,32 +181,32 @@ export const stake = async (
     operatorContractAddress: string,
     sponsorshipContractAddress: string,
     amount: WeiAmount,
-    bumpGasLimitPct: number = 0,
+    txOpts: TransactionOpts = {},
     onSubmit: (tx: ContractTransactionResponse) => void = () => {},
     transactionTimeout?: number
 ): Promise<ContractTransactionReceipt | null> => {
     logger.debug('Stake', { amount: formatEther(amount), sponsorshipContractAddress })
     const operatorContract = getOperatorContract(operatorContractAddress).connect(staker)
-
-    let gasLimit = await operatorContract.stake.estimateGas(sponsorshipContractAddress, amount)
-    if (bumpGasLimitPct > 0) {
-        gasLimit = bumpGasLimit(gasLimit, bumpGasLimitPct)
-    }
-
-    const tx = await operatorContract.stake(sponsorshipContractAddress, amount, { gasLimit })
-    logger.debug('Stake: transaction submitted', { tx: tx.hash })
+    const tx = await operatorContract.stake(sponsorshipContractAddress, amount, txOpts)
+    logger.debug('Stake: transaction submitted', { tx: tx.hash, nonce: tx.nonce })
     onSubmit(tx)
-    const receipt = await tx.wait(undefined, transactionTimeout)
-    logger.debug('Stake: confirmation received', { receipt: receipt?.hash })
-    return receipt
+    logger.debug('Stake: waiting for transaction to be mined', { tx: tx.hash, timeout: transactionTimeout })
+    try {
+        const receipt = await tx.wait(undefined, transactionTimeout)
+        logger.debug('Stake: confirmation received', { receipt: receipt?.hash })
+        return receipt
+    } catch (error) {
+        logger.error(`Stake: error waiting for tx to be mined`, { tx: tx.hash, error })
+        throw error
+    }
 }
 
 export const unstake = async (
     staker: SignerWithProvider,
     operatorContractAddress: string,
     sponsorshipContractAddress: string,
     amount: WeiAmount,
-    bumpGasLimitPct: number = 0,
+    txOpts: TransactionOpts = {},
     onSubmit: (tx: ContractTransactionResponse) => void = () => {},
     transactionTimeout?: number
 ): Promise<ContractTransactionReceipt | null> => {
@@ -205,17 +216,18 @@ export const unstake = async (
     const currentAmount = await sponsorshipContract.stakedWei(operatorContractAddress)
     const targetAmount = currentAmount - amount
 
-    let gasLimit = await operatorContract.reduceStakeTo.estimateGas(sponsorshipContractAddress, targetAmount)
-    if (bumpGasLimitPct > 0) {
-        gasLimit = bumpGasLimit(gasLimit, bumpGasLimitPct)
-    }
-
-    const tx = await operatorContract.reduceStakeTo(sponsorshipContractAddress, targetAmount, { gasLimit })
-    logger.debug('Unstake: transaction submitted', { tx: tx.hash })
+    const tx = await operatorContract.reduceStakeTo(sponsorshipContractAddress, targetAmount, txOpts)
+    logger.debug('Unstake: transaction submitted', { tx: tx.hash, nonce: tx.nonce })
     onSubmit(tx)
-    const receipt = await tx.wait(undefined, transactionTimeout)
-    logger.debug('Unstake: confirmation received', { receipt: receipt?.hash })
-    return receipt
+    logger.debug('Unstake: waiting for transaction to be mined', { tx: tx.hash, timeout: transactionTimeout })
+    try {
+        const receipt = await tx.wait(undefined, transactionTimeout)
+        logger.debug('Unstake: confirmation received', { receipt: receipt?.hash })
+        return receipt
+    } catch (error) {
+        logger.error(`Unstake: error waiting for tx to be mined`, { tx: tx.hash, error })
+        throw error
+    }
 }
 
 export const sponsor = async (
@@ -252,7 +264,3 @@ const getSponsorshipContract = (sponsorshipAddress: string): SponsorshipContract
 const getTokenContract = (tokenAddress: string): DATATokenContract => {
     return new Contract(tokenAddress, DATATokenABI) as unknown as DATATokenContract
 }
-
-const bumpGasLimit = (gasEstimate: bigint, increasePercentage: number): bigint => {
-    return gasEstimate * BigInt(100 + increasePercentage) / 100n
-}

packages/sdk/src/exports.ts

@@ -111,7 +111,8 @@ import {
     stake,
     unstake,
     DeploySponsorshipContractOpts,
-    getOperatorContract
+    getOperatorContract,
+    TransactionOpts
 } from './contracts/operatorContractUtils'
 
 /**
@@ -127,10 +128,10 @@ const _operatorContractUtils = {
     stake,
     unstake,
     deployOperatorContract,
-    getOperatorContract
+    getOperatorContract,
 }
 export { _operatorContractUtils }
-export type { DeployOperatorContractOpts, DeploySponsorshipContractOpts }
+export type { DeployOperatorContractOpts, DeploySponsorshipContractOpts, TransactionOpts }
 
 export type { IceServer, PeerDescriptor, PortRange } from '@streamr/dht'
 export type { AbstractSigner, Eip1193Provider, Overrides } from 'ethers'