@eth-optimism/actions-sdk 0.0.2

package/src/wallet/node/wallets/hosted/turnkey/__tests__/TurnkeyWallet.spec.ts

@@ -0,0 +1,104 @@
+import type { TurnkeySDKClientBase } from '@turnkey/core'
+import type { TurnkeyClient as TurnkeyHttpClient } from '@turnkey/http'
+import type { TurnkeyServerClient } from '@turnkey/sdk-server'
+import { createAccount } from '@turnkey/viem'
+import type { LocalAccount, WalletClient } from 'viem'
+import { createWalletClient } from 'viem'
+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 { TurnkeyWallet } from '@/wallet/node/wallets/hosted/turnkey/TurnkeyWallet.js'
+
+vi.mock('viem', async () => ({
+  // @ts-ignore - importActual returns unknown
+  ...(await vi.importActual('viem')),
+  createWalletClient: vi.fn(),
+}))
+
+vi.mock('@turnkey/viem', async () => ({
+  createAccount: vi.fn(),
+}))
+
+const mockAddress = getRandomAddress()
+const mockChainManager = new MockChainManager({
+  supportedChains: [unichain.id],
+}) as unknown as ChainManager
+
+function createMockTurnkeyClient():
+  | TurnkeyHttpClient
+  | TurnkeyServerClient
+  | TurnkeySDKClientBase {
+  return {
+    // minimal shape for typing; createAccount uses this via @turnkey/viem
+  } as unknown as TurnkeyHttpClient
+}
+
+describe('TurnkeyWallet', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should initialize signer and address from Turnkey account', async () => {
+    const mockLocalAccount = { address: mockAddress } as unknown as LocalAccount
+    vi.mocked(createAccount).mockResolvedValue(mockLocalAccount)
+
+    const wallet = await TurnkeyWallet.create({
+      client: createMockTurnkeyClient(),
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+      chainManager: mockChainManager,
+    })
+
+    expect(wallet.address).toBe(mockAddress)
+    expect(wallet.signer).toBe(mockLocalAccount)
+    expect(createAccount).toHaveBeenCalledOnce()
+    const args = vi.mocked(createAccount).mock.calls[0][0]
+    expect(args.client).toEqual(createMockTurnkeyClient())
+    expect(args.organizationId).toBe('org_123')
+    expect(args.signWith).toBe('key_abc')
+    expect(args.ethereumAddress).toBeUndefined()
+  })
+
+  it('takes ethereumAddress', async () => {
+    const mockLocalAccount = { address: mockAddress } as unknown as LocalAccount
+    vi.mocked(createAccount).mockResolvedValue(mockLocalAccount)
+
+    await TurnkeyWallet.create({
+      client: createMockTurnkeyClient(),
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+      ethereumAddress: '0x123',
+      chainManager: mockChainManager,
+    })
+
+    const args = vi.mocked(createAccount).mock.calls[0][0]
+    expect(args.ethereumAddress).toBe('0x123')
+  })
+
+  it('should create a wallet client with correct configuration', async () => {
+    const mockLocalAccount = { address: mockAddress } as unknown as LocalAccount
+    vi.mocked(createAccount).mockResolvedValue(mockLocalAccount)
+    const wallet = await TurnkeyWallet.create({
+      client: createMockTurnkeyClient(),
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+      chainManager: mockChainManager,
+    })
+    const mockWalletClient = {
+      account: mockLocalAccount,
+      address: mockAddress,
+    } 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/node/wallets/hosted/turnkey/utils/__tests__/createSigner.spec.ts

@@ -0,0 +1,77 @@
+import type { TurnkeySDKClientBase } from '@turnkey/core'
+import type { TurnkeyClient as TurnkeyHttpClient } from '@turnkey/http'
+import type { TurnkeyServerClient } from '@turnkey/sdk-server'
+import { createAccount } from '@turnkey/viem'
+import type { LocalAccount } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import { getRandomAddress } from '@/test/utils.js'
+import { createSigner } from '@/wallet/node/wallets/hosted/turnkey/utils/createSigner.js'
+
+vi.mock('@turnkey/viem', async () => ({
+  createAccount: vi.fn(),
+}))
+
+function createMockTurnkeyClient():
+  | TurnkeyHttpClient
+  | TurnkeyServerClient
+  | TurnkeySDKClientBase {
+  return {
+    // minimal shape for typing; createAccount uses this via @turnkey/viem
+  } as unknown as TurnkeyHttpClient
+}
+
+describe('createSigner (Node Turnkey)', () => {
+  const mockAddress = getRandomAddress()
+
+  it('should create a LocalAccount with correct configuration', async () => {
+    const mockLocalAccount = {
+      address: mockAddress,
+      signMessage: vi.fn(),
+      sign: vi.fn(),
+      signTransaction: vi.fn(),
+      signTypedData: vi.fn(),
+    } as unknown as LocalAccount
+    vi.mocked(createAccount).mockResolvedValue(mockLocalAccount)
+
+    const client = createMockTurnkeyClient()
+    const signer = await createSigner({
+      client,
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+    })
+
+    expect(createAccount).toHaveBeenCalledWith({
+      client,
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+      ethereumAddress: undefined,
+    })
+    expect(signer).toBe(mockLocalAccount)
+  })
+
+  it('should pass ethereumAddress when provided', async () => {
+    const mockLocalAccount = {
+      address: mockAddress,
+      type: 'local',
+    } as unknown as LocalAccount
+    vi.mocked(createAccount).mockResolvedValue(mockLocalAccount)
+
+    const client = createMockTurnkeyClient()
+    const ethereumAddress = getRandomAddress()
+    const signer = await createSigner({
+      client,
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+      ethereumAddress,
+    })
+
+    expect(createAccount).toHaveBeenCalledWith({
+      client,
+      organizationId: 'org_123',
+      signWith: 'key_abc',
+      ethereumAddress,
+    })
+    expect(signer).toBe(mockLocalAccount)
+  })
+})

package/src/wallet/node/wallets/hosted/turnkey/utils/createSigner.ts

@@ -0,0 +1,32 @@
+import { createAccount } from '@turnkey/viem'
+import type { LocalAccount } from 'viem'
+
+import type {
+  NodeOptionsMap,
+  TurnkeyHostedWalletToActionsWalletOptions,
+} from '@/wallet/node/providers/hosted/types/index.js'
+
+/**
+ * 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.
+ * @param params.client - Turnkey client instance
+ * @param params.organizationId - Turnkey organization ID that owns the signing key
+ * @param params.signWith - Wallet account address, private key address, or private key ID
+ * @param params.ethereumAddress - Ethereum address to use for this account, in the case that a private key ID is used to sign.
+ * @returns Promise resolving to a viem `LocalAccount` with Turnkey as the signer backend
+ */
+export async function createSigner(
+  params: TurnkeyHostedWalletToActionsWalletOptions & NodeOptionsMap['turnkey'],
+): Promise<LocalAccount> {
+  const { client, organizationId, signWith, ethereumAddress } = params
+  return createAccount({
+    client,
+    organizationId,
+    signWith,
+    ethereumAddress,
+  })
+}

package/src/wallet/react/index.ts

@@ -0,0 +1,5 @@
+export type {
+  ReactHostedWalletProvidersSchema,
+  ReactProviderTypes,
+} from '@/wallet/react/providers/hosted/types/index.js'
+export { DynamicWallet } from '@/wallet/react/wallets/hosted/dynamic/DynamicWallet.js'

package/src/wallet/react/providers/hosted/dynamic/DynamicHostedWalletProvider.ts

@@ -0,0 +1,54 @@
+import type { LocalAccount } from 'viem'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+import type { ReactToActionsOptionsMap } from '@/wallet/react/providers/hosted/types/index.js'
+import { DynamicWallet } from '@/wallet/react/wallets/hosted/dynamic/DynamicWallet.js'
+import { createSigner } from '@/wallet/react/wallets/hosted/dynamic/utils/createSigner.js'
+
+/**
+ * Dynamic wallet provider implementation
+ * @description Wallet provider implementation using Dynamic service
+ */
+export class DynamicHostedWalletProvider extends HostedWalletProvider<
+  'dynamic',
+  ReactToActionsOptionsMap
+> {
+  /**
+   * Create a new Dynamic wallet provider
+   */
+  constructor(
+    chainManager: ChainManager,
+    lendProvider?: LendProvider<LendConfig>,
+  ) {
+    super(chainManager, lendProvider)
+  }
+
+  async toActionsWallet(
+    params: ReactToActionsOptionsMap['dynamic'],
+  ): Promise<Wallet> {
+    return DynamicWallet.create({
+      dynamicWallet: params.wallet,
+      chainManager: this.chainManager,
+      lendProvider: this.lendProvider,
+    })
+  }
+
+  /**
+   * Create a viem LocalAccount signer from Dynamic credentials
+   * @description Produces a signing account backed by Dynamic without wrapping
+   * it in a full Actions wallet. This is useful when you need to pass the signer
+   * into an Actions smart wallet as a signer, for lower-level viem operations, or
+   * for passing to other libraries that accept a viem `LocalAccount`.
+   * @param params - Dynamic configuration for the signer
+   * @param params.wallet - Dynamic wallet instance
+   * @returns Promise resolving to a viem `LocalAccount` with Dynamic as the signer backend
+   */
+  async createSigner(
+    params: ReactToActionsOptionsMap['dynamic'],
+  ): Promise<LocalAccount> {
+    return createSigner(params)
+  }
+}

package/src/wallet/react/providers/hosted/dynamic/__mocks__/DynamicHostedWalletProviderMock.ts

@@ -0,0 +1,57 @@
+import type { LocalAccount } from 'viem'
+import { unichain } from 'viem/op-stack'
+import { vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+import type {
+  DynamicHostedWalletToActionsWalletOptions,
+  ReactToActionsOptionsMap,
+} from '@/wallet/react/providers/hosted/types/index.js'
+
+/**
+ * Minimal mock implementation matching the shape of HostedWalletProvider<'dynamic'>
+ * for use in unit tests without importing browser-only dependencies.
+ */
+export class DynamicHostedWalletProviderMock extends HostedWalletProvider<
+  'dynamic',
+  ReactToActionsOptionsMap
+> {
+  // Exposed mock for assertions if needed
+  public readonly toActionsWalletMock = vi.fn(
+    async (
+      _params: DynamicHostedWalletToActionsWalletOptions,
+    ): Promise<Wallet> => {
+      return {} as unknown as Wallet
+    },
+  )
+
+  public readonly createSignerMock = vi.fn(
+    async (
+      _params: DynamicHostedWalletToActionsWalletOptions,
+    ): Promise<LocalAccount> => {
+      return {} as unknown as LocalAccount
+    },
+  )
+
+  constructor() {
+    const mockChainManager = new MockChainManager({
+      supportedChains: [unichain.id],
+    }) as unknown as ChainManager
+    super(mockChainManager)
+  }
+
+  async toActionsWallet(
+    params: DynamicHostedWalletToActionsWalletOptions,
+  ): Promise<Wallet> {
+    return this.toActionsWalletMock(params)
+  }
+
+  async createSigner(
+    params: DynamicHostedWalletToActionsWalletOptions,
+  ): Promise<LocalAccount> {
+    return this.createSignerMock(params)
+  }
+}

package/src/wallet/react/providers/hosted/dynamic/__tests__/DynamicHostedWalletProvider.spec.ts

@@ -0,0 +1,105 @@
+import type { LocalAccount } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { DynamicHostedWalletProvider } from '@/wallet/react/providers/hosted/dynamic/DynamicHostedWalletProvider.js'
+import type { DynamicHostedWalletToActionsWalletOptions } from '@/wallet/react/providers/hosted/types/index.js'
+import { DynamicWallet } from '@/wallet/react/wallets/hosted/dynamic/DynamicWallet.js'
+import * as createSignerUtil from '@/wallet/react/wallets/hosted/dynamic/utils/createSigner.js'
+
+// Mock DynamicWallet to avoid importing browser-related deps
+vi.mock('@/wallet/react/wallets/hosted/dynamic/DynamicWallet.js', async () => {
+  const { DynamicWalletMock } = await import(
+    '@/wallet/react/wallets/hosted/dynamic/__mocks__/DynamicWalletMock.js'
+  )
+  return { DynamicWallet: DynamicWalletMock }
+})
+
+describe('DynamicHostedWalletProvider', () => {
+  describe('toActionsWallet', () => {
+    it('toActionsWallet delegates to DynamicWallet.create with correct args', async () => {
+      const mockChainManager = new MockChainManager({
+        supportedChains: [1],
+      }) as unknown as ChainManager
+      const provider = new DynamicHostedWalletProvider(mockChainManager)
+
+      const mockDynamicWallet = {
+        __brand: 'dynamic-wallet',
+      } as unknown as DynamicHostedWalletToActionsWalletOptions['wallet']
+      const mockResult = {
+        __brand: 'actions-wallet',
+      } as unknown as DynamicWallet
+      vi.mocked(DynamicWallet.create).mockResolvedValueOnce(mockResult)
+
+      const result = await provider.toActionsWallet({
+        wallet: mockDynamicWallet,
+      })
+
+      expect(DynamicWallet.create).toHaveBeenCalledTimes(1)
+      expect(DynamicWallet.create).toHaveBeenCalledWith({
+        dynamicWallet: mockDynamicWallet,
+        chainManager: mockChainManager,
+      })
+      expect(result).toBe(mockResult)
+    })
+
+    it('forwards lendProvider when provided to constructor', async () => {
+      const mockChainManager = new MockChainManager({
+        supportedChains: [1],
+      }) as unknown as ChainManager
+      const mockLendProvider = {} as any
+      const provider = new DynamicHostedWalletProvider(
+        mockChainManager,
+        mockLendProvider as LendProvider<LendConfig>,
+      )
+
+      const mockDynamicWallet = {
+        __brand: 'dynamic-wallet',
+      } as unknown as DynamicHostedWalletToActionsWalletOptions['wallet']
+      const mockResult = {
+        __brand: 'actions-wallet',
+      } as unknown as DynamicWallet
+      vi.mocked(DynamicWallet.create).mockResolvedValueOnce(mockResult)
+
+      await provider.toActionsWallet({
+        wallet: mockDynamicWallet,
+      })
+
+      expect(DynamicWallet.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          lendProvider: mockLendProvider,
+        }),
+      )
+    })
+  })
+
+  describe('createSigner', () => {
+    it('should delegate to createSigner utility with correct params', async () => {
+      const mockChainManager = new MockChainManager({
+        supportedChains: [1],
+      }) as unknown as ChainManager
+      const provider = new DynamicHostedWalletProvider(mockChainManager)
+
+      const mockDynamicWallet = {
+        __brand: 'dynamic-wallet',
+      } as unknown as DynamicHostedWalletToActionsWalletOptions['wallet']
+
+      const mockSigner = {
+        address: '0xabc',
+        type: 'local',
+      } as unknown as LocalAccount
+
+      const createSignerSpy = vi
+        .spyOn(createSignerUtil, 'createSigner')
+        .mockResolvedValueOnce(mockSigner)
+
+      const params = { wallet: mockDynamicWallet }
+      const signer = await provider.createSigner(params)
+
+      expect(createSignerSpy).toHaveBeenCalledWith(params)
+      expect(signer).toBe(mockSigner)
+    })
+  })
+})

package/src/wallet/react/providers/hosted/privy/PrivyHostedWalletProvider.ts

@@ -0,0 +1,56 @@
+import type { LocalAccount } from 'viem'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+import type { ReactToActionsOptionsMap } from '@/wallet/react/providers/hosted/types/index.js'
+import { PrivyWallet } from '@/wallet/react/wallets/hosted/privy/PrivyWallet.js'
+import { createSigner } from '@/wallet/react/wallets/hosted/privy/utils/createSigner.js'
+
+/**
+ * Privy hosted wallet provider (React)
+ */
+export class PrivyHostedWalletProvider extends HostedWalletProvider<
+  'privy',
+  ReactToActionsOptionsMap
+> {
+  /**
+   * Create a new Privy wallet provider
+   * @param chainManager Chain manager for RPC, chain info, and transports
+   */
+  constructor(
+    chainManager: ChainManager,
+    lendProvider?: LendProvider<LendConfig>,
+  ) {
+    super(chainManager, lendProvider)
+  }
+
+  async toActionsWallet(
+    params: ReactToActionsOptionsMap['privy'],
+  ): Promise<Wallet> {
+    const { connectedWallet } = params
+    const wallet = await PrivyWallet.create({
+      chainManager: this.chainManager,
+      connectedWallet,
+      lendProvider: this.lendProvider,
+    })
+    return wallet
+  }
+
+  /**
+   * Create a viem LocalAccount signer from Privy credentials
+   * @description Produces a signing account backed by Privy without wrapping
+   * it in a full Actions wallet. This is useful when you need to pass the signer
+   * into an Actions smart wallet as a signer, for lower-level viem operations, or
+   * for passing to other libraries that accept a viem `LocalAccount`.
+   * @param params - Privy configuration for the signer
+   * @param params.connectedWallet - Privy connected wallet
+   * @returns Promise resolving to a viem `LocalAccount` with Privy as the signer backend
+   */
+  async createSigner(
+    params: ReactToActionsOptionsMap['privy'],
+  ): Promise<LocalAccount> {
+    return createSigner(params)
+  }
+}

package/src/wallet/react/providers/hosted/privy/__mocks__/PrivyHostedWalletProviderMock.ts

@@ -0,0 +1,56 @@
+import type { LocalAccount } from 'node_modules/viem/_types/accounts/types.js'
+import { unichain } from 'viem/op-stack'
+import { vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import { HostedWalletProvider } from '@/wallet/core/providers/hosted/abstract/HostedWalletProvider.js'
+import type { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+import type {
+  PrivyHostedWalletToActionsWalletOptions,
+  ReactToActionsOptionsMap,
+} from '@/wallet/react/providers/hosted/types/index.js'
+
+/**
+ * Minimal mock implementation matching the shape of HostedWalletProvider<'privy'>
+ * for use in unit tests without importing browser-only dependencies.
+ */
+export class PrivyHostedWalletProviderMock extends HostedWalletProvider<
+  'privy',
+  ReactToActionsOptionsMap
+> {
+  public readonly toActionsWalletMock = vi.fn(
+    async (
+      _params: PrivyHostedWalletToActionsWalletOptions,
+    ): Promise<Wallet> => {
+      return {} as unknown as Wallet
+    },
+  )
+
+  public readonly createSignerMock = vi.fn(
+    async (
+      _params: PrivyHostedWalletToActionsWalletOptions,
+    ): Promise<LocalAccount> => {
+      return {} as unknown as LocalAccount
+    },
+  )
+
+  constructor() {
+    const mockChainManager = new MockChainManager({
+      supportedChains: [unichain.id],
+    }) as unknown as ChainManager
+    super(mockChainManager)
+  }
+
+  async toActionsWallet(
+    params: PrivyHostedWalletToActionsWalletOptions,
+  ): Promise<Wallet> {
+    return this.toActionsWalletMock(params)
+  }
+
+  async createSigner(
+    params: PrivyHostedWalletToActionsWalletOptions,
+  ): Promise<LocalAccount> {
+    return this.createSignerMock(params)
+  }
+}

package/src/wallet/react/providers/hosted/privy/__tests__/PrivyHostedWalletProvider.spec.ts

@@ -0,0 +1,103 @@
+import type { ConnectedWallet } from '@privy-io/react-auth'
+import type { LocalAccount } from 'viem'
+import { describe, expect, it, vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { PrivyHostedWalletProvider } from '@/wallet/react/providers/hosted/privy/PrivyHostedWalletProvider.js'
+import { PrivyWallet } from '@/wallet/react/wallets/hosted/privy/PrivyWallet.js'
+import * as createSignerUtil from '@/wallet/react/wallets/hosted/privy/utils/createSigner.js'
+
+// Mock PrivyWallet to avoid importing browser-related deps
+vi.mock('@/wallet/react/wallets/hosted/privy/PrivyWallet.js', async () => {
+  const { PrivyWalletMock } = await import(
+    '@/wallet/react/wallets/hosted/privy/__mocks__/PrivyWalletMock.js'
+  )
+  return { PrivyWallet: PrivyWalletMock }
+})
+
+describe('PrivyHostedWalletProvider (React)', () => {
+  describe('toActionsWallet', () => {
+    it('toActionsWallet delegates to PrivyWallet.create with correct args', async () => {
+      const mockChainManager = new MockChainManager({
+        supportedChains: [1],
+      }) as unknown as ChainManager
+      const provider = new PrivyHostedWalletProvider(mockChainManager)
+      const mockActionsWallet = {
+        __brand: 'actions-wallet',
+      } as unknown as PrivyWallet
+      const mockConnectedWallet = {
+        __brand: 'privy-connected-wallet',
+      } as unknown as ConnectedWallet
+      vi.mocked(PrivyWallet.create).mockResolvedValueOnce(mockActionsWallet)
+
+      const result = await provider.toActionsWallet({
+        connectedWallet: mockConnectedWallet,
+      })
+
+      expect(PrivyWallet.create).toHaveBeenCalledTimes(1)
+      expect(PrivyWallet.create).toHaveBeenCalledWith({
+        chainManager: mockChainManager,
+        connectedWallet: mockConnectedWallet,
+      })
+      expect(result).toBe(mockActionsWallet)
+    })
+
+    it('forwards lendProvider when provided to constructor', async () => {
+      const mockChainManager = new MockChainManager({
+        supportedChains: [1],
+      }) as unknown as ChainManager
+      const mockLendProvider = {} as any
+      const provider = new PrivyHostedWalletProvider(
+        mockChainManager,
+        mockLendProvider as LendProvider<LendConfig>,
+      )
+      const mockActionsWallet = {
+        __brand: 'actions-wallet',
+      } as unknown as PrivyWallet
+      const mockConnectedWallet = {
+        __brand: 'privy-connected-wallet',
+      } as unknown as ConnectedWallet
+      vi.mocked(PrivyWallet.create).mockResolvedValueOnce(mockActionsWallet)
+
+      await provider.toActionsWallet({
+        connectedWallet: mockConnectedWallet,
+      })
+
+      expect(PrivyWallet.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          lendProvider: mockLendProvider,
+        }),
+      )
+    })
+  })
+
+  describe('createSigner', () => {
+    it('should delegate to createSigner utility with correct params', async () => {
+      const mockChainManager = new MockChainManager({
+        supportedChains: [1],
+      }) as unknown as ChainManager
+      const provider = new PrivyHostedWalletProvider(mockChainManager)
+
+      const mockConnectedWallet = {
+        __brand: 'privy-connected-wallet',
+      } as unknown as ConnectedWallet
+
+      const mockSigner = {
+        address: '0xabc',
+        type: 'local',
+      } as unknown as LocalAccount
+
+      const createSignerSpy = vi
+        .spyOn(createSignerUtil, 'createSigner')
+        .mockResolvedValueOnce(mockSigner)
+
+      const params = { connectedWallet: mockConnectedWallet }
+      const signer = await provider.createSigner(params)
+
+      expect(createSignerSpy).toHaveBeenCalledWith(params)
+      expect(signer).toBe(mockSigner)
+    })
+  })
+})