feat(APP-667): Pull token voting ERC20 members from aragon-subdomain

.changeset/app-667-token-voting-members-from-aragon-domain.md

@@ -0,0 +1,5 @@
+---
+"@aragon/app": minor
+---
+
+Serve mainnet ERC-20 token-voting member lists from the aragon-domain (Envio) BFF, with source routing and a legacy-backend fallback

apps/app/config/.env.local

@@ -1,5 +1,6 @@
 # URL of the Aragon backend
 ARAGON_BACKEND_URL=https://dev.backend.aragonservices.in
+# ARAGON_BACKEND_URL=http://localhost:3000
 
 # Application environment
 NEXT_PUBLIC_ENV=local

apps/app/package.json

@@ -30,7 +30,7 @@
         "e2e:codegen": "playwright codegen --config e2e/playwright.config.ts"
     },
     "dependencies": {
-        "@aragon/aragon-domain": "^0.3.1",
+        "@aragon/aragon-domain": "0.0.0-20260730113648",
         "@aragon/assistant-chat": "workspace:*",
         "@aragon/assistant-contracts": "workspace:*",
         "@aragon/gov-ui-kit": "catalog:",

apps/app/src/app/api/domain/token-voting/members/route.ts

@@ -0,0 +1,47 @@
+import { type NextRequest, NextResponse } from 'next/server';
+import { tokenVotingMembershipServiceServer } from '@/modules/governance/api/tokenVotingMembershipService/tokenVotingMembershipService.server';
+import { monitoringUtils } from '@/shared/utils/monitoringUtils';
+
+export const GET = async (req: NextRequest) => {
+    const params = req.nextUrl.searchParams;
+    const pluginAddress = params.get('pluginAddress');
+    const tokenContractAddress = params.get('tokenContractAddress');
+    const page = params.get('page');
+    const pageSize = params.get('pageSize');
+
+    if (pluginAddress == null || tokenContractAddress == null) {
+        return NextResponse.json(
+            {
+                error: 'pluginAddress and tokenContractAddress query parameters are required',
+            },
+            { status: 400 },
+        );
+    }
+
+    try {
+        const result =
+            await tokenVotingMembershipServiceServer.getTokenVotingMembership({
+                queryParams: {
+                    pluginAddress,
+                    tokenContractAddress,
+                    page: page != null ? Number(page) : undefined,
+                    pageSize: pageSize != null ? Number(pageSize) : undefined,
+                },
+            });
+
+        return NextResponse.json(result);
+    } catch (error) {
+        monitoringUtils.logError(error, {
+            context: {
+                errorType: 'get_token_voting_membership_error',
+                pluginAddress,
+                tokenContractAddress,
+            },
+        });
+
+        return NextResponse.json(
+            { error: 'getTokenVotingMembership request failed' },
+            { status: 500 },
+        );
+    }
+};

apps/app/src/app/dao/[network]/[addressOrEns]/(daoPage)/members/page.tsx

@@ -1,3 +1,5 @@
-import { DaoMembersPage } from '@/modules/governance/pages/daoMembersPage';
+// Imported from the page file (not the module barrel): the RSC pulls in
+// server-only prefetch code that must stay out of the barrel's client graph.
+import { DaoMembersPage } from '@/modules/governance/pages/daoMembersPage/daoMembersPage';
 
 export default DaoMembersPage;

apps/app/src/modules/governance/api/governanceService/domain/memberMetrics.ts

@@ -1,10 +1,10 @@
 export interface IMemberMetrics {
     /**
-     * Block number of the first activity of the member in the given body plugin.
+     * Unix-seconds timestamp of the member's first observed activity.
      */
-    firstActivity: number | null;
+    firstActivityTimestamp: number | null;
     /**
-     * Block number of the latest activity of the member in the given body plugin.
+     * Unix-seconds timestamp of the member's most recent observed activity.
      */
-    lastActivity: number | null;
+    lastActivityTimestamp: number | null;
 }

apps/app/src/modules/governance/api/governanceService/governanceService.api.ts

@@ -2,7 +2,7 @@ import type {
     IOrderedRequest,
     IPaginatedRequest,
 } from '@/shared/api/aragonBackendService';
-import type { Network } from '@/shared/api/daoService';
+import type { Network, PluginInterfaceType } from '@/shared/api/daoService';
 import type {
     IRequestQueryParams,
     IRequestUrlParams,
@@ -59,6 +59,32 @@ export interface IGetMemberListQueryParams extends IPaginatedRequest {
 export interface IGetMemberListParams
     extends IRequestQueryParams<IGetMemberListQueryParams> {}
 
+export interface IGetTokenVotingMembershipQueryParams
+    extends IGetMemberListQueryParams {
+    /**
+     * Network of the plugin, used to route the query to the aragon-domain BFF
+     * when the network is indexed by Envio.
+     */
+    network?: Network;
+    /**
+     * Interface type of the plugin.
+     */
+    pluginInterfaceType?: PluginInterfaceType;
+    /**
+     * Address of the governance token.
+     */
+    tokenAddress?: string;
+    /**
+     * Address of the underlying token when the governance token is a wrapped
+     * or voting-escrow adapter. `null` / `undefined` means the governance
+     * token is a plain ERC-20.
+     */
+    tokenUnderlying?: string | null;
+}
+
+export interface IGetTokenVotingMembershipParams
+    extends IRequestQueryParams<IGetTokenVotingMembershipQueryParams> {}
+
 export interface IGetMemberUrlParams {
     /**
      * Address of a DAO member.

apps/app/src/modules/governance/api/governanceService/governanceService.test.ts

@@ -8,25 +8,32 @@ import { generateSppProposal } from '@/plugins/sppPlugin/testUtils/generators/sp
 import { generateSppPluginSettings } from '@/plugins/sppPlugin/testUtils/generators/sppSettings';
 import { generateSppStage } from '@/plugins/sppPlugin/testUtils/generators/sppStage';
 import type { ISppProposal } from '@/plugins/sppPlugin/types';
+import { generateTokenMember } from '@/plugins/tokenPlugin/testUtils';
 import { Network, PluginInterfaceType } from '@/shared/api/daoService';
 import { generatePaginatedResponse } from '@/shared/testUtils';
 import {
     generateMember,
     generateProposal,
     generateVote,
 } from '../../testUtils';
+import { tokenVotingMembershipServiceClient } from '../tokenVotingMembershipService';
 import { governanceService } from './governanceService';
 import * as fetchTokensTotalSupplyHelpers from './utils/fetchTokensTotalSupply';
 
 describe('governance service', () => {
     const requestSpy = jest.spyOn(governanceService, 'request');
+    const domainMembersSpy = jest.spyOn(
+        tokenVotingMembershipServiceClient,
+        'getTokenVotingMembership',
+    );
     const fetchTokensTotalSupplySpy = jest.spyOn(
         fetchTokensTotalSupplyHelpers,
         'fetchTokensTotalSupply',
     );
 
     afterEach(() => {
         requestSpy.mockReset();
+        domainMembersSpy.mockReset();
         fetchTokensTotalSupplySpy.mockReset();
     });
 
@@ -53,6 +60,144 @@ describe('governance service', () => {
         expect(result).toEqual(members);
     });
 
+    it('getTokenVotingMembership delegates mainnet token-voting to the aragon-domain service', async () => {
+        const responseBody = {
+            data: [
+                {
+                    address: '0xabc',
+                    ens: 'alice.eth',
+                    votingPower: '5000',
+                    metrics: {
+                        firstActivityTimestamp: 1_705_320_000,
+                        lastActivityTimestamp: 1_718_872_200,
+                        delegationCount: 3,
+                    },
+                },
+            ],
+            metadata: {
+                page: 1,
+                pageSize: 10,
+                totalPages: 1,
+                totalRecords: 1,
+            },
+        };
+        domainMembersSpy.mockResolvedValue(responseBody);
+
+        const result = await governanceService.getTokenVotingMembership({
+            queryParams: {
+                daoId: 'dao-id-test',
+                pluginAddress: '0xPlugin',
+                tokenAddress: '0xToken',
+                network: Network.ETHEREUM_MAINNET,
+                pluginInterfaceType: PluginInterfaceType.TOKEN_VOTING,
+                page: 2,
+                pageSize: 25,
+            },
+        });
+
+        expect(requestSpy).not.toHaveBeenCalled();
+        expect(domainMembersSpy).toHaveBeenCalledWith({
+            queryParams: {
+                pluginAddress: '0xplugin',
+                tokenContractAddress: '0xtoken',
+                page: 2,
+                pageSize: 25,
+            },
+        });
+        expect(result).toEqual(responseBody);
+    });
+
+    it.each([
+        ['non-mainnet network', { network: Network.POLYGON_MAINNET }],
+        [
+            'non-token-voting interface type',
+            { pluginInterfaceType: PluginInterfaceType.MULTISIG },
+        ],
+        ['missing tokenAddress', { tokenAddress: undefined }],
+        [
+            'wrapped / VE-adapter governance token',
+            { tokenUnderlying: '0xunderlying' },
+        ],
+    ])('getTokenVotingMembership routes to the legacy backend for %s', async (_label, routingOverrides) => {
+        requestSpy.mockResolvedValue(generatePaginatedResponse({}));
+        await governanceService.getTokenVotingMembership({
+            queryParams: {
+                daoId: 'dao-id-test',
+                pluginAddress: '0x123',
+                tokenAddress: '0xtoken',
+                network: Network.ETHEREUM_MAINNET,
+                pluginInterfaceType: PluginInterfaceType.TOKEN_VOTING,
+                ...routingOverrides,
+            },
+        });
+
+        expect(domainMembersSpy).not.toHaveBeenCalled();
+        expect(requestSpy).toHaveBeenCalledWith(
+            governanceService['urls'].members,
+            expect.objectContaining({
+                queryParams: expect.objectContaining({
+                    pluginAddress: '0x123',
+                }),
+            }),
+        );
+    });
+
+    it('getTokenVotingMembership maps the backend members to DTOs when routing to the legacy backend', async () => {
+        const member = generateTokenMember({
+            address: '0xabc',
+            ens: 'alice.eth',
+            votingPower: '5000',
+            type: 'token-voting',
+            firstActive: 100,
+            lastActive: 200,
+            metrics: {
+                firstActivityTimestamp: 1_705_320_000,
+                lastActivityTimestamp: 1_718_872_200,
+                delegationCount: 3,
+            },
+        });
+        requestSpy.mockResolvedValue(
+            generatePaginatedResponse({ data: [member] }),
+        );
+
+        const result = await governanceService.getTokenVotingMembership({
+            queryParams: {
+                daoId: 'dao-id-test',
+                pluginAddress: '0xPlugin',
+                tokenAddress: '0xToken',
+                // Non-mainnet → backend branch.
+                network: Network.POLYGON_MAINNET,
+                pluginInterfaceType: PluginInterfaceType.TOKEN_VOTING,
+            },
+        });
+
+        expect(domainMembersSpy).not.toHaveBeenCalled();
+        // Routing-only fields are stripped before hitting the backend.
+        expect(requestSpy).toHaveBeenCalledWith(
+            governanceService['urls'].members,
+            {
+                queryParams: {
+                    daoId: 'dao-id-test',
+                    pluginAddress: '0xPlugin',
+                },
+            },
+        );
+        expect(result.data).toEqual([
+            {
+                address: '0xabc',
+                ens: 'alice.eth',
+                votingPower: '5000',
+                metrics: {
+                    firstActivityTimestamp: 1_705_320_000,
+                    lastActivityTimestamp: 1_718_872_200,
+                    delegationCount: 3,
+                },
+            },
+        ]);
+        expect(result.data[0]).not.toHaveProperty('type');
+        expect(result.data[0]).not.toHaveProperty('firstActive');
+    });
+
     it('getMember fetches the member of the specified DAO by address', async () => {
         const member = generateMember({ address: '0x123' });
         const params = {

apps/app/src/modules/governance/api/governanceService/governanceService.ts

@@ -1,6 +1,8 @@
+import type { PageDTO, TokenVotingMemberDTO } from '@aragon/aragon-domain';
 import { invariant } from '@aragon/gov-ui-kit';
 import { lockToVoteProposalUtils } from '@/plugins/lockToVotePlugin/utils/lockToVoteProposalUtils';
 import { sppProposalUtils } from '@/plugins/sppPlugin/utils/sppProposalUtils';
+import type { ITokenMember } from '@/plugins/tokenPlugin/types';
 import {
     AragonBackendService,
     type IPaginatedResponse,
@@ -9,6 +11,7 @@ import type {
     ICanCreateProposalResult,
     IMemberExistsResult,
 } from '../../types';
+import { tokenVotingMembershipServiceClient } from '../tokenVotingMembershipService';
 import type {
     IMember,
     IProposal,
@@ -24,10 +27,12 @@ import type {
     IGetProposalActionsParams,
     IGetProposalBySlugParams,
     IGetProposalListParams,
+    IGetTokenVotingMembershipParams,
     IGetVoteListParams,
 } from './governanceService.api';
 import { collectTokenAddresses } from './utils/collectTokenAddresses';
 import { fetchTokensTotalSupply } from './utils/fetchTokensTotalSupply';
+import { fetchTokenVotingMembership } from './utils/fetchTokenVotingMembership';
 
 class GovernanceService extends AragonBackendService {
     private urls = {
@@ -52,6 +57,21 @@ class GovernanceService extends AragonBackendService {
         return result;
     };
 
+    /**
+     * Token-voting member list. Routes between the aragon-domain BFF and the
+     * legacy backend (see `fetchTokenVotingMembership`), returning the
+     * library-owned `TokenVotingMemberDTO` page regardless of source. The
+     * generic `getMemberList` still serves multisig/admin.
+     */
+    getTokenVotingMembership = (
+        params: IGetTokenVotingMembershipParams,
+    ): Promise<PageDTO<TokenVotingMemberDTO>> =>
+        fetchTokenVotingMembership(
+            params,
+            tokenVotingMembershipServiceClient.getTokenVotingMembership,
+            (legacyParams) => this.getMemberList<ITokenMember>(legacyParams),
+        );
+
     getMember = async <TMember extends IMember = IMember>(
         params: IGetMemberParams,
     ): Promise<TMember> => {

apps/app/src/modules/governance/api/governanceService/governanceServiceKeys.ts

@@ -6,6 +6,7 @@ import type {
     IGetProposalActionsParams,
     IGetProposalBySlugParams,
     IGetProposalListParams,
+    IGetTokenVotingMembershipParams,
     IGetVoteListParams,
 } from './governanceService.api';
 
@@ -15,6 +16,7 @@ export enum GovernanceServiceKey {
     PROPOSAL_ACTIONS = 'PROPOSAL_ACTIONS',
     CAN_CREATE_PROPOSAL = 'CAN_CREATE_PROPOSAL',
     MEMBER_LIST = 'MEMBER_LIST',
+    TOKEN_VOTING_MEMBERSHIP = 'TOKEN_VOTING_MEMBERSHIP',
     MEMBER = 'MEMBER',
     MEMBER_EXISTS = 'MEMBER_EXISTS',
     VOTE_LIST = 'VOTE_LIST',
@@ -41,6 +43,10 @@ export const governanceServiceKeys = {
         GovernanceServiceKey.MEMBER_LIST,
         params,
     ],
+    tokenVotingMembership: (params: IGetTokenVotingMembershipParams) => [
+        GovernanceServiceKey.TOKEN_VOTING_MEMBERSHIP,
+        params,
+    ],
     member: (params: IGetMemberParams) => [GovernanceServiceKey.MEMBER, params],
     memberExists: (params: IGetMemberExistsParams) => [
         GovernanceServiceKey.MEMBER_EXISTS,

apps/app/src/modules/governance/api/governanceService/index.ts

@@ -6,3 +6,8 @@ export {
     governanceServiceKeys,
 } from './governanceServiceKeys';
 export * from './queries';
+export {
+    buildTokenVotingMembershipParams,
+    type ITokenVotingMembershipPluginSettings,
+    isTokenMemberListPlugin,
+} from './utils/buildTokenVotingMembershipParams';