@ledgerhq/coin-tezos 7.12.0 → 9.0.0

package/src/api/index.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { TezosConfig } from '../config'
+import type { TezosContext } from '../config'
 import type { CoreAccountInfo, CoreTransactionInfo, EstimatedFees } from '../logic/estimateFees'
 import type { TezosOperationMode } from '../types/model'
 import type { TezosAccountInfo, TezosApi, TezosFeeEstimation } from './types'
@@ -24,7 +24,6 @@ import { craftTransactionData } from '@ledgerhq/coin-module-framework/logic/craf
 import { log } from '@ledgerhq/logs'
 import { getRevealFee } from '@taquito/taquito'
 import { getPkhfromPk, validatePublicKey, ValidationResult } from '@taquito/utils'
-import coinConfig from '../config'
 import {
   broadcast,
   combine,
@@ -43,7 +42,7 @@ import {
 import { getTezosToolkit } from '../logic/tezosToolkit'
 import { validateAddress } from '../logic/validateAddress'
 import { hasManagerKey } from '../network/types'
-import api from '../network/tzkt'
+import { createTzktApi } from '../network/tzkt'
 import {
   DUST_MARGIN_MUTEZ,
   hasEmptyBalance,
@@ -52,53 +51,56 @@ import {
   resolveTezosOperationMode,
 } from '../utils'
 
-export function createApi(config: TezosConfig): TezosApi {
-  coinConfig.setCoinConfig(() => ({ ...config, status: { type: 'active' } }))
-
+// The caller builds the {@link TezosContext} (config + logger) and passes it to each method (ADR-019).
+export function createApi(): TezosApi {
   return {
-    broadcast,
+    broadcast: (context, tx) => broadcast(context, tx),
     async call() {
       throw new Error('call is not supported')
     },
-    combine,
-    craftTransaction: craft,
+    combine: (_context, tx, signature) => combine(tx, signature),
+    craftTransaction: (context, transactionIntent, options) =>
+      craft(context, transactionIntent, options?.customFees),
     craftRawTransaction: async (
+      context,
       transaction: string,
       sender: string,
       publicKey: string,
       sequence: bigint
     ): Promise<CraftedTransaction> => {
-      const tx = await craftRawOperations(transaction, sender, publicKey, sequence)
+      const tx = await craftRawOperations(context, transaction, sender, publicKey, sequence)
       return { transaction: tx }
     },
-    estimateFees: estimate,
-    getBalance: (address: string, options?: BalanceOptions) =>
-      rejectBalanceOptions(() => getBalance(address), options),
-    lastBlock,
-    listOperations: operations,
-    getStakes,
-    validateIntent,
-    getNextSequence: async (address: string) => {
-      const accountInfo = await api.getAccountByAddress(address)
+    estimateFees: (context, transactionIntent) => estimate(context, transactionIntent),
+    getBalance: (context, address: string, options?: BalanceOptions) =>
+      rejectBalanceOptions(() => getBalance(context, address), options),
+    lastBlock: (context) => lastBlock(context),
+    listOperations: (context, address, options) => operations(context, address, options),
+    getStakes: (context, address, options) => getStakes(context, address, options?.cursor),
+    validateIntent: (context, transactionIntent) => validateIntent(context, transactionIntent),
+    getNextSequence: async (context, address: string) => {
+      const config = await context.config()
+      const accountInfo = await createTzktApi(config).getAccountByAddress(address)
       return hasManagerKey(accountInfo) ? BigInt(accountInfo.counter + 1) : 0n
     },
-    getAccountInfo: async (address: string): Promise<TezosAccountInfo> => {
-      const account = await api.getAccountByAddress(address)
+    getAccountInfo: async (context, address: string): Promise<TezosAccountInfo> => {
+      const config = await context.config()
+      const account = await createTzktApi(config).getAccountByAddress(address)
       // Manager-key accounts (plain wallets "user" and registered bakers "delegate") carry a
       // reveal state; empty / non-existent accounts are treated as unrevealed (no public key
       // published on-chain yet).
       return { type: 'tezos', revealed: hasManagerKey(account) ? account.revealed : false }
     },
-    getBlock,
-    getBlockInfo,
-    getRewards(_address: string, _cursor?: Cursor): Promise<Page<Reward>> {
+    getBlock: (context, height) => getBlock(context, height),
+    getBlockInfo: (context, height) => getBlockInfo(context, height),
+    getRewards(_context, _address: string, _options?: { cursor?: Cursor }): Promise<Page<Reward>> {
       throw new Error('getRewards is not supported')
     },
-    getValidators(_cursor?: Cursor): Promise<Page<Validator>> {
+    getValidators(_context, _options?: { cursor?: Cursor }): Promise<Page<Validator>> {
       throw new Error('getValidators is not supported')
     },
-    validateAddress,
-    craftTransactionData,
+    validateAddress: (_context, address, parameters) => validateAddress(address, parameters),
+    craftTransactionData: (_context, intent) => craftTransactionData(intent),
   }
 }
 
@@ -108,6 +110,7 @@ function isTezosTransactionType(
   return ['send', 'delegate', 'undelegate', 'stake', 'unstake', 'finalize_unstake'].includes(type)
 }
 async function craft(
+  context: TezosContext,
   transactionIntent: TransactionIntent,
   customFees?: FeeEstimation
 ): Promise<CraftedTransaction> {
@@ -115,8 +118,11 @@ async function craft(
     throw new IncorrectTypeError(transactionIntent.type)
   }
 
+  const config = await context.config()
+  const api = createTzktApi(config)
+
   // Always estimate to get gasLimit/storageLimit
-  const estimation = await estimate(transactionIntent)
+  const estimation = await estimate(context, transactionIntent)
   const fee = {
     fees: (customFees?.value ?? estimation.value).toString(),
     gasLimit: estimation.parameters?.gasLimit?.toString(),
@@ -156,7 +162,7 @@ async function craft(
   const needsReveal = hasManagerKey(senderApiAcc) && !senderApiAcc.revealed
   const totalFee = Number(fee.fees || '0')
 
-  const feesConfig = coinConfig.getCoinConfig().fees
+  const feesConfig = config.fees
   const revealFeeForSplit = needsReveal
     ? Math.max(feesConfig.minFees ?? 0, getRevealFee(transactionIntent.sender))
     : 0
@@ -207,14 +213,23 @@ async function craft(
           return { publicKey: pk, publicKeyHash: transactionIntent.sender }
         })()
       : undefined
-  const { contents } = await craftTransaction(accountForCraft, txForCraft, publicKeyForCraft)
-  const tx = await rawEncode(contents)
+  const { contents } = await craftTransaction(
+    context,
+    accountForCraft,
+    txForCraft,
+    publicKeyForCraft
+  )
+  const tx = await rawEncode(config, contents)
   return { transaction: tx }
 }
 
-async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeEstimation> {
+async function estimate(
+  context: TezosContext,
+  transactionIntent: TransactionIntent
+): Promise<TezosFeeEstimation> {
   // avoid taquito error when estimating a 0-amount transfer during input
-  const config = coinConfig.getCoinConfig()
+  const config = await context.config()
+  const api = createTzktApi(config)
   const tezosModeForEstimate = resolveTezosOperationMode(
     transactionIntent.type,
     transactionIntent.asset
@@ -276,7 +291,7 @@ async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeE
     // needed by the compiler (it can assume it's a manager-key account with respective fields)
     if (!hasManagerKey(senderAccountInfo)) throw new Error('unexpected account type')
     const account = xpub ? { ...accountBase, xpub } : accountBase
-    return await estimateFees({ account, transaction })
+    return await estimateFees(context, { account, transaction })
   }
   const xpub = transactionIntent.senderPublicKey ?? senderAccountInfo.publicKey
 
@@ -332,7 +347,7 @@ async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeE
       let txGasLimit: bigint
 
       try {
-        const toolkit = getTezosToolkit()
+        const toolkit = getTezosToolkit(config)
         const simpleEstimate = await toolkit.estimate.transfer({
           to: transactionIntent.recipient,
           amount: Number(transactionIntent.amount),
@@ -382,13 +397,14 @@ async function estimate(transactionIntent: TransactionIntent): Promise<TezosFeeE
 }
 
 async function operations(
+  context: TezosContext,
   address: string,
   { minHeight = 0, cursor, order = 'asc' }: ListOperationsOptions
 ): Promise<Page<Operation>> {
   // FIXME This wrapper hard-codes limit: 1000 and ignores any caller-provided limit from ListOperationsOptions. Either
   //  forward options.limit (as a soft/capped limit) or throw a "not supported" error when limit is set to match the
   //  ListOperationsOptions contract.
-  const [items, newNextCursor] = await listOperations(address, {
+  const [items, newNextCursor] = await listOperations(context, address, {
     limit: 1000, // Increased limit to 1000 to ensure delegation information is available when displaying account details (temporary fix until proper pagination is implemented).
     token: cursor,
     sort: order === 'asc' ? 'Ascending' : 'Descending',

package/src/api/types.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
+import type { TezosCoinConfig, TezosContext } from '../config'
 import type { CoinModuleApi, FeeEstimation } from '@ledgerhq/coin-module-framework/api/types'
 
 export type TezosFeeParameters = {
@@ -32,6 +33,6 @@ export type TezosAccountInfo = { type: 'tezos'; revealed: boolean }
  * signatures would otherwise intersect into an incompatible-return-type collision) and letting the
  * implementation satisfy the generic method directly.
  */
-export type TezosApi = CoinModuleApi & {
-  getAccountInfo: (address: string) => Promise<TezosAccountInfo>
+export type TezosApi = CoinModuleApi<TezosCoinConfig> & {
+  getAccountInfo: (context: TezosContext, address: string) => Promise<TezosAccountInfo>
 }

package/src/config.ts

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
-import type { CoinConfig, CurrencyConfig } from '@ledgerhq/coin-module-framework/config'
+import type { CoinConfig, Context, CurrencyConfig } from '@ledgerhq/coin-module-framework/config'
 import buildCoinConfig from '@ledgerhq/coin-module-framework/config'
 
 export type TezosConfig = {
@@ -26,6 +26,9 @@ export type TezosConfig = {
 
 export type TezosCoinConfig = CurrencyConfig & TezosConfig
 
+/** The {@link Context} threaded through the coin-tezos low layers (ADR-019). */
+export type TezosContext = Context<TezosCoinConfig>
+
 const coinConfig: {
   setCoinConfig: (config: CoinConfig<TezosCoinConfig>) => void
   getCoinConfig: (currencyId?: string) => TezosCoinConfig

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

@@ -1,23 +1,22 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
+import type { TezosContext } from '../config'
 import { InMemorySigner } from '@taquito/signer'
 import { OpKind, TezosToolkit } from '@taquito/taquito'
-import coinConfig from '../config'
 import { broadcast } from './broadcast'
 
 describe('Broadcast', () => {
-  beforeAll(() => {
-    coinConfig.setCoinConfig(
-      () =>
-        ({
-          status: { type: 'active' },
-          node: {
-            url: 'https://xtz-node.api.live.ledger.com',
-          },
-        }) as any
-    )
-  })
+  const context: TezosContext = {
+    config: async () =>
+      ({
+        status: { type: 'active' },
+        node: {
+          url: 'https://xtz-node.api.live.ledger.com',
+        },
+      }) as any,
+    logger: () => undefined,
+  }
 
   it('throws on insufficient funds', async () => {
     const tezos = new TezosToolkit('https://xtz-node.api.live.ledger.com')
@@ -47,6 +46,6 @@ describe('Broadcast', () => {
     })
     const { sbytes } = await signer.sign(prepared, new Uint8Array([3]))
 
-    await expect(broadcast(sbytes)).rejects.toThrow(/Empty implicit contract/)
+    await expect(broadcast(context, sbytes)).rejects.toThrow(/Empty implicit contract/)
   })
 })

package/src/logic/broadcast.ts

@@ -1,9 +1,11 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
+import type { TezosContext } from '../config'
 import { getTezosToolkit } from './tezosToolkit'
 
-export async function broadcast(signature: string): Promise<string> {
-  const { rpc } = getTezosToolkit()
+export async function broadcast(context: TezosContext, signature: string): Promise<string> {
+  const config = await context.config()
+  const { rpc } = getTezosToolkit(config)
   return await rpc.injectOperation(signature)
 }

package/src/logic/combine.test.ts

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: © 2026 LEDGER SAS
+// SPDX-License-Identifier: Apache-2.0
+
+import { combine } from './combine'
+
+describe('combine', () => {
+  it('concatenates transaction and signature and strips the leading 2 chars', () => {
+    // slice(2) removes the first byte (magic byte) from the concatenated hex string
+    expect(combine('03aabbcc', ['ddeeff'])).toBe('aabbccddeeff')
+  })
+
+  it('throws when more than one signature is provided', () => {
+    expect(() => combine('0xdeadbeef', ['0xsig0', '0xsig1'])).toThrow(
+      'Tezos combine expects exactly one signature, got 2'
+    )
+  })
+})

package/src/logic/combine.ts

@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0
 
 // Source: https://github.com/ecadlabs/taquito/blob/97832fc088eccb93c152659367618ce1782a8b51/packages/taquito-ledger-signer/src/taquito-ledger-signer.ts#L187C23-L187C32
-export function combine(transaction: string, signature: string): string {
-  return `${transaction}${signature}`.slice(2)
+export function combine(transaction: string, signature: string[]): string {
+  if (signature.length !== 1) {
+    throw new Error(`Tezos combine expects exactly one signature, got ${signature.length}`)
+  }
+  return `${transaction}${signature[0]}`.slice(2)
 }

package/src/logic/craftRawOperations.test.ts

@@ -1,17 +1,14 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
+import type { TezosCoinConfig, TezosContext } from '../config'
 import { OpKind } from '@taquito/rpc'
 import { getPkhfromPk } from '@taquito/utils'
-import coinConfig from '../config'
 import { UnsupportedOperationKind } from '../types/errors'
 import { craftRawOperations } from './craftRawOperations'
 import { getTezosToolkit } from './tezosToolkit'
 
 jest.mock('./tezosToolkit')
-jest.mock('../config', () => ({
-  getCoinConfig: jest.fn(),
-}))
 // Keep real validatePublicKey/normalize, override only the pkh derivation so we can
 // pair an arbitrary valid edpk with our test sender in the reveal path.
 jest.mock('@taquito/utils', () => ({
@@ -47,6 +44,14 @@ describe('craftRawOperations', () => {
     return mockTezosToolkit.rpc.forgeOperations.mock.calls[0][0].contents
   }
 
+  const context: TezosContext = {
+    config: async () =>
+      ({
+        fees: { minFees: 100, minRevealGasLimit: 0, minStorageLimit: 0 },
+      }) as unknown as TezosCoinConfig,
+    logger: () => undefined,
+  }
+
   beforeEach(() => {
     jest.clearAllMocks()
     ;(getTezosToolkit as jest.Mock).mockReturnValue(mockTezosToolkit)
@@ -58,15 +63,12 @@ describe('craftRawOperations', () => {
     mockTezosToolkit.estimate.batch.mockResolvedValue([
       { suggestedFeeMutez: 500, gasLimit: 1400, storageLimit: 0 },
     ])
-    ;(coinConfig.getCoinConfig as jest.Mock).mockReturnValue({
-      fees: { minFees: 100, minRevealGasLimit: 0, minStorageLimit: 0 },
-    })
   })
 
   it('forges a plain transfer, estimating the missing limits', async () => {
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 
-    const result = await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    const result = await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
 
     expect(result).toBe('03deadbeef') // 0x03 watermark + forged bytes
     expect(mockTezosToolkit.estimate.batch).toHaveBeenCalledWith([
@@ -90,7 +92,7 @@ describe('craftRawOperations', () => {
     const parameters = { entrypoint: 'transfer', value: { prim: 'Unit' } }
     const ops = [{ kind: 'transaction', destination: CONTRACT, amount: '0', parameters }]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 7n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 7n)
 
     expect(mockTezosToolkit.estimate.batch).toHaveBeenCalledWith([
       {
@@ -116,7 +118,7 @@ describe('craftRawOperations', () => {
     ])
     const ops = [{ kind: 'delegation', delegate: BAKER }]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 3n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 3n)
 
     expect(mockTezosToolkit.estimate.batch).toHaveBeenCalledWith([
       { kind: OpKind.DELEGATION, source: SENDER, delegate: BAKER },
@@ -149,7 +151,7 @@ describe('craftRawOperations', () => {
       },
     ]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 9n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 9n)
 
     expect(mockTezosToolkit.estimate.batch).toHaveBeenCalledTimes(1)
     const contents = forgedContents()
@@ -173,7 +175,7 @@ describe('craftRawOperations', () => {
     ])
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
 
     const contents = forgedContents()
     expect(contents[0].kind).toBe(OpKind.REVEAL)
@@ -193,9 +195,9 @@ describe('craftRawOperations', () => {
     ])
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 
-    await expect(craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
-      'expected 1 estimate(s)'
-    )
+    await expect(
+      craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    ).rejects.toThrow('expected 1 estimate(s)')
   })
 
   it('honours caller-provided fee/gas/storage without estimating', async () => {
@@ -210,7 +212,7 @@ describe('craftRawOperations', () => {
       },
     ]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
 
     expect(mockTezosToolkit.estimate.batch).not.toHaveBeenCalled()
     expect(forgedContents()[0]).toMatchObject({
@@ -231,7 +233,7 @@ describe('craftRawOperations', () => {
 
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
 
     const contents = forgedContents()
     expect(contents).toHaveLength(2)
@@ -251,7 +253,7 @@ describe('craftRawOperations', () => {
 
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 
-    await craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    await craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
 
     const reveal = forgedContents()[0]
     expect(reveal.kind).toBe(OpKind.REVEAL)
@@ -266,39 +268,40 @@ describe('craftRawOperations', () => {
 
     const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
 
-    await expect(craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
-      'does not match the sender'
-    )
+    await expect(
+      craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+    ).rejects.toThrow('does not match the sender')
   })
 
   it('throws on an unsupported operation kind', async () => {
     const ops = [{ kind: 'origination', balance: '0' }]
 
     await expect(
-      craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+      craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
     ).rejects.toBeInstanceOf(UnsupportedOperationKind)
   })
 
   describe('input validation', () => {
     it('throws on malformed JSON or an empty array', async () => {
-      await expect(craftRawOperations('not-json', SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
+      await expect(craftRawOperations(context, 'not-json', SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
         'must be a JSON array'
       )
-      await expect(craftRawOperations('[]', SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
+      await expect(craftRawOperations(context, '[]', SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
         'non-empty array'
       )
     })
 
     it('throws on a non-integer amount', async () => {
       const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1.5' }]
-      await expect(craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
-        '`amount` must be a non-negative integer string'
-      )
+      await expect(
+        craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+      ).rejects.toThrow('`amount` must be a non-negative integer string')
     })
 
     it('throws on a missing or invalid destination', async () => {
       await expect(
         craftRawOperations(
+          context,
           JSON.stringify([{ kind: 'transaction', amount: '1000' }]),
           SENDER,
           PUBLIC_KEY,
@@ -307,6 +310,7 @@ describe('craftRawOperations', () => {
       ).rejects.toThrow('valid `destination`')
       await expect(
         craftRawOperations(
+          context,
           JSON.stringify([{ kind: 'transaction', destination: 'not-an-address', amount: '1000' }]),
           SENDER,
           PUBLIC_KEY,
@@ -317,14 +321,15 @@ describe('craftRawOperations', () => {
 
     it('throws on a non-numeric fee', async () => {
       const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000', fee: 'abc' }]
-      await expect(craftRawOperations(JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)).rejects.toThrow(
-        '`fee` must be a non-negative integer string'
-      )
+      await expect(
+        craftRawOperations(context, JSON.stringify(ops), SENDER, PUBLIC_KEY, 5n)
+      ).rejects.toThrow('`fee` must be a non-negative integer string')
     })
 
     it('rejects an empty or invalid delegate (must not be treated as undelegation)', async () => {
       await expect(
         craftRawOperations(
+          context,
           JSON.stringify([{ kind: 'delegation', delegate: '' }]),
           SENDER,
           PUBLIC_KEY,
@@ -333,6 +338,7 @@ describe('craftRawOperations', () => {
       ).rejects.toThrow('`delegate` must be a valid implicit account address')
       await expect(
         craftRawOperations(
+          context,
           JSON.stringify([{ kind: 'delegation', delegate: 123 }]),
           SENDER,
           PUBLIC_KEY,
@@ -344,6 +350,7 @@ describe('craftRawOperations', () => {
     it('rejects a contract (KT1) delegate (delegates must be implicit accounts)', async () => {
       await expect(
         craftRawOperations(
+          context,
           JSON.stringify([{ kind: 'delegation', delegate: CONTRACT }]),
           SENDER,
           PUBLIC_KEY,
@@ -356,7 +363,13 @@ describe('craftRawOperations', () => {
       mockTezosToolkit.estimate.batch.mockResolvedValue([
         { suggestedFeeMutez: 400, gasLimit: 1000, storageLimit: 0 },
       ])
-      await craftRawOperations(JSON.stringify([{ kind: 'delegation' }]), SENDER, PUBLIC_KEY, 5n)
+      await craftRawOperations(
+        context,
+        JSON.stringify([{ kind: 'delegation' }]),
+        SENDER,
+        PUBLIC_KEY,
+        5n
+      )
 
       const content = forgedContents()[0]
       expect(content.kind).toBe(OpKind.DELEGATION)
@@ -367,6 +380,7 @@ describe('craftRawOperations', () => {
       const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
       await expect(
         craftRawOperations(
+          context,
           JSON.stringify(ops),
           SENDER,
           PUBLIC_KEY,
@@ -378,10 +392,10 @@ describe('craftRawOperations', () => {
     it('throws on an invalid or contract (KT1) sender address', async () => {
       const ops = [{ kind: 'transaction', destination: RECIPIENT, amount: '1000' }]
       await expect(
-        craftRawOperations(JSON.stringify(ops), 'not-an-address', PUBLIC_KEY, 5n)
+        craftRawOperations(context, JSON.stringify(ops), 'not-an-address', PUBLIC_KEY, 5n)
       ).rejects.toThrow('`sender` must be a valid implicit account address')
       await expect(
-        craftRawOperations(JSON.stringify(ops), CONTRACT, PUBLIC_KEY, 5n)
+        craftRawOperations(context, JSON.stringify(ops), CONTRACT, PUBLIC_KEY, 5n)
       ).rejects.toThrow('`sender` must be a valid implicit account address')
     })
   })

package/src/logic/craftRawOperations.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: © 2026 LEDGER SAS
 // SPDX-License-Identifier: Apache-2.0
 
+import type { TezosContext } from '../config'
 import type { MichelsonV1Expression, OperationContents } from '@taquito/rpc'
 import type { Estimate, ParamsWithKind } from '@taquito/taquito'
 import { OpKind } from '@taquito/rpc'
@@ -11,7 +12,6 @@ import {
   validatePublicKey,
   ValidationResult,
 } from '@taquito/utils'
-import coinConfig from '../config'
 import { UnsupportedOperationKind } from '../types/errors'
 import { createMockSigner, normalizePublicKeyForAddress } from '../utils'
 import { rawEncode } from './craftTransaction'
@@ -61,11 +61,13 @@ type ResolvedLimits = { fee: string; gasLimit: string; storageLimit: string }
  * `signer.signTransaction` + `combine` + broadcast path applies to it unchanged.
  */
 export async function craftRawOperations(
+  context: TezosContext,
   rawTransaction: string,
   sender: string,
   publicKey: string,
   sequence: bigint
 ): Promise<string> {
+  const config = await context.config()
   if (sequence < 0n || sequence > BigInt(Number.MAX_SAFE_INTEGER)) {
     throw new Error('craftRawOperations: sequence is out of the safe integer range')
   }
@@ -74,12 +76,12 @@ export async function craftRawOperations(
   }
   const operations = parseOperations(rawTransaction)
 
-  const tezosToolkit = getTezosToolkit()
+  const tezosToolkit = getTezosToolkit(config)
   const normalizedPk = normalizePublicKeyForAddress(publicKey, sender)
   // Mock signer lets Taquito estimate without a connected device.
   tezosToolkit.setProvider({ signer: createMockSigner(sender, normalizedPk ?? '') })
 
-  const feesConfig = coinConfig.getCoinConfig().fees
+  const feesConfig = config.fees
   const minFees = feesConfig.minFees
 
   let counter = Number(sequence)
@@ -115,7 +117,7 @@ export async function craftRawOperations(
     counter += 1
   })
 
-  return rawEncode(contents)
+  return rawEncode(config, contents)
 }
 
 function parseOperations(rawTransaction: string): PartialTezosOperation[] {