@eth-optimism/actions-sdk 0.0.0-main-20251009211102

package/src/wallet/react/wallets/hosted/dynamic/__tests__/DynamicWallet.spec.ts

@@ -0,0 +1,148 @@
+import { isEthereumWallet } from '@dynamic-labs/ethereum'
+import type {
+  Address,
+  CustomSource,
+  Hash,
+  LocalAccount,
+  WalletClient,
+} from 'viem'
+import { createWalletClient } from 'viem'
+import { toAccount } from 'viem/accounts'
+import { unichain } from 'viem/chains'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import { getRandomAddress } from '@/test/utils.js'
+import type { DynamicHostedWalletToActionsWalletOptions } from '@/wallet/react/providers/hosted/types/index.js'
+import { DynamicWallet } from '@/wallet/react/wallets/hosted/dynamic/DynamicWallet.js'
+
+vi.mock('viem', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem')),
+  createWalletClient: vi.fn(),
+}))
+
+vi.mock('viem/accounts', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem/accounts')),
+  toAccount: vi.fn(),
+}))
+
+vi.mock('@dynamic-labs/ethereum', () => ({
+  isEthereumWallet: vi.fn().mockReturnValue(true),
+}))
+
+const mockAddress = getRandomAddress()
+const mockChainManager = new MockChainManager({
+  supportedChains: [unichain.id],
+}) as unknown as ChainManager
+const mockLocalAccount = {
+  address: mockAddress,
+  signMessage: vi.fn(),
+  sign: vi.fn(),
+  signTransaction: vi.fn(),
+  signTypedData: vi.fn(),
+} as unknown as LocalAccount
+
+function createMockDynamicWallet(): DynamicHostedWalletToActionsWalletOptions['wallet'] {
+  const mockConnector = {
+    signRawMessage: vi.fn().mockResolvedValue('0xsigned'),
+  }
+  const mockWalletClient = {
+    account: { address: mockAddress },
+    signMessage: vi.fn(),
+    signTransaction: vi.fn(),
+    signTypedData: vi.fn(),
+  } as unknown as WalletClient
+  return {
+    connector: mockConnector,
+    getWalletClient: vi.fn().mockResolvedValue(mockWalletClient),
+    __mock: { connector: mockConnector, walletClient: mockWalletClient },
+  }
+}
+
+describe('DynamicWallet', () => {
+  it('should initialize signer and address from dynamic wallet', async () => {
+    const dynamic = createMockDynamicWallet()
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+
+    const wallet = await DynamicWallet.create({
+      dynamicWallet: dynamic,
+      chainManager: mockChainManager,
+    })
+
+    expect(wallet.address).toBe(mockAddress)
+    expect(dynamic.getWalletClient).toHaveBeenCalled()
+  })
+
+  it('should wire toAccount signer to connector.signRawMessage with 0x trim', async () => {
+    const dynamic = createMockDynamicWallet()
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+
+    await DynamicWallet.create({
+      dynamicWallet: dynamic,
+      chainManager: mockChainManager,
+    })
+
+    const calls = vi.mocked(toAccount).mock.calls
+    const callArgs = calls[calls.length - 1][0] as CustomSource
+    expect(callArgs.address).toBe(dynamic.__mock.walletClient.account.address)
+
+    // Invoke the sign function and assert message formatting
+    await callArgs.sign!({ hash: '0xdeadbeef' })
+    expect(dynamic.__mock.connector.signRawMessage).toHaveBeenCalledWith({
+      accountAddress: dynamic.__mock.walletClient.account.address,
+      message: 'deadbeef',
+    })
+
+    await callArgs.sign!({ hash: 'cafebabe' as Hash })
+    expect(dynamic.__mock.connector.signRawMessage).toHaveBeenCalledWith({
+      accountAddress: dynamic.__mock.walletClient.account.address,
+      message: 'cafebabe',
+    })
+  })
+
+  it('should create a wallet client with correct configuration', async () => {
+    const dynamic = createMockDynamicWallet()
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+
+    const wallet = await DynamicWallet.create({
+      dynamicWallet: dynamic,
+      chainManager: mockChainManager,
+    })
+
+    const mockWalletClient = {
+      account: mockLocalAccount,
+      address: mockAddress as Address,
+    } as unknown as WalletClient
+
+    vi.mocked(createWalletClient).mockResolvedValue(mockWalletClient)
+
+    const walletClient = await wallet.walletClient(unichain.id)
+
+    expect(createWalletClient).toHaveBeenCalledOnce()
+    const args = vi.mocked(createWalletClient).mock.calls[0][0]
+    expect(args.account).toBe(mockLocalAccount)
+    expect(args.chain).toBe(mockChainManager.getChain(unichain.id))
+    expect(walletClient).toBe(mockWalletClient)
+  })
+
+  it('should throw if dynamic wallet is not EVM compatible', async () => {
+    const dynamic = createMockDynamicWallet()
+    // Force isEthereumWallet to return false for this test
+    vi.mocked(isEthereumWallet).mockReturnValueOnce(false)
+
+    try {
+      await DynamicWallet.create({
+        dynamicWallet: dynamic,
+        chainManager: mockChainManager,
+      })
+    } catch (err) {
+      expect((err as Error).message).toBe('Failed to initialize wallet')
+      expect((err as any).cause?.message).toBe(
+        'Wallet not connected or not EVM compatible',
+      )
+    }
+  })
+})

