@zerodev/wallet-core 0.0.1-alpha.10

package/src/actions/wallet/getUserWallet.ts

@@ -0,0 +1,53 @@
+import type { Hex } from 'viem'
+import type { Client } from '../../client/types.js'
+
+export type GetUserWalletParameters = {
+  /** The organization ID */
+  organizationId: string
+  /** The project ID for the request */
+  projectId: string
+  /** The token for the request */
+  token: string
+}
+
+export type GetUserWalletReturnType = {
+  /** The wallet address */
+  walletAddresses: Hex[]
+  /** The user ID */
+  userId?: string
+}
+
+/**
+ * Gets the user's wallet information
+ *
+ * @param client - The ZeroDev Wallet client
+ * @param params - The parameters for getting wallet info
+ * @returns The wallet information
+ *
+ * @example
+ * ```ts
+ * const wallet = await getUserWallet(client, {
+ *   organizationId: 'org_123',
+ *   projectId: 'proj_456'
+ * });
+ * console.log(wallet.walletAddresses); // ['0x...', '0x...']
+ * ```
+ */
+export async function getUserWallet(
+  client: Client,
+  params: GetUserWalletParameters,
+): Promise<GetUserWalletReturnType> {
+  const { organizationId, projectId, token } = params
+
+  return await client.request({
+    path: `${projectId}/user-wallet`,
+    body: {
+      organizationId,
+    },
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+    stamp: true,
+    stampPostion: 'headers',
+  })
+}

package/src/actions/wallet/index.ts

@@ -0,0 +1,17 @@
+export {
+  type GetUserWalletParameters,
+  type GetUserWalletReturnType,
+  getUserWallet,
+} from './getUserWallet.js'
+
+export {
+  type SignRawPayloadParameters,
+  type SignRawPayloadReturnType,
+  signRawPayload,
+} from './signRawPayload.js'
+
+export {
+  type SignTransactionParameters,
+  type SignTransactionReturnType,
+  signTransaction,
+} from './signTransaction.js'

package/src/actions/wallet/signRawPayload.ts

@@ -0,0 +1,75 @@
+import type { Hex } from 'viem'
+import type { Client } from '../../client/types.js'
+
+export type SignRawPayloadParameters = {
+  /** The organization ID */
+  organizationId: string
+  /** The project ID for the request */
+  projectId: string
+  /** The session token for authorization */
+  token: string
+  /** The address to sign with */
+  address: Hex
+  /** The payload hash to sign (without 0x prefix) */
+  payload: string
+  /** The encoding type */
+  encoding?: 'PAYLOAD_ENCODING_HEXADECIMAL' | 'PAYLOAD_ENCODING_EIP712'
+  /** The hash function type */
+  hashFunction?: 'HASH_FUNCTION_NO_OP'
+}
+
+export type SignRawPayloadReturnType = Hex
+
+/**
+ * Signs a raw payload with the user's wallet
+ *
+ * @param client - The ZeroDev Wallet client
+ * @param params - The parameters for signing
+ * @returns The signature
+ *
+ * @example
+ * ```ts
+ * const result = await signRawPayload(client, {
+ *   organizationId: 'org_123',
+ *   projectId: 'proj_456',
+ *   address: '0x123...',
+ *   payload: 'abc123...',
+ * });
+ * console.log(result.signature); // '0x...'
+ * ```
+ */
+export async function signRawPayload(
+  client: Client,
+  params: SignRawPayloadParameters,
+): Promise<SignRawPayloadReturnType> {
+  const {
+    organizationId,
+    projectId,
+    token,
+    address,
+    payload,
+    encoding = 'PAYLOAD_ENCODING_HEXADECIMAL',
+    hashFunction = 'HASH_FUNCTION_NO_OP',
+  } = params
+
+  const { signature } = await client.request({
+    path: `${projectId}/sign/raw-payload`,
+    body: {
+      type: 'ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2',
+      timestampMs: Date.now().toString(),
+      organizationId,
+      parameters: {
+        signWith: address,
+        payload,
+        encoding,
+        hashFunction,
+      },
+    },
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+    stamp: true,
+    stampPostion: 'headers',
+  })
+  return signature as Hex
+}

