@eth-optimism/actions-sdk 0.0.2

package/src/wallet/core/wallets/smart/default/utils/__tests__/formatPublicKey.spec.ts

@@ -0,0 +1,28 @@
+import type { Address, Hex } from 'viem'
+import { pad } from 'viem'
+import type { WebAuthnAccount } from 'viem/account-abstraction'
+import { describe, expect, it } from 'vitest'
+
+import { formatPublicKey } from '@/wallet/core/wallets/smart/default/utils/formatPublicKey.js'
+
+describe('formatPublicKey', () => {
+  it('pads EOA address to 32 bytes', () => {
+    const eoa: Address = '0x7838d2724FC686813CAf81d4429beff1110c739a'
+    const result = formatPublicKey(eoa)
+    expect(result).toBe(pad(eoa))
+    // 32 bytes = 64 hex chars after 0x
+    expect((result as string).length).toBe(66)
+  })
+
+  it('returns WebAuthn publicKey as-is', () => {
+    const publicKey64Bytes: Hex =
+      '0xe7575170745fe55d7a26190c6d5504743496c49498b129d2b3660da3697e81d4daebb2496f89aa4a05f1705e1d5d316153211c198f80d3100b51489bf4963f47'
+    const webAuthn: WebAuthnAccount = {
+      type: 'webAuthn',
+      publicKey: publicKey64Bytes,
+    } as unknown as WebAuthnAccount
+
+    const result = formatPublicKey(webAuthn.publicKey)
+    expect(result).toBe(publicKey64Bytes)
+  })
+})

package/src/wallet/core/wallets/smart/default/utils/__tests__/getSignerPublicKey.spec.ts

@@ -0,0 +1,60 @@
+import type { Address, Hex, LocalAccount } from 'viem'
+import type { WebAuthnAccount } from 'viem/account-abstraction'
+import { describe, expect, it } from 'vitest'
+
+import { getRandomAddress } from '@/test/utils.js'
+import { getSignerPublicKey } from '@/wallet/core/wallets/smart/default/utils/getSignerPublicKey.js'
+
+describe('getSignerPublicKey', () => {
+  it('returns the address itself when signer is a plain address string', () => {
+    const address = getRandomAddress()
+    const result = getSignerPublicKey(address)
+    expect(result).toBe(address)
+  })
+
+  it('returns the address when signer is a LocalAccount', () => {
+    const address = getRandomAddress()
+    const localAccount: LocalAccount = {
+      address,
+      type: 'local',
+      publicKey: '0xaabbccdd' as Hex,
+    } as unknown as LocalAccount
+
+    const result = getSignerPublicKey(localAccount)
+    expect(result).toBe(address)
+  })
+
+  it('returns the publicKey when signer is a WebAuthnAccount', () => {
+    const publicKey: Hex =
+      '0xe7575170745fe55d7a26190c6d5504743496c49498b129d2b3660da3697e81d4daebb2496f89aa4a05f1705e1d5d316153211c198f80d3100b51489bf4963f47'
+    const webAuthnAccount: WebAuthnAccount = {
+      type: 'webAuthn',
+      publicKey,
+      id: 'test-id',
+    } as unknown as WebAuthnAccount
+
+    const result = getSignerPublicKey(webAuthnAccount)
+    expect(result).toBe(publicKey)
+  })
+
+  it('throws error for invalid signer type', () => {
+    const invalidSigner = {
+      type: 'unknown',
+      address: '0x1234567890123456789012345678901234567890' as Address,
+    } as unknown as LocalAccount
+
+    expect(() => getSignerPublicKey(invalidSigner)).toThrow(
+      'invalid signer type',
+    )
+  })
+
+  it('handles different address formats correctly', () => {
+    const checksummedAddress: Address =
+      '0x7838d2724FC686813CAf81d4429beff1110c739a'
+    const lowercaseAddress: Address =
+      '0x7838d2724fc686813caf81d4429beff1110c739a'
+
+    expect(getSignerPublicKey(checksummedAddress)).toBe(checksummedAddress)
+    expect(getSignerPublicKey(lowercaseAddress)).toBe(lowercaseAddress)
+  })
+})

package/src/wallet/core/wallets/smart/default/utils/findSignerInArray.ts

