@ledgerhq/coin-tezos 10.2.0 → 10.2.2

package/src/api/index.ts

@@ -11,13 +11,14 @@ import type {
   ListOperationsOptions,
   Page,
 } from '@ledgerhq/coin-module-framework/api/index'
+import type { Operation } from '@ledgerhq/coin-module-framework/api/index'
 import type {
   BalanceOptions,
   FeeEstimation,
   TransactionIntent,
 } from '@ledgerhq/coin-module-framework/api/types'
 import { rejectBalanceOptions } from '@ledgerhq/coin-module-framework/api/getBalance/rejectBalanceOptions'
-import { IncorrectTypeError, type Operation } from '@ledgerhq/coin-module-framework/api/index'
+import { IncorrectTypeError } from '@ledgerhq/coin-module-framework/api/index'
 import { craftTransactionData } from '@ledgerhq/coin-module-framework/logic/craftTransactionData'
 import { log } from '@ledgerhq/logs'
 import { getRevealFee } from '@taquito/taquito'
@@ -128,7 +129,7 @@ async function craft(
 
   const tezosMode = resolveTezosOperationMode(transactionIntent.type, transactionIntent.asset)
   const mappedType: TezosOperationMode =
-    tezosMode === 'send_token' ? 'send_token' : (transactionIntent.type as TezosOperationMode)
+    tezosMode === 'send_token' ? 'send_token' : transactionIntent.type
   const tokenCraftInfo =
     tezosMode === 'send_token' ? parseTezosTokenAsset(transactionIntent.asset)! : undefined
 
@@ -329,9 +330,9 @@ async function estimate(
         txFee: estimation.fees,
       },
     }