package/src/actions/wallet/signTransaction.ts

@@ -0,0 +1,64 @@
+import type { Hex } from 'viem'
+import type { Client } from '../../client/types.js'
+
+export type SignTransactionParameters = {
+  /** The organization ID */
+  organizationId: string
+  /** The project ID for the request */
+  projectId: string
+  /** The session token for authorization */
+  token: string
+  /** The address to sign with */
+  address: Hex
+  /** The unsigned transaction to sign */
+  unsignedTransaction: string
+}
+
+export type SignTransactionReturnType = Hex
+
+/**
+ * Signs a raw transaction with the user's wallet
+ *
+ * @param client - The ZeroDev Wallet client
+ * @param params - The parameters for signing
+ * @returns The signature
+ *
+ * @example
+ * ```ts
+ * const result = await signTransaction(client, {
+ *   organizationId: 'org_123',
+ *   projectId: 'proj_456',
+ *   address: '0x123...',
+ *   unsignedTransaction: 'abc123...',
+ * });
+ * console.log(result.signature); // '0x...'
+ * ```
+ */
+export async function signTransaction(
+  client: Client,
+  params: SignTransactionParameters,
+): Promise<SignTransactionReturnType> {
+  const { organizationId, projectId, token, address, unsignedTransaction } =
+    params
+
+  const { signature } = await client.request({
+    path: `${projectId}/sign/transaction`,
+    body: {
+      type: 'ACTIVITY_TYPE_SIGN_TRANSACTION_V2',
+      timestampMs: Date.now().toString(),
+      organizationId,
+      parameters: {
+        signWith: address,
+        type: 'TRANSACTION_TYPE_ETHEREUM',
+        unsignedTransaction,
+      },
+    },
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+    stamp: true,
+    stampPostion: 'headers',
+  })
+
+  return `0x${signature}` as Hex
+}

package/src/adapters/viem.ts

