fix(payments): use Coinflow session keys on web and mobile

packages/common/src/hooks/index.ts

@@ -31,6 +31,7 @@ export * from './useCollectionMetadata'
 export * from './useCollectionDogEar'
 export * from './useCollectionAccessTypeLabel'
 export * from './useCoinflowAdapter'
+export * from './useCoinflowSessionKey'
 export * from './useChangePasswordFormConfiguration'
 export * from './useChangeEmailFormConfiguration'
 export * from './useCanSendChatBlast'

packages/common/src/hooks/useCoinflowAdapter.ts

@@ -21,6 +21,8 @@ import {
 } from '~/store'
 
 type CoinflowAdapter = {
+  accountWallet: string | null | undefined
+  signerWallet: string | null | undefined
   wallet: {
     publicKey: PublicKey
     sendTransaction: (
@@ -41,10 +43,11 @@ export const useCoinflowWithdrawalAdapter = () => {
   } = useAppContext()
   const [adapter, setAdapter] = useState<CoinflowAdapter | null>(null)
   const { data: walletAddresses } = useWalletAddresses()
-  const { currentUser } = walletAddresses ?? {}
+  const { currentUser, web3User } = walletAddresses ?? {}
   const { audiusSdk, solanaWalletService } = useQueryContext()
 
   useEffect(() => {
+    let canceled = false
     const initWallet = async () => {
       const wallet = await solanaWalletService.getKeypair()
       const sdk = await audiusSdk()
@@ -57,7 +60,10 @@ export const useCoinflowWithdrawalAdapter = () => {
         return
       }
 
+      if (canceled) return
       setAdapter({
+        accountWallet: currentUser,
+        signerWallet: web3User,
         connection,
         wallet: {
           publicKey: wallet.publicKey,
@@ -111,9 +117,23 @@ export const useCoinflowWithdrawalAdapter = () => {
       })
     }
     initWallet()
-  }, [audiusBackend, currentUser, solanaWalletService, make, track, audiusSdk])
+    return () => {
+      canceled = true
+    }
+  }, [
+    audiusBackend,
+    currentUser,
+    web3User,
+    solanaWalletService,
+    make,
+    track,
+    audiusSdk
+  ])
 
-  return adapter
+  return adapter?.accountWallet === currentUser &&
+    adapter?.signerWallet === web3User
+    ? adapter
+    : null
 }
 
 /** An adapter for signing and sending unmodified Coinflow transactions. Will partialSign with the
@@ -128,11 +148,14 @@ export const useCoinflowAdapter = ({
   onFailure: () => void
 }) => {
   const { audiusBackend } = useAppContext()
+  const { data: walletAddresses } = useWalletAddresses()
+  const { currentUser, web3User } = walletAddresses ?? {}
   const [adapter, setAdapter] = useState<CoinflowAdapter | null>(null)
   const { audiusSdk, solanaWalletService } = useQueryContext()
   const dispatch = useDispatch()
 
   useEffect(() => {
+    let canceled = false
     const initWallet = async () => {
       const wallet = await solanaWalletService.getKeypair()
       const sdk = await audiusSdk()
@@ -144,7 +167,10 @@ export const useCoinflowAdapter = ({
         return
       }
 
+      if (canceled) return
       setAdapter({
+        accountWallet: currentUser,
+        signerWallet: web3User,
         connection,
         wallet: {
           publicKey: wallet.publicKey,
@@ -192,7 +218,12 @@ export const useCoinflowAdapter = ({
       })
     }
     initWallet()
+    return () => {
+      canceled = true
+    }
   }, [
+    currentUser,
+    web3User,
     audiusBackend,
     solanaWalletService,
     audiusSdk,
@@ -201,5 +232,8 @@ export const useCoinflowAdapter = ({
     onFailure
   ])
 
-  return adapter
+  return adapter?.accountWallet === currentUser &&
+    adapter?.signerWallet === web3User
+    ? adapter
+    : null
 }

packages/common/src/hooks/useCoinflowSessionKey.test.tsx

@@ -0,0 +1,186 @@
+// @vitest-environment jsdom
+import { PropsWithChildren } from 'react'
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { act, cleanup, renderHook } from '@testing-library/react'
+import nacl from 'tweetnacl'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useCoinflowSessionKey } from './useCoinflowSessionKey'
+
+const mocks = vi.hoisted(() => ({
+  addresses: { currentUser: '0xabc', web3User: '0xabc' } as {
+    currentUser: string | null
+    web3User: string | null
+  },
+  getKeypair: vi.fn(),
+  createSession: vi.fn()
+}))
+
+vi.mock('~/api', () => ({
+  useWalletAddresses: () => ({ data: mocks.addresses })
+}))
+vi.mock('~/api/tan-query/utils', () => ({
+  useQueryContext: () => ({
+    identityService: {
+      identityServiceEndpoint: 'https://identity.example',
+      createCoinflowSessionKey: mocks.createSession
+    },
+    solanaWalletService: { getKeypair: mocks.getKeypair }
+  })
+}))
+
+const keys = nacl.sign.keyPair.fromSeed(new Uint8Array(32).fill(1))
+const minutes = (value: number) => value * 60 * 1000
+const session = (key: string) => ({ key, expiresAt: Date.now() + minutes(30) })
+let client: QueryClient
+
+function Wrapper({ children }: PropsWithChildren) {
+  return <QueryClientProvider client={client}>{children}</QueryClientProvider>
+}
+
+const flush = async (ms = 10) => {
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(ms)
+  })
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+  vi.setSystemTime(new Date('2026-09-28T12:00:00Z'))
+  vi.clearAllMocks()
+  mocks.addresses = { currentUser: '0xabc', web3User: '0xabc' }
+  mocks.getKeypair.mockResolvedValue({
+    publicKey: { toBase58: () => 'wallet-a' },
+    secretKey: keys.secretKey
+  })
+  mocks.createSession.mockImplementation(async () => session('key-a'))
+  client = new QueryClient()
+})
+
+afterEach(() => {
+  cleanup()
+  client.clear()
+  vi.useRealTimers()
+})
+
+describe('useCoinflowSessionKey', () => {
+  const props = {
+    wallet: 'wallet-a',
+    environment: 'sandbox' as const,
+    enabled: true
+  }
+
+  it('waits until opened, then signs proof for the active identity and wallet', async () => {
+    const { result, rerender } = renderHook(useCoinflowSessionKey, {
+      wrapper: Wrapper,
+      initialProps: { ...props, enabled: false }
+    })
+    await flush()
+    expect(mocks.createSession).not.toHaveBeenCalled()
+    expect(result.current.sessionKey).toBeUndefined()
+    rerender(props)
+    await flush()
+    expect(result.current.sessionKey).toBe('key-a')
+    const proof = mocks.createSession.mock.calls[0][0]
+    const message = `Audius Coinflow session:0xabc:wallet-a:sandbox:${proof.timestamp}`
+    expect(
+      nacl.sign.detached.verify(
+        new Uint8Array(Buffer.from(message)),
+        new Uint8Array(Buffer.from(proof.signature, 'base64')),
+        keys.publicKey
+      )
+    ).toBe(true)
+  })
+
+  it('refreshes before expiry and stops using the old key if refresh fails', async () => {
+    const { result } = renderHook(useCoinflowSessionKey, {
+      wrapper: Wrapper,
+      initialProps: props
+    })
+    await flush()
+    expect(result.current.sessionKey).toBe('key-a')
+    mocks.createSession.mockRejectedValue(new Error('Network error'))
+    await flush(minutes(25) + 2000)
+    expect(mocks.createSession.mock.calls.length).toBeGreaterThanOrEqual(3)
+    expect(result.current.sessionKey).toBe('key-a')
+    await flush(minutes(4))
+    expect(result.current.sessionKey).toBeUndefined()
+    expect(result.current.isError).toBe(true)
+    mocks.createSession.mockResolvedValue(session('key-refreshed'))
+    await act(async () => {
+      await result.current.retry()
+    })
+    await flush()
+    expect(result.current.sessionKey).toBe('key-refreshed')
+  })
+
+  it('does not reuse a key across account changes or logout', async () => {
+    const { result, rerender } = renderHook(useCoinflowSessionKey, {
+      wrapper: Wrapper,
+      initialProps: props
+    })
+    await flush()
+    expect(result.current.sessionKey).toBe('key-a')
+    mocks.addresses = { currentUser: '0xdef', web3User: '0xdef' }
+    mocks.createSession.mockImplementation(async () => session('key-b'))
+    rerender(props)
+    expect(result.current.sessionKey).toBeUndefined()
+    await flush()
+    expect(result.current.sessionKey).toBe('key-b')
+    mocks.addresses = { currentUser: null, web3User: null }
+    rerender(props)
+    expect(result.current.sessionKey).toBeUndefined()
+  })
+
+  it('ignores late session responses after a wallet switch', async () => {
+    let resolveOld!: (value: { key: string; expiresAt: number }) => void
+    mocks.createSession.mockImplementationOnce(
+      () =>
+        new Promise((resolve) => {
+          resolveOld = resolve
+        })
+    )
+    const { result, rerender } = renderHook(useCoinflowSessionKey, {
+      wrapper: Wrapper,
+      initialProps: props
+    })
+    await flush()
+    mocks.getKeypair.mockResolvedValue({
+      publicKey: { toBase58: () => 'wallet-b' },
+      secretKey: keys.secretKey
+    })
+    mocks.createSession.mockResolvedValue(session('key-b'))
+    rerender({ ...props, wallet: 'wallet-b' })
+    await flush()
+    expect(result.current.sessionKey).toBe('key-b')
+    resolveOld(session('key-a'))
+    await flush()
+    expect(result.current.sessionKey).toBe('key-b')
+  })
+
+  it('rejects an adapter whose wallet no longer matches the signing wallet', async () => {
+    const { result } = renderHook(useCoinflowSessionKey, {
+      wrapper: Wrapper,
+      initialProps: { ...props, wallet: 'stale-wallet' }
+    })
+    await flush(2000)
+    expect(mocks.createSession).not.toHaveBeenCalled()
+    expect(result.current.sessionKey).toBeUndefined()
+    expect(result.current.isError).toBe(true)
+  })
+
+  it('discards invalid or already expired credentials', async () => {
+    mocks.createSession.mockResolvedValue({
+      key: 'expired',
+      expiresAt: Date.now()
+    })
+    const { result } = renderHook(useCoinflowSessionKey, {
+      wrapper: Wrapper,
+      initialProps: props
+    })
+    await flush(2000)
+    expect(result.current.sessionKey).toBeUndefined()
+    expect(result.current.isError).toBe(true)
+  })
+})