-  } catch (error: any) {
+  } catch (error: unknown) {
     // Handle PublicKeyNotFoundError
-    if (error?.message?.includes('Public key not found')) {
+    if (error instanceof Error && error.message.includes('Public key not found')) {
       const apiAccount = await api.getAccountByAddress(transactionIntent.recipient)
       const storageLimit =
         !hasEmptyBalance(apiAccount) || transactionIntent.type === 'stake' ? 0n : 277n

package/src/logic/broadcast.integ.test.ts

@@ -4,17 +4,12 @@
 import type { TezosContext } from '../config'
 import { InMemorySigner } from '@taquito/signer'
 import { OpKind, TezosToolkit } from '@taquito/taquito'
+import { mockConfig } from '../test/config'
 import { broadcast } from './broadcast'
 
 describe('Broadcast', () => {
   const context: TezosContext = {
-    config: async () =>
-      ({
-        status: { type: 'active' },
-        node: {
-          url: 'https://xtz-node.api.live.ledger.com',
-        },
-      }) as any,
+    config: async () => mockConfig,
     logger: () => undefined,
   }
 

package/src/logic/craftRawOperations.test.ts

@@ -1,9 +1,11 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig, TezosContext } from '../config'
+import type { TezosContext } from '../config'
+import type { DeepPartialReturn } from '@ledgerhq/coin-module-framework/test/utils'
 import { OpKind } from '@taquito/rpc'
 import { getPkhfromPk } from '@taquito/utils'
+import { mockConfig } from '../test/config'
 import { UnsupportedOperationKind } from '../types/errors'
 import { craftRawOperations } from './craftRawOperations'
 import { getTezosToolkit } from './tezosToolkit'
@@ -45,16 +47,15 @@ describe('craftRawOperations', () => {
   }
 
   const context: TezosContext = {
-    config: async () =>
-      ({
-        fees: { minFees: 100, minRevealGasLimit: 0, minStorageLimit: 0 },
-      }) as unknown as TezosCoinConfig,
+    config: async () => ({ ...mockConfig, fees: { ...mockConfig.fees, minFees: 100 } }),
     logger: () => undefined,
   }
 
   beforeEach(() => {
     jest.clearAllMocks()
-    ;(getTezosToolkit as jest.Mock).mockReturnValue(mockTezosToolkit)
+    jest
+      .mocked<DeepPartialReturn<typeof getTezosToolkit>>(getTezosToolkit)
+      .mockReturnValue(mockTezosToolkit)
     mockTezosToolkit.rpc.getBlock.mockResolvedValue({ hash: 'BLockHash' })
     mockTezosToolkit.rpc.forgeOperations.mockResolvedValue('deadbeef')
     // Default: account already revealed (no leading reveal op).
@@ -162,7 +163,7 @@ describe('craftRawOperations', () => {
 
   it('uses the trailing op estimate when a reveal estimate is prepended for an unrevealed source', async () => {
     mockTezosToolkit.rpc.getManagerKey.mockResolvedValue(null)
-    ;(getPkhfromPk as jest.Mock).mockReturnValue(SENDER)
+    jest.mocked(getPkhfromPk).mockReturnValue(SENDER)
     mockTezosToolkit.estimate.reveal.mockResolvedValue({
       suggestedFeeMutez: 374,
       gasLimit: 1000,
@@ -224,7 +225,7 @@ describe('craftRawOperations', () => {
 
   it('prepends a reveal when the sender is not revealed', async () => {
     mockTezosToolkit.rpc.getManagerKey.mockResolvedValue(null)
-    ;(getPkhfromPk as jest.Mock).mockReturnValue(SENDER)
+    jest.mocked(getPkhfromPk).mockReturnValue(SENDER)
     mockTezosToolkit.estimate.reveal.mockResolvedValue({
       suggestedFeeMutez: 374,
       gasLimit: 1000,
@@ -248,7 +249,7 @@ describe('craftRawOperations', () => {
 
   it('falls back to SDK reveal helpers when estimate.reveal throws', async () => {
     mockTezosToolkit.rpc.getManagerKey.mockResolvedValue(null)
-    ;(getPkhfromPk as jest.Mock).mockReturnValue(SENDER)
+    jest.mocked(getPkhfromPk).mockReturnValue(SENDER)
     mockTezosToolkit.estimate.reveal.mockRejectedValue(new Error('inconsistent_hash'))
 
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
@@ -264,7 +265,7 @@ describe('craftRawOperations', () => {
 
   it('rejects a reveal whose public key does not match the sender', async () => {
     mockTezosToolkit.rpc.getManagerKey.mockResolvedValue(null)
-    ;(getPkhfromPk as jest.Mock).mockReturnValue('tz1someoneElse')
+    jest.mocked(getPkhfromPk).mockReturnValue('tz1someoneElse')
 
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 

package/src/logic/craftRawOperations.ts

@@ -133,31 +133,46 @@ function parseOperations(rawTransaction: string): PartialTezosOperation[] {
   return parsed.map(validateOperation)
 }
 
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return !!v && typeof v === 'object' && !Array.isArray(v)
+}
+
+function assertTransaction(
+  op: Record<string, unknown>
+): asserts op is PartialTezosTransactionOperation {
+  if (!isValidAddress(op.destination)) {
+    throw new Error('craftRawOperations: a transaction requires a valid `destination` address')
+  }
+  assertMutezAmount(op.amount)
+}
+
+function assertDelegation(
+  op: Record<string, unknown>
+): asserts op is PartialTezosDelegationOperation {
+  // A delegation with no `delegate` is an undelegation; when present it must be a valid
+  // implicit account (an empty/invalid string must not be silently treated as absent).
+  if (op.delegate !== undefined && !isImplicitAddress(op.delegate)) {
+    throw new Error(
+      'craftRawOperations: `delegate` must be a valid implicit account address when present'
+    )
+  }
+}
+
 function validateOperation(op: unknown): PartialTezosOperation {
-  if (!op || typeof op !== 'object') {
+  if (!isRecord(op)) {
     throw new Error('craftRawOperations: invalid operation')
   }
-  const candidate = op as Record<string, unknown>
-  assertOptionalLimits(candidate)
-  switch (candidate.kind) {
+  assertOptionalLimits(op)
+  switch (op.kind) {
     case 'transaction':
-      if (!isValidAddress(candidate.destination)) {
-        throw new Error('craftRawOperations: a transaction requires a valid `destination` address')
-      }
-      assertMutezAmount(candidate.amount)
-      return candidate as PartialTezosTransactionOperation
+      assertTransaction(op)
+      return op
     case 'delegation':
-      // A delegation with no `delegate` is an undelegation; when present it must be a valid
-      // implicit account (an empty/invalid string must not be silently treated as absent).
-      if (candidate.delegate !== undefined && !isImplicitAddress(candidate.delegate)) {
-        throw new Error(
-          'craftRawOperations: `delegate` must be a valid implicit account address when present'
-        )
-      }
-      return candidate as unknown as PartialTezosDelegationOperation
+      assertDelegation(op)
+      return op
     default:
       throw new UnsupportedOperationKind('unsupported operation kind', {
-        kind: String(candidate.kind),
+        kind: String(op.kind),
       })
   }
 }
@@ -284,8 +299,9 @@ function buildOperationContent(
 // Compile-time exhaustiveness guard: a new PartialTezosOperation kind becomes a type error
 // here. validateOperation already rejects unknown kinds at runtime before crafting.
 function assertNever(op: never): never {
+  const r: Record<string, unknown> = op
   throw new UnsupportedOperationKind('unsupported operation kind', {
-    kind: String((op as { kind?: unknown }).kind),
+    kind: String(r.kind),
   })
 }
 

package/src/logic/craftTransaction.integ.test.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig, TezosContext } from '../config'
+import type { TezosContext } from '../config'
 import { OpKind } from '@taquito/rpc'
 import { mockConfig } from '../test/config'
 import { craftTransaction } from '.'
@@ -16,7 +16,7 @@ import { craftTransaction } from '.'
 describe('Tezos Api', () => {
   const address = 'tz1heMGVHQnx7ALDcDKqez8fan64Eyicw4DJ'
   const context: TezosContext = {
-    config: async () => mockConfig as TezosCoinConfig,
+    config: async () => mockConfig,
     logger: () => undefined,
   }
   it('should craft a send transaction', async () => {

package/src/logic/craftTransaction.test.ts

@@ -2,19 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import type { TezosCoinConfig, TezosContext } from '../config'
+import type { DeepPartialReturn } from '@ledgerhq/coin-module-framework/test/utils'
 import { OpKind } from '@taquito/rpc'
 import { getRevealFee } from '@taquito/taquito'
+import { mockConfig } from '../test/config'
 import { craftTransaction, rawEncode } from './craftTransaction'
 import { getTezosToolkit } from './tezosToolkit'
 
-type TransactionType =
-  | 'send'
-  | 'delegate'
-  | 'undelegate'
-  | 'send_token'
-  | 'stake'
-  | 'unstake'
-  | 'finalize_unstake'
+type TransactionInput = Parameters<typeof craftTransaction>[2]
 
 jest.mock('./tezosToolkit')
 
@@ -52,16 +47,18 @@ describe('craftTransaction', () => {
 
   beforeEach(() => {
     jest.clearAllMocks()
-    ;(getTezosToolkit as jest.Mock).mockReturnValue(mockTezosToolkit)
-    currentConfig = {} as unknown as TezosCoinConfig
+    jest
+      .mocked<DeepPartialReturn<typeof getTezosToolkit>>(getTezosToolkit)
+      .mockReturnValue(mockTezosToolkit)
+    currentConfig = mockConfig
   })
 
   it('should craft a send transaction', async () => {
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'send' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'send',
       recipient: 'tz2...',
       amount: BigInt(1000),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -88,8 +85,8 @@ describe('craftTransaction', () => {
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'delegate' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'delegate',
       recipient: 'tz2...',
       amount: BigInt(0),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -115,8 +112,8 @@ describe('craftTransaction', () => {
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'undelegate' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'undelegate',
       recipient: '',
       amount: BigInt(0),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -144,17 +141,11 @@ describe('craftTransaction', () => {
       storageLimit: 0,
       suggestedFeeMutez: getRevealFee('tz1...'),
     })
-    currentConfig = {
-      fees: {
-        minRevealGasLimit: 100,
-        minFees: 0,
-        minStorageLimit: 0,
-      },
-    } as unknown as TezosCoinConfig
+    currentConfig = { ...mockConfig, fees: { ...mockConfig.fees, minRevealGasLimit: 100 } }
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'send' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'send',
       recipient: 'tz2...',
       amount: BigInt(1000),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -197,17 +188,14 @@ describe('craftTransaction', () => {
       })
       const minFees = 500
       currentConfig = {
-        fees: {
-          minRevealGasLimit: 300,
-          minFees,
-          minStorageLimit: 0,
-        },
-      } as unknown as TezosCoinConfig
+        ...mockConfig,
+        fees: { ...mockConfig.fees, minRevealGasLimit: 300, minFees },
+      }
 
       const account = { address: 'tz2...' }
       const mainOpFee = 600
-      const transaction = {
-        type: 'delegate' as TransactionType,
+      const transaction: TransactionInput = {
+        type: 'delegate',
         recipient: 'tz3...',
         amount: BigInt(0),
         fee: { fees: String(mainOpFee), gasLimit: '10000', storageLimit: '0' },
@@ -216,11 +204,11 @@ describe('craftTransaction', () => {
 
       const result = await craftTransaction(context, account, transaction, publicKey)
 
-      const revealOp = result.contents[0]
-      expect(revealOp.kind).toBe(OpKind.REVEAL)
-      expect(Number(revealOp.fee ?? 0)).toBe(suggestedRevealFee)
-      const delegationOp = result.contents[1]
-      expect(Number(delegationOp.fee ?? 0)).toBe(mainOpFee)
+      expect(result.contents[0]).toMatchObject({
+        kind: OpKind.REVEAL,
+        fee: String(suggestedRevealFee),
+      })
+      expect(result.contents[1]).toMatchObject({ fee: String(mainOpFee) })
     })
 
     it('craft transaction when default estimation is lesser than minFees', async () => {
@@ -232,16 +220,13 @@ describe('craftTransaction', () => {
       })
       const minFees = 500
       currentConfig = {
-        fees: {
-          minRevealGasLimit: 300,
-          minFees,
-          minStorageLimit: 25,
-        },
-      } as unknown as TezosCoinConfig
+        ...mockConfig,
+        fees: { ...mockConfig.fees, minRevealGasLimit: 300, minStorageLimit: 25, minFees },
+      }
 
       const account = { address: 'tz2...' }
-      const transaction = {
-        type: 'delegate' as TransactionType,
+      const transaction: TransactionInput = {
+        type: 'delegate',
         recipient: 'tz3...',
         amount: BigInt(0),
         fee: { fees: '200', gasLimit: '1000', storageLimit: '0' },
@@ -250,11 +235,12 @@ describe('craftTransaction', () => {
 
       const result = await craftTransaction(context, account, transaction, publicKey)
 
-      const revealOp = result.contents[0]
-      expect(revealOp.kind).toBe(OpKind.REVEAL)
-      expect(revealOp.fee).toBe(String(minFees))
-      expect(revealOp.gas_limit).toBe('300')
-      expect(revealOp.storage_limit).toBe('25')
+      expect(result.contents[0]).toMatchObject({
+        kind: OpKind.REVEAL,
+        fee: String(minFees),
+        gas_limit: '300',
+        storage_limit: '25',
+      })
     })
 
     it('craft transaction with customFee splits total so reveal and main op respect minFees', async () => {
@@ -266,17 +252,14 @@ describe('craftTransaction', () => {
       })
       const minFees = 1000
       currentConfig = {
-        fees: {
-          minRevealGasLimit: 300,
-          minFees,
-          minStorageLimit: 0,
-        },
-      } as unknown as TezosCoinConfig
+        ...mockConfig,
+        fees: { ...mockConfig.fees, minRevealGasLimit: 300, minFees },
+      }
 
       const account = { address: 'tz2TaTpo31sAiX2HBJUTLLdUnqVJR4QjLy1V' }
       const mainOpFee = 1000
-      const transaction = {
-        type: 'delegate' as TransactionType,
+      const transaction: TransactionInput = {
+        type: 'delegate',
         recipient: 'tz3Vq38qYD3GEbWcXHMLt5PaASZrkDtEiA8D',
         amount: BigInt(0),
         fee: { fees: String(mainOpFee), gasLimit: '10000', storageLimit: '0' },
@@ -286,25 +269,21 @@ describe('craftTransaction', () => {
       const result = await craftTransaction(context, account, transaction, publicKey)
 
       expect(result.contents).toHaveLength(2)
-      const revealFee = Number(result.contents[0].fee ?? 0)
-      const delegationFee = Number(result.contents[1].fee ?? 0)
-      const total = revealFee + delegationFee
-      expect(revealFee).toBe(minFees)
-      expect(delegationFee).toBe(mainOpFee)
-      expect(total).toBe(minFees + mainOpFee)
+      expect(result.contents[0]).toMatchObject({ fee: String(minFees) })
+      expect(result.contents[1]).toMatchObject({ fee: String(mainOpFee) })
     })
   })
 
   it('should craft an FA2 send_token transaction', async () => {
-    const fa2Param = { entrypoint: 'transfer', value: { prim: 'Pair' as const } }
+    const fa2Param = { entrypoint: 'transfer', value: { prim: 'Pair' } }
     const { transfer } = setupFa2ContractMock(fa2Param)
     mockTezosToolkit.contract.at.mockResolvedValue({ methods: { transfer } })
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const contractAddress = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
     const account = { address: 'tz1VSUr8wwNhLAzempoch5d6nLRSNtxK8LBr' }
-    const transaction = {
-      type: 'send_token' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'send_token',
       recipient: 'tz1VSUr8wwNhLAzempoch5d6nLRSNtxK8LBr',
       amount: BigInt(5),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -347,18 +326,12 @@ describe('craftTransaction', () => {
       storageLimit: 0,
       suggestedFeeMutez: getRevealFee('tz1...'),
     })
-    currentConfig = {
-      fees: {
-        minRevealGasLimit: 100,
-        minFees: 0,
-        minStorageLimit: 0,
-      },
-    } as unknown as TezosCoinConfig
+    currentConfig = { ...mockConfig, fees: { ...mockConfig.fees, minRevealGasLimit: 100 } }
 
     const contractAddress = 'KT1CpeSQKdkhWi4pinYcseCFKmDhs5M74BkU'
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'send_token' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'send_token',
       recipient: 'tz2...',
       amount: BigInt(1),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -388,7 +361,7 @@ describe('craftTransaction', () => {
         context,
         { address: 'tz1...' },
         {
-          type: 'send_token' as TransactionType,
+          type: 'send_token',
           recipient: 'tz2...',
           amount: 1n,
           fee: {},
@@ -401,7 +374,7 @@ describe('craftTransaction', () => {
         context,
         { address: 'tz1...' },
         {
-          type: 'send_token' as TransactionType,
+          type: 'send_token',
           recipient: 'tz2...',
           amount: 1n,
           fee: {},
@@ -415,8 +388,8 @@ describe('craftTransaction', () => {
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'stake' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'stake',
       recipient: '',
       amount: BigInt(1234),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -444,8 +417,8 @@ describe('craftTransaction', () => {
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'unstake' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'unstake',
       recipient: '',
       amount: BigInt(4321),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -473,8 +446,8 @@ describe('craftTransaction', () => {
     mockTezosToolkit.rpc.getContract.mockResolvedValue({ counter: '1' })
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'finalize_unstake' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'finalize_unstake',
       recipient: '',
       // even with a non-zero amount the operation must serialize amount: "0"
       amount: BigInt(999),
@@ -506,17 +479,11 @@ describe('craftTransaction', () => {
       storageLimit: 0,
       suggestedFeeMutez: getRevealFee('tz1...'),
     })
-    currentConfig = {
-      fees: {
-        minRevealGasLimit: 100,
-        minFees: 0,
-        minStorageLimit: 0,
-      },
-    } as unknown as TezosCoinConfig
+    currentConfig = { ...mockConfig, fees: { ...mockConfig.fees, minRevealGasLimit: 100 } }
 
     const account = { address: 'tz1...' }
-    const transaction = {
-      type: 'stake' as TransactionType,
+    const transaction: TransactionInput = {
+      type: 'stake',
       recipient: '',
       amount: BigInt(500),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
@@ -553,12 +520,13 @@ describe('craftTransaction', () => {
   it('should throw an error for unsupported transaction type', async () => {
     const account = { address: 'tz1...' }
     const transaction = {
-      type: 'invalid' as any,
+      type: 'invalid',
       recipient: 'tz2...',
       amount: BigInt(1000),
       fee: { fees: '100', gasLimit: '200', storageLimit: '300' },
     }
 
+    // @ts-expect-error -- intentionally invalid type to test the unsupported-type error path
     await expect(craftTransaction(context, account, transaction)).rejects.toThrow(
       'unsupported mode'
     )

package/src/logic/estimateFees.integ.test.ts

@@ -1,14 +1,13 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosCoinConfig, TezosContext } from '../config'
-import type { CoreTransactionInfo } from './estimateFees'
+import type { TezosContext } from '../config'
 import { mockConfig } from '../test/config'
 import { estimateFees } from './estimateFees'
 
 describe('estimateFees', () => {
   const context: TezosContext = {
-    config: async () => mockConfig as TezosCoinConfig,
+    config: async () => mockConfig,
     logger: () => undefined,
   }
 
@@ -31,15 +30,15 @@ describe('estimateFees', () => {
     [accounts[0], 'with xpub'],
     [accounts[1], 'without xpub'],
   ])('returns correct value %s', async (account, _description) => {
-    // Given
-    const transaction = {
-      mode: 'send',
-      recipient: 'tz1PWFt4Ym6HedY78MgUP2kVDtSampGwprs5',
-      amount: BigInt(1_000_000),
-    } satisfies CoreTransactionInfo
-
     // When
-    const result = await estimateFees(context, { account, transaction })
+    const result = await estimateFees(context, {
+      account,
+      transaction: {
+        mode: 'send',
+        recipient: 'tz1PWFt4Ym6HedY78MgUP2kVDtSampGwprs5',
+        amount: BigInt(1_000_000),
+      },
+    })
     // Then
     expect(result).toEqual({
       estimatedFees: BigInt('825'),
@@ -54,16 +53,16 @@ describe('estimateFees', () => {
     [accounts[0], 'with xpub'],
     [accounts[1], 'without xpub'],
   ])('returns correct value when useAllAmount %s', async (account, _description) => {
-    // Given
-    const transaction = {
-      mode: 'send',
-      recipient: 'tz1PWFt4Ym6HedY78MgUP2kVDtSampGwprs5',
-      amount: BigInt(1_000_000),
-      useAllAmount: true,
-    } satisfies CoreTransactionInfo
-
     // When
-    const result = await estimateFees(context, { account, transaction })
+    const result = await estimateFees(context, {
+      account,
+      transaction: {
+        mode: 'send',
+        recipient: 'tz1PWFt4Ym6HedY78MgUP2kVDtSampGwprs5',
+        amount: BigInt(1_000_000),
+        useAllAmount: true,
+      },
+    })
 
     // Then
     expect(result).toEqual({