@ledgerhq/coin-tezos 10.2.2 → 10.2.6

package/src/logic/estimateFees.test.ts

@@ -54,9 +54,19 @@ describe('estimateFees', () => {
     contract: {
       at: jest.fn(),
     },
+    rpc: {
+      getConstants: jest.fn(),
+    },
     setProvider: jest.fn(),
   }
 
+  // Mainnet values; the two are equal, which is what makes a reveal + operation batch
+  // overflow the block limit unless the operation's gas is capped.
+  const MAINNET_GAS_CONSTANTS = {
+    hard_gas_limit_per_operation: 1040000,
+    hard_gas_limit_per_block: 1040000,
+  }
+
   let currentConfig: TezosCoinConfig
   const context: TezosContext = {
     config: async () => currentConfig,
@@ -72,6 +82,7 @@ describe('estimateFees', () => {
     jest
       .mocked<DeepPartialReturn<typeof getTezosToolkit>>(getTezosToolkit)
       .mockReturnValue(mockTezosToolkit)
+    mockTezosToolkit.rpc.getConstants.mockResolvedValue(MAINNET_GAS_CONSTANTS)
     currentConfig = mkConfig(defaultFeesConfig)
   })
 
@@ -312,7 +323,7 @@ describe('estimateFees', () => {
     expect(result.amount).toBe(5000n)
   })
 
-  it('useAllAmount stake coerces amount to 1 for estimation and resolves max to balance minus fees and reserve', async () => {
+  it('useAllAmount stake probes above the pseudotoken rate and resolves max to balance minus fees and reserve', async () => {
     const suggestedFee = 700
     const balance = 1_000_000n
     mockTezosToolkit.estimate.stake.mockResolvedValue({
@@ -334,13 +345,48 @@ describe('estimateFees', () => {
     })
 
     expect(mockTezosToolkit.estimate.stake).toHaveBeenCalledWith({
-      amount: 1,
+      amount: 1000,
       mutez: true,
     })
     expect(result.fees).toBe(BigInt(suggestedFee))
     expect(result.amount).toBe(balance - BigInt(suggestedFee) - 10_000n)
   })
 
+  it('stake with no amount yet returns the fallback estimation without simulating', async () => {
+    const result = await estimateFees(context, {
+      account: revealedAccount,
+      transaction: {
+        mode: 'stake',
+        recipient: '',
+        amount: 0n,
+      },
+    })
+
+    expect(mockTezosToolkit.estimate.stake).not.toHaveBeenCalled()
+    expect(result.fees).toBe(BigInt(defaultFeesConfig.minEstimatedFees))
+    expect(result.estimatedFees).toBe(BigInt(defaultFeesConfig.minEstimatedFees))
+    expect(result.gasLimit).toBe(BigInt(defaultFeesConfig.minGasLimit))
+    expect(result.storageLimit).toBe(BigInt(defaultFeesConfig.minStorageLimit))
+  })
+
+  it('stake with no amount yet adds the reveal fee to the fallback on unrevealed accounts', async () => {
+    const result = await estimateFees(context, {
+      account: unrevealedAccount,
+      transaction: {
+        mode: 'stake',
+        recipient: '',
+        amount: 0n,
+      },
+    })
+
+    expect(mockTezosToolkit.estimate.stake).not.toHaveBeenCalled()
+    const expectedRevealFee = BigInt(getRevealFee(unrevealedAccount.address))
+    expect(result.fees).toBe(BigInt(defaultFeesConfig.minEstimatedFees))
+    expect(result.estimatedFees).toBe(
+      BigInt(defaultFeesConfig.minEstimatedFees) + expectedRevealFee
+    )
+  })
+
   it('useAllAmount stake subtracts reveal fee from maxStakable on unrevealed accounts', async () => {
     const suggestedFee = 700
     const balance = 1_000_000n
@@ -620,6 +666,93 @@ describe('estimateFees', () => {
     expect(result.estimatedFees).toBe(BigInt(400 + expectedRevealFee))
   })
 
+  it('reports a validation-time protocol error as taquitoError instead of throwing', async () => {
+    const stakeAmountTooSmall = 'proto.025-PsUshuai.block_validation_plugin.stake_amount_too_small'
+    mockTezosToolkit.estimate.stake.mockRejectedValue(
+      Object.assign(new Error('Http error response: (500)'), {
+        status: 500,
+        body: `[{"kind":"permanent","id":"${stakeAmountTooSmall}","amount":"1"}]`,
+      })
+    )
+
+    const result = await estimateFees(context, {
+      account: revealedAccount,
+      transaction: {
+        mode: 'stake',
+        recipient: '',
+        amount: 1n,
+      },
+    })
+
+    expect(result.taquitoError).toBe(stakeAmountTooSmall)
+    expect(result.fees).toBe(0n)
+  })
+
+  it('picks the mapped id out of a multi-error trace, not the generic one leading it', async () => {
+    const scriptRejected = 'proto.025-PsUshuai.michelson_v1.script_rejected'
+    mockTezosToolkit.estimate.transfer.mockRejectedValue(
+      Object.assign(new Error('Http error response: (500)'), {
+        status: 500,
+        body: JSON.stringify([
+          { kind: 'temporary', id: 'proto.025-PsUshuai.michelson_v1.runtime_error' },
+          { kind: 'temporary', id: scriptRejected, with: { string: 'nope' } },
+        ]),
+      })
+    )
+
+    const result = await estimateFees(context, {
+      account: revealedAccount,
+      transaction: {
+        mode: 'send',
+        recipient: 'tz3Vq38qYD3GEbWcXHMLt5PaASZrkDtEiA8D',
+        amount: 1000n,
+      },
+    })
+
+    expect(result.taquitoError).toBe(scriptRejected)
+  })
+
+  it('still finds the id when the body is not valid JSON', async () => {
+    const stakeAmountTooSmall = 'proto.025-PsUshuai.block_validation_plugin.stake_amount_too_small'
+    mockTezosToolkit.estimate.stake.mockRejectedValue(
+      Object.assign(new Error('Http error response: (500)'), {
+        status: 500,
+        body: `[{"kind":"permanent","id":"${stakeAmountTooSmall}","amount":"1"`,
+      })
+    )
+
+    const result = await estimateFees(context, {
+      account: revealedAccount,
+      transaction: {
+        mode: 'stake',
+        recipient: '',
+        amount: 1n,
+      },
+    })
+
+    expect(result.taquitoError).toBe(stakeAmountTooSmall)
+  })
+
+  it('rethrows a protocol error the mapping does not cover, so callers can still retry', async () => {
+    mockTezosToolkit.estimate.setDelegate.mockRejectedValue(
+      Object.assign(new Error('Http error response: (500)'), {
+        status: 500,
+        body: '[{"kind":"permanent","id":"proto.025-PsUshuai.gas_limit_too_high"}]',
+      })
+    )
+
+    await expect(
+      estimateFees(context, {
+        account: revealedAccount,
+        transaction: {
+          mode: 'delegate',
+          recipient: 'tz1validator',
+          amount: 0n,
+        },
+      })
+    ).rejects.toThrow('Http error response: (500)')
+  })
+
   it('send_token (FA2) revealed applies estimation from contract transfer', async () => {
     const { transfer } = setupFa2ContractMock()
     mockTezosToolkit.contract.at.mockResolvedValue({ methods: { transfer } })
@@ -657,6 +790,95 @@ describe('estimateFees', () => {
     expect(result.amount).toBe(100n)
   })
 
+  it('send_token unrevealed caps gas so the reveal batch fits the block limit', async () => {
+    const { transfer } = setupFa2ContractMock()
+    mockTezosToolkit.contract.at.mockResolvedValue({ methods: { transfer } })
+    mockTezosToolkit.estimate.transfer.mockResolvedValue({
+      suggestedFeeMutez: 600,
+      gasLimit: 4000,
+      storageLimit: 0,
+      burnFeeMutez: 0,
+      opSize: 250,
+    })
+
+    await estimateFees(context, {
+      account: unrevealedAccount,
+      transaction: {
+        mode: 'send_token',
+        recipient: 'tz1VSUr8wwNhLAzempoch5d6nLRSNtxK8LBr',
+        amount: BigInt(100),
+        contractAddress: 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU',
+        tokenId: 0,
+      },
+    })
+
+    // min(1040000, 1040000 / 3): leaves room for the reveal Taquito prepends, so the
+    // simulation does not overflow hard_gas_limit_per_block.
+    expect(mockTezosToolkit.estimate.transfer).toHaveBeenCalledWith(
+      expect.objectContaining({ gasLimit: 346666 })
+    )
+  })
+
+  it('send_token derives the gas cap from protocol constants', async () => {
+    mockTezosToolkit.rpc.getConstants.mockResolvedValue({
+      hard_gas_limit_per_operation: 900000,
+      hard_gas_limit_per_block: 2400000,
+    })
+    const { transfer } = setupFa2ContractMock()
+    mockTezosToolkit.contract.at.mockResolvedValue({ methods: { transfer } })
+    mockTezosToolkit.estimate.transfer.mockResolvedValue({
+      suggestedFeeMutez: 600,
+      gasLimit: 4000,
+      storageLimit: 0,
+      burnFeeMutez: 0,
+      opSize: 250,
+    })
+
+    await estimateFees(context, {
+      account: unrevealedAccount,
+      transaction: {
+        mode: 'send_token',
+        recipient: 'tz1VSUr8wwNhLAzempoch5d6nLRSNtxK8LBr',
+        amount: BigInt(100),
+        contractAddress: 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU',
+        tokenId: 0,
+      },
+    })
+
+    // min(900000, 2400000 / 3): the block-derived bound is the tighter one here.
+    expect(mockTezosToolkit.estimate.transfer).toHaveBeenCalledWith(
+      expect.objectContaining({ gasLimit: 800000 })
+    )
+  })
+
+  it('send_token revealed passes no gas cap', async () => {
+    const { transfer } = setupFa2ContractMock()
+    mockTezosToolkit.contract.at.mockResolvedValue({ methods: { transfer } })
+    mockTezosToolkit.estimate.transfer.mockResolvedValue({
+      suggestedFeeMutez: 600,
+      gasLimit: 4000,
+      storageLimit: 0,
+      burnFeeMutez: 0,
+      opSize: 250,
+    })
+
+    await estimateFees(context, {
+      account: revealedAccount,
+      transaction: {
+        mode: 'send_token',
+        recipient: 'tz1VSUr8wwNhLAzempoch5d6nLRSNtxK8LBr',
+        amount: BigInt(100),
+        contractAddress: 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU',
+        tokenId: 0,
+      },
+    })
+
+    // No reveal is prepended, so the batch cannot overflow and Taquito keeps its own default.
+    const params = mockTezosToolkit.estimate.transfer.mock.calls.at(-1)?.[0]
+    expect(params).not.toHaveProperty('gasLimit')
+    expect(mockTezosToolkit.rpc.getConstants).not.toHaveBeenCalled()
+  })
+
   it('send_token unrevealed adds reveal fee to estimatedFees', async () => {
     const { transfer } = setupFa2ContractMock()
     mockTezosToolkit.contract.at.mockResolvedValue({ methods: { transfer } })

package/src/logic/estimateFees.ts

@@ -4,7 +4,6 @@
 import type { TezosCoinConfig, TezosContext } from '../config'
 import type { TezosOperationMode } from '../types/model'
 import type { Estimate } from '@taquito/taquito'
-import { log } from '@ledgerhq/logs'
 import { COST_PER_BYTE, getRevealFee, ORIGINATION_SIZE } from '@taquito/taquito'
 import { validatePublicKey, ValidationResult } from '@taquito/utils'
 import { UnsupportedTransactionMode } from '../types/errors'
@@ -13,10 +12,12 @@ import {
   createFallbackEstimation,
   createMockSigner,
   DUST_MARGIN_MUTEZ,
+  isMappedTaquitoError,
   MIN_SUGGESTED_FEE_SMALL_TRANSFER,
   OP_SIZE_XTZ_TRANSFER,
   normalizePublicKeyForAddress,
   partitionNativeBalance,
+  STAKE_ESTIMATION_PROBE_MUTEZ,
 } from '../utils'
 import { getTezosToolkit } from './tezosToolkit'
 
@@ -106,7 +107,8 @@ export async function estimateFees(
         transaction.mode === 'unstake')) ||
     (amount === 0n && transaction.mode !== 'send_token')
   if (coerceMinAmountForEstimation) {
-    amount = 1n // send/stake max or zero-amount pre-estimation (taquito refuses 0); not used for FA2 send_token
+    // send/stake max or zero-amount pre-estimation (taquito refuses 0); not used for FA2 send_token
+    amount = transaction.mode === 'stake' ? STAKE_ESTIMATION_PROBE_MUTEZ : 1n
   }
 
   try {
@@ -119,6 +121,19 @@ export async function estimateFees(
         ...createFallbackEstimation(config),
       }
     }
+    const isStakeWithNoAmountYet =
+      transaction.mode === 'stake' && transaction.amount === 0n && !transaction.useAllAmount
+    if (isStakeWithNoAmountYet) {
+      const fallback = createFallbackEstimation(config)
+      const revealFee = account.revealed
+        ? 0n
+        : BigInt(getRevealFeeForEstimation(config, account.address))
+      return {
+        ...estimation,
+        ...fallback,
+        estimatedFees: fallback.estimatedFees + revealFee,
+      }
+    }
     let estimate: Estimate
     switch (transaction.mode) {
       case 'send':
@@ -175,9 +190,13 @@ export async function estimateFees(
             },
           ])
           .toTransferParams({ mutez: true })
+        const revealBatchGasLimit = account.revealed
+          ? undefined
+          : await gasLimitForRevealBatch(tezosToolkit)
         estimate = await tezosToolkit.estimate.transfer({
           ...transferParams,
           source: account.address,
+          ...(revealBatchGasLimit !== undefined && { gasLimit: revealBatchGasLimit }),
         })
         break
       }
@@ -210,7 +229,7 @@ export async function estimateFees(
       const incr = DUST_MARGIN_MUTEZ * MINIMAL_FEE_PER_GAS_MUTEZ + Number(estimate.opSize)
       const maxMinusBuff = maxAmount - (DUST_MARGIN_MUTEZ - incr)
       estimation.amount = maxMinusBuff > 0 ? BigInt(maxMinusBuff) : 0n
-      log('tezos-send-max', 'send-max fee inputs', {
+      context.logger('tezos-send-max', 'send-max fee inputs', {
         minFees,
         mainOpFee,
         suggestedFeeMutez: estimate.suggestedFeeMutez,
@@ -240,14 +259,15 @@ export async function estimateFees(
     if (typeof e !== 'object' || !e) throw e
     if ('id' in e) {
       estimation.taquitoError = String(e.id)
-      log('taquito-error', 'taquito got error ' + String(e.id))
+      context.logger('taquito-error', 'taquito got error ' + String(e.id))
     } else if ('status' in e) {
       const errorMessage = 'message' in e ? String(e.message) : ''
+      const protocolErrorId = mappedProtocolErrorId(e)
       if (
         errorMessage.includes('Public key not found') ||
         errorMessage.includes('wallet or contract API')
       ) {
-        log(
+        context.logger(
           'taquito-network-error',
           'Recipient address not found (new account), using default fees',
           {
@@ -297,8 +317,14 @@ export async function estimateFees(
           // preserve input amount in fallback for readability/tests
           estimation.amount = transaction.amount
         }
+      } else if (protocolErrorId) {
+        estimation.taquitoError = protocolErrorId
+        context.logger(
+          'taquito-error',
+          'node refused the operation before applying it ' + protocolErrorId
+        )
       } else {
-        log('taquito-network-error', errorMessage, {
+        context.logger('taquito-network-error', errorMessage, {
           transaction: transaction,
         })
         throw e
@@ -352,7 +378,66 @@ export async function estimateFees(
   return estimation
 }
 
-function getRevealFeeForEstimation(config: TezosCoinConfig, address: string): number {
+/**
+ * A protocol error raised while validating an operation comes back as an HTTP error whose body is
+ * the raw error array, so Taquito exposes no `id` of its own for `mapTaquitoErrors` to match.
+ *
+ * Only the ids that mapping covers are reported: any other has to keep propagating, because
+ * callers retry on a thrown estimation (see the without-public-key retry in `api/index.ts`).
+ */
+function mappedProtocolErrorId(error: object): string | undefined {
+  const body = 'body' in error && typeof error.body === 'string' ? error.body : ''
+  const message = 'message' in error ? String(error.message) : ''
+  // A trace lists the generic error first and the specific one last, the convention Taquito's
+  // own `TezosOperationError.lastError` relies on.
+  return protocolErrorIds(body || message)
+    .filter(isMappedTaquitoError)
+    .at(-1)
+}
+
+function protocolErrorIds(text: string): string[] {
+  try {
+    const parsed: unknown = JSON.parse(text)
+    const errors: unknown[] = Array.isArray(parsed) ? parsed : [parsed]
+    return errors.flatMap((error) =>
+      typeof error === 'object' && error !== null && 'id' in error && typeof error.id === 'string'
+        ? [error.id]
+        : []
+    )
+  } catch {
+    return Array.from(text.matchAll(/"id"\s*:\s*"([^"]+)"/g), (match) => match[1])
+  }
+}
+
+/**
+ * Gas limit to hand Taquito when the source account is unrevealed.
+ *
+ * Taquito prepends a reveal to any operation from an unrevealed account, then gives the
+ * operation itself `hard_gas_limit_per_operation` for the simulation. Mainnet sets
+ * `hard_gas_limit_per_block` to that same value, so the reveal's own gas tips the batch past
+ * the block limit and the node answers HTTP 500 `gas_exhausted.block`. Without a cap the
+ * estimation fails and the caller falls back to native-transfer constants, which are far too
+ * small for an FA2 transfer.
+ *
+ * Mirrors Taquito's own batch adjustment, `min(perOperation, perBlock / (opCount + 1))`, so
+ * the value tracks the protocol rather than a hardcoded figure.
+ */
+async function gasLimitForRevealBatch(
+  tezosToolkit: ReturnType<typeof getTezosToolkit>
+): Promise<number> {
+  const constants = await tezosToolkit.rpc.getConstants()
+  const perOperation = Number(constants.hard_gas_limit_per_operation)
+  const perBlock = Number(constants.hard_gas_limit_per_block)
+  const REVEAL_PLUS_OPERATION = 2
+  return Math.floor(Math.min(perOperation, perBlock / (REVEAL_PLUS_OPERATION + 1)))
+}
+
+/**
+ * Reveal fee the estimation reports as part of the total, derived from Taquito's static per-curve
+ * table rather than a node estimate. The account is unrevealed and the public key is often absent
+ * at estimation time, so `estimate.reveal()` is not reliably available here.
+ */
+export function getRevealFeeForEstimation(config: TezosCoinConfig, address: string): number {
   const minFees = config.fees.minFees ?? 0
   return Math.max(minFees, getRevealFee(address))
 }

package/src/logic/estimateRevealLimits.ts

@@ -1,9 +1,8 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosConfig } from '../config'
+import type { TezosContext } from '../config'
 import type { getTezosToolkit } from './tezosToolkit'
-import { log } from '@ledgerhq/logs'
 import { getRevealFee, getRevealGasLimit } from '@taquito/taquito'
 
 type RevealLimits = { fee: number; gasLimit: number; storageLimit: number }
@@ -14,19 +13,24 @@ type RevealLimits = { fee: number; gasLimit: number; storageLimit: number }
  * (some addresses error with "inconsistent_hash").
  */
 export async function estimateRevealLimits(
+  context: TezosContext,
   tezosToolkit: ReturnType<typeof getTezosToolkit>,
-  address: string,
-  feesConfig: TezosConfig['fees']
+  address: string
 ): Promise<RevealLimits> {
+  const { fees: feesConfig } = await context.config()
   type RevealEstimate = { gasLimit?: number; storageLimit?: number; suggestedFeeMutez?: number }
   let revealEstimate: RevealEstimate | undefined
   try {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     revealEstimate = (await tezosToolkit.estimate.reveal()) as RevealEstimate | undefined
   } catch (error) {
-    log('estimate-error', 'error estimating reveal fees, trying to use getRevealGasLimit', {
-      error,
-    })
+    context.logger(
+      'estimate-error',
+      'error estimating reveal fees, trying to use getRevealGasLimit',
+      {
+        error,
+      }
+    )
     revealEstimate = {
       gasLimit: getRevealGasLimit(address),
       suggestedFeeMutez: getRevealFee(address),

package/src/logic/getBalance.ts

@@ -3,7 +3,6 @@
 
 import type { TezosContext } from '../config'
 import type { Balance } from '@ledgerhq/coin-module-framework/api/index'
-import { log } from '@ledgerhq/logs'
 import { hasManagerKey } from '../network/types'
 import { createTzktApi } from '../network/tzkt'
 import { partitionNativeBalance } from '../utils'
@@ -60,14 +59,18 @@ export async function getBalance(context: TezosContext, address: string): Promis
   const normalized = BigInt(apiAccount.balance)
 
   const unstakeRequests = await fetchUnstakeRequests(config, address, apiAccount).catch((error) => {
-    log('coin:tezos', 'getBalance: fetchUnstakeRequests failed; degrading stakes to []', {
-      error,
-      address,
-    })
+    context.logger(
+      'coin:tezos',
+      'getBalance: fetchUnstakeRequests failed; degrading stakes to []',
+      {
+        error,
+        address,
+      }
+    )
     return []
   })
 
-  const stakes = buildStakesForAccount(address, apiAccount, unstakeRequests)
+  const stakes = buildStakesForAccount(context.logger, address, apiAccount, unstakeRequests)
   const stakedBalance = BigInt(apiAccount.stakedBalance ?? 0)
   const unstakedBalance = BigInt(apiAccount.unstakedBalance ?? 0)
   const { locked } = partitionNativeBalance(normalized, stakedBalance, unstakedBalance)

package/src/logic/getBlock.ts

@@ -534,12 +534,12 @@ export async function getBlock(context: TezosContext, height: number): Promise<B
   ] = await Promise.all([
     tzkt.getBlockByLevel(height),
     tzkt.getBlockByLevel(height - 1),
-    fetchBlockTransactions(config, height),
-    fetchBlockTokenTransfers(config, height),
-    fetchBlockDelegations(config, height),
-    fetchBlockStaking(config, height),
-    fetchBlockOriginations(config, height),
-    fetchBlockReveals(config, height),
+    fetchBlockTransactions(context, height),
+    fetchBlockTokenTransfers(context, height),
+    fetchBlockDelegations(context, height),
+    fetchBlockStaking(context, height),
+    fetchBlockOriginations(context, height),
+    fetchBlockReveals(context, height),
   ])
 
   // Token transfers triggered by originations from other blocks carry an

package/src/logic/getStakes.ts

@@ -4,7 +4,7 @@
 import type { TezosCoinConfig, TezosContext } from '../config'
 import type { APIAccount, APIManagerAccount, APIUnstakeRequest } from '../network/types'
 import type { Cursor, Page, Stake } from '@ledgerhq/coin-module-framework/api/types'
-import { log } from '@ledgerhq/logs'
+import type { Logger } from '@ledgerhq/coin-module-framework/config'
 import { hasManagerKey } from '../network/types'
 import { createTzktApi } from '../network/tzkt'
 import { partitionNativeBalance } from '../utils'
@@ -28,17 +28,21 @@ export function fetchUnstakeRequests(
     : Promise.resolve([])
 }
 
-function unstakeRequestToStake(address: string, req: APIUnstakeRequest): Stake | null {
+function unstakeRequestToStake(
+  logger: Logger,
+  address: string,
+  req: APIUnstakeRequest
+): Stake | null {
   // TzKT's status filter is unreliable; never build a position for a finalized request.
   if (req.status !== 'pending' && req.status !== 'finalizable') {
-    log('coin:tezos', 'unstakeRequestToStake: dropping non-active unstake request', {
+    logger('coin:tezos', 'unstakeRequestToStake: dropping non-active unstake request', {
       requestId: req.id,
       status: req.status,
     })
     return null
   }
   if (req.actualAmount <= 0) {
-    log('coin:tezos', 'unstakeRequestToStake: dropping non-positive unstake request', {
+    logger('coin:tezos', 'unstakeRequestToStake: dropping non-positive unstake request', {
       requestId: req.id,
       actualAmount: req.actualAmount,
     })
@@ -46,7 +50,7 @@ function unstakeRequestToStake(address: string, req: APIUnstakeRequest): Stake |
   }
   const createdAt = new Date(req.firstTime)
   if (!Number.isFinite(createdAt.getTime())) {
-    log('coin:tezos', 'unstakeRequestToStake: dropping unstake request with invalid firstTime', {
+    logger('coin:tezos', 'unstakeRequestToStake: dropping unstake request with invalid firstTime', {
       requestId: req.id,
       firstTime: req.firstTime,
     })
@@ -67,6 +71,7 @@ function unstakeRequestToStake(address: string, req: APIUnstakeRequest): Stake |
 }
 
 export function buildStakesForAccount(
+  logger: Logger,
   address: string,
   account: APIManagerAccount,
   unstakeRequests: APIUnstakeRequest[]
@@ -80,7 +85,7 @@ export function buildStakesForAccount(
 
   const unstakeStakes: Stake[] = []
   for (const req of unstakeRequests) {
-    const stake = unstakeRequestToStake(address, req)
+    const stake = unstakeRequestToStake(logger, address, req)
     if (stake) unstakeStakes.push(stake)
   }
 
@@ -93,7 +98,7 @@ export function buildStakesForAccount(
       unstakedBalance
     )
     if (locked < stakedBalance + unstakedBalance) {
-      log('coin:tezos', 'buildStakesForAccount: balance < staked + unstaked, clamping to 0', {
+      logger('coin:tezos', 'buildStakesForAccount: balance < staked + unstaked, clamping to 0', {
         address,
         balance: balance.toString(),
         stakedBalance: stakedBalance.toString(),
@@ -137,5 +142,5 @@ export async function getStakes(
   const accountInfo = await createTzktApi(config).getAccountByAddress(address)
   if (!hasManagerKey(accountInfo)) return { items: [] }
   const unstakeRequests = await fetchUnstakeRequests(config, address, accountInfo)
-  return { items: buildStakesForAccount(address, accountInfo, unstakeRequests) }
+  return { items: buildStakesForAccount(context.logger, address, accountInfo, unstakeRequests) }
 }