@@ -0,0 +1,162 @@
+import {
+  type Hex,
+  hashMessage,
+  type LocalAccount,
+  parseSignature,
+  parseTransaction,
+  type SerializeTransactionFn,
+  type SignableMessage,
+  serializeTransaction,
+  serializeTypedData,
+  type TransactionSerializable,
+  zeroAddress,
+} from 'viem'
+import type {
+  SignAuthorizationParameters,
+  SignAuthorizationReturnType,
+} from 'viem/accounts'
+import { toAccount } from 'viem/accounts'
+import { hashAuthorization } from 'viem/utils'
+import type { signRawPayload } from '../actions/index.js'
+import type { ZeroDevWalletClient } from '../client/index.js'
+
+export interface ToViemAccountParams {
+  client: ZeroDevWalletClient
+  organizationId: string
+  projectId: string
+  token: string
+}
+
+export async function toViemAccount(
+  params: ToViemAccountParams,
+): Promise<LocalAccount> {
+  const { client, organizationId, projectId, token } = params
+
+  let address: Hex = zeroAddress
+
+  try {
+    const walletResponse = await client.getUserWallet({
+      organizationId,
+      projectId,
+      token,
+    })
+    address = walletResponse.walletAddresses[0]
+  } catch {
+    address = zeroAddress
+  }
+  const signRawPayloadInternal = async (
+    payload: string,
+    encoding: Parameters<
+      typeof signRawPayload
+    >[1]['encoding'] = 'PAYLOAD_ENCODING_HEXADECIMAL',
+  ) => {
+    return await client.signRawPayload({
+      organizationId,
+      projectId,
+      token,
+      address,
+      payload,
+      encoding,
+    })
+  }
+
+  // Modified from: https://github.com/tkhq/sdk/blob/4e439bf2973ea13b51d981d7c24a4841d4e5fd5f/packages/viem/src/index.ts#L419-L461
+  const signTransactionInternal = async <
+    TTransactionSerializable extends TransactionSerializable,
+  >(
+    transaction: TTransactionSerializable,
+    serializer: SerializeTransactionFn<TTransactionSerializable>,
+  ): Promise<Hex> => {
+    // Note: for Type 3 transactions, we are specifically handling parsing for payloads containing only the transaction payload body, without any wrappers around blobs, commitments, or proofs.
+    // See more: https://github.com/wevm/viem/blob/3ef19eac4963014fb20124d1e46d1715bed5509f/src/accounts/utils/signTransaction.ts#L54-L55
+    const signableTransaction =
+      transaction.type === 'eip4844'
+        ? { ...transaction, sidecars: false }
+        : transaction
+
+    const serializedTx = await serializer(signableTransaction)
+    const nonHexPrefixedSerializedTx = serializedTx.replace(/^0x/, '')
+    const signature = await client.signTransaction({
+      organizationId,
+      projectId,
+      token,
+      address,
+      unsignedTransaction: nonHexPrefixedSerializedTx,
+    })
+
+    if (transaction.type === 'eip4844') {
+      // Grab components of the signature
+      const { r, s, v } = parseTransaction(signature)
+
+      // Recombine with the original transaction
+      return serializeTransaction(transaction, {
+        r: r!,
+        s: s!,
+        v: v!,
+      })
+    }
+
+    return signature
+  }
+
+  return toAccount({
+    address,
+
+    async signMessage({ message }: { message: SignableMessage }): Promise<Hex> {
+      const hashedMessage = hashMessage(message)
+      return signRawPayloadInternal(hashedMessage)
+    },
+
+    signTransaction: async <
+      TTransactionSerializable extends TransactionSerializable,
+    >(
+      transaction: TTransactionSerializable,
+      options?: {
+        serializer?:
+          | SerializeTransactionFn<TTransactionSerializable>
+          | undefined
+      },
+    ) => {
+      const serializer: SerializeTransactionFn<TTransactionSerializable> =
+        options?.serializer ??
+        (serializeTransaction as SerializeTransactionFn<TTransactionSerializable>)
+      return signTransactionInternal(transaction, serializer)
+    },
+    signTypedData: async (typedData) => {
+      const serializedTypedData = serializeTypedData(typedData)
+      return signRawPayloadInternal(
+        serializedTypedData,
+        'PAYLOAD_ENCODING_EIP712',
+      )
+    },
+
+    async signAuthorization(
+      parameters: Omit<SignAuthorizationParameters, 'privateKey'>,
+    ): Promise<SignAuthorizationReturnType> {
+      const { chainId, nonce } = parameters
+      const authAddress = parameters.contractAddress ?? parameters.address
+
+      if (!authAddress) {
+        throw new Error('Unable to sign authorization: address is undefined')
+      }
+
+      const hashedAuthorization = hashAuthorization({
+        address: authAddress,
+        chainId,
+        nonce,
+      })
+
+      const signature = await signRawPayloadInternal(hashedAuthorization)
+
+      const parsedSignature = parseSignature(signature)
+
+      return {
+        address: authAddress,
+        chainId,
+        nonce,
+        ...parsedSignature,
+        yParity: parsedSignature.v === BigInt(27) ? 0 : 1,
+      } as SignAuthorizationReturnType
+    },
+  })
+}

package/src/client/authProxy.ts

