Merge pull request #66 from ethereumfollowprotocol/leaderboard-and-slots

leaderboard fixes and lookup by slot

Author: 0xthrpw

src/router/api/v1/index.ts

@@ -13,6 +13,7 @@ import { leaderboard } from './leaderboard'
 import { lists } from './lists'
 import { minters } from './minters'
 import { serviceHealth } from './serviceHealth'
+import { slots } from './slots'
 import { stats } from './stats'
 import { token } from './token'
 import { users } from './users'
@@ -45,6 +46,7 @@ export function api(services: Services): Hono<{ Bindings: Environment }> {
   api.route('/leaderboard', leaderboard(services))
   api.route('/lists', lists(services))
   api.route('/minters', minters(services))
+  api.route('/slots', slots(services))
   api.route('/stats', stats(services))
   api.route('/token', token(services))
   api.route('/users', users(services))

src/router/api/v1/leaderboard/blocked/index.ts

@@ -5,32 +5,32 @@ import type { Services } from '#/service'
 import type { Environment } from '#/types'
 import type { IncludeValidator, LimitValidator } from '../validators'
 
-/**
- * TODO: add support for whether :addressOrENS is followed, is following, is muting, is blocking, is blocked by
- */
 export function blocked(
   leaderboard: Hono<{ Bindings: Environment }>,
   services: Services,
   limitValidator: LimitValidator,
   includeValidator: IncludeValidator
 ) {
-  /**
-   * Same as /followers, but for blocked.
-   */
   leaderboard.get('/blocked', limitValidator, includeValidator, async context => {
-    const { include, limit } = context.req.valid('query')
+    const { limit, offset, cache } = context.req.valid('query')
     const parsedLimit = Number.parseInt(limit?.toString() || '10', 10)
-    let mostBlocked: { address: string; blocked_by_count: number }[] = await services
+    const parsedOffset = Number.parseInt(offset?.toString() || '0', 10)
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/blocked?limit=${parsedLimit}&offset=${parsedOffset}`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+
+    const mostBlocked: { address: string; blocked_by_count: number }[] = await services
       .efp(env(context))
       .getLeaderboardBlocked(parsedLimit)
-    if (include?.includes('ens')) {
-      const ens = services.ens(env(context))
-      const ensProfiles = await Promise.all(mostBlocked.map(user => ens.getENSProfile(user.address)))
-      mostBlocked = mostBlocked.map((user, index) => ({
-        ...user,
-        ens: ensProfiles[index]
-      }))
-    }
-    return context.json(mostBlocked, 200)
+
+    const packagedResponse = mostBlocked
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/leaderboard/blocks/index.ts

@@ -5,32 +5,32 @@ import type { Services } from '#/service'
 import type { Environment } from '#/types'
 import type { IncludeValidator, LimitValidator } from '../validators'
 
-/**
- * TODO: add support for whether :addressOrENS is followed, is following, is muting, is blocking, is blocked by
- */
 export function blocks(
   leaderboard: Hono<{ Bindings: Environment }>,
   services: Services,
   limitValidator: LimitValidator,
   includeValidator: IncludeValidator
 ) {
-  /**
-   * Same as /followers, but for following.
-   */
-  leaderboard.get('/blocks/:addressOrENS?', limitValidator, includeValidator, async context => {
-    const { include, limit } = context.req.valid('query')
+  leaderboard.get('/blocks', limitValidator, includeValidator, async context => {
+    const { limit, offset, cache } = context.req.valid('query')
     const parsedLimit = Number.parseInt(limit?.toString() || '10', 10)
-    let mostBlocks: { address: string; blocks_count: number }[] = await services
+    const parsedOffset = Number.parseInt(offset?.toString() || '0', 10)
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/blocks?limit=${parsedLimit}&offset=${parsedOffset}`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+
+    const mostBlocks: { address: string; blocks_count: number }[] = await services
       .efp(env(context))
       .getLeaderboardBlocks(parsedLimit)
-    if (include?.includes('ens')) {
-      const ens = services.ens(env(context))
-      const ensProfiles = await Promise.all(mostBlocks.map(user => ens.getENSProfile(user.address)))
-      mostBlocks = mostBlocks.map((user, index) => ({
-        ...user,
-        ens: ensProfiles[index]
-      }))
-    }
-    return context.json(mostBlocks, 200)
+
+    const packagedResponse = mostBlocks
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/leaderboard/count/index.ts

@@ -13,9 +13,21 @@ export function count(
   includeValidator: IncludeValidator
 ) {
   leaderboard.get('/count', limitValidator, includeValidator, async context => {
-    const efp = await services.efp(env(context))
+    const { cache } = context.req.valid('query')
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/count`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+    const efp = services.efp(env(context))
     const leaderboardCount: number = await efp.getLeaderboardCount()
 
-    return context.json({ leaderboardCount }, 200)
+    const packagedResponse = { leaderboardCount }
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/leaderboard/followers/index.ts

@@ -5,36 +5,31 @@ import type { Services } from '#/service'
 import type { Environment } from '#/types'
 import type { IncludeValidator, LimitValidator } from '../validators'
 
-/**
- * TODO: add support for whether :addressOrENS is followed, is following, is muting, is blocking, is blocked by
- */
 export function followers(
   leaderboard: Hono<{ Bindings: Environment }>,
   services: Services,
   limitValidator: LimitValidator,
   includeValidator: IncludeValidator
 ) {
-  /**
-   * By default, only returns leaderboard with address and followers_count/following_count of each user.
-   * If include=ens, also returns ens profile of each user.
-   * If include=muted, also returns how many users each user has muted.
-   * If include=blocked, also returns how many users each user has blocked.
-   * If addressOrENS path param is provided AND include=mutuals query param is provided, returns mutuals between addressOrENS and each user.
-   */
-  leaderboard.get('/followers/:addressOrENS?', limitValidator, includeValidator, async context => {
-    const { include, limit } = context.req.valid('query')
+  leaderboard.get('/followers', limitValidator, includeValidator, async context => {
+    const { limit, offset, cache } = context.req.valid('query')
     const parsedLimit = Number.parseInt(limit?.toString() || '10', 10)
-    let mostFollowers: { address: string; followers_count: number }[] = await services
+    const parsedOffset = Number.parseInt(offset?.toString() || '0', 10)
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/followers?limit=${parsedLimit}&offset=${parsedOffset}`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+    const mostFollowers: { address: string; followers_count: number }[] = await services
       .efp(env(context))
       .getLeaderboardFollowers(parsedLimit)
-    if (include?.includes('ens')) {
-      const ens = services.ens(env(context))
-      const ensProfiles = await Promise.all(mostFollowers.map(user => ens.getENSProfile(user.address)))
-      mostFollowers = mostFollowers.map((user, index) => ({
-        ...user,
-        ens: ensProfiles[index]
-      }))
-    }
-    return context.json(mostFollowers, 200)
+
+    const packagedResponse = mostFollowers
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/leaderboard/following/index.ts

@@ -5,32 +5,32 @@ import type { Services } from '#/service'
 import type { Environment } from '#/types'
 import type { IncludeValidator, LimitValidator } from '../validators'
 
-/**
- * TODO: add support for whether :addressOrENS is followed, is following, is muting, is blocking, is blocked by
- */
 export function following(
   leaderboard: Hono<{ Bindings: Environment }>,
   services: Services,
   limitValidator: LimitValidator,
   includeValidator: IncludeValidator
 ) {
-  /**
-   * Same as /followers, but for following.
-   */
-  leaderboard.get('/following/:addressOrENS?', limitValidator, includeValidator, async context => {
-    const { include, limit } = context.req.valid('query')
+  leaderboard.get('/following', limitValidator, includeValidator, async context => {
+    const { limit, offset, cache } = context.req.valid('query')
     const parsedLimit = Number.parseInt(limit?.toString() || '10', 10)
-    let mostFollowing: { address: string; following_count: number }[] = await services
+    const parsedOffset = Number.parseInt(offset?.toString() || '0', 10)
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/following?limit=${parsedLimit}&offset=${parsedOffset}`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+
+    const mostFollowing: { address: string; following_count: number }[] = await services
       .efp(env(context))
       .getLeaderboardFollowing(parsedLimit)
-    if (include?.includes('ens')) {
-      const ens = services.ens(env(context))
-      const ensProfiles = await Promise.all(mostFollowing.map(user => ens.getENSProfile(user.address)))
-      mostFollowing = mostFollowing.map((user, index) => ({
-        ...user,
-        ens: ensProfiles[index]
-      }))
-    }
-    return context.json(mostFollowing, 200)
+
+    const packagedResponse = mostFollowing
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/leaderboard/muted/index.ts

@@ -5,32 +5,32 @@ import type { Services } from '#/service'
 import type { Environment } from '#/types'
 import type { IncludeValidator, LimitValidator } from '../validators'
 
-/**
- * TODO: add support for whether :addressOrENS is followed, is following, is muting, is blocking, is blocked by
- */
 export function muted(
   leaderboard: Hono<{ Bindings: Environment }>,
   services: Services,
   limitValidator: LimitValidator,
   includeValidator: IncludeValidator
 ) {
-  /**
-   * Same as /followers, but for muted.
-   */
-  leaderboard.get('/muted?', limitValidator, includeValidator, async context => {
-    const { include, limit } = context.req.valid('query')
+  leaderboard.get('/muted', limitValidator, includeValidator, async context => {
+    const { limit, offset, cache } = context.req.valid('query')
     const parsedLimit = Number.parseInt(limit?.toString() || '10', 10)
-    let mostMuted: { address: string; muted_by_count: number }[] = await services
+    const parsedOffset = Number.parseInt(offset?.toString() || '0', 10)
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/muted?limit=${parsedLimit}&offset=${parsedOffset}`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+
+    const mostMuted: { address: string; muted_by_count: number }[] = await services
       .efp(env(context))
       .getLeaderboardMuted(parsedLimit)
-    if (include?.includes('ens')) {
-      const ens = services.ens(env(context))
-      const ensProfiles = await Promise.all(mostMuted.map(user => ens.getENSProfile(user.address)))
-      mostMuted = mostMuted.map((user, index) => ({
-        ...user,
-        ens: ensProfiles[index]
-      }))
-    }
-    return context.json(mostMuted, 200)
+
+    const packagedResponse = mostMuted
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/leaderboard/mutes/index.ts

@@ -5,32 +5,31 @@ import type { Services } from '#/service'
 import type { Environment } from '#/types'
 import type { IncludeValidator, LimitValidator } from '../validators'
 
-/**
- * TODO: add support for whether :addressOrENS is followed, is following, is muting, is blocking, is blocked by
- */
 export function mutes(
   leaderboard: Hono<{ Bindings: Environment }>,
   services: Services,
   limitValidator: LimitValidator,
   includeValidator: IncludeValidator
 ) {
-  /**
-   * Same as /followers, but for following.
-   */
-  leaderboard.get('/mutes/:addressOrENS?', limitValidator, includeValidator, async context => {
-    const { include, limit } = context.req.valid('query')
+  leaderboard.get('/mutes', limitValidator, includeValidator, async context => {
+    const { limit, offset, cache } = context.req.valid('query')
     const parsedLimit = Number.parseInt(limit?.toString() || '10', 10)
-    let mostMutes: { address: string; mutes_count: number }[] = await services
+    const parsedOffset = Number.parseInt(offset?.toString() || '0', 10)
+
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `leaderboard/mutes?limit=${parsedLimit}&offset=${parsedOffset}`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+    const mostMutes: { address: string; mutes_count: number }[] = await services
       .efp(env(context))
       .getLeaderboardMutes(parsedLimit)
-    if (include?.includes('ens')) {
-      const ens = services.ens(env(context))
-      const ensProfiles = await Promise.all(mostMutes.map(user => ens.getENSProfile(user.address)))
-      mostMutes = mostMutes.map((user, index) => ({
-        ...user,
-        ens: ensProfiles[index]
-      }))
-    }
-    return context.json(mostMutes, 200)
+
+    const packagedResponse = mostMutes
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
   })
 }

src/router/api/v1/slots/details/index.ts

@@ -0,0 +1,31 @@
+import type { Hono } from 'hono'
+import { env } from 'hono/adapter'
+
+import type { Services } from '#/service'
+import type { Environment } from '#/types'
+
+export function details(slots: Hono<{ Bindings: Environment }>, services: Services) {
+  slots.get('/:chain_id/:contract/:slot/details', async context => {
+    const { chain_id, contract, slot } = context.req.param()
+    const { cache } = context.req.query()
+    const cacheService = services.cache(env(context))
+    const cacheTarget = `slots/${slot}/details`
+    if (cache !== 'fresh') {
+      const cacheHit = await cacheService.get(cacheTarget)
+      if (cacheHit) {
+        return context.json({ ...cacheHit }, 200)
+      }
+    }
+
+    // const slotDetails: {}[] = ['details not implemented']
+    const slotDetails = await services.efp(env(context)).getListDetailsBySlot(Number(chain_id), contract, slot)
+
+    if (!slotDetails) {
+      return context.json({ response: 'No List Found' }, 404)
+    }
+
+    const packagedResponse = { slotDetails }
+    await cacheService.put(cacheTarget, JSON.stringify(packagedResponse))
+    return context.json(packagedResponse, 200)
+  })
+}

src/router/api/v1/slots/index.ts

@@ -0,0 +1,13 @@
+import { Hono } from 'hono'
+
+import type { Services } from '#/service'
+import type { Environment } from '#/types'
+
+import { details } from './details'
+
+export function slots(services: Services): Hono<{ Bindings: Environment }> {
+  const slots = new Hono<{ Bindings: Environment }>()
+  details(slots, services)
+
+  return slots
+}