@zerodev/wallet-core 0.0.1-alpha.4 → 0.0.1-alpha.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerodev/wallet-core",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.6",
   "description": "ZeroDev Wallet SDK built on Turnkey",
   "main": "./dist/_cjs/index.js",
   "module": "./dist/_esm/index.js",

package/src/actions/wallet/getUserWallet.ts

@@ -6,11 +6,13 @@ export type GetUserWalletParameters = {
   organizationId: string
   /** The project ID for the request */
   projectId: string
+  /** The token for the request */
+  token: string
 }
 
 export type GetUserWalletReturnType = {
   /** The wallet address */
-  walletAddress: Hex
+  walletAddresses: Hex[]
   /** The user ID */
   userId?: string
 }
@@ -28,19 +30,24 @@ export type GetUserWalletReturnType = {
  *   organizationId: 'org_123',
  *   projectId: 'proj_456'
  * });
- * console.log(wallet.walletAddress); // '0x...'
+ * console.log(wallet.walletAddresses); // ['0x...', '0x...']
  * ```
  */
 export async function getUserWallet(
   client: Client,
   params: GetUserWalletParameters,
 ): Promise<GetUserWalletReturnType> {
-  const { organizationId, projectId } = params
+  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/adapters/viem.ts

@@ -24,12 +24,13 @@ export interface ToViemAccountParams {
   client: ZeroDevWalletClient
   organizationId: string
   projectId: string
+  token: string
 }
 
 export async function toViemAccount(
   params: ToViemAccountParams,
 ): Promise<LocalAccount> {
-  const { client, organizationId, projectId } = params
+  const { client, organizationId, projectId, token } = params
 
   let address: Hex = zeroAddress
 
@@ -37,8 +38,9 @@ export async function toViemAccount(
     const walletResponse = await client.getUserWallet({
       organizationId,
       projectId,
+      token,
     })
-    address = walletResponse.walletAddress
+    address = walletResponse.walletAddresses[0]
   } catch {
     address = zeroAddress
   }

package/src/client/transports/rest.ts

@@ -8,6 +8,7 @@ export type RestRequestArgs = {
   headers?: Record<string, string>
   stamp?: boolean
   stampWith?: 'indexedDb' | 'webAuthn'
+  stampPostion?: 'body' | 'headers'
 }
 
 export type RestRequestFn = <T = any>(args: RestRequestArgs) => Promise<T>
@@ -44,7 +45,7 @@ export function rest(url: string, cfg: RestTransportConfig): RestTransport {
 
     try {
       let requestBody = args.body
-      const requestHeaders = {
+      let requestHeaders = {
         'content-type': 'application/json',
         ...(args.headers ?? {}),
         ...(cfg.fetchOptions?.headers ?? {}),
@@ -65,7 +66,12 @@ export function rest(url: string, cfg: RestTransportConfig): RestTransport {
         const stamp = await stamper.stamp(bodyString)
 
         // Restructure request body to match backend expectation
-        if (body) {
+        if (args.stampPostion === 'headers') {
+          requestHeaders = {
+            ...requestHeaders,
+            [stamp.stampHeaderName]: stamp.stampHeaderValue,
+          }
+        } else if (body) {
           requestBody = {
             body: bodyString,
             stamp: {

package/src/core/createZeroDevWallet.ts

@@ -422,6 +422,7 @@ export async function createZeroDevWallet(
         client,
         organizationId: session.organizationId,
         projectId,
+        token: session.token ?? '',
       })
     },
   }

package/src/index.ts

@@ -70,6 +70,8 @@ export type {
 export type { StorageAdapter, StorageManager } from './storage/manager.js'
 // Session types
 export type { StamperType, ZeroDevWalletSession } from './types/session.js'
+export type { KeyFormat } from './utils/exportPrivateKey.js'
+export { exportPrivateKey } from './utils/exportPrivateKey.js'
 export { exportWallet } from './utils/exportWallet.js'
 // Utils
 export { normalizeTimestamp } from './utils/utils.js'

package/src/stampers/iframeStamper.ts

@@ -1,5 +1,8 @@
-import { IframeStamper as TurnkeyIframeStamper } from '@turnkey/iframe-stamper'
-import type { IframeStamper } from './types.js'
+import {
+  KeyFormat,
+  IframeStamper as TurnkeyIframeStamper,
+} from '@turnkey/iframe-stamper'
+import type { IframeStamper, KeyFormat as KeyFormatType } from './types.js'
 
 export async function createIframeStamper(cfg: {
   iframeUrl: string
@@ -31,5 +34,16 @@ export async function createIframeStamper(cfg: {
     async injectWalletExportBundle(bundle: string, organizationId: string) {
       return await inner.injectWalletExportBundle(bundle, organizationId)
     },
+    async injectKeyExportBundle(
+      bundle: string,
+      organizationId: string,
+      keyFormat?: KeyFormatType,
+    ) {
+      return await inner.injectKeyExportBundle(
+        bundle,
+        organizationId,
+        keyFormat ? KeyFormat[keyFormat] : KeyFormat.Hexadecimal,
+      )
+    },
   }
 }

package/src/stampers/types.ts

@@ -13,6 +13,8 @@ export type Stamper = {
   clear: () => Promise<void>
 }
 
+export type KeyFormat = 'Hexadecimal' | 'Solana'
+
 export type IframeStamper = Stamper & {
   init(): Promise<string>
   injectCredentialBundle(bundle: string): Promise<boolean>
@@ -20,6 +22,11 @@ export type IframeStamper = Stamper & {
     bundle: string,
     organizationId: string,
   ): Promise<boolean>
+  injectKeyExportBundle(
+    bundle: string,
+    organizationId: string,
+    keyFormat?: KeyFormat,
+  ): Promise<boolean>
 }
 
 export type IndexedDbStamper = Stamper & {

package/src/utils/exportPrivateKey.ts

@@ -0,0 +1,116 @@
+import type { ZeroDevWalletSDK } from '../core/createZeroDevWallet.js'
+import type { KeyFormat } from '../stampers/types.js'
+
+export type ExportPrivateKeyParameters = {
+  /** Wallet to use for the export */
+  wallet: ZeroDevWalletSDK
+  /** Target public key from export iframe for encryption */
+  targetPublicKey: string
+  /** Wallet address to export (optional, defaults to wallet's account address) */
+  address?: string
+}
+
+/**
+ * Export a wallet account's private key
+ *
+ * This calls Turnkey's export_wallet_account API to get an encrypted bundle
+ * containing the account's private key. The bundle is encrypted with the
+ * targetPublicKey (from Turnkey's export iframe).
+ *
+ * @param params - Export parameters
+ * @returns Encrypted export bundle and metadata
+ *
+ * @example
+ * ```ts
+ * // In UI: Initialize export iframe first
+ * const iframeStamper = await createIframeStamper({
+ *   iframeUrl: 'https://export.turnkey.com',
+ *   iframeContainer: document.getElementById('export-container'),
+ *   iframeElementId: 'export-iframe'
+ * });
+ * const targetPublicKey = await iframeStamper.init();
+ *
+ * // Call SDK to get encrypted bundle
+ * const { exportBundle, address, organizationId } = await exportPrivateKey({
+ *   wallet,
+ *   targetPublicKey
+ * });
+ *
+ * // Inject into iframe to display private key
+ * await iframeStamper.injectKeyExportBundle(exportBundle, organizationId, 'Hexadecimal');
+ * ```
+ */
+export async function exportPrivateKey(
+  params: ExportPrivateKeyParameters,
+): Promise<{ exportBundle: string; address: string; organizationId: string }> {
+  const { targetPublicKey, wallet, address: addressParam } = params
+
+  const session = await wallet.getSession()
+  if (!session) {
+    throw new Error('Session not found')
+  }
+  const { organizationId } = session
+
+  // If address not provided, get it from the wallet's account
+  let address = addressParam
+  if (!address) {
+    const account = await wallet.toAccount()
+    if (!account?.address) {
+      throw new Error('Could not get address from wallet account')
+    }
+    address = account.address
+  }
+
+  const exportBody = JSON.stringify({
+    type: 'ACTIVITY_TYPE_EXPORT_WALLET_ACCOUNT',
+    timestampMs: Date.now().toString(),
+    organizationId: organizationId,
+    parameters: {
+      address: address,
+      targetPublicKey,
+    },
+  })
+
+  const stamperKey =
+    session.stamperType === 'indexedDb' ? 'indexedDbStamper' : 'webauthnStamper'
+  const stamper = wallet.client[stamperKey]
+  if (!stamper) {
+    throw new Error(`Stamper '${stamperKey}' not found on wallet.client`)
+  }
+
+  const exportStamp = await stamper.stamp(exportBody)
+  if (!exportStamp) {
+    throw new Error('Failed to stamp export body')
+  }
+
+  const exportResponse = await fetch(
+    'https://api.turnkey.com/public/v1/submit/export_wallet_account',
+    {
+      method: 'POST',
+      body: exportBody,
+      headers: {
+        [exportStamp.stampHeaderName]: exportStamp.stampHeaderValue,
+      },
+    },
+  )
+  if (!exportResponse.ok) {
+    const errorText = await exportResponse.text()
+    throw new Error(
+      `Failed to export wallet account: ${exportResponse.status} ${errorText}`,
+    )
+  }
+  const exportData = await exportResponse.json()
+
+  const exportBundle =
+    exportData?.activity?.result?.exportWalletAccountResult?.exportBundle
+
+  if (!exportBundle) {
+    throw new Error(
+      `Export bundle not found in response: ${JSON.stringify(exportData)}`,
+    )
+  }
+
+  return { exportBundle, address: address!, organizationId }
+}
+
+export type { KeyFormat }