@0xsequence/wallet-wdk 3.0.4 → 3.0.5

package/src/sequence/wallets.ts

@@ -8,7 +8,7 @@ import { MnemonicHandler } from './handlers/mnemonic.js'
 import { OtpHandler } from './handlers/otp.js'
 import { Shared } from './manager.js'
 import { Device } from './types/device.js'
-import { Action, Module } from './types/index.js'
+import { Action, Actions, Module } from './types/index.js'
 import { Kinds, SignerWithKind, WitnessExtraSignerKind } from './types/signer.js'
 import { Wallet, WalletSelectionUiHandler } from './types/wallet.js'
 import { PasskeysHandler } from './handlers/passkeys.js'
@@ -57,6 +57,12 @@ export type StartSignUpWithRedirectArgs = {
   metadata: { [key: string]: string }
 }
 
+export type StartAddLoginSignerWithRedirectArgs = {
+  wallet: Address.Address
+  kind: 'google-pkce' | 'apple' | `custom-${string}`
+  target: string
+}
+
 export type SignupStatus =
   | { type: 'login-signer-created'; address: Address.Address }
   | { type: 'device-signer-created'; address: Address.Address }
@@ -112,6 +118,19 @@ export type SignupArgs =
   | IdTokenSignupArgs
   | AuthCodeSignupArgs
 
+export type AddLoginSignerArgs = {
+  wallet: Address.Address
+} & (
+  | { kind: 'mnemonic'; mnemonic: string }
+  | { kind: 'email-otp'; email: string }
+  | { kind: 'google-id-token' | 'apple-id-token' | `custom-${string}`; idToken: string }
+)
+
+export type RemoveLoginSignerArgs = {
+  wallet: Address.Address
+  signerAddress: Address.Address
+}
+
 export type LoginToWalletArgs = {
   wallet: Address.Address
 }
