feat: data provider for Otterspace

group-generators/generators/index.ts

@@ -308,6 +308,7 @@ import optimismGovernanceCommitteeMember from "./optimism-governance-committee-m
 import optimists from "./optimists";
 import orangeDaoContributors from "./orange-dao-contributors";
 import osa from "./osa";
+import otterspace from "./otterspace-sample";
 import ox10 from "./ox10";
 import oxbage from "./oxbage";
 import padultra from "./padultra";
@@ -826,6 +827,7 @@ export const groupGenerators: GroupGeneratorsLibrary = {
   "optimists": optimists,
   "orange-dao-contributors": orangeDaoContributors,
   "osa": osa,
+  "otterspace-sample":otterspace,
   "ox10": ox10,
   "oxbage": oxbage,
   "padultra": padultra,

group-generators/generators/otterspace-sample/index.ts

@@ -0,0 +1,31 @@
+import { dataProviders } from "@group-generators/helpers/data-providers";
+import { GroupWithData, Tags, ValueType } from "topics/group";
+import {
+  GenerationContext,
+  GenerationFrequency,
+  GroupGenerator,
+} from "topics/group-generator";
+
+const generator: GroupGenerator = {
+  generationFrequency: GenerationFrequency.Weekly,
+
+  generate: async (context: GenerationContext): Promise<GroupWithData[]> => {
+    const otterspaceProvider = new dataProviders.OtterSpaceSubgraphProvider();
+    const addresses = await otterspaceProvider.getBadgeHolders({
+      id: "bafyreicl3unvw6tvzjfduvrhxbfi74gsob6mpf6ekn3s2nkopqz2phtx7e",
+    });
+    return [
+      {
+        name: "otterspace-sample",
+        description: "Have sample badge on Otterspace",
+        specs: "Get all holders of Otterspace badge",
+        timestamp: context.timestamp,
+        data: addresses,
+        valueType: ValueType.Info,
+        tags: [Tags.User],
+      },
+    ];
+  },
+};
+
+export default generator;

group-generators/helpers/data-providers/index.ts

@@ -19,6 +19,8 @@ import HiveInterfaceSchema from "./hive/interface-schema.json";
 import { JsonRpcProvider } from "./json-rpc";
 import { LensProvider } from "./lens";
 import lensInterfaceSchema from "./lens/interface-schema.json";
+import { OtterSpaceSubgraphProvider } from "./otterspace";
+import otterspaceInterfaceSchema from "./otterspace/interface-schema.json";
 import { PoapSubgraphProvider } from "./poap";
 import poapInterfaceSchema from "./poap/interface-schema.json";
 import { RestProvider } from "./rest-api";
@@ -61,6 +63,7 @@ export const dataProviders = {
   HiveProvider,
   JsonRpcProvider,
   LensProvider,
+  OtterSpaceSubgraphProvider,
   PoapSubgraphProvider,
   RestProvider,
   SismoSubgraphProvider,
@@ -82,6 +85,7 @@ export const dataProvidersInterfacesSchemas: DataProviderInterface[] = [
   gitPoapInterfaceSchema,
   HiveInterfaceSchema,
   lensInterfaceSchema,
+  otterspaceInterfaceSchema,
   poapInterfaceSchema,
   restInterfaceSchema,
   snapshotInterfaceSchema,
@@ -153,6 +157,10 @@ export const dataProvidersAPIEndpoints = {
     getPublicationMirrorsCount: async (_: any) =>
       new LensProvider().getPublicationMirrorsCount(_),
   },
+  OtterSpaceSubgraphProvider: {
+    getBadgeHolders: async (_: any) =>
+      new OtterSpaceSubgraphProvider().getBadgeHoldersCount(_),
+  },
   HiveProvider: {
     getInfluencersFromClusterWithMinimumFollowersCount: async (_: any) =>
       new HiveProvider().getInfluencersFromClusterWithMinimumFollowersCount(_),

group-generators/helpers/data-providers/otterspace/base-provider.ts

@@ -0,0 +1,57 @@
+import { gql } from "graphql-request";
+import {
+  QueryBadgeHoldersInput,
+  IOtterspaceSubgraphProvider,
+  QueryBadgeHoldersOutput,
+} from "./types";
+import { SubgraphHostedServiceProvider } from "@group-generators/helpers/data-providers/subgraph";
+import { FetchedData } from "topics/group";
+
+export default class OtterspaceSubgraphBaseProvider
+  extends SubgraphHostedServiceProvider
+  implements IOtterspaceSubgraphProvider
+{
+  constructor(url?: string) {
+    super({
+      url:
+        url ??
+        "https://api.thegraph.com/subgraphs/name/otterspace-xyz/badges-optimism",
+    });
+  }
+
+  /**
+   * Use this method to query all holders of specific Otterspace badge
+   * @param param0 The badgeId to query holders of
+   * @returns The group of all adresses having that badge
+   */
+  public async getBadgeHolders({
+    id,
+  }: QueryBadgeHoldersInput): Promise<FetchedData> {
+    const holders: FetchedData = {};
+
+    try {
+      const query = gql`
+        query badges {
+          badgeSpec(
+            id: "${id}"
+          ) {
+            id
+            badges {
+              id
+              owner
+            }
+          }
+        }
+      `;
+      const res: QueryBadgeHoldersOutput =
+        await this.query<QueryBadgeHoldersOutput>(query);
+
+      res.badgeSpec.badges.forEach((badge) => {
+        holders[badge.owner] = 1;
+      });
+    } catch (error) {
+      console.log(error);
+    }
+    return holders;
+  }
+}

group-generators/helpers/data-providers/otterspace/index.ts

@@ -0,0 +1,16 @@
+import OtterspaceSubgraphBaseProvider from "./base-provider";
+import { OtterSpaceSubgraphProvider } from "./provider";
+
+import {
+  IOtterspaceSubgraphProvider,
+  QueryBadgeHoldersInput,
+  QueryBadgeHoldersOutput,
+} from "./types";
+
+export {
+  OtterSpaceSubgraphProvider,
+  OtterspaceSubgraphBaseProvider,
+  IOtterspaceSubgraphProvider,
+  QueryBadgeHoldersInput as OtterspaceQueryBadgeHoldersInput,
+  QueryBadgeHoldersOutput as OtterspaceQueryBadgeHoldersOutput,
+};

group-generators/helpers/data-providers/otterspace/interface-schema.json

@@ -0,0 +1,23 @@
+{
+  "name": "Otterspace",
+  "iconUrl": "",
+  "providerClassName": "OtterspaceSubgraphProvider",
+  "functions": [
+    {
+      "name": "Get holders of badge",
+      "functionName": "getBadgeHolders",
+      "countFunctionName": "getBadgeHoldersCount",
+      "description": "Returns all holders of a specific Otterspace badge",
+      "args": [
+        {
+          "name": "BadgeId",
+          "argName": "id",
+          "type": "string",
+          "required": "true",
+          "example": "bafyreicl3unvw6tvzjfduvrhxbfi74gsob6mpf6ekn3s2nkopqz2phtx7e",
+          "description": "A specific BadgeId"
+        }
+      ]
+    }
+  ]
+}

group-generators/helpers/data-providers/otterspace/provider.ts

@@ -0,0 +1,52 @@
+import { gql } from "graphql-request";
+import OtterspaceSubgraphBaseProvider from "./base-provider";
+import { QueryBadgeHoldersInput, QueryBadgeHoldersOutput } from "./types";
+import { FetchedData } from "topics/group";
+
+export class OtterSpaceSubgraphProvider {
+  otterspaceSubgraphProvider: OtterspaceSubgraphBaseProvider;
+
+  constructor(url?: string) {
+    this.otterspaceSubgraphProvider = new OtterspaceSubgraphBaseProvider(url);
+  }
+
+  public async getBadgeHolders({
+    id,
+  }: QueryBadgeHoldersInput): Promise<FetchedData> {
+    const holders: FetchedData = {};
+
+    try {
+      const query = gql`
+        query badges {
+          badgeSpec(
+            id: "${id}"
+          ) {
+            id
+            badges {
+              id
+              owner
+            }
+          }
+        }
+      `;
+      const res: QueryBadgeHoldersOutput =
+        await this.otterspaceSubgraphProvider.query<QueryBadgeHoldersOutput>(
+          query
+        );
+
+      res.badgeSpec.badges.forEach((badge) => {
+        holders[badge.owner] = 1;
+      });
+    } catch (error) {
+      console.log(error);
+    }
+    return holders;
+  }
+
+  public async getBadgeHoldersCount({
+    id,
+  }: QueryBadgeHoldersInput): Promise<number> {
+    const holders = await this.getBadgeHolders({ id });
+    return Object.keys(holders).length;
+  }
+}

group-generators/helpers/data-providers/otterspace/types.ts

@@ -0,0 +1,20 @@
+import { ISubgraphProvider } from "@group-generators/helpers/data-providers/subgraph";
+import { FetchedData } from "topics/group";
+
+export type QueryBadgeHoldersOutput = {
+  badgeSpec: {
+    id: string;
+    badges: [
+      {
+        id: string;
+        owner: string;
+      }
+    ];
+  };
+};
+
+export type QueryBadgeHoldersInput = { id: string };
+
+export interface IOtterspaceSubgraphProvider extends ISubgraphProvider {
+  getBadgeHolders(input: QueryBadgeHoldersInput): Promise<FetchedData>;
+}