Merge pull request #44 from DimensionDev/dao-space

feat: add dao space twitter project

Author: guanbinrui

public/dao/specific-list.json

@@ -0,0 +1,7 @@
+[
+  {
+    "spaceId": "cakevote.eth",
+    "spaceName": "PancakeSwap",
+    "twitterHandler": "PancakeSwap"
+  }
+]

src/index.ts

@@ -1,24 +1,24 @@
 import * as process from 'process'
 import { FungibleToken, NonFungibleCollection, NonFungibleToken } from './type'
 import { CoinGecko } from './providers/coingecko'
-import { initFolder, mergePublicFileToOutput, writeCollectionsToFile, writeTokensToFile } from './utils'
+import { initFolder, mergePublicFileToOutput, writeCollectionsToFile, writeTokensToFile, writeDAOToFile } from './utils'
 import { CoinMarketCap } from './providers/coinmarketcap'
 import { NFTScanCollection, NFTScanToken } from './providers/NFTScan'
+import { DAO } from './providers/dao'
 
 const coinGeckoAPI = new CoinGecko()
 const nftScanTokenAPI = new NFTScanToken()
 const nftScanCollectionAPI = new NFTScanCollection()
 const cmcAPI = new CoinMarketCap()
+const daoAPI = new DAO()
 
 const fungibleProviders = [coinGeckoAPI, cmcAPI]
 const nonFungibleTokenProviders = [nftScanTokenAPI]
 const nonFungibleCollectionProviders = [nftScanCollectionAPI]
 
 async function main() {
   await initFolder()
-  await initFolder()
 
-  // Fetch fungible token
   for (const p of fungibleProviders) {
     let fungibleTokens: FungibleToken[] = []
     console.log(`Fetch the data from ${p.getProviderName()}`)
@@ -41,9 +41,6 @@ async function main() {
     }
   }
 
-  await mergePublicFileToOutput('fungible-tokens')
-
-  // Fetch nonFungible token
   for (const p of nonFungibleTokenProviders) {
     let nonFungibleTokens: NonFungibleToken[] = []
     console.log(`Fetch the data from ${p.getProviderName()}`)
@@ -61,9 +58,7 @@ async function main() {
       await writeTokensToFile(p.getProviderName(), 'non-fungible-tokens', nonFungibleTokens)
     }
   }
-  await mergePublicFileToOutput('non-fungible-tokens')
 
-  // Fetch nonFungible Collections
   for (const p of nonFungibleCollectionProviders) {
     let nonFungibleCollections: NonFungibleCollection[] = []
     console.log(`Fetch the data from ${p.getProviderName()}`)
@@ -81,10 +76,15 @@ async function main() {
       await writeCollectionsToFile(p.getProviderName(), nonFungibleCollections)
     }
   }
-  await mergePublicFileToOutput('non-fungible-collections')
 
-  // merge nft lucky drop file
+  const spaces = await daoAPI.getSpaces()
+  await writeDAOToFile(spaces)
+
+  await mergePublicFileToOutput('non-fungible-collections')
+  await mergePublicFileToOutput('non-fungible-tokens')
   await mergePublicFileToOutput('nft-lucky-drop')
+  await mergePublicFileToOutput('fungible-tokens')
+  await mergePublicFileToOutput('dao')
 
   console.log('Generate success!')
   process.exit(0)

src/providers/dao.ts

@@ -0,0 +1,56 @@
+import { DaoProvider, Space } from '../type'
+import axios from 'axios'
+import { uniqBy } from 'lodash'
+
+interface RawSpace {
+  id: string,
+  name: string,
+  avatar: string,
+  twitter: string,
+  followersCount: number,
+  validation: { name: string }
+}
+
+export class DAO implements DaoProvider {
+  async getSpaces(): Promise<Space[]> {
+    const allSettled = await Promise.allSettled(Array.from(Array(14)).map(async (x, i) => {
+      return axios.post<{
+        data: {
+          spaces: RawSpace[]
+        }
+      }>('https://hub.snapshot.org/graphql', {
+        operationName: "Spaces",
+        query: `
+          query Spaces {
+            spaces(
+              first: 1000,
+              skip: ${i * 1000},
+              orderDirection: asc
+            ) {
+              id
+              name
+              avatar
+              twitter
+              followersCount
+              validation {
+                params
+                name
+              }
+            }
+          }      
+        `,
+        variables: null
+      })
+    }))
+
+    const rawSpaces = allSettled.flatMap(
+      (x) => (x.status === 'fulfilled' ? x.value.data.data.spaces ?? undefined : undefined)
+    ).filter(x => x) as RawSpace[]
+
+    return uniqBy(rawSpaces.filter(x => x.avatar && x.followersCount > 499 && x.validation.name !== 'any' && x.twitter).map(x => ({
+      spaceId: x.id,
+      spaceName: x.name,
+      twitterHandler: x.twitter
+    }) as Space), x => x.spaceId)
+  }
+}

src/type.ts

@@ -160,6 +160,12 @@ export interface NonFungibleCollection {
   }
 }
 
+export interface Space {
+  spaceId: string
+  spaceName: string
+  twitterHandler: string
+}
+
 export interface FungibleTokenProvider {
   getTopTokens(): Promise<FungibleToken[]>
   getProviderName(): SourceType
@@ -174,3 +180,7 @@ export interface NonFungibleCollectionProvider {
   getCollections(): Promise<NonFungibleCollection[]>
   getProviderName(): SourceType
 }
+
+export interface DaoProvider {
+  getSpaces(): Promise<Space[]>
+}

src/utils/file.ts

@@ -1,6 +1,6 @@
 import path from 'node:path'
 import fs from 'node:fs/promises'
-import { FungibleToken, NonFungibleCollection, NonFungibleToken, SourceType } from '../type'
+import { FungibleToken, NonFungibleCollection, NonFungibleToken, SourceType, Space } from '../type'
 
 // @ts-ignore
 export const getOutputDir = (type) => path.join(process.env.PWD, `output/${type}`)
@@ -12,6 +12,7 @@ export async function initFolder() {
   await createIfNotExist(getOutputDir('non-fungible-tokens'))
   await createIfNotExist(getOutputDir('non-fungible-collections'))
   await createIfNotExist(getOutputDir('nft-lucky-drop'))
+  await createIfNotExist(getOutputDir('dao'))
 }
 
 export async function writeTokensToFile(
@@ -42,8 +43,20 @@ export async function writeCollectionsToFile(provider: SourceType, tokens: Fungi
   )
 }
 
+export async function writeDAOToFile(spaces: Space[]) {
+  if (!spaces.length) throw new Error(`Forbid writing the empty data of DAO to output`)
+
+  await fs.writeFile(
+    path.join(getOutputDir('dao'), `spaces.json`),
+    JSON.stringify(spaces, undefined, 2),
+    {
+      encoding: 'utf-8',
+    },
+  )
+}
+
 export async function mergePublicFileToOutput(
-  type: 'fungible-tokens' | 'non-fungible-tokens' | 'non-fungible-collections' | 'nft-lucky-drop',
+  type: 'fungible-tokens' | 'non-fungible-tokens' | 'non-fungible-collections' | 'nft-lucky-drop' | 'dao',
 ) {
   const src = path.join(`${getPublicDir(type)}`, 'specific-list.json')
   const dest = path.join(`${getOutputDir(type)}`, 'specific-list.json')