Vouched projects and superfluid Base improvements

migration/data/seedTokens.ts

@@ -1695,6 +1695,16 @@ const seedTokens: ITokenData[] = [
     coingeckoId: 'degen-base',
     isGivbackEligible: false,
   },
+  // cbBTC - https://basescan.org/token/0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf
+  {
+    name: 'Coinbase Wrapped BTC',
+    symbol: 'cbBTC',
+    address: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
+    decimals: 8,
+    networkId: NETWORK_IDS.BASE_MAINNET,
+    coingeckoId: 'coinbase-wrapped-btc',
+    isGivbackEligible: false,
+  },
   // Osaka Protocol - https://basescan.org/token/0xbFd5206962267c7b4b4A8B3D76AC2E1b2A5c4d5e
   {
     name: 'Osaka Protocol',

package.json

@@ -136,6 +136,7 @@
     "test:qfRoundService": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/services/qfRoundService.test.ts",
     "test:project": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/entities/project.test.ts",
     "test:projectsTab": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/server/adminJs/tabs/projectsTab.test.ts",
+    "test:projectVerificationTab": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/server/adminJs/tabs/projectVerificationTab.test.ts",
     "test:syncUsersModelScore": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/services/cronJobs/syncUsersModelScore.test.ts",
     "test:notifyDonationsWithSegment": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/services/cronJobs/notifyDonationsWithSegment.test.ts",
     "test:checkProjectVerificationStatus": "NODE_ENV=test mocha ./test/pre-test-scripts.ts  ./src/services/cronJobs/checkProjectVerificationStatus.test.ts",

src/adapters/superFluid/superFluidAdapter.ts

@@ -1,19 +1,33 @@
 import axios from 'axios';
 import { logger } from '../../utils/logger';
-import { isProduction } from '../../utils/utils';
 import {
   FlowUpdatedEvent,
   SuperFluidAdapterInterface,
 } from './superFluidAdapterInterface';
+import { NETWORK_IDS } from '../../provider';
 
-const superFluidGraphqlUrl =
+const superFluidGraphqlPolygonUrl =
   'https://subgraph-endpoints.superfluid.dev/optimism-mainnet/protocol-v1';
-const superFluidGraphqlStagingUrl =
+const superFluidGraphqlPolygonStagingUrl =
   'https://optimism-sepolia.subgraph.x.superfluid.dev';
+const superFluidGraphBaseUrl =
+  'https://subgraph-endpoints.superfluid.dev/base-mainnet/protocol-v1';
 
-const subgraphUrl = isProduction
-  ? superFluidGraphqlUrl
-  : superFluidGraphqlStagingUrl;
+const subgraphUrlMap = {
+  [NETWORK_IDS.OPTIMISTIC]: superFluidGraphqlPolygonUrl,
+  [NETWORK_IDS.OPTIMISM_SEPOLIA]: superFluidGraphqlPolygonStagingUrl,
+  [NETWORK_IDS.BASE_MAINNET]: superFluidGraphBaseUrl,
+  [NETWORK_IDS.BASE_SEPOLIA]: superFluidGraphBaseUrl,
+};
+
+// Function to retrieve the subgraph URL for a given network ID
+const getSubgraphUrl = (networkId: number) => {
+  const url = subgraphUrlMap[networkId];
+  if (!url) {
+    throw new Error(`No subgraph URL found for network ID: ${networkId}`);
+  }
+  return url;
+};
 
 // Define your GraphQL query as a string and prepare your variables
 const accountQuery = `
@@ -169,8 +183,9 @@ export class SuperFluidAdapter implements SuperFluidAdapterInterface {
     */
 
   // Optimism works
-  async accountBalance(accountId: string) {
+  async accountBalance(accountId: string, networkId: number) {
     try {
+      const subgraphUrl = getSubgraphUrl(networkId);
       const response = await axios.post(subgraphUrl, {
         query: accountQuery,
         variables: {
@@ -189,12 +204,21 @@ export class SuperFluidAdapter implements SuperFluidAdapterInterface {
     sender: string;
     flowRate: string;
     transactionHash: string;
+    networkId: number;
   }): Promise<FlowUpdatedEvent | undefined> {
     try {
+      const subgraphUrl = getSubgraphUrl(params.networkId);
+      const whereParams = {
+        receiver: params.receiver,
+        sender: params.sender,
+        flowRate: params.flowRate,
+        transactionHash: params.transactionHash,
+      };
+
       const response = await axios.post(subgraphUrl, {
         query: getFlowsQuery,
         variables: {
-          where: params,
+          where: whereParams,
           orderBy: 'timestamp',
           orderDirection: 'asc',
         },
@@ -213,14 +237,24 @@ export class SuperFluidAdapter implements SuperFluidAdapterInterface {
     sender: string;
     flowRate: string;
     timestamp_gt: number;
+    networkId: number;
   }): Promise<FlowUpdatedEvent | undefined> {
     try {
+      const subgraphUrl = getSubgraphUrl(params.networkId);
+
       logger.debug('getFlowByReceiverSenderFlowRate has been called', params);
 
+      const whereParams = {
+        receiver: params.receiver,
+        sender: params.sender,
+        flowRate: params.flowRate,
+        timestamp_gt: params.timestamp_gt,
+      };
+
       const response = await axios.post(subgraphUrl, {
         query: getFlowsQuery,
         variables: {
-          where: params,
+          where: whereParams,
           orderBy: 'timestamp',
           orderDirection: 'asc',
         },

src/adapters/superFluid/superFluidAdapterInterface.ts

@@ -20,17 +20,19 @@ export interface SuperFluidAdapterInterface {
     currency: string;
     recurringDonationTxHash: string;
   }): Promise<any>;
-  accountBalance(accountId: string): Promise<any>;
+  accountBalance(accountId: string, networkId: number): Promise<any>;
   getFlowByTxHash(params: {
     receiver: string;
     sender: string;
     flowRate: string;
     transactionHash: string;
+    networkId: number;
   }): Promise<FlowUpdatedEvent | undefined>;
   getFlowByReceiverSenderFlowRate(params: {
     receiver: string;
     sender: string;
     flowRate: string;
     timestamp_gt: number;
+    networkId: number;
   }): Promise<FlowUpdatedEvent | undefined>;
 }

src/adapters/superFluid/superFluidMockAdapter.ts

@@ -85,6 +85,7 @@ export class SuperFluidMockAdapter implements SuperFluidAdapterInterface {
     sender: string;
     flowRate: string;
     timestamp_gt: number;
+    networkId: number;
   }): Promise<FlowUpdatedEvent | undefined> {
     return Promise.resolve(undefined);
   }
@@ -94,6 +95,7 @@ export class SuperFluidMockAdapter implements SuperFluidAdapterInterface {
     sender: string;
     flowRate: string;
     transactionHash: string;
+    networkId: number;
   }): Promise<FlowUpdatedEvent | undefined> {
     const { receiver, sender, flowRate, transactionHash } = params;
     return Promise.resolve({

src/entities/user.ts

@@ -263,3 +263,18 @@ export class User extends BaseEntity {
     return `givethId-${this.id}`;
   }
 }
+
+@ObjectType()
+export class UserPublicData extends BaseEntity {
+  @Field(_type => String, { nullable: true })
+  firstName?: string;
+
+  @Field(_type => String, { nullable: true })
+  lastName?: string;
+
+  @Field(_type => String, { nullable: true })
+  name?: string;
+
+  @Field(_type => String, { nullable: true })
+  walletAddress?: string;
+}

src/provider.ts

@@ -42,8 +42,76 @@ export const superTokensToToken = {
   DAIx: 'DAI',
   OPx: 'OP',
   GIVx: 'GIV',
+  DEGENx: 'DEGEN',
+  cbBTCx: 'cbBTC',
 };
 
+export const superTokensBase = [
+  {
+    underlyingToken: {
+      decimals: 6,
+      id: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+      name: 'USD Coin',
+      symbol: 'USDC',
+      coingeckoId: 'usd-coin',
+    },
+    decimals: 18,
+    id: '0xD04383398dD2426297da660F9CCA3d439AF9ce1b',
+    name: 'Super USD Coin',
+    symbol: 'USDCx',
+    isSuperToken: true,
+    coingeckoId: 'usd-coin',
+  },
+  {
+    underlyingToken: {
+      name: 'Ethereum',
+      symbol: 'ETH',
+      decimals: 18,
+      id: '0x0000000000000000000000000000000000000000',
+    },
+    decimals: 18,
+    id: '0x46fd5cfB4c12D87acD3a13e92BAa53240C661D93',
+    name: 'Super ETH',
+    symbol: 'ETHx',
+  },
+  {
+    underlyingToken: {
+      decimals: 8,
+      id: '0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf',
+      name: 'Coinbase Wrapped BTC',
+      symbol: 'cbBTC',
+    },
+    decimals: 18,
+    id: '0xDFd428908909CB5E24F5e79E6aD6BDE10bdf2327',
+    name: 'Super Coinbase Wrapped BTC',
+    symbol: 'cbBTCx',
+  },
+  {
+    underlyingToken: {
+      decimals: 18,
+      id: '0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb',
+      name: 'DAI Stablecoin',
+      symbol: 'DAI',
+    },
+    decimals: 18,
+    id: '0x708169c8C87563Ce904E0a7F3BFC1F3b0b767f41',
+    name: 'Super DAI Stablecoin',
+    symbol: 'DAIx',
+  },
+  {
+    underlyingToken: {
+      decimals: 18,
+      id: '0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed',
+      name: 'Degen',
+      symbol: 'DEGEN',
+    },
+    decimals: 18,
+    id: '0x1efF3Dd78F4A14aBfa9Fa66579bD3Ce9E1B30529',
+    name: 'Super Degen',
+    symbol: 'DEGENx',
+  },
+];
+
 export const superTokens = [
   {
     underlyingToken: {

src/repositories/projectRepository.ts

@@ -83,6 +83,7 @@ export type FilterProjectQueryInputParams = {
   qfRoundId?: number;
   activeQfRoundId?: number;
   qfRoundSlug?: string;
+  includeUnlisted?: boolean;
 };
 export const filterProjectsQuery = (params: FilterProjectQueryInputParams) => {
   const {
@@ -97,6 +98,7 @@ export const filterProjectsQuery = (params: FilterProjectQueryInputParams) => {
     qfRoundId,
     qfRoundSlug,
     activeQfRoundId,
+    includeUnlisted,
   } = params;
 
   let query = Project.createQueryBuilder('project')
@@ -122,11 +124,16 @@ export const filterProjectsQuery = (params: FilterProjectQueryInputParams) => {
       'projectPower.totalPower',
       'projectPower.powerRank',
       'projectPower.round',
-    ])
-    .where(
+    ]);
+
+  if (includeUnlisted) {
+    query = query.where(`project.statusId = ${ProjStatus.active}`);
+  } else {
+    query = query.where(
       `project.statusId = ${ProjStatus.active} AND project.reviewStatus = :reviewStatus`,
       { reviewStatus: ReviewStatus.Listed },
     );
+  }
 
   const isFilterByQF =
     !!filters?.find(f => f === FilterField.ActiveQfRound) && activeQfRoundId;
@@ -255,7 +262,6 @@ export const filterProjectsQuery = (params: FilterProjectQueryInputParams) => {
       break;
     case SortingField.BestMatch:
       break;
-
     default:
       query
         .addOrderBy('projectInstantPower.totalPower', OrderDirection.DESC)

src/repositories/projectVerificationRepository.ts

@@ -417,24 +417,20 @@ export const approveProject = async (params: {
   return project.save();
 };
 
-export const approveMultipleProjects = async (params: {
+export const approveMultipleProjects = async ({
+  approved,
+  projectsIds,
+}: {
   approved: boolean;
   projectsIds: string[] | number[];
 }): Promise<UpdateResult> => {
-  if (params.approved) {
-    await Project.query(`
-      UPDATE project
-      SET "verificationStatus" = NULL
-      WHERE id IN (${params.projectsIds?.join(',')})
-    `);
-  }
-
   return Project.createQueryBuilder('project')
-    .update<Project>(Project, {
-      isGivbackEligible: params.approved,
+    .update<Project>(Project)
+    .set({
+      isGivbackEligible: approved,
+      ...(approved && { verificationStatus: null, verified: true }),
     })
-    .where('project.id IN (:...ids)')
-    .setParameter('ids', params.projectsIds)
+    .where('project.id IN (:...ids)', { ids: projectsIds })
     .returning('*')
     .updateEntity(true)
     .execute();