Release: SuperFluid Anchor Contract

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',

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/resolvers/anchorContractAddressResolver.ts

@@ -14,6 +14,9 @@ import { ApolloContext } from '../types/ApolloContext';
 import { findUserById } from '../repositories/userRepository';
 import { getProvider } from '../provider';
 import { logger } from '../utils/logger';
+import { ChainType } from '../types/network';
+import { addBulkNewProjectAddress } from '../repositories/projectAddressRepository';
+import { validateProjectRelatedAddresses } from '../utils/validators/projectValidator';
 
 @Resolver(_of => AnchorContractAddress)
 export class AnchorContractAddressResolver {
@@ -24,6 +27,7 @@ export class AnchorContractAddressResolver {
     @Arg('networkId', () => Int) networkId: number,
     @Arg('address', () => String) address: string,
     @Arg('txHash', () => String) txHash: string,
+    @Arg('recipientAddress', { nullable: true }) recipientAddress?: string,
   ): Promise<AnchorContractAddress> {
     const userId = ctx?.req?.user?.userId;
     const creatorUser = await findUserById(userId);
@@ -53,11 +57,29 @@ export class AnchorContractAddressResolver {
           projectAddress.isRecipient === true,
       )
     ) {
-      throw new Error(
-        i18n.__(
-          translationErrorMessagesKeys.PROJECT_DOESNT_HAVE_RECIPIENT_ADDRESS_ON_THIS_NETWORK,
-        ),
-      );
+      if (recipientAddress) {
+        const recipientAddressInput = {
+          project,
+          user: creatorUser,
+          address: recipientAddress!,
+          chainType: ChainType.EVM,
+          networkId: networkId,
+          isRecipient: true,
+        };
+
+        await validateProjectRelatedAddresses(
+          [recipientAddressInput],
+          projectId,
+        );
+
+        await addBulkNewProjectAddress([recipientAddressInput]);
+      } else {
+        throw new Error(
+          i18n.__(
+            translationErrorMessagesKeys.PROJECT_DOESNT_HAVE_RECIPIENT_ADDRESS_ON_THIS_NETWORK,
+          ),
+        );
+      }
     }
 
     const web3Provider = getProvider(networkId);

src/resolvers/projectResolver.ts

@@ -268,6 +268,9 @@ class GetProjectsArgs {
 
   @Field(_type => String, { nullable: true })
   qfRoundSlug?: string;
+
+  @Field({ nullable: true })
+  includeUnlisted?: boolean;
 }
 
 @ObjectType()
@@ -740,6 +743,7 @@ export class ProjectResolver {
       campaignSlug,
       qfRoundId,
       qfRoundSlug,
+      includeUnlisted,
     }: GetProjectsArgs,
     @Ctx() { req: { user }, projectsFiltersThreadPool }: ApolloContext,
   ): Promise<AllProjects> {
@@ -766,6 +770,7 @@ export class ProjectResolver {
       qfRoundId,
       qfRoundSlug,
       activeQfRoundId,
+      includeUnlisted,
     };
     let campaign;
     if (campaignSlug) {

src/resolvers/recurringDonationResolver.test.ts

@@ -29,6 +29,11 @@ import { QfRound } from '../entities/qfRound';
 import { generateRandomString } from '../utils/utils';
 import { ORGANIZATION_LABELS } from '../entities/organization';
 
+describe(
+  'recurringDonationEligibleProjects test cases',
+  recurringDonationEligibleProjectsTestCases,
+);
+
 describe(
   'createRecurringDonation test cases',
   createRecurringDonationTestCases,
@@ -63,6 +68,85 @@ describe(
   recurringDonationsByProjectDateTestCases,
 );
 
+function recurringDonationEligibleProjectsTestCases() {
+  it('should return eligible projects with their anchor contracts', async () => {
+    const projectOwner = await saveUserDirectlyToDb(
+      generateRandomEtheriumAddress(),
+    );
+
+    const project = await saveProjectDirectlyToDb(
+      {
+        ...createProjectData(),
+        isGivbackEligible: true,
+      },
+      projectOwner,
+    );
+
+    const anchorContractAddress = await addNewAnchorAddress({
+      project,
+      owner: projectOwner,
+      creator: projectOwner,
+      address: generateRandomEtheriumAddress(),
+      networkId: NETWORK_IDS.OPTIMISTIC,
+      txHash: generateRandomEvmTxHash(),
+    });
+
+    const anchorContractAddressBASE = await addNewAnchorAddress({
+      project,
+      owner: projectOwner,
+      creator: projectOwner,
+      address: generateRandomEtheriumAddress(),
+      networkId: NETWORK_IDS.BASE_MAINNET,
+      txHash: generateRandomEvmTxHash(),
+    });
+
+    const result = await axios.post(graphqlUrl, {
+      query: `
+          query {
+            recurringDonationEligibleProjects {
+              id
+              slug
+              title
+              anchorContracts {
+                address
+                networkId
+                isActive
+              }
+            }
+          }
+        `,
+    });
+
+    assert.isNotNull(result.data.data.recurringDonationEligibleProjects);
+    const foundProject =
+      result.data.data.recurringDonationEligibleProjects.find(
+        p => p.id === project.id,
+      );
+
+    assert.isNotNull(
+      foundProject,
+      'Project should be found in eligible projects',
+    );
+    assert.equal(foundProject.slug, project.slug);
+    assert.equal(foundProject.title, project.title);
+    assert.equal(foundProject.anchorContracts.length, 2);
+
+    // Assert Optimistic anchor contract
+    const optimisticContract = foundProject.anchorContracts.find(
+      contract => contract.networkId === NETWORK_IDS.OPTIMISTIC,
+    );
+    assert.isNotNull(optimisticContract);
+    assert.equal(optimisticContract.address, anchorContractAddress.address);
+
+    // Assert BASE anchor contract
+    const baseContract = foundProject.anchorContracts.find(
+      contract => contract.networkId === NETWORK_IDS.BASE_MAINNET,
+    );
+    assert.isNotNull(baseContract);
+    assert.equal(baseContract.address, anchorContractAddressBASE.address);
+  });
+}
+
 function createRecurringDonationTestCases() {
   it('should create recurringDonation successfully', async () => {
     const projectOwner = await saveUserDirectlyToDb(