fix(react-components): gate CSP votes on real bundle membership (#243)

Author: elboletaire

packages/react-components/src/components/Election/VoteWeight.tsx

@@ -4,6 +4,7 @@ import { up } from 'up-fetch'
 import { useComponents } from '~components/context/useComponents'
 import { useReactComponentsLocalize } from '~i18n/localize'
 import { useElection } from '~providers'
+import { fetchCheckMembership } from '~providers/csp'
 import { results } from './Results'
 
 const upfetch = up(fetch)
@@ -37,10 +38,21 @@ export const VoteWeight = () => {
           const decimals = (election.meta as any)?.token?.decimals || 0
           setWeight(results(Number(proof.weight), decimals))
         } else {
-          const { weight } = await upfetch<{ weight: string }>(`${election.census.censusURI}/weight`, {
-            method: 'POST',
-            body: { authToken: token },
+          // The bundle /check endpoint returns the voter weight alongside the
+          // membership result, so prefer it and only fall back to the dedicated
+          // /weight endpoint when it doesn't carry a weight.
+          const check = await fetchCheckMembership({
+            endpoint: election.census.censusURI,
+            authToken: token as string,
+            electionId: election.id,
           })
+          let weight = check.belongs ? check.weight : undefined
+          if (typeof weight === 'undefined') {
+            ;({ weight } = await upfetch<{ weight: string }>(`${election.census.censusURI}/weight`, {
+              method: 'POST',
+              body: { authToken: token },
+            }))
+          }
           setWeight(results(Number.parseInt(weight, 16)))
         }
       } catch (error) {

packages/react-components/src/providers/csp/index.test.ts

@@ -1,5 +1,5 @@
 import { CensusType, CspProofType, PublishedElection, VocdoniSDKClient, Vote, WeightedCensus } from '@vocdoni/sdk'
-import { vote } from './index'
+import { fetchCheckMembership, vote } from './index'
 
 const { upFetchMock } = vi.hoisted(() => ({
   upFetchMock: vi.fn(),
@@ -47,3 +47,36 @@ describe('csp vote', () => {
     expect(client.submitVote).toHaveBeenCalledWith(expect.objectContaining({ weight: BigInt(10) }))
   })
 })
+
+describe('fetchCheckMembership', () => {
+  beforeEach(() => {
+    upFetchMock.mockReset()
+  })
+
+  it('posts to the bundle ${censusURI}/check endpoint with token and electionId', async () => {
+    upFetchMock.mockResolvedValue({ belongs: true, weight: '0a', hasVoted: false })
+
+    const result = await fetchCheckMembership({
+      endpoint: 'https://csp.example/process/bundle/abc',
+      authToken: 'token',
+      electionId: 'election-1',
+    })
+
+    expect(upFetchMock).toHaveBeenCalledWith('https://csp.example/process/bundle/abc/check', {
+      method: 'POST',
+      body: { authToken: 'token', electionId: 'election-1' },
+    })
+    expect(result).toEqual({ belongs: true, weight: '0a', hasVoted: false })
+  })
+
+  it('omits electionId from the body when not provided', async () => {
+    upFetchMock.mockResolvedValue({ belongs: false, hasVoted: false })
+
+    await fetchCheckMembership({ endpoint: 'https://csp.example/process/bundle/abc', authToken: 'token' })
+
+    expect(upFetchMock).toHaveBeenCalledWith('https://csp.example/process/bundle/abc/check', {
+      method: 'POST',
+      body: { authToken: 'token' },
+    })
+  })
+})

packages/react-components/src/providers/csp/index.ts

@@ -51,3 +51,28 @@ export const fetchSignInfo = ({
     method: 'POST',
     body: { authToken },
   })
+
+type CheckMembershipResponse = {
+  belongs: boolean
+  weight?: string // hex
+  hasVoted: boolean
+}
+
+type CheckMembershipMutationVariables = {
+  endpoint: string
+  authToken: string
+  electionId?: string
+}
+
+// Posts to ${endpoint}/check, where endpoint is the bundle base
+// (the same base used by /sign and /weight, i.e. census.censusURI), which
+// resolves to POST /process/bundle/{bundleId}/check on the backend.
+export const fetchCheckMembership = ({
+  endpoint,
+  authToken,
+  electionId,
+}: CheckMembershipMutationVariables): Promise<CheckMembershipResponse> =>
+  f(`${endpoint}/check`, {
+    method: 'POST',
+    body: { authToken, ...(electionId ? { electionId } : {}) },
+  })

packages/react-components/src/providers/election/ElectionProvider.test.tsx

@@ -4,7 +4,7 @@ import { CensusType, EnvOptions, PublishedElection, VocdoniSDKClient, WeightedCe
 import { act } from 'react'
 import * as browserModule from '~providers/browser'
 import { ClientContext, ClientProvider, useClient } from '~providers/client'
-import { fetchSignInfo } from '~providers/csp'
+import { fetchCheckMembership, fetchSignInfo } from '~providers/csp'
 import { TestProvider, onlyProps, properProps } from '~providers/test-utils'
 import * as webWorkerModule from '~providers/worker/webWorker'
 import { ElectionProvider, useElection } from './ElectionProvider'
@@ -17,13 +17,23 @@ vi.mock('~providers/csp', () => ({
       at: new Date().toISOString(),
     })
   ),
+  fetchCheckMembership: vi.fn(() => Promise.resolve({ belongs: true, hasVoted: false })),
   vote: vi.fn(),
 }))
 
 describe('<ElectionProvider />', () => {
   beforeEach(() => {
     localStorage.removeItem('csp_token')
-    vi.mocked(fetchSignInfo).mockClear()
+    // mockReset (not mockClear) drains any *Once queued implementations so they
+    // can't leak into later tests, then we re-establish the default behaviour.
+    vi.mocked(fetchSignInfo).mockReset()
+    vi.mocked(fetchSignInfo).mockResolvedValue({
+      address: '0x0',
+      nullifier: '0xdeadbeef',
+      at: new Date().toISOString(),
+    })
+    vi.mocked(fetchCheckMembership).mockReset()
+    vi.mocked(fetchCheckMembership).mockResolvedValue({ belongs: true, hasVoted: false })
   })
 
   it('renders child elements', () => {
@@ -876,9 +886,65 @@ describe('<ElectionProvider />', () => {
     localStorage.removeItem('csp_token')
   })
 
-  it('enables voting when CSP token is set after initial render and sign-info returns 401', async () => {
-    vi.mocked(fetchSignInfo).mockRejectedValueOnce({ status: 401 })
+  it('gates CSP voters out of census when bundle check reports they do not belong', async () => {
+    localStorage.setItem('csp_token', 'token')
+    vi.mocked(fetchCheckMembership).mockResolvedValue({ belongs: false, hasVoted: false })
+
+    const signer = Wallet.createRandom()
+    const client = new VocdoniSDKClient({
+      env: EnvOptions.STG,
+      wallet: signer,
+    })
+    client.voteService.info = vi.fn().mockResolvedValue({ voteID: null, overwriteCount: 0 })
+
+    const census = new WeightedCensus()
+    census.type = CensusType.CSP
+    census.censusURI = 'https://csp.example/api'
+
+    // @ts-ignore
+    const election = PublishedElection.build({
+      id: 'csp-election-not-belonging',
+      title: 'test',
+      description: 'test',
+      endDate: new Date(),
+      census,
+      electionType: { anonymous: false },
+      voteType: { maxVoteOverwrites: 0, maxCount: 1, maxValue: 1 },
+    })
+
+    const wrapper = (props: any) => {
+      return (
+        <TestProvider>
+          <ClientProvider {...onlyProps(props)}>
+            <ElectionProvider {...properProps(props)} />
+          </ClientProvider>
+        </TestProvider>
+      )
+    }
+
+    const { result } = renderHook(() => useElection(), {
+      wrapper,
+      initialProps: { election, fetchCensus: true, client, signer },
+    })
+
+    await waitFor(() => {
+      expect(result.current.loaded.census).toBeTruthy()
+    })
 
+    expect(fetchCheckMembership).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: 'https://csp.example/api',
+        authToken: 'token',
+        electionId: 'csp-election-not-belonging',
+      })
+    )
+    expect(result.current.isInCensus).toBeFalsy()
+    expect(result.current.isAbleToVote).toBeFalsy()
+
+    localStorage.removeItem('csp_token')
+  })
+
+  it('enables voting when the CSP token is set after the initial render', async () => {
     const client = new VocdoniSDKClient({
       env: EnvOptions.STG,
     })
@@ -925,9 +991,9 @@ describe('<ElectionProvider />', () => {
     expect(result.current.isAbleToVote).toBeTruthy()
   })
 
-  it('treats 401 on CSP sign info as no prior vote', async () => {
+  it('grants full allowance to a CSP member who has not voted (check hasVoted=false)', async () => {
     localStorage.setItem('csp_token', 'token')
-    vi.mocked(fetchSignInfo).mockRejectedValueOnce({ status: 401 })
+    vi.mocked(fetchCheckMembership).mockResolvedValue({ belongs: true, hasVoted: false })
 
     const signer = Wallet.createRandom()
     const client = new VocdoniSDKClient({
@@ -941,7 +1007,7 @@ describe('<ElectionProvider />', () => {
 
     // @ts-ignore
     const election = PublishedElection.build({
-      id: 'csp-election-401',
+      id: 'csp-election-not-voted',
       title: 'test',
       description: 'test',
       endDate: new Date(),
@@ -981,15 +1047,18 @@ describe('<ElectionProvider />', () => {
     })
 
     expect(result.current.election.voted).toBeNull()
-    expect(result.current.election.loaded.voted).toBeFalsy()
     expect(result.current.election.votesLeft).toBe(1)
     expect(result.current.election.isAbleToVote).toBeTruthy()
+    // membership check resolved hasVoted directly, so no nullifier lookup is needed
+    expect(fetchSignInfo).not.toHaveBeenCalled()
 
     localStorage.removeItem('csp_token')
   })
 
   it('sets CSP votesLeft to 0 when vote exists and overwrites are disabled', async () => {
     localStorage.setItem('csp_token', 'token')
+    // hasVoted=true forces the exact-overwrite resolution via the nullifier
+    vi.mocked(fetchCheckMembership).mockResolvedValue({ belongs: true, hasVoted: true })
 
     const signer = Wallet.createRandom()
     const client = new VocdoniSDKClient({
@@ -1106,7 +1175,7 @@ describe('<ElectionProvider />', () => {
     })
 
     await waitFor(() => {
-      expect(result.current.election.loaded.voted).toBeTruthy()
+      expect(result.current.election.isAbleToVote).toBe(false)
     })
 
     expect(result.current.election.isInCensus).toBeFalsy()