package/src/wallet/react/wallets/hosted/dynamic/utils/__tests__/createSigner.spec.ts

@@ -0,0 +1,82 @@
+import { isEthereumWallet } from '@dynamic-labs/ethereum'
+import type { DynamicWaasEVMConnector } from '@dynamic-labs/waas-evm'
+import type { Wallet } from '@dynamic-labs/wallet-connector-core'
+import type { LocalAccount, WalletClient } from 'viem'
+import { toAccount } from 'viem/accounts'
+import { describe, expect, it, vi } from 'vitest'
+
+import { getRandomAddress } from '@/test/utils.js'
+import { createSigner } from '@/wallet/react/wallets/hosted/dynamic/utils/createSigner.js'
+
+vi.mock('@dynamic-labs/ethereum', async () => ({
+  isEthereumWallet: vi.fn(),
+}))
+
+vi.mock('viem/accounts', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem/accounts')),
+  toAccount: vi.fn(),
+}))
+
+describe('createSigner (React Dynamic)', () => {
+  const mockAddress = getRandomAddress()
+
+  it('should create a LocalAccount with correct configuration', async () => {
+    const mockWalletClient = {
+      account: {
+        address: mockAddress,
+      },
+      signMessage: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as unknown as WalletClient
+
+    const mockConnector = {
+      signRawMessage: vi.fn(),
+    } as unknown as DynamicWaasEVMConnector
+
+    const mockWallet = {
+      getWalletClient: vi.fn().mockResolvedValue(mockWalletClient),
+      connector: mockConnector,
+    } as unknown as Wallet
+
+    const mockLocalAccount = {
+      address: mockAddress,
+      sign: vi.fn(),
+      signMessage: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as unknown as LocalAccount
+
+    vi.mocked(isEthereumWallet).mockReturnValue(true)
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+
+    const signer = await createSigner({
+      wallet: mockWallet,
+    })
+
+    expect(isEthereumWallet).toHaveBeenCalledWith(mockWallet)
+    expect(mockWallet.getWalletClient).toHaveBeenCalled()
+    expect(toAccount).toHaveBeenCalledWith(
+      expect.objectContaining({
+        address: mockAddress,
+        signMessage: mockWalletClient.signMessage,
+        signTransaction: mockWalletClient.signTransaction,
+        signTypedData: mockWalletClient.signTypedData,
+      }),
+    )
+    expect(signer).toBe(mockLocalAccount)
+  })
+
+  it('should throw error for non-Ethereum wallet', async () => {
+    const mockWallet = {} as unknown as Wallet
+
+    vi.mocked(isEthereumWallet).mockReturnValue(false)
+
+    await expect(
+      createSigner({
+        wallet: mockWallet,
+      }),
+    ).rejects.toThrow('Wallet not connected or not EVM compatible')
+  })
+})

package/src/wallet/react/wallets/hosted/dynamic/utils/createSigner.ts

@@ -0,0 +1,38 @@
+import { isEthereumWallet } from '@dynamic-labs/ethereum'
+import type { DynamicWaasEVMConnector } from '@dynamic-labs/waas-evm'
+import type { LocalAccount } from 'viem'
+import { toAccount } from 'viem/accounts'
+
+import type { DynamicHostedWalletToActionsWalletOptions } from '@/wallet/react/providers/hosted/types/index.js'
+
+/**
+ * Create a LocalAccount from a Dynamic wallet
+ * @description Converts the Dynamic wallet into a viem-compatible LocalAccount that can sign
+ * messages and transactions. The returned account uses Dynamic's signing infrastructure
+ * under the hood while providing a standard viem interface.
+ * @param params.dynamicWallet - Dynamic wallet instance
+ * @returns Promise resolving to a LocalAccount configured for signing operations
+ * @throws Error if wallet retrieval fails or signing operations are not supported
+ */
+export async function createSigner(
+  params: DynamicHostedWalletToActionsWalletOptions,
+): Promise<LocalAccount> {
+  const { wallet } = params
+  if (!isEthereumWallet(wallet)) {
+    throw new Error('Wallet not connected or not EVM compatible')
+  }
+  const walletClient = await wallet.getWalletClient()
+  const connector = wallet.connector as DynamicWaasEVMConnector
+  return toAccount({
+    address: walletClient.account.address,
+    sign: ({ hash }) => {
+      return connector.signRawMessage({
+        accountAddress: walletClient.account.address,
+        message: hash.startsWith('0x') ? hash.slice(2) : hash,
+      })
+    },
+    signMessage: walletClient.signMessage,
+    signTransaction: walletClient.signTransaction,
+    signTypedData: walletClient.signTypedData,
+  })
+}

package/src/wallet/react/wallets/hosted/privy/PrivyWallet.ts

@@ -0,0 +1,63 @@
+import type { ConnectedWallet } from '@privy-io/react-auth'
+import type { Address, LocalAccount } from 'viem'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { EOAWallet } from '@/wallet/core/wallets/eoa/EOAWallet.js'
+import { createSigner } from '@/wallet/react/wallets/hosted/privy/utils/createSigner.js'
+
+/**
+ * Privy wallet implementation
+ * @description Wallet implementation using Privy service
+ */
+export class PrivyWallet extends EOAWallet {
+  public address!: Address
+  public signer!: LocalAccount
+
+  private readonly connectedWallet: ConnectedWallet
+
+  private constructor(
+    chainManager: ChainManager,
+    connectedWallet: ConnectedWallet,
+    lendProvider?: LendProvider<LendConfig>,
+  ) {
+    super(chainManager, lendProvider)
+    this.connectedWallet = connectedWallet
+  }
+
+  static async create(params: {
+    chainManager: ChainManager
+    connectedWallet: ConnectedWallet
+    lendProvider?: LendProvider<LendConfig>
+  }): Promise<PrivyWallet> {
+    const wallet = new PrivyWallet(
+      params.chainManager,
+      params.connectedWallet,
+      params.lendProvider,
+    )
+    await wallet.initialize()
+    return wallet
+  }
+
+  /**
+   * Initialize the PrivyWallet by creating the signer account
+   */
+  protected async performInitialization() {
+    this.signer = await this.createSigner()
+    this.address = this.signer.address
+  }
+
+  /**
+   * Create a LocalAccount from this Privy wallet
+   * @description Converts the Privy wallet into a viem-compatible LocalAccount that can sign
+   * messages and transactions. The returned account uses Privy's signing infrastructure
+   * under the hood while providing a standard viem interface.
+   * @returns Promise resolving to a LocalAccount configured for signing operations
+   * @throws Error if wallet retrieval fails or signing operations are not supported
+   */
+  private async createSigner(): Promise<LocalAccount> {
+    return createSigner({
+      connectedWallet: this.connectedWallet,
+    })
+  }
+}

package/src/wallet/react/wallets/hosted/privy/__mocks__/PrivyWalletMock.ts

@@ -0,0 +1,22 @@
+import type { ConnectedWallet } from '@privy-io/react-auth'
+import { vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+
+/**
+ * Minimal mock for PrivyWallet used in React tests
+ * @description
+ * Provides a static `create` spy that returns a stubbed `Wallet`, avoiding
+ * browser-only dependencies. Use with `vi.mock` to replace the real module.
+ */
+export class PrivyWalletMock {
+  static readonly create = vi.fn(
+    async (_params: {
+      chainManager: ChainManager
+      connectedWallet: ConnectedWallet
+    }): Promise<Wallet> => {
+      return {} as unknown as Wallet
+    },
+  )
+}

package/src/wallet/react/wallets/hosted/privy/__tests__/PrivyWallet.spec.ts

@@ -0,0 +1,109 @@
+import { type ConnectedWallet, toViemAccount } from '@privy-io/react-auth'
+import type { Address, LocalAccount, WalletClient } from 'viem'
+import { createWalletClient } from 'viem'
+import { toAccount } from 'viem/accounts'
+import { unichain } from 'viem/chains'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import { getRandomAddress } from '@/test/utils.js'
+import { PrivyWallet } from '@/wallet/react/wallets/hosted/privy/PrivyWallet.js'
+
+vi.mock('viem', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem')),
+  createWalletClient: vi.fn(),
+}))
+
+vi.mock('viem/accounts', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem/accounts')),
+  toAccount: vi.fn(),
+}))
+
+vi.mock('@privy-io/react-auth', () => ({
+  toViemAccount: vi.fn(),
+}))
+
+describe('PrivyWallet (React)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+  const mockAddress = getRandomAddress()
+  const mockChainManager = new MockChainManager({
+    supportedChains: [unichain.id],
+  }) as unknown as ChainManager
+  const mockLocalAccount = {
+    address: mockAddress,
+    signMessage: vi.fn(),
+    sign: vi.fn(),
+    signTransaction: vi.fn(),
+    signTypedData: vi.fn(),
+  } as unknown as LocalAccount
+
+  it('initializes signer and address from Privy viem account', async () => {
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+    const mockViemAccount = {
+      address: mockAddress,
+      sign: vi.fn(),
+      signMessage: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as any
+    vi.mocked(toViemAccount).mockResolvedValue(mockViemAccount)
+    const connectedWallet = {
+      __brand: 'privy-connected-wallet',
+    } as unknown as ConnectedWallet
+
+    const wallet = await PrivyWallet.create({
+      connectedWallet: connectedWallet,
+      chainManager: mockChainManager,
+    })
+
+    expect(wallet.address).toBe(mockViemAccount.address)
+    expect(toViemAccount).toHaveBeenCalledWith({
+      wallet: connectedWallet,
+    })
+    expect(toAccount).toHaveBeenCalledWith({
+      address: mockAddress,
+      sign: mockViemAccount.sign,
+      signMessage: mockViemAccount.signMessage,
+      signTransaction: mockViemAccount.signTransaction,
+      signTypedData: mockViemAccount.signTypedData,
+    })
+  })
+
+  it('creates a WalletClient with correct configuration', async () => {
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+    vi.mocked(toViemAccount).mockResolvedValue({
+      address: mockAddress,
+      sign: vi.fn(),
+      signMessage: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as any)
+    const connectedWallet = {
+      __brand: 'privy-connected-wallet',
+    } as unknown as ConnectedWallet
+    const wallet = await PrivyWallet.create({
+      connectedWallet: connectedWallet,
+      chainManager: mockChainManager,
+    })
+
+    const mockWalletClient = {
+      account: mockLocalAccount,
+      address: mockAddress as Address,
+    } as unknown as WalletClient
+
+    vi.mocked(createWalletClient).mockResolvedValue(mockWalletClient)
+
+    const walletClient = await wallet.walletClient(unichain.id)
+
+    expect(createWalletClient).toHaveBeenCalledOnce()
+    const args = vi.mocked(createWalletClient).mock.calls[0][0]
+    expect(args.account).toBe(mockLocalAccount)
+    expect(args.chain).toBe(mockChainManager.getChain(unichain.id))
+    expect(walletClient).toBe(mockWalletClient)
+  })
+})

package/src/wallet/react/wallets/hosted/privy/utils/__tests__/createSigner.spec.ts

@@ -0,0 +1,66 @@
+import type { ConnectedWallet } from '@privy-io/react-auth'
+import { toViemAccount } from '@privy-io/react-auth'
+import type { LocalAccount } from 'viem'
+import { toAccount } from 'viem/accounts'
+import { describe, expect, it, vi } from 'vitest'
+
+import { getRandomAddress } from '@/test/utils.js'
+import { createSigner } from '@/wallet/react/wallets/hosted/privy/utils/createSigner.js'
+
+vi.mock('@privy-io/react-auth', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('@privy-io/react-auth')),
+  toViemAccount: vi.fn(),
+}))
+
+vi.mock('viem/accounts', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem/accounts')),
+  toAccount: vi.fn(),
+}))
+
+describe('createSigner', () => {
+  const mockAddress = getRandomAddress()
+
+  it('should create a LocalAccount with correct configuration', async () => {
+    const mockConnectedWallet = {
+      address: mockAddress,
+      walletClientType: 'privy',
+    } as unknown as ConnectedWallet
+
+    const mockPrivyViemAccount = {
+      address: mockAddress,
+      sign: vi.fn(),
+      signMessage: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as unknown as Awaited<ReturnType<typeof toViemAccount>>
+
+    const mockLocalAccount = {
+      address: mockAddress,
+      sign: vi.fn(),
+      signMessage: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as unknown as LocalAccount
+
+    vi.mocked(toViemAccount).mockResolvedValue(mockPrivyViemAccount)
+    vi.mocked(toAccount).mockReturnValue(mockLocalAccount)
+
+    const signer = await createSigner({
+      connectedWallet: mockConnectedWallet,
+    })
+
+    expect(toViemAccount).toHaveBeenCalledWith({
+      wallet: mockConnectedWallet,
+    })
+    expect(toAccount).toHaveBeenCalledWith({
+      address: mockPrivyViemAccount.address,
+      sign: mockPrivyViemAccount.sign,
+      signMessage: mockPrivyViemAccount.signMessage,
+      signTransaction: mockPrivyViemAccount.signTransaction,
+      signTypedData: mockPrivyViemAccount.signTypedData,
+    })
+    expect(signer).toBe(mockLocalAccount)
+  })
+})

package/src/wallet/react/wallets/hosted/privy/utils/createSigner.ts

@@ -0,0 +1,30 @@
+import { toViemAccount } from '@privy-io/react-auth'
+import type { CustomSource, LocalAccount } from 'viem'
+import { toAccount } from 'viem/accounts'
+
+import type { PrivyHostedWalletToActionsWalletOptions } from '@/wallet/react/providers/hosted/types/index.js'
+
+/**
+ * Create a LocalAccount from a Privy wallet
+ * @description Converts the Privy wallet into a viem-compatible LocalAccount that can sign
+ * messages and transactions. The returned account uses Privy's signing infrastructure
+ * under the hood while providing a standard viem interface.
+ * @param params.connectedWallet - Privy connected wallet
+ * @returns Promise resolving to a LocalAccount configured for signing operations
+ * @throws Error if wallet retrieval fails or signing operations are not supported
+ */
+export async function createSigner(
+  params: PrivyHostedWalletToActionsWalletOptions,
+): Promise<LocalAccount> {
+  const privyViemAccount = await toViemAccount({
+    wallet: params.connectedWallet,
+  })
+  return toAccount({
+    address: privyViemAccount.address,
+    sign: privyViemAccount.sign,
+    signMessage: privyViemAccount.signMessage,
+    signTransaction: privyViemAccount.signTransaction,
+    signTypedData:
+      privyViemAccount.signTypedData as CustomSource['signTypedData'],
+  })
+}

package/src/wallet/react/wallets/hosted/turnkey/TurnkeyWallet.ts

@@ -0,0 +1,94 @@
+import type { TurnkeySDKClientBase } from '@turnkey/react-wallet-kit'
+import type { Address, LocalAccount } from 'viem'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { EOAWallet } from '@/wallet/core/wallets/eoa/EOAWallet.js'
+import { createSigner } from '@/wallet/react/wallets/hosted/turnkey/utils/createSigner.js'
+
+/**
+ * Turnkey wallet implementation
+ * @description Wallet implementation using Turnkey service
+ */
+export class TurnkeyWallet extends EOAWallet {
+  public address!: Address
+  public signer!: LocalAccount
+  /**
+   * Turnkey client instance
+   */
+  private readonly client: TurnkeySDKClientBase
+  /**
+   * Turnkey organization ID that owns the signing key
+   */
+  private readonly organizationId: string
+  /**
+   * This can be a wallet account address, private key address, or private key ID.
+   */
+  private readonly signWith: string
+  /**
+   * Ethereum address to use for this account, in the case that a private key ID is used to sign.
+   * If left undefined, `createSigner` will fetch it from the Turnkey API.
+   * We recommend setting this if you're using a passkey client, so that your users are not prompted for a passkey signature just to fetch their address.
+   * You may leave this undefined if using an API key client.
+   */
+  private readonly ethereumAddress?: string
+
+  private constructor(params: {
+    chainManager: ChainManager
+    client: TurnkeySDKClientBase
+    organizationId: string
+    signWith: string
+    ethereumAddress?: string
+    lendProvider?: LendProvider<LendConfig>
+  }) {
+    const {
+      chainManager,
+      client,
+      organizationId,
+      signWith,
+      ethereumAddress,
+      lendProvider,
+    } = params
+    super(chainManager, lendProvider)
+    this.client = client
+    this.organizationId = organizationId
+    this.signWith = signWith
+    this.ethereumAddress = ethereumAddress
+  }
+
+  static async create(params: {
+    chainManager: ChainManager
+    client: TurnkeySDKClientBase
+    organizationId: string
+    signWith: string
+    ethereumAddress?: string
+    lendProvider?: LendProvider<LendConfig>
+  }): Promise<TurnkeyWallet> {
+    const wallet = new TurnkeyWallet(params)
+    await wallet.initialize()
+    return wallet
+  }
+
+  protected async performInitialization() {
+    this.signer = await this.createSigner()
+    this.address = this.signer.address
+  }
+
+  /**
+   * Create a viem LocalAccount instance backed by Turnkey
+   * @description Wraps the Turnkey SDK's `createAccount` to produce a signing
+   * account compatible with viem. Under the hood, this uses the provided
+   * `client`, `organizationId`, and `signWith` to authenticate signing requests
+   * with Turnkey. If `ethereumAddress` is supplied, it's used directly;
+   * otherwise the SDK fetches it from the Turnkey API.
+   * @returns Promise resolving to a viem `LocalAccount` with Turnkey as the signer backend
+   */
+  private async createSigner(): Promise<LocalAccount> {
+    return createSigner({
+      client: this.client,
+      organizationId: this.organizationId,
+      signWith: this.signWith,
+      ethereumAddress: this.ethereumAddress,
+    })
+  }
+}