@@ -0,0 +1,30 @@
+import { getAddress, type LocalAccount } from 'viem'
+
+import type { Signer } from '@/wallet/core/wallets/smart/abstract/types/index.js'
+
+/**
+ * Find the index of a signer in the signers array
+ * @description Searches through the signers array to find the index where the signer matches.
+ * We only support signer type of LocalAccount for now.
+ * @param signers - Array of wallet signers (addresses, LocalAccounts, or WebAuthn accounts)
+ * @param signer - The signer to find in the signers array
+ * @returns The index of the signer in the signers array
+ */
+export function findSignerInArray(
+  signers: Signer[],
+  signer: LocalAccount,
+): number {
+  return signers.findIndex((signerEntry) => {
+    // we only support signer type of LocalAccount for now
+    if (typeof signerEntry === 'string') {
+      // EOA address comparison
+      return getAddress(signerEntry) === getAddress(signer.address)
+    }
+
+    if (signerEntry.type === 'local') {
+      return getAddress(signerEntry.address) === getAddress(signer.address)
+    }
+
+    return false
+  })
+}

package/src/wallet/core/wallets/smart/default/utils/findSignerIndexOnChain.ts

@@ -0,0 +1,66 @@
+import type { Client, Hex } from 'viem'
+import { readContract } from 'viem/actions'
+
+import { smartWalletAbi } from '@/wallet/core/wallets/smart/default/constants/index.js'
+import { formatPublicKey } from '@/wallet/core/wallets/smart/default/utils/formatPublicKey.js'
+
+type FindSignerIndexOnChainParams = {
+  /**
+   * The address of the account to get the owner index for
+   */
+  address: `0x${string}`
+  /**
+   * The client to use to get the code and read the contract
+   */
+  client: Client
+  /**
+   * The public key of the owner
+   */
+  signerPublicKey: Hex
+}
+
+/**
+ * Find the index of a signer in a smart wallet
+ * @description Iterates over the wallet's owner slots from highest to lowest index
+ * (using the contract's `nextOwnerIndex` and `ownerAtIndex`) to locate the provided signer.
+ * The signer may be an EOA address or a WebAuthn account; in both cases it is normalized via
+ * {@link formatPublicKey} to the 32-byte form used by the contract for comparisons.
+ * Returns the owner's index if found, otherwise -1.
+ * @param address - Address of the smart wallet contract to inspect
+ * @param client - Public client used to perform contract reads
+ * @param signerPublicKey - Signer public key to search for (EOA `Address` or `WebAuthnAccount`)
+ * @returns Promise that resolves to the 0-based signer index, or -1 if not found
+ */
+export async function findSignerIndexOnChain({
+  address,
+  client,
+  signerPublicKey,
+}: FindSignerIndexOnChainParams): Promise<number> {
+  const nextOwnerIndex = await readContract(client, {
+    address,
+    abi: smartWalletAbi,
+    functionName: 'nextOwnerIndex',
+  })
+  const formattedSignerPublicKey = formatPublicKey(signerPublicKey)
+
+  // Iterate from highest index down and return early when found
+  for (let i = Number(nextOwnerIndex) - 1; i >= 0; i--) {
+    const signerAtIndex = await readContract(client, {
+      address,
+      abi: smartWalletAbi,
+      functionName: 'ownerAtIndex',
+      args: [BigInt(i)],
+    })
+
+    // Skip empty slots (deleted owners)
+    if (!signerAtIndex || signerAtIndex === '0x') continue
+
+    if (
+      signerAtIndex.toLowerCase() === formattedSignerPublicKey.toLowerCase()
+    ) {
+      return i
+    }
+  }
+
+  return -1
+}

package/src/wallet/core/wallets/smart/default/utils/formatPublicKey.ts

@@ -0,0 +1,14 @@
+import type { Address, Hex } from 'viem'
+import { isAddress, pad } from 'viem'
+
+/**
+ * Formats 20 byte addresses to 32 byte public keys. Contract uses 32 byte keys for owners.
+ * @param publicKey - The public key to format
+ * @returns The formatted public key
+ */
+export function formatPublicKey(publicKey: Hex | Address): Hex {
+  if (isAddress(publicKey)) {
+    return pad(publicKey)
+  }
+  return publicKey
+}

package/src/wallet/core/wallets/smart/default/utils/getSignerPublicKey.ts