@@ -0,0 +1,78 @@
+const AUTH_PROXY_BASE_URL = 'https://authproxy.turnkey.com'
+
+export type AuthProxyClientConfig = {
+  /** The Auth Proxy Config ID from the backend */
+  authProxyConfigId: string
+  /** Optional base URL override (for testing) */
+  baseUrl?: string
+}
+
+export type AuthProxyVerifyOtpRequest = {
+  /** The OTP ID from registration */
+  otpId: string
+  /** The OTP code entered by the user */
+  otpCode: string
+  /** The public key to associate with the verification */
+  public_key: string
+}
+
+export type AuthProxyVerifyOtpResponse = {
+  /** The verification token to use for login */
+  verificationToken: string
+}
+
+/**
+ * Creates an Auth Proxy client for making requests to Turnkey's Auth Proxy
+ *
+ * Note: This client only handles OTP verification. The actual OTP login
+ * is handled by the backend (/auth/login/otp) which manages sub-organization
+ * creation and session handling.
+ */
+export function createAuthProxyClient(config: AuthProxyClientConfig) {
+  const { authProxyConfigId, baseUrl = AUTH_PROXY_BASE_URL } = config
+
+  async function request<T>(
+    path: string,
+    body: unknown,
+    method: 'POST' | 'GET' = 'POST',
+  ): Promise<T> {
+    const fetchOptions: RequestInit = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Auth-Proxy-Config-Id': authProxyConfigId,
+      },
+    }
+
+    if (method !== 'GET') {
+      fetchOptions.body = JSON.stringify(body)
+    }
+
+    const response = await fetch(`${baseUrl}${path}`, fetchOptions)
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      throw new Error(
+        `Auth Proxy request failed: ${response.status} ${response.statusText} - ${errorText}`,
+      )
+    }
+
+    return response.json()
+  }
+
+  return {
+    /**
+     * Verifies an OTP code with Turnkey's Auth Proxy
+     *
+     * Returns a verificationToken that should be passed to the backend's
+     * /auth/login/otp endpoint along with a client signature.
+     */
+    async verifyOtp(
+      params: AuthProxyVerifyOtpRequest,
+    ): Promise<AuthProxyVerifyOtpResponse> {
+      return request<AuthProxyVerifyOtpResponse>('/v1/otp_verify', params)
+    },
+  }
+}
+
+export type AuthProxyClient = ReturnType<typeof createAuthProxyClient>

package/src/client/createClient.ts

@@ -0,0 +1,90 @@
+import {
+  type ZeroDevWalletActions,
+  zeroDevWalletActions,
+} from './decorators/client.js'
+import type { Client, ClientConfig } from './types.js'
+
+let clientId = 0
+
+/**
+ * Creates a base ZeroDev Wallet client.
+ * This is the foundation client without any pre-loaded actions.
+ * Use createClient() for a client with ZeroDev Wallet actions pre-loaded.
+ */
+export function createBaseClient<
+  extended extends Record<string, unknown> | undefined = undefined,
+>(config: ClientConfig): Client<extended> {
+  const {
+    transport,
+    indexedDbStamper,
+    webauthnStamper,
+    organizationId,
+    key = 'zeroDevWallet',
+    name = 'ZeroDev Wallet Client',
+  } = config
+
+  // Initialize the transport with stamper
+  const {
+    config: transportConfig,
+    request,
+    value,
+  } = transport({
+    indexedDbStamper,
+    webauthnStamper,
+  })
+  const transportInstance = { ...transportConfig, ...value }
+
+  const uid = `${key}-${++clientId}`
+
+  const client = {
+    transport: transportInstance,
+    request,
+    indexedDbStamper,
+    webauthnStamper,
+    organizationId,
+    key,
+    name,
+    type: 'zeroDevWallet',
+    uid,
+  } as const
+
+  function extend(base: typeof client) {
+    type ExtendFn = (base: typeof client) => Record<string, unknown>
+    return (extendFn: ExtendFn) => {
+      const extended = extendFn(base) as Record<string, unknown>
+
+      // Remove base properties from extended to avoid conflicts
+      for (const key in client) {
+        delete extended[key]
+      }
+
+      // Combine base client with extensions
+      const combined = { ...base, ...extended }
+
+      // Return new client with updated extend function
+      return Object.assign(combined, { extend: extend(combined as any) })
+    }
+  }
+
+  return Object.assign(client, {
+    extend: extend(client) as any,
+  }) as Client<extended>
+}
+
+export type ZeroDevWalletClient = Client<ZeroDevWalletActions>
+
+/**
+ * Creates a ZeroDev Wallet client with ZeroDev Wallet actions pre-loaded.
+ * This is equivalent to calling createBaseClient(config).extend(zeroDevWalletActions).
+ *
+ * For a client without pre-loaded actions, use createBaseClient().
+ */
+export function createClient(config: ClientConfig): ZeroDevWalletClient {
+  const { key = 'zeroDevWallet', name = 'ZeroDev Wallet Client' } = config
+  const client = createBaseClient({
+    ...config,
+    key,
+    name,
+  })
+  return client.extend(zeroDevWalletActions) as ZeroDevWalletClient
+}