@@ -292,6 +311,66 @@ export interface WalletsInterface {
    */
   completeLogin(requestId: string): Promise<void>
 
+  /**
+   * Adds a new login signer to an existing wallet, enabling account federation.
+   *
+   * This allows a user to link a new login method (e.g., Google, email OTP, mnemonic) to a wallet
+   * that was originally created with a different credential. After federation, the wallet can be
+   * discovered and accessed via any of its linked login methods.
+   *
+   * @param args The arguments specifying the wallet and the new login credential to add.
+   * @returns A promise that resolves to a `requestId` for the configuration update signature request.
+   * @see {completeAddLoginSigner}
+   */
+  addLoginSigner(args: AddLoginSignerArgs): Promise<string>
+
+  /**
+   * Completes the add-login-signer process after the configuration update has been signed.
+   *
+   * @param requestId The ID of the completed signature request returned by `addLoginSigner`.
+   * @returns A promise that resolves when the configuration update has been submitted.
+   */
+  completeAddLoginSigner(requestId: string): Promise<void>
+
+  /**
+   * Initiates an add-login-signer process that involves an OAuth redirect.
+   *
+   * This is the first step for adding a social login signer (e.g., Google, Apple) to an existing wallet
+   * via a redirect-based OAuth flow. It validates the wallet, generates the necessary challenges and state,
+   * stores them locally, and returns a URL. Your application should redirect the user to this URL.
+   *
+   * After the redirect callback, call `completeRedirect` with the returned state and code. This will
+   * create a pending `AddLoginSigner` signature request internally. The caller can then discover
+   * the pending request through the signatures module and call `completeAddLoginSigner` with the requestId
+   * once it has been signed.
+   *
+   * @param args Arguments specifying the wallet, provider (`kind`), and the `target` URL for the redirect callback.
+   * @returns A promise that resolves to the full OAuth URL to which the user should be redirected.
+   * @see {completeRedirect} for the second step of this flow.
+   * @see {completeAddLoginSigner} to finalize after signing.
+   */
+  startAddLoginSignerWithRedirect(args: StartAddLoginSignerWithRedirectArgs): Promise<string>
+
+  /**
+   * Removes a login signer from an existing wallet, enabling account defederation.
+   *
+   * This allows a user to unlink a login method from a wallet. A safety guard ensures
+   * at least one login signer always remains.
+   *
+   * @param args The arguments specifying the wallet and the signer address to remove.
+   * @returns A promise that resolves to a `requestId` for the configuration update signature request.
+   * @see {completeRemoveLoginSigner}
+   */
+  removeLoginSigner(args: RemoveLoginSignerArgs): Promise<string>
+
+  /**
+   * Completes the remove-login-signer process after the configuration update has been signed.
+   *
+   * @param requestId The ID of the completed signature request returned by `removeLoginSigner`.
+   * @returns A promise that resolves when the configuration update has been submitted.
+   */
+  completeRemoveLoginSigner(requestId: string): Promise<void>
+
   /**
    * Logs out from a given wallet, ending the current session.
    *
@@ -417,6 +496,20 @@ export function isIdTokenArgs(args: SignupArgs): args is IdTokenSignupArgs {
   return 'idToken' in args
 }
 
+function addLoginSignerToSignupArgs(args: AddLoginSignerArgs): SignupArgs {
+  switch (args.kind) {
+    case 'mnemonic':
+      return { kind: 'mnemonic', mnemonic: args.mnemonic }
+    case 'email-otp':
+      return { kind: 'email-otp', email: args.email }
+    default: {
+      // google-id-token, apple-id-token, custom-*
+      const _args = args as { kind: string; idToken: string }
+      return { kind: _args.kind as IdTokenSignupArgs['kind'], idToken: _args.idToken }
+    }
+  }
+}
+
 function buildCappedTree(members: { address: Address.Address; imageHash?: Hex.Hex }[]): Config.Topology {
   const loginMemberWeight = 1n
 
@@ -807,7 +900,27 @@ export class Wallets implements WalletsInterface {
     if (!(handler instanceof AuthCodeHandler)) {
       throw new Error('handler-does-not-support-redirect')
     }
-    return handler.commitAuth(args.target, true)
+    return handler.commitAuth(args.target, { type: 'auth' })
+  }
+
+  async startAddLoginSignerWithRedirect(args: StartAddLoginSignerWithRedirectArgs) {
+    const walletEntry = await this.get(args.wallet)
+    if (!walletEntry) {
+      throw new Error('wallet-not-found')
+    }
+    if (walletEntry.status !== 'ready') {
+      throw new Error('wallet-not-ready')
+    }
+
+    const kind = getSignupHandlerKey(args.kind)
+    const handler = this.shared.handlers.get(kind)
+    if (!handler) {
+      throw new Error('handler-not-registered')
+    }
+    if (!(handler instanceof AuthCodeHandler)) {
+      throw new Error('handler-does-not-support-redirect')
+    }
+    return handler.commitAuth(args.target, { type: 'add-signer', wallet: args.wallet })
   }
 
   async completeRedirect(args: CompleteRedirectArgs): Promise<string> {
@@ -816,28 +929,62 @@ export class Wallets implements WalletsInterface {
       throw new Error('invalid-state')
     }
 
-    // commitment.isSignUp and signUp also mean 'signIn' from wallet's perspective
-    if (commitment.isSignUp) {
-      await this.signUp({
-        kind: commitment.kind,
-        commitment,
-        code: args.code,
-        noGuard: args.noGuard,
-        target: commitment.target,
-        isRedirect: true,
-        use4337: args.use4337,
-      })
-    } else {
-      const handlerKind = getSignupHandlerKey(commitment.kind)
-      const handler = this.shared.handlers.get(handlerKind)
-      if (!handler) {
-        throw new Error('handler-not-registered')
+    switch (commitment.type) {
+      case 'add-signer': {
+        const handlerKind = getSignupHandlerKey(commitment.kind)
+        const handler = this.shared.handlers.get(handlerKind)
+        if (!handler) {
+          throw new Error('handler-not-registered')
+        }
+        if (!(handler instanceof AuthCodeHandler)) {
+          throw new Error('handler-does-not-support-redirect')
+        }
+
+        const walletAddress = commitment.wallet as Address.Address
+        const walletEntry = await this.get(walletAddress)
+        if (!walletEntry) {
+          throw new Error('wallet-not-found')
+        }
+        if (walletEntry.status !== 'ready') {
+          throw new Error('wallet-not-ready')
+        }
+
+        const [signer] = await handler.completeAuth(commitment, args.code)
+        const signerKind = getSignerKindForSignup(commitment.kind)
+
+        await this.addLoginSignerFromPrepared(walletAddress, {
+          signer,
+          extra: { signerKind },
+        })
+        break
       }
-      if (!(handler instanceof AuthCodeHandler)) {
-        throw new Error('handler-does-not-support-redirect')
+
+      case 'auth': {
+        await this.signUp({
+          kind: commitment.kind,
+          commitment,
+          code: args.code,
+          noGuard: args.noGuard,
+          target: commitment.target,
+          isRedirect: true,
+          use4337: args.use4337,
+        })
+        break
       }
 
-      await handler.completeAuth(commitment, args.code)
+      case 'reauth': {
+        const handlerKind = getSignupHandlerKey(commitment.kind)
+        const handler = this.shared.handlers.get(handlerKind)
+        if (!handler) {
+          throw new Error('handler-not-registered')
+        }
+        if (!(handler instanceof AuthCodeHandler)) {
+          throw new Error('handler-does-not-support-redirect')
+        }
+
+        await handler.completeAuth(commitment, args.code)
+        break
+      }
     }
 
     if (!commitment.target) {
@@ -1273,6 +1420,87 @@ export class Wallets implements WalletsInterface {
     })
   }
 
+  async addLoginSigner(args: AddLoginSignerArgs): Promise<string> {
+    const walletEntry = await this.get(args.wallet)
+    if (!walletEntry) {
+      throw new Error('wallet-not-found')
+    }
+    if (walletEntry.status !== 'ready') {
+      throw new Error('wallet-not-ready')
+    }
+
+    const signupArgs = addLoginSignerToSignupArgs(args)
+    const loginSigner = await this.prepareSignUp(signupArgs)
+    return this.addLoginSignerFromPrepared(args.wallet, loginSigner)
+  }
+
+  async completeAddLoginSigner(requestId: string): Promise<void> {
+    const request = await this.shared.modules.signatures.get(requestId)
+    if (request.action !== Actions.AddLoginSigner) {
+      throw new Error('invalid-request-action')
+    }
+    await this.completeConfigurationUpdate(requestId)
+  }
+
+  async removeLoginSigner(args: RemoveLoginSignerArgs): Promise<string> {
+    const walletEntry = await this.get(args.wallet)
+    if (!walletEntry) {
+      throw new Error('wallet-not-found')
+    }
+    if (walletEntry.status !== 'ready') {
+      throw new Error('wallet-not-ready')
+    }
+
+    const { loginTopology, modules } = await this.getConfigurationParts(args.wallet)
+
+    const existingSigners = Config.getSigners(loginTopology)
+    const allExistingAddresses = [...existingSigners.signers, ...existingSigners.sapientSigners.map((s) => s.address)]
+
+    if (!allExistingAddresses.some((addr) => Address.isEqual(addr, args.signerAddress))) {
+      throw new Error('signer-not-found')
+    }
+
+    const remainingMembers = [
+      ...existingSigners.signers
+        .filter((x) => x !== Constants.ZeroAddress && !Address.isEqual(x, args.signerAddress))
+        .map((x) => ({ address: x })),
+      ...existingSigners.sapientSigners
+        .filter((x) => !Address.isEqual(x.address, args.signerAddress))
+        .map((x) => ({ address: x.address, imageHash: x.imageHash })),
+    ]
+
+    if (remainingMembers.length < 1) {
+      throw new Error('cannot-remove-last-login-signer')
+    }
+
+    const nextLoginTopology = buildCappedTree(remainingMembers)
+
+    if (this.shared.modules.sessions.hasSessionModule(modules)) {
+      await this.shared.modules.sessions.removeIdentitySignerFromModules(modules, args.signerAddress)
+    }
+
+    if (this.shared.modules.recovery.hasRecoveryModule(modules)) {
+      await this.shared.modules.recovery.removeRecoverySignerFromModules(modules, args.signerAddress)
+    }
+
+    const requestId = await this.requestConfigurationUpdate(
+      args.wallet,
+      { loginTopology: nextLoginTopology, modules },
+      Actions.RemoveLoginSigner,
+      'wallet-webapp',
+    )
+
+    return requestId
+  }
+
+  async completeRemoveLoginSigner(requestId: string): Promise<void> {
+    const request = await this.shared.modules.signatures.get(requestId)
+    if (request.action !== Actions.RemoveLoginSigner) {
+      throw new Error('invalid-request-action')
+    }
+    await this.completeConfigurationUpdate(requestId)
+  }
+
   async logout<T extends { skipRemoveDevice?: boolean } | undefined = undefined>(
     wallet: Address.Address,
     options?: T,
@@ -1503,4 +1731,54 @@ export class Wallets implements WalletsInterface {
 
     return requestId
   }
+
+  private async addLoginSignerFromPrepared(
+    wallet: Address.Address,
+    loginSigner: {
+      signer: (Signers.Signer | Signers.SapientSigner) & Signers.Witnessable
+      extra: WitnessExtraSignerKind
+    },
+  ): Promise<string> {
+    const newSignerAddress = await loginSigner.signer.address
+
+    const { loginTopology, modules } = await this.getConfigurationParts(wallet)
+
+    // Check for duplicate signer
+    const existingSigners = Config.getSigners(loginTopology)
+    const allExistingAddresses = [...existingSigners.signers, ...existingSigners.sapientSigners.map((s) => s.address)]
+    if (allExistingAddresses.some((addr) => Address.isEqual(addr, newSignerAddress))) {
+      throw new Error('signer-already-exists')
+    }
+
+    // Build new login topology with the additional signer
+    const existingMembers = [
+      ...existingSigners.signers.filter((x) => x !== Constants.ZeroAddress).map((x) => ({ address: x })),
+      ...existingSigners.sapientSigners.map((x) => ({ address: x.address, imageHash: x.imageHash })),
+    ]
+    const newMember = {
+      address: newSignerAddress,
+      imageHash: Signers.isSapientSigner(loginSigner.signer) ? await loginSigner.signer.imageHash : undefined,
+    }
+    const nextLoginTopology = buildCappedTree([...existingMembers, newMember])
+
+    // Add non-sapient login signer to sessions module identity signers
+    if (!Signers.isSapientSigner(loginSigner.signer) && this.shared.modules.sessions.hasSessionModule(modules)) {
+      await this.shared.modules.sessions.addIdentitySignerToModules(modules, newSignerAddress)
+    }
+
+    // Add to recovery module if present
+    if (this.shared.modules.recovery.hasRecoveryModule(modules)) {
+      await this.shared.modules.recovery.addRecoverySignerToModules(modules, newSignerAddress)
+    }
+
+    // Witness so the wallet becomes discoverable via the new credential
+    await loginSigner.signer.witness(this.shared.sequence.stateProvider, wallet, loginSigner.extra)
+
+    return this.requestConfigurationUpdate(
+      wallet,
+      { loginTopology: nextLoginTopology, modules },
+      Actions.AddLoginSigner,
+      'wallet-webapp',
+    )
+  }
 }

package/test/authcode-pkce.test.ts

@@ -90,9 +90,8 @@ describe('AuthCodePkceHandler', () => {
   describe('commitAuth', () => {
     it('Should create Google PKCE auth commitment and return OAuth URL', async () => {
       const target = 'https://example.com/success'
-      const isSignUp = true
 
-      const result = await handler.commitAuth(target, isSignUp)
+      const result = await handler.commitAuth(target, { type: 'auth' })
 
       // Verify nitroCommitVerifier was called with correct challenge
       expect(handler['nitroCommitVerifier']).toHaveBeenCalledWith(
@@ -110,7 +109,7 @@ describe('AuthCodePkceHandler', () => {
         challenge: 'mock-challenge-hash',
         target,
         metadata: {},
-        isSignUp,
+        type: 'auth',
       })
 
       // Verify OAuth URL is constructed correctly
@@ -127,10 +126,13 @@ describe('AuthCodePkceHandler', () => {
 
     it('Should use provided state instead of generating random one', async () => {
       const target = 'https://example.com/success'
-      const isSignUp = false
       const customState = 'custom-state-123'
 
-      const result = await handler.commitAuth(target, isSignUp, customState)
+      const result = await handler.commitAuth(target, {
+        type: 'reauth',
+        state: customState,
+        signer: '0x1234567890123456789012345678901234567890',
+      })
 
       // Verify commitment was saved with custom state
       expect(mockCommitments.set).toHaveBeenCalledWith({
@@ -140,7 +142,8 @@ describe('AuthCodePkceHandler', () => {
         challenge: 'mock-challenge-hash',
         target,
         metadata: {},
-        isSignUp,
+        type: 'reauth',
+        signer: '0x1234567890123456789012345678901234567890',
       })
 
       // Verify URL contains custom state
@@ -149,10 +152,9 @@ describe('AuthCodePkceHandler', () => {
 
     it('Should include signer in challenge when provided', async () => {
       const target = 'https://example.com/success'
-      const isSignUp = true
       const signer = '0x9876543210987654321098765432109876543210'
 
-      await handler.commitAuth(target, isSignUp, undefined, signer)
+      await handler.commitAuth(target, { type: 'reauth', state: 'test-state', signer })
 
       // Verify nitroCommitVerifier was called with signer in challenge
       expect(handler['nitroCommitVerifier']).toHaveBeenCalledWith(
@@ -164,9 +166,8 @@ describe('AuthCodePkceHandler', () => {
 
     it('Should generate random state when not provided', async () => {
       const target = 'https://example.com/success'
-      const isSignUp = true
 
-      const result = await handler.commitAuth(target, isSignUp)
+      const result = await handler.commitAuth(target, { type: 'auth' })
 
       // Verify that a state parameter is present and looks like a hex string
       expect(result).toMatch(/state=0x[a-f0-9]+/)
@@ -181,18 +182,22 @@ describe('AuthCodePkceHandler', () => {
       const target = 'https://example.com/success'
 
       // Test signup
-      await handler.commitAuth(target, true)
+      await handler.commitAuth(target, { type: 'auth' })
       expect(mockCommitments.set).toHaveBeenLastCalledWith(
         expect.objectContaining({
-          isSignUp: true,
+          type: 'auth',
         }),
       )
 
       // Test login
-      await handler.commitAuth(target, false)
+      await handler.commitAuth(target, {
+        type: 'reauth',
+        state: 'test-state',
+        signer: '0x1234567890123456789012345678901234567890',
+      })
       expect(mockCommitments.set).toHaveBeenLastCalledWith(
         expect.objectContaining({
-          isSignUp: false,
+          type: 'reauth',
         }),
       )
     })
@@ -200,13 +205,17 @@ describe('AuthCodePkceHandler', () => {
     it('Should handle errors from nitroCommitVerifier', async () => {
       vi.spyOn(handler as any, 'nitroCommitVerifier').mockRejectedValue(new Error('Nitro service unavailable'))
 
-      await expect(handler.commitAuth('https://example.com/success', true)).rejects.toThrow('Nitro service unavailable')
+      await expect(handler.commitAuth('https://example.com/success', { type: 'auth' })).rejects.toThrow(
+        'Nitro service unavailable',
+      )
     })
 
     it('Should handle database errors during commitment storage', async () => {
       vi.mocked(mockCommitments.set).mockRejectedValue(new Error('Database write failed'))
 
-      await expect(handler.commitAuth('https://example.com/success', true)).rejects.toThrow('Database write failed')
+      await expect(handler.commitAuth('https://example.com/success', { type: 'auth' })).rejects.toThrow(
+        'Database write failed',
+      )
     })
   })
 
@@ -221,7 +230,7 @@ describe('AuthCodePkceHandler', () => {
         challenge: 'test-challenge-hash',
         target: 'https://example.com/success',
         metadata: { scope: 'openid profile email' },
-        isSignUp: true,
+        type: 'auth',
       }
     })
 
@@ -333,7 +342,7 @@ describe('AuthCodePkceHandler', () => {
       const newRedirectUri = 'https://newdomain.com/callback'
       handler.setRedirectUri(newRedirectUri)
 
-      return handler.commitAuth('https://example.com/success', true).then((result) => {
+      return handler.commitAuth('https://example.com/success', { type: 'auth' }).then((result) => {
         expect(result).toContain(`redirect_uri=${encodeURIComponent(newRedirectUri)}`)
       })
     })

package/test/authcode.test.ts

@@ -113,7 +113,7 @@ describe('AuthCodeHandler', () => {
       kind: 'google-pkce',
       metadata: {},
       target: '/test-target',
-      isSignUp: false,
+      type: 'reauth',
       signer: testWallet,
     }
 
@@ -247,20 +247,17 @@ describe('AuthCodeHandler', () => {
 
     it('Should create auth commitment and return OAuth URL', async () => {
       const target = '/test-target'
-      const isSignUp = true
-      const signer = testWallet
 
-      const result = await authCodeHandler.commitAuth(target, isSignUp, undefined, signer)
+      const result = await authCodeHandler.commitAuth(target, { type: 'auth' })
 
       // Verify commitment was saved
       expect(mockAuthCommitmentsSet).toHaveBeenCalledOnce()
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
 
       expect(commitmentCall.kind).toBe('google-pkce')
-      expect(commitmentCall.signer).toBe(signer)
       expect(commitmentCall.target).toBe(target)
       expect(commitmentCall.metadata).toEqual({})
-      expect(commitmentCall.isSignUp).toBe(isSignUp)
+      expect(commitmentCall.type).toBe('auth')
       expect(commitmentCall.id).toBeDefined()
       expect(typeof commitmentCall.id).toBe('string')
 
@@ -276,7 +273,11 @@ describe('AuthCodeHandler', () => {
     it('Should use provided state parameter', async () => {
       const customState = 'custom-state-123'
 
-      const result = await authCodeHandler.commitAuth('/target', false, customState)
+      const result = await authCodeHandler.commitAuth('/target', {
+        type: 'reauth',
+        state: customState,
+        signer: testWallet,
+      })
 
       // Verify commitment uses custom state
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
@@ -285,7 +286,7 @@ describe('AuthCodeHandler', () => {
     })
 
     it('Should generate random state when not provided', async () => {
-      await authCodeHandler.commitAuth('/target', false)
+      await authCodeHandler.commitAuth('/target', { type: 'auth' })
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
       expect(commitmentCall.id).toBeDefined()
       expect(typeof commitmentCall.id).toBe('string')
@@ -306,7 +307,7 @@ describe('AuthCodeHandler', () => {
       )
       appleHandler.setRedirectUri('https://example.com/callback')
 
-      const result = await appleHandler.commitAuth('/target', false)
+      const result = await appleHandler.commitAuth('/target', { type: 'auth' })
 
       expect(result).toContain('https://appleid.apple.com/auth/authorize?')
       expect(result).toContain('client_id=apple-client-id')
@@ -315,10 +316,10 @@ describe('AuthCodeHandler', () => {
     })
 
     it('Should create commitment without signer', async () => {
-      await authCodeHandler.commitAuth('/target', true)
+      await authCodeHandler.commitAuth('/target', { type: 'auth' })
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
       expect(commitmentCall.signer).toBeUndefined()
-      expect(commitmentCall.isSignUp).toBe(true)
+      expect(commitmentCall.type).toBe('auth')
     })
   })
 
@@ -492,7 +493,7 @@ describe('AuthCodeHandler', () => {
 
       const commitmentCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
       expect(commitmentCall.target).toBe(window.location.pathname)
-      expect(commitmentCall.isSignUp).toBe(false)
+      expect(commitmentCall.type).toBe('reauth')
       expect(commitmentCall.signer).toBe(testWallet)
     })
   })
@@ -654,7 +655,7 @@ describe('AuthCodeHandler', () => {
     it('Should handle auth commitments database errors', async () => {
       mockAuthCommitmentsSet.mockRejectedValueOnce(new Error('Database error'))
 
-      await expect(authCodeHandler.commitAuth('/target', false)).rejects.toThrow('Database error')
+      await expect(authCodeHandler.commitAuth('/target', { type: 'auth' })).rejects.toThrow('Database error')
     })
 
     it('Should handle auth keys database errors', async () => {
@@ -671,7 +672,11 @@ describe('AuthCodeHandler', () => {
       authCodeHandler.setRedirectUri('https://example.com/callback')
 
       // Step 1: Commit auth
-      const commitUrl = await authCodeHandler.commitAuth('/test-target', false, 'test-state', testWallet)
+      const commitUrl = await authCodeHandler.commitAuth('/test-target', {
+        type: 'reauth',
+        state: 'test-state',
+        signer: testWallet,
+      })
 
       expect(commitUrl).toContain('state=test-state')
       expect(mockAuthCommitmentsSet).toHaveBeenCalledWith(
@@ -679,7 +684,7 @@ describe('AuthCodeHandler', () => {
           id: 'test-state',
           kind: 'google-pkce',
           target: '/test-target',
-          isSignUp: false,
+          type: 'reauth',
           signer: testWallet,
         }),
       )
@@ -709,17 +714,17 @@ describe('AuthCodeHandler', () => {
       authCodeHandler.setRedirectUri('https://example.com/callback')
 
       // Test signup flow
-      await authCodeHandler.commitAuth('/signup-target', true, 'signup-state')
+      await authCodeHandler.commitAuth('/signup-target', { type: 'auth', state: 'signup-state' })
 
       const signupCall = mockAuthCommitmentsSet.mock.calls[0]![0]!
-      expect(signupCall.isSignUp).toBe(true)
+      expect(signupCall.type).toBe('auth')
       expect(signupCall.target).toBe('/signup-target')
 
       // Test login flow
-      await authCodeHandler.commitAuth('/login-target', false, 'login-state')
+      await authCodeHandler.commitAuth('/login-target', { type: 'reauth', state: 'login-state', signer: testWallet })
 
       const loginCall = mockAuthCommitmentsSet.mock.calls[1]![0]!
-      expect(loginCall.isSignUp).toBe(false)
+      expect(loginCall.type).toBe('reauth')
       expect(loginCall.target).toBe('/login-target')
     })
   })