@@ -0,0 +1,18 @@
+import type { Hex } from 'viem'
+
+import type { Signer } from '@/wallet/core/wallets/smart/abstract/types/index.js'
+
+/**
+ * Extracts the public key or identifier from a smart wallet signer.
+ *
+ * Returns the appropriate public identifier for each signer type:
+ * - Address: returns the address itself
+ * - LocalAccount: returns the account's address
+ * - WebAuthnAccount: returns the P256 public key
+ */
+export function getSignerPublicKey(signer: Signer): Hex {
+  if (typeof signer === 'string') return signer
+  if (signer.type === 'webAuthn') return signer.publicKey
+  if (signer.type === 'local') return signer.address
+  throw new Error('invalid signer type')
+}

package/src/wallet/core/wallets/smart/error/errors.ts

@@ -0,0 +1,18 @@
+import type { WaitForUserOperationReceiptReturnType } from 'viem/account-abstraction'
+
+import type { SupportedChainId } from '@/constants/supportedChains.js'
+
+export class SmartWalletDeploymentError extends Error {
+  chainId: SupportedChainId
+  receipt?: WaitForUserOperationReceiptReturnType
+  constructor(
+    message: string,
+    chainId: SupportedChainId,
+    receipt?: WaitForUserOperationReceiptReturnType,
+  ) {
+    super(message)
+    this.name = 'SmartWalletDeploymentError'
+    this.chainId = chainId
+    this.receipt = receipt
+  }
+}

package/src/wallet/node/index.ts

@@ -0,0 +1,7 @@
+export { PrivyHostedWalletProvider } from '@/wallet/node/providers/hosted/privy/PrivyHostedWalletProvider.js'
+export type {
+  NodeHostedWalletProvidersSchema,
+  NodeOptionsMap,
+  NodeProviderTypes,
+} from '@/wallet/node/providers/hosted/types/index.js'
+export { PrivyWallet } from '@/wallet/node/wallets/hosted/privy/PrivyWallet.js'

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

@@ -0,0 +1,65 @@
+import type { PrivyClient } from '@privy-io/server-auth'
+import type { LocalAccount } from 'viem'
+import { getAddress } 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 {
+  NodeToActionsOptionsMap,
+  PrivyHostedWalletToActionsWalletOptions,
+} from '@/wallet/node/providers/hosted/types/index.js'
+import { PrivyWallet } from '@/wallet/node/wallets/hosted/privy/PrivyWallet.js'
+import { createSigner } from '@/wallet/node/wallets/hosted/privy/utils/createSigner.js'
+
+/**
+ * Privy wallet provider implementation
+ * @description Wallet provider implementation using Privy service
+ */
+export class PrivyHostedWalletProvider extends HostedWalletProvider<
+  'privy',
+  NodeToActionsOptionsMap
+> {
+  /**
+   * Create a new Privy wallet provider
+   * @param privyClient - Privy client instance
+   */
+  constructor(
+    private readonly privyClient: PrivyClient,
+    chainManager: ChainManager,
+    lendProvider?: LendProvider<LendConfig>,
+  ) {
+    super(chainManager, lendProvider)
+  }
+
+  async toActionsWallet(
+    params: PrivyHostedWalletToActionsWalletOptions,
+  ): Promise<Wallet> {
+    return PrivyWallet.create({
+      privyClient: this.privyClient,
+      walletId: params.walletId,
+      address: getAddress(params.address),
+      chainManager: this.chainManager,
+      lendProvider: this.lendProvider,
+    })
+  }
+
+  /**
+   * 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.
+   * @param params - Privy configuration for the signer
+   * @param params.privyClient - Privy client instance
+   * @param params.walletId - Privy wallet identifier
+   * @param params.address - Ethereum address of the wallet
+   * @returns Promise resolving to a LocalAccount configured for signing operations
+   * @throws Error if wallet retrieval fails or signing operations are not supported
+   */
+  async createSigner(
+    params: NodeToActionsOptionsMap['privy'],
+  ): Promise<LocalAccount> {
+    return createSigner({ ...params, privyClient: this.privyClient })
+  }
+}

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

