@0xsequence/dapp-client 3.0.0-beta.9 → 3.0.1

package/src/utils/storage.ts

@@ -5,6 +5,7 @@ import {
   SignMessagePayload,
   SignTypedDataPayload,
   GuardConfig,
+  ETHAuthProof,
   SendWalletTransactionPayload,
   ModifyExplicitSessionPayload,
   CreateNewSessionPayload,
@@ -81,6 +82,10 @@ export interface SequenceStorage {
   getSessionlessConnection(): Promise<SessionlessConnectionData | null>
   clearSessionlessConnection(): Promise<void>
 
+  saveEthAuthProof(proof: ETHAuthProof): Promise<void>
+  getEthAuthProof(): Promise<ETHAuthProof | null>
+  clearEthAuthProof(): Promise<void>
+
   saveSessionlessConnectionSnapshot?(sessionData: SessionlessConnectionData): Promise<void>
   getSessionlessConnectionSnapshot?(): Promise<SessionlessConnectionData | null>
   clearSessionlessConnectionSnapshot?(): Promise<void>
@@ -94,6 +99,7 @@ const STORE_NAME = 'userKeys'
 const IMPLICIT_SESSIONS_IDB_KEY = 'SequenceImplicitSession'
 const EXPLICIT_SESSIONS_IDB_KEY = 'SequenceExplicitSession'
 const SESSIONLESS_CONNECTION_IDB_KEY = 'SequenceSessionlessConnection'
+const ETH_AUTH_PROOF_IDB_KEY = 'SequenceEthAuthProof'
 const SESSIONLESS_CONNECTION_SNAPSHOT_IDB_KEY = 'SequenceSessionlessConnectionSnapshot'
 
 const PENDING_REDIRECT_REQUEST_KEY = 'SequencePendingRedirect'
@@ -305,6 +311,15 @@ export class WebStorage implements SequenceStorage {
     }
   }
 
+  async saveEthAuthProof(proof: ETHAuthProof): Promise<void> {
+    try {
+      await this.setIDBItem(ETH_AUTH_PROOF_IDB_KEY, proof)
+    } catch (error) {
+      console.error('Failed to save ETHAuth proof:', error)
+      throw error
+    }
+  }
+
   async getSessionlessConnection(): Promise<SessionlessConnectionData | null> {
     try {
       return (await this.getIDBItem<SessionlessConnectionData>(SESSIONLESS_CONNECTION_IDB_KEY)) ?? null
@@ -314,6 +329,15 @@ export class WebStorage implements SequenceStorage {
     }
   }
 
+  async getEthAuthProof(): Promise<ETHAuthProof | null> {
+    try {
+      return (await this.getIDBItem<ETHAuthProof>(ETH_AUTH_PROOF_IDB_KEY)) ?? null
+    } catch (error) {
+      console.error('Failed to retrieve ETHAuth proof:', error)
+      return null
+    }
+  }
+
   async clearSessionlessConnection(): Promise<void> {
     try {
       await this.deleteIDBItem(SESSIONLESS_CONNECTION_IDB_KEY)
@@ -323,6 +347,15 @@ export class WebStorage implements SequenceStorage {
     }
   }
 
+  async clearEthAuthProof(): Promise<void> {
+    try {
+      await this.deleteIDBItem(ETH_AUTH_PROOF_IDB_KEY)
+    } catch (error) {
+      console.error('Failed to clear ETHAuth proof:', error)
+      throw error
+    }
+  }
+
   async saveSessionlessConnectionSnapshot(sessionData: SessionlessConnectionData): Promise<void> {
     try {
       await this.setIDBItem(SESSIONLESS_CONNECTION_SNAPSHOT_IDB_KEY, sessionData)
@@ -363,6 +396,7 @@ export class WebStorage implements SequenceStorage {
       await this.clearExplicitSessions()
       await this.clearImplicitSession()
       await this.clearSessionlessConnection()
+      await this.clearEthAuthProof()
       await this.clearSessionlessConnectionSnapshot()
     } catch (error) {
       console.error('Failed to clear all data:', error)

package/test/ethauth-proof.test.ts

@@ -0,0 +1,207 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import { DappClient } from '../src/DappClient.js'
+import { DappTransport } from '../src/DappTransport.js'
+import { RequestActionType, TransportMode } from '../src/types/index.js'
+import { WebStorage } from '../src/utils/storage.js'
+
+describe('ETHAuth proof persistence', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.unstubAllGlobals()
+  })
+
+  const createSequenceStorageMock = () => ({
+    setPendingRedirectRequest: vi.fn().mockResolvedValue(undefined),
+    isRedirectRequestPending: vi.fn().mockResolvedValue(false),
+    saveTempSessionPk: vi.fn().mockResolvedValue(undefined),
+    getAndClearTempSessionPk: vi.fn().mockResolvedValue(null),
+    savePendingRequest: vi.fn().mockResolvedValue(undefined),
+    getAndClearPendingRequest: vi.fn().mockResolvedValue(null),
+    peekPendingRequest: vi.fn().mockResolvedValue(null),
+    saveExplicitSession: vi.fn().mockResolvedValue(undefined),
+    getExplicitSessions: vi.fn().mockResolvedValue([]),
+    clearExplicitSessions: vi.fn().mockResolvedValue(undefined),
+    saveImplicitSession: vi.fn().mockResolvedValue(undefined),
+    getImplicitSession: vi.fn().mockResolvedValue(null),
+    clearImplicitSession: vi.fn().mockResolvedValue(undefined),
+    saveSessionlessConnection: vi.fn().mockResolvedValue(undefined),
+    getSessionlessConnection: vi.fn().mockResolvedValue(null),
+    clearSessionlessConnection: vi.fn().mockResolvedValue(undefined),
+    saveEthAuthProof: vi.fn().mockResolvedValue(undefined),
+    getEthAuthProof: vi.fn().mockResolvedValue(null),
+    clearEthAuthProof: vi.fn().mockResolvedValue(undefined),
+    clearAllData: vi.fn().mockResolvedValue(undefined),
+  })
+
+  it('persists ETHAuth proof when connect requests ethAuth in redirect mode', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+    vi.stubGlobal('window', { fetch: fetchMock })
+
+    const ethAuthProof = {
+      typedData: {
+        domain: {},
+        types: {},
+        message: {},
+      },
+      ewtString: 'proof-string',
+    }
+
+    const sequenceStorage = createSequenceStorageMock()
+    const sendRequestMock = vi.spyOn(DappTransport.prototype, 'sendRequest').mockResolvedValue({
+      walletAddress: '0x1111111111111111111111111111111111111111',
+      ethAuthProof,
+    })
+
+    const client = new DappClient('https://wallet.example', 'https://dapp.example', 'test-project-access-key', {
+      sequenceStorage,
+      transportMode: TransportMode.REDIRECT,
+      canUseIndexedDb: false,
+      redirectActionHandler: vi.fn(),
+    })
+
+    await client.connect(1, undefined, {
+      ethAuth: {
+        app: 'app-name',
+      },
+    })
+
+    expect(sendRequestMock).toHaveBeenCalledWith(
+      RequestActionType.CREATE_NEW_SESSION,
+      'https://dapp.example',
+      expect.objectContaining({
+        ethAuth: {
+          app: 'app-name',
+        },
+      }),
+      expect.any(Object),
+    )
+    expect(sequenceStorage.saveEthAuthProof).toHaveBeenCalledWith(ethAuthProof)
+  })
+
+  it('persists ETHAuth proof when connect requests ethAuth in popup mode', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+    vi.stubGlobal('window', { fetch: fetchMock })
+    vi.stubGlobal('document', {})
+
+    const ethAuthProof = {
+      typedData: {
+        domain: {},
+        types: {},
+        message: {},
+      },
+      ewtString: 'proof-string',
+    }
+
+    const sequenceStorage = createSequenceStorageMock()
+    const sendRequestMock = vi.spyOn(DappTransport.prototype, 'sendRequest').mockResolvedValue({
+      walletAddress: '0x1111111111111111111111111111111111111111',
+      ethAuthProof,
+    })
+
+    const client = new DappClient('https://wallet.example', 'https://dapp.example', 'test-project-access-key', {
+      sequenceStorage,
+      transportMode: TransportMode.POPUP,
+      canUseIndexedDb: false,
+    })
+
+    await client.connect(1, undefined, {
+      ethAuth: {
+        app: 'app-name',
+      },
+    })
+
+    expect(sendRequestMock).toHaveBeenCalledWith(
+      RequestActionType.CREATE_NEW_SESSION,
+      'https://dapp.example',
+      expect.objectContaining({
+        ethAuth: {
+          app: 'app-name',
+        },
+      }),
+      expect.any(Object),
+    )
+    expect(sequenceStorage.saveEthAuthProof).toHaveBeenCalledWith(ethAuthProof)
+  })
+
+  it('does not persist ETHAuth proof when connect does not request ethAuth', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+    vi.stubGlobal('window', { fetch: fetchMock })
+
+    const ethAuthProof = {
+      typedData: {
+        domain: {},
+        types: {},
+        message: {},
+      },
+      ewtString: 'proof-string',
+    }
+
+    const sequenceStorage = createSequenceStorageMock()
+    const sendRequestMock = vi.spyOn(DappTransport.prototype, 'sendRequest').mockResolvedValue({
+      walletAddress: '0x1111111111111111111111111111111111111111',
+      ethAuthProof,
+    })
+
+    const client = new DappClient('https://wallet.example', 'https://dapp.example', 'test-project-access-key', {
+      sequenceStorage,
+      transportMode: TransportMode.REDIRECT,
+      canUseIndexedDb: false,
+      redirectActionHandler: vi.fn(),
+    })
+
+    await client.connect(1)
+
+    expect(sendRequestMock).toHaveBeenCalledWith(
+      RequestActionType.CREATE_NEW_SESSION,
+      'https://dapp.example',
+      expect.not.objectContaining({
+        ethAuth: expect.anything(),
+      }),
+      expect.any(Object),
+    )
+    expect(sequenceStorage.saveEthAuthProof).not.toHaveBeenCalled()
+  })
+
+  it('clears ETHAuth proof on disconnect', async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal('fetch', fetchMock)
+    vi.stubGlobal('window', { fetch: fetchMock })
+
+    const ethAuthProof = {
+      typedData: {
+        domain: {},
+        types: {},
+        message: {},
+      },
+      ewtString: 'proof-string',
+    }
+
+    vi.spyOn(DappTransport.prototype, 'sendRequest').mockResolvedValue({
+      walletAddress: '0x1111111111111111111111111111111111111111',
+      ethAuthProof,
+    })
+
+    const client = new DappClient('https://wallet.example', 'https://dapp.example', 'test-project-access-key', {
+      sequenceStorage: new WebStorage(),
+      transportMode: TransportMode.REDIRECT,
+      canUseIndexedDb: false,
+      redirectActionHandler: vi.fn(),
+    })
+
+    await client.connect(1, undefined, {
+      ethAuth: {
+        app: 'app-name',
+      },
+    })
+
+    expect(await client.getEthAuthProof()).toEqual(ethAuthProof)
+
+    await client.disconnect()
+
+    expect(await client.getEthAuthProof()).toBeNull()
+  })
+})