Introduce Unified Wallet Interface and Providers

packages/demo/backend/package.json

@@ -39,6 +39,7 @@
     "@eth-optimism/verbs-sdk": "workspace:*",
     "@eth-optimism/viem": "^0.4.13",
     "@hono/node-server": "^1.14.0",
+    "@privy-io/server-auth": "^1.31.1",
     "commander": "^13.1.0",
     "dotenv": "^16.4.5",
     "envalid": "^8.1.0",

packages/demo/backend/src/app.integration.spec.ts

@@ -12,54 +12,93 @@ import { router } from './router.js'
 vi.mock('./config/verbs.js', () => ({
   initializeVerbs: vi.fn(),
   getVerbs: vi.fn(() => ({
-    createWallet: vi.fn((userId: string) =>
-      Promise.resolve({
-        id: `wallet-${userId}`,
-        address: `0x${userId.padEnd(40, '0')}`,
-        getBalance: () =>
-          Promise.resolve([
-            { symbol: 'USDC', balance: 1000000n },
-            { symbol: 'MORPHO', balance: 500000n },
-          ]),
-      }),
-    ),
-    getWallet: vi.fn((userId: string) => {
-      // Simulate some users existing and others not
-      if (userId.includes('non-existent')) {
-        return Promise.resolve(null)
-      }
-      return Promise.resolve({
-        id: `wallet-${userId}`,
-        address: `0x${userId.padEnd(40, '0')}`,
-        getBalance: () =>
-          Promise.resolve([
-            { symbol: 'USDC', balance: 1000000n },
-            { symbol: 'MORPHO', balance: 500000n },
-          ]),
-      })
-    }),
-    getAllWallets: vi.fn(() =>
-      Promise.resolve([
-        {
-          id: 'wallet-1',
-          address: '0x1111111111111111111111111111111111111111',
+    wallet: {
+      createWalletWithEmbeddedSigner: vi.fn(() =>
+        Promise.resolve({
+          id: `wallet-1`,
+          signer: {
+            address: `0x1111111111111111111111111111111111111111`,
+          },
+          getAddress: () =>
+            Promise.resolve(`0x1111111111111111111111111111111111111111`),
           getBalance: () =>
             Promise.resolve([
               { symbol: 'USDC', balance: 1000000n },
               { symbol: 'MORPHO', balance: 500000n },
             ]),
+        }),
+      ),
+      getSmartWalletWithEmbeddedSigner: vi.fn(
+        ({ walletId: userId }: { walletId: string }) => {
+          // Simulate some users existing and others not
+          if (userId.includes('non-existent')) {
+            return Promise.resolve(null)
+          }
+          return Promise.resolve({
+            id: `wallet-${userId}`,
+            getAddress: () => Promise.resolve(`0x${userId.padEnd(40, '0')}`),
+            getBalance: () =>
+              Promise.resolve([
+                { symbol: 'USDC', balance: 1000000n },
+                { symbol: 'MORPHO', balance: 500000n },
+              ]),
+          })
         },
-        {
-          id: 'wallet-2',
-          address: '0x2222222222222222222222222222222222222222',
-          getBalance: () =>
-            Promise.resolve([
-              { symbol: 'USDC', balance: 2000000n },
-              { symbol: 'MORPHO', balance: 750000n },
-            ]),
-        },
-      ]),
-    ),
+      ),
+      smartWalletProvider: {
+        getWalletAddress: vi.fn(({ owners }: { owners: string[] }) => {
+          return Promise.resolve(owners[0])
+        }),
+        getWallet: vi.fn(
+          ({
+            walletAddress,
+            signer,
+            ownerIndex,
+          }: {
+            walletAddress: string
+            signer: string
+            ownerIndex: number
+          }) => {
+            return {
+              address: walletAddress,
+              getAddress: () => Promise.resolve(walletAddress),
+              signer,
+              ownerIndex,
+            }
+          },
+        ),
+      },
+      embeddedWalletProvider: {
+        getAllWallets: vi.fn(() =>
+          Promise.resolve([
+            {
+              id: 'wallet-1',
+              address: '0x1111111111111111111111111111111111111111',
+              getBalance: () =>
+                Promise.resolve([
+                  { symbol: 'USDC', balance: 1000000n },
+                  { symbol: 'MORPHO', balance: 500000n },
+                ]),
+              signer: vi.fn().mockResolvedValue({
+                address: '0x1111111111111111111111111111111111111111',
+              }),
+            },
+            {
+              id: 'wallet-2',
+              address: '0x2222222222222222222222222222222222222222',
+              getBalance: () =>
+                Promise.resolve([
+                  { symbol: 'USDC', balance: 2000000n },
+                  { symbol: 'MORPHO', balance: 750000n },
+                ]),
+              signer: vi.fn().mockResolvedValue({
+                address: '0x2222222222222222222222222222222222222222',
+              }),
+            },
+          ]),
+        ),
+      },
+    },
     lend: {
       getVaults: vi.fn(() =>
         Promise.resolve([
@@ -186,11 +225,12 @@ describe('HTTP API Integration', () => {
 
       expect(response.statusCode).toBe(200)
       const data = (await response.body.json()) as any
-
-      expect(data).toHaveProperty('address')
+      expect(data).toHaveProperty('privyAddress')
+      expect(data).toHaveProperty('smartWalletAddress')
       expect(data).toHaveProperty('userId')
       expect(data.userId).toBe(testUserId)
-      expect(data.address).toMatch(/^0x[a-zA-Z0-9\-]{1,}$/) // Basic address format validation
+      expect(data.smartWalletAddress).toMatch(/^0x[a-zA-Z0-9\-]{1,}$/)
+      expect(data.privyAddress).toMatch(/^0x[a-zA-Z0-9\-]{1,}$/)
     })
 
     it('should get an existing wallet', async () => {

packages/demo/backend/src/app.ts

@@ -84,4 +84,5 @@ class VerbsApp extends App {
   }
 }
 
+export * from '@/types/index.js'
 export { VerbsApp }

packages/demo/backend/src/config/env.ts

@@ -45,12 +45,14 @@ export const env = cleanEnv(process.env, {
   PRIVY_APP_ID: str({ devDefault: 'dummy' }),
   PRIVY_APP_SECRET: str({ devDefault: 'dummy' }),
   LOCAL_DEV: bool({ default: false }),
-  RPC_URL: str({ default: 'http://127.0.0.1:9545' }),
+  BASE_SEPOLIA_RPC_URL: str({ default: undefined }),
+  UNICHAIN_RPC_URL: str({ default: undefined }),
   FAUCET_ADMIN_PRIVATE_KEY: str({
     default:
       '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
   }),
   FAUCET_ADDRESS: str({
     default: getFaucetAddressDefault(),
   }),
+  BASE_SEPOLIA_BUNDER_URL: str({ default: undefined }),
 })

packages/demo/backend/src/config/verbs.ts

@@ -1,39 +1,49 @@
-import {
-  initVerbs,
-  type VerbsConfig,
-  type VerbsInterface,
-} from '@eth-optimism/verbs-sdk'
-import { unichain } from 'viem/chains'
+import { Verbs, type VerbsConfig } from '@eth-optimism/verbs-sdk'
+import { PrivyClient } from '@privy-io/server-auth'
+import { baseSepolia, unichain } from 'viem/chains'
 
 import { env } from './env.js'
 
-let verbsInstance: VerbsInterface
+let verbsInstance: Verbs
 
 export function createVerbsConfig(): VerbsConfig {
   return {
     wallet: {
-      type: 'privy',
-      appId: env.PRIVY_APP_ID,
-      appSecret: env.PRIVY_APP_SECRET,
+      embeddedWalletConfig: {
+        provider: {
+          type: 'privy',
+          privyClient: new PrivyClient(env.PRIVY_APP_ID, env.PRIVY_APP_SECRET),
+        },
+      },
+      smartWalletConfig: {
+        provider: {
+          type: 'default',
+        },
+      },
     },
     lend: {
       type: 'morpho',
     },
     chains: [
       {
         chainId: unichain.id,
-        rpcUrl: env.RPC_URL,
+        rpcUrl: env.UNICHAIN_RPC_URL || unichain.rpcUrls.default.http[0],
+      },
+      {
+        chainId: baseSepolia.id,
+        rpcUrl: env.BASE_SEPOLIA_RPC_URL || baseSepolia.rpcUrls.default.http[0],
+        bundlerUrl: env.BASE_SEPOLIA_BUNDER_URL,
       },
     ],
   }
 }
 
 export function initializeVerbs(config?: VerbsConfig): void {
   const verbsConfig = config || createVerbsConfig()
-  verbsInstance = initVerbs(verbsConfig)
+  verbsInstance = new Verbs(verbsConfig)
 }
 
-export function getVerbs(): VerbsInterface {
+export function getVerbs() {
   if (!verbsInstance) {
     throw new Error('Verbs SDK not initialized. Call initializeVerbs() first.')
   }

packages/demo/backend/src/controllers/lend.ts

@@ -1,9 +1,11 @@
 import type { Context } from 'hono'
 import type { Address } from 'viem'
+import { baseSepolia } from 'viem/chains'
 import { z } from 'zod'
 
 import { validateRequest } from '../helpers/validation.js'
 import * as lendService from '../services/lend.js'
+import { serializeBigInt } from '../utils/serializers.js'
 
 const DepositRequestSchema = z.object({
   body: z.object({
@@ -117,10 +119,16 @@ export class LendController {
       const {
         body: { walletId, amount, token },
       } = validation.data
-      const lendTransaction = await lendService.deposit(walletId, amount, token)
+      const lendTransaction = await lendService.deposit(
+        walletId,
+        amount,
+        token,
+        baseSepolia.id,
+      )
       const result = await lendService.executeLendTransaction(
         walletId,
         lendTransaction,
+        baseSepolia.id,
       )
 
       return c.json({
@@ -132,10 +140,11 @@ export class LendController {
           apy: result.apy,
           timestamp: result.timestamp,
           slippage: result.slippage,
-          transactionData: result.transactionData,
+          transactionData: serializeBigInt(result.transactionData),
         },
       })
     } catch (error) {
+      console.error('Failed to deposit', error)
       return c.json(
         {
           error: 'Failed to deposit',

packages/demo/backend/src/controllers/wallet.ts

@@ -1,11 +1,12 @@
+import type { Context } from 'hono'
+import type { Address } from 'viem'
+import { z } from 'zod'
+
 import type {
   CreateWalletResponse,
   GetAllWalletsResponse,
   GetWalletResponse,
-} from '@eth-optimism/verbs-sdk'
-import type { Context } from 'hono'
-import type { Address } from 'viem'
-import { z } from 'zod'
+} from '@/types/service.js'
 
 import { validateRequest } from '../helpers/validation.js'
 import * as walletService from '../services/wallet.js'
@@ -58,13 +59,16 @@ export class WalletController {
       const {
         params: { userId },
       } = validation.data
-      const wallet = await walletService.createWallet(userId)
+      const { privyAddress, smartWalletAddress } =
+        await walletService.createWallet()
 
       return c.json({
-        address: wallet.address,
+        privyAddress,
+        smartWalletAddress,
         userId,
       } satisfies CreateWalletResponse)
     } catch (error) {
+      console.error(error)
       return c.json(
         {
           error: 'Failed to create wallet',
@@ -86,7 +90,7 @@ export class WalletController {
       const {
         params: { userId },
       } = validation.data
-      const wallet = await walletService.getWallet(userId)
+      const { wallet } = await walletService.getWallet(userId)
 
       if (!wallet) {
         return c.json(
@@ -97,12 +101,14 @@ export class WalletController {
           404,
         )
       }
+      const walletAddress = await wallet.getAddress()
 
       return c.json({
-        address: wallet.address,
+        address: walletAddress,
         userId,
       } satisfies GetWalletResponse)
     } catch (error) {
+      console.error(error)
       return c.json(
         {
           error: 'Failed to get wallet',
@@ -125,15 +131,19 @@ export class WalletController {
         query: { limit, cursor },
       } = validation.data
       const wallets = await walletService.getAllWallets({ limit, cursor })
+      const walletsData = await Promise.all(
+        wallets.map(async ({ wallet, id }) => ({
+          address: await wallet.getAddress(),
+          id,
+        })),
+      )
 
       return c.json({
-        wallets: wallets.map((wallet) => ({
-          address: wallet.address,
-          id: wallet.id,
-        })),
+        wallets: walletsData,
         count: wallets.length,
       } satisfies GetAllWalletsResponse)
     } catch (error) {
+      console.error(error)
       return c.json(
         {
           error: 'Failed to get wallets',