@@ -0,0 +1,112 @@
+import type { Address } from 'viem'
+import { getAddress } from 'viem'
+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 { createMockPrivyClient } from '@/test/MockPrivyClient.js'
+import { getRandomAddress } from '@/test/utils.js'
+import type { LendConfig, LendProvider } from '@/types/lend/index.js'
+import { Wallet } from '@/wallet/core/wallets/abstract/Wallet.js'
+import { PrivyHostedWalletProvider } from '@/wallet/node/providers/hosted/privy/PrivyHostedWalletProvider.js'
+import { PrivyWallet } from '@/wallet/node/wallets/hosted/privy/PrivyWallet.js'
+
+describe('PrivyHostedWalletProvider', () => {
+  const mockChainManager = new MockChainManager({
+    supportedChains: [unichain.id],
+  }) as unknown as ChainManager
+
+  describe('toActionsWallet', () => {
+    it('toActionsWallet creates an ActionsWallet with correct address and signer', async () => {
+      const privy = createMockPrivyClient('app', 'secret')
+      const provider = new PrivyHostedWalletProvider(privy, mockChainManager)
+
+      const hostedWallet = await privy.walletApi.createWallet({
+        chainType: 'ethereum',
+      })
+
+      const actionsWallet = await provider.toActionsWallet({
+        walletId: hostedWallet.id,
+        address: hostedWallet.address as Address,
+      })
+
+      expect(actionsWallet).toBeInstanceOf(Wallet)
+      expect(actionsWallet.address).toBe(hostedWallet.address)
+      expect(actionsWallet.signer.address).toBe(hostedWallet.address)
+    })
+
+    it('forwards params to PrivyWallet.create', async () => {
+      const privy = createMockPrivyClient('app', 'secret')
+      const provider = new PrivyHostedWalletProvider(privy, mockChainManager)
+      const spy = vi.spyOn(PrivyWallet, 'create')
+
+      const id = 'mock-wallet-123'
+      const addr = getRandomAddress().toLowerCase()
+
+      await provider.toActionsWallet({ walletId: id, address: addr as Address })
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          privyClient: privy,
+          walletId: id,
+          address: getAddress(addr),
+          chainManager: mockChainManager,
+        }),
+      )
+    })
+
+    it('throws on invalid address', async () => {
+      const privy = createMockPrivyClient('app', 'secret')
+      const provider = new PrivyHostedWalletProvider(privy, mockChainManager)
+
+      await expect(
+        provider.toActionsWallet({ walletId: 'id', address: '0x123' }),
+      ).rejects.toBeTruthy()
+    })
+
+    it('forwards lendProvider when provided to constructor', async () => {
+      const privy = createMockPrivyClient('app', 'secret')
+      const mockLendProvider = {} as LendProvider<LendConfig>
+      const provider = new PrivyHostedWalletProvider(
+        privy,
+        mockChainManager,
+        mockLendProvider,
+      )
+      const spy = vi.spyOn(PrivyWallet, 'create')
+
+      const id = 'mock-wallet-123'
+      const addr = getRandomAddress().toLowerCase()
+
+      await provider.toActionsWallet({
+        walletId: id,
+        address: addr as Address,
+      })
+
+      expect(spy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          lendProvider: mockLendProvider,
+        }),
+      )
+    })
+  })
+
+  describe('createSigner', () => {
+    it('should create a LocalAccount with correct address', async () => {
+      const privy = createMockPrivyClient('app', 'secret')
+      const provider = new PrivyHostedWalletProvider(privy, mockChainManager)
+
+      const hostedWallet = await privy.walletApi.createWallet({
+        chainType: 'ethereum',
+      })
+
+      const signer = await provider.createSigner({
+        walletId: hostedWallet.id,
+        address: hostedWallet.address as Address,
+      })
+
+      expect(signer.address).toBe(hostedWallet.address)
+      expect(signer.type).toBe('local')
+    })
+  })
+})

package/src/wallet/node/providers/hosted/registry/NodeHostedWalletProviderRegistry.ts

@@ -0,0 +1,55 @@
+import { HostedWalletProviderRegistry } from '@/wallet/core/providers/hosted/registry/HostedWalletProviderRegistry.js'
+import { PrivyHostedWalletProvider } from '@/wallet/node/providers/hosted/privy/PrivyHostedWalletProvider.js'
+import { TurnkeyHostedWalletProvider } from '@/wallet/node/providers/hosted/turnkey/TurnkeyHostedWalletProvider.js'
+import type {
+  NodeHostedProviderInstanceMap,
+  NodeOptionsMap,
+  NodeProviderTypes,
+} from '@/wallet/node/providers/hosted/types/index.js'
+
+/**
+ * Node hosted wallet provider registry
+ * @description
+ * Environment-scoped registry that binds Node/server provider keys to their
+ * factory implementations. This ensures browser-only hosted providers are
+ * discoverable at runtime without importing Node-only code. The registry
+ * pre-registers 'privy' and 'turnkey' providers and can be extended with
+ * additional providers via `register`.
+ */
+export class NodeHostedWalletProviderRegistry extends HostedWalletProviderRegistry<
+  NodeHostedProviderInstanceMap,
+  NodeOptionsMap,
+  NodeProviderTypes
+> {
+  public constructor() {
+    super()
+    this.register<'privy'>({
+      type: 'privy',
+      validateOptions(options): options is NodeOptionsMap['privy'] {
+        return Boolean((options as NodeOptionsMap['privy'])?.privyClient)
+      },
+      create({ chainManager, lendProvider }, options) {
+        return new PrivyHostedWalletProvider(
+          options.privyClient,
+          chainManager,
+          lendProvider,
+        )
+      },
+    })
+
+    this.register<'turnkey'>({
+      type: 'turnkey',
+      validateOptions(options): options is NodeOptionsMap['turnkey'] {
+        const o = options as NodeOptionsMap['turnkey']
+        return Boolean(o?.client)
+      },
+      create({ chainManager, lendProvider }, options) {
+        return new TurnkeyHostedWalletProvider(
+          options.client,
+          chainManager,
+          lendProvider,
+        )
+      },
+    })
+  }
+}

package/src/wallet/node/providers/hosted/registry/__tests__/NodeHostedWalletProviderRegistry.spec.ts

@@ -0,0 +1,89 @@
+import type { PrivyClient } from '@privy-io/server-auth'
+import type { TurnkeyClient } from '@turnkey/http'
+import { unichain } from 'viem/chains'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import type { ChainManager } from '@/services/ChainManager.js'
+import { MockChainManager } from '@/test/MockChainManager.js'
+import { createMockPrivyClient } from '@/test/MockPrivyClient.js'
+import { PrivyHostedWalletProvider } from '@/wallet/node/providers/hosted/privy/PrivyHostedWalletProvider.js'
+import { NodeHostedWalletProviderRegistry } from '@/wallet/node/providers/hosted/registry/NodeHostedWalletProviderRegistry.js'
+import { TurnkeyHostedWalletProvider } from '@/wallet/node/providers/hosted/turnkey/TurnkeyHostedWalletProvider.js'
+import type { NodeOptionsMap } from '@/wallet/node/providers/hosted/types/index.js'
+
+describe('NodeHostedWalletProviderRegistry', () => {
+  const mockChainManager = new MockChainManager({
+    supportedChains: [unichain.id],
+  }) as unknown as ChainManager
+  let mockPrivyClient: PrivyClient
+  const mockTurnkeyClient = {} as unknown as TurnkeyClient
+
+  beforeEach(() => {
+    mockPrivyClient = createMockPrivyClient('test-app-id', 'test-app-secret')
+  })
+
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns privy factory and validates options', () => {
+    const registry = new NodeHostedWalletProviderRegistry()
+    const factory = registry.getFactory('privy')
+
+    expect(factory.type).toBe('privy')
+    expect(
+      factory.validateOptions?.({
+        privyClient: mockPrivyClient,
+      } as NodeOptionsMap['privy']),
+    ).toBe(true)
+    // Invalid shape should not pass validation
+    expect(factory.validateOptions?.({})).toBe(false)
+  })
+
+  it('creates a PrivyHostedWalletProvider instance', () => {
+    const registry = new NodeHostedWalletProviderRegistry()
+    const factory = registry.getFactory('privy')
+
+    const provider = factory.create({ chainManager: mockChainManager }, {
+      privyClient: mockPrivyClient,
+    } as NodeOptionsMap['privy'])
+
+    expect(provider).toBeInstanceOf(PrivyHostedWalletProvider)
+  })
+
+  it('returns turnkey factory and validates options', () => {
+    const registry = new NodeHostedWalletProviderRegistry()
+    const factory = registry.getFactory('turnkey')
+
+    expect(factory.type).toBe('turnkey')
+    expect(
+      factory.validateOptions?.({
+        client: mockTurnkeyClient,
+      } as NodeOptionsMap['turnkey']),
+    ).toBe(true)
+    // Invalid shape should not pass validation
+    expect(factory.validateOptions?.({})).toBe(false)
+  })
+
+  it('creates a TurnkeyHostedWalletProvider instance', () => {
+    const registry = new NodeHostedWalletProviderRegistry()
+    const factory = registry.getFactory('turnkey')
+
+    const provider = factory.create(
+      { chainManager: mockChainManager },
+      {
+        client: mockTurnkeyClient,
+      },
+    )
+
+    expect(provider).toBeInstanceOf(TurnkeyHostedWalletProvider)
+  })
+
+  it('throws for unknown provider type', () => {
+    const registry = new NodeHostedWalletProviderRegistry()
+    // @ts-expect-error: testing runtime error for unknown type
+    expect(() => registry.getFactory('unknown')).toThrow(
+      'Unknown hosted wallet provider: unknown',
+    )
+  })
+})

package/src/wallet/node/providers/hosted/turnkey/TurnkeyHostedWalletProvider.ts

@@ -0,0 +1,84 @@
+import type { TurnkeySDKClientBase } from '@turnkey/core'
+import type { TurnkeyClient as TurnkeyHttpClient } from '@turnkey/http'
+import type { TurnkeyServerClient } from '@turnkey/sdk-server'
+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 { NodeToActionsOptionsMap } from '@/wallet/node/providers/hosted/types/index.js'
+import { TurnkeyWallet } from '@/wallet/node/wallets/hosted/turnkey/TurnkeyWallet.js'
+import { createSigner } from '@/wallet/node/wallets/hosted/turnkey/utils/createSigner.js'
+
+/**
+ * Turnkey wallet provider implementation
+ * @description Hosted wallet provider that wraps Turnkey's signing infrastructure
+ * and exposes an Actions-compatible wallet. This provider is intended for Node
+ * environments where the Turnkey client (HTTP, server, or core SDK) and
+ * organization context are provided at construction time.
+ */
+export class TurnkeyHostedWalletProvider extends HostedWalletProvider<
+  'turnkey',
+  NodeToActionsOptionsMap
+> {
+  /**
+   * Create a new Turnkey wallet provider
+   * @param client - Turnkey client instance (HTTP, server, or core SDK base)
+   * @param chainManager - Chain manager used to resolve chains and RPC transports
+   */
+  constructor(
+    private readonly client:
+      | TurnkeyHttpClient
+      | TurnkeyServerClient
+      | TurnkeySDKClientBase,
+    chainManager: ChainManager,
+    lendProvider?: LendProvider<LendConfig>,
+  ) {
+    super(chainManager, lendProvider)
+  }
+
+  /**
+   * Convert a Turnkey hosted wallet context into an Actions wallet
+   * @description Creates a `TurnkeyWallet` configured with the provider's Turnkey
+   * client and organization.
+   * @param params - Options for creating the Actions wallet from Turnkey context
+   * @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 an Actions-compatible wallet instance
+   */
+  async toActionsWallet(
+    params: NodeToActionsOptionsMap['turnkey'],
+  ): Promise<Wallet> {
+    return TurnkeyWallet.create({
+      client: this.client,
+      organizationId: params.organizationId,
+      signWith: params.signWith,
+      ethereumAddress: params.ethereumAddress,
+      chainManager: this.chainManager,
+      lendProvider: this.lendProvider,
+    })
+  }
+
+  /**
+   * Create a viem LocalAccount signer from Turnkey credentials
+   * @description Produces a signing account backed by Turnkey 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 - Turnkey configuration for the signer
+   * @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 - Optional Ethereum address (recommended for passkey clients to avoid extra prompts)
+   * @returns Promise resolving to a viem `LocalAccount` with Turnkey as the signer backend
+   */
+  async createSigner(
+    params: NodeToActionsOptionsMap['turnkey'],
+  ): Promise<LocalAccount> {
+    return createSigner({
+      ...params,
+      client: this.client,
+    })
+  }
+}