feat: finish implementing affiliate revenue endpoint

.gitignore

@@ -35,4 +35,5 @@ monitoring/my-kube-prometheus/manifests
 monitoring/my-kube-prometheus/alertmanager-config.yaml
 
 # misc
-.DS_Store
+.DS_Store
+docker-compose.override.yml

node/proxy/api/package.json

@@ -15,6 +15,8 @@
     "@shapeshiftoss/common-api": "^10.0.0",
     "@shapeshiftoss/prometheus": "^10.0.0",
     "bottleneck": "^2.19.5",
-    "elliptic-sdk": "^0.7.2"
+    "elliptic-sdk": "^0.7.2",
+    "lru-cache": "^10.2.0",
+    "viem": "^2.33.2"
   }
 }

node/proxy/api/src/affiliateRevenue/bebop/bebop.ts

@@ -0,0 +1,89 @@
+import axios from 'axios'
+import { Fees } from '..'
+import {
+  getCacheableThreshold,
+  getDateEndTimestamp,
+  getDateStartTimestamp,
+  groupFeesByDate,
+  saveCachedFees,
+  splitDateRange,
+  tryGetCachedFees,
+} from '../cache'
+import { SLIP44 } from '../constants'
+import { BEBOP_API_KEY, BEBOP_API_URL, FEE_BPS_DENOMINATOR, NANOSECONDS_PER_SECOND, SHAPESHIFT_REFERRER } from './constants'
+import type { TradesResponse } from './types'
+
+const fetchFeesFromAPI = async (startTimestamp: number, endTimestamp: number): Promise<Fees[]> => {
+  const fees: Fees[] = []
+
+  const start = startTimestamp * NANOSECONDS_PER_SECOND
+  const end = endTimestamp * NANOSECONDS_PER_SECOND
+
+  const { data } = await axios.get<TradesResponse>(BEBOP_API_URL, {
+    params: { source: SHAPESHIFT_REFERRER, start, end },
+    headers: { 'source-auth': BEBOP_API_KEY },
+  })
+
+  for (const trade of data.results) {
+    if (!trade.partnerFeeBps || !trade.partnerFeeNative) continue
+
+    const chainId = `eip155:${trade.chain_id}`
+    const assetId = `${chainId}/slip44:${SLIP44.ETHEREUM}`
+
+    fees.push({
+      chainId,
+      assetId,
+      service: 'bebop',
+      txHash: trade.txHash,
+      timestamp: Math.floor(new Date(trade.timestamp).getTime() / 1000),
+      amount: trade.partnerFeeNative,
+      amountUsd:
+        trade.volumeUsd !== undefined ? String(trade.volumeUsd * (Number(trade.partnerFeeBps) / FEE_BPS_DENOMINATOR)) : undefined,
+    })
+  }
+
+  return fees
+}
+
+export const getFees = async (startTimestamp: number, endTimestamp: number): Promise<Fees[]> => {
+  const threshold = getCacheableThreshold()
+  const { cacheableDates, recentStart } = splitDateRange(startTimestamp, endTimestamp, threshold)
+
+  const cachedFees: Fees[] = []
+  const datesToFetch: string[] = []
+  let cacheHits = 0
+  let cacheMisses = 0
+
+  for (const date of cacheableDates) {
+    const cached = tryGetCachedFees('bebop', 'all', date)
+    if (cached) {
+      cachedFees.push(...cached)
+      cacheHits++
+    } else {
+      datesToFetch.push(date)
+      cacheMisses++
+    }
+  }
+
+  const newFees: Fees[] = []
+  if (datesToFetch.length > 0) {
+    const fetchStart = getDateStartTimestamp(datesToFetch[0])
+    const fetchEnd = getDateEndTimestamp(datesToFetch[datesToFetch.length - 1])
+    const fetched = await fetchFeesFromAPI(fetchStart, fetchEnd)
+
+    const feesByDate = groupFeesByDate(fetched)
+    for (const date of datesToFetch) {
+      saveCachedFees('bebop', 'all', date, feesByDate[date] || [])
+    }
+    newFees.push(...fetched)
+  }
+
+  const recentFees: Fees[] = []
+  if (recentStart !== null) {
+    recentFees.push(...(await fetchFeesFromAPI(recentStart, endTimestamp)))
+  }
+
+  console.log(`[bebop] Cache stats: ${cacheHits} hits, ${cacheMisses} misses`)
+
+  return [...cachedFees, ...newFees, ...recentFees]
+}

node/proxy/api/src/affiliateRevenue/bebop/constants.ts

@@ -0,0 +1,8 @@
+export const BEBOP_API_KEY = process.env.BEBOP_API_KEY
+
+if (!BEBOP_API_KEY) throw new Error('BEBOP_API_KEY env var not set')
+
+export const BEBOP_API_URL = 'https://api.bebop.xyz/history/v2/trades'
+export const SHAPESHIFT_REFERRER = 'shapeshift'
+export const NANOSECONDS_PER_SECOND = 1_000_000_000
+export const FEE_BPS_DENOMINATOR = 10000

node/proxy/api/src/affiliateRevenue/bebop/index.ts

@@ -0,0 +1 @@
+export { getFees } from './bebop'

node/proxy/api/src/affiliateRevenue/bebop/types.ts

@@ -0,0 +1,37 @@
+export type TradesResponse = {
+  results: Array<{
+    chain_id: number
+    txHash: string
+    status: string
+    type: string
+    taker: string
+    receiver: string
+    sellTokens: Record<string, { amount?: string; amountUsd?: number }>
+    buyTokens: Record<string, { amount?: string; amountUsd?: number }>
+    volumeUsd?: number
+    gasFeeUsd?: number
+    timestamp: string
+    route: 'JAM' | 'PMM'
+    gasless: boolean
+    partnerFeeNative?: string
+    partnerFeeBps?: string
+  }>
+  nextAvailableTimestamp?: string
+  metadata: {
+    timestamp: string
+    results?: number
+    tokens: Record<
+      string,
+      Record<
+        string,
+        {
+          name: string
+          symbol: string
+          decimals: number
+          displayDecimals?: number
+          icon?: string
+        }
+      >
+    >
+  }
+}

node/proxy/api/src/affiliateRevenue/butterswap/butterswap.ts

@@ -0,0 +1,110 @@
+import { createHash } from 'crypto'
+import { encodeAbiParameters, parseAbiParameters } from 'viem'
+import { Fees } from '..'
+import { getDateRange, getDateStartTimestamp } from '../cache'
+import {
+  API_SUCCESS_CODE,
+  BUTTERSWAP_AFFILIATE_ID,
+  BUTTERSWAP_CONTRACT,
+  FALLBACK_TOKENS,
+  GET_TOTAL_BALANCE_SELECTOR,
+  HEX_PREFIX_LENGTH,
+  HEX_RADIX,
+  MAP_CHAIN_ID,
+  MAP_USDT_ADDRESS,
+  TOKEN_CACHE_TTL_MS,
+  TOKEN_LIST_API,
+  UINT256_HEX_LENGTH,
+  USDT_DECIMALS,
+} from './constants'
+import type { TokenListResponse } from './types'
+import { estimateBlockFromTimestamp, rpcCall } from './utils'
+
+let cachedTokens: string[] | null = null
+let tokensCachedAt = 0
+
+const fetchTokenList = async (): Promise<string[]> => {
+  const now = Date.now()
+  if (cachedTokens && now - tokensCachedAt < TOKEN_CACHE_TTL_MS) {
+    return cachedTokens
+  }
+
+  try {
+    const response = await fetch(TOKEN_LIST_API)
+    const data: TokenListResponse = await response.json()
+
+    if (data.errno === API_SUCCESS_CODE && data.data?.items?.length > 0) {
+      cachedTokens = data.data.items.map((t) => t.address.toLowerCase())
+      tokensCachedAt = now
+      return cachedTokens
+    }
+  } catch {
+    // Fall through to return fallback tokens
+  }
+
+  return FALLBACK_TOKENS
+}
+
+const getBlockNumber = async (): Promise<number> => {
+  const result = await rpcCall<string>('eth_blockNumber', [])
+  return parseInt(result, HEX_RADIX)
+}
+
+const getTotalBalance = async (blockNumber: number, tokens: string[]): Promise<bigint> => {
+  const params = encodeAbiParameters(parseAbiParameters('uint256, address[], address'), [
+    BigInt(BUTTERSWAP_AFFILIATE_ID),
+    tokens as `0x${string}`[],
+    MAP_USDT_ADDRESS as `0x${string}`,
+  ])
+
+  const data = GET_TOTAL_BALANCE_SELECTOR + params.slice(HEX_PREFIX_LENGTH)
+  const blockHex = `0x${blockNumber.toString(HEX_RADIX)}`
+
+  const result = await rpcCall<string>('eth_call', [{ to: BUTTERSWAP_CONTRACT, data }, blockHex])
+
+  return BigInt(result.slice(0, UINT256_HEX_LENGTH))
+}
+
+const generateSyntheticTxHash = (service: string, date: string): string => {
+  return '0x' + createHash('sha256').update(`${service}-${date}`).digest('hex')
+}
+
+export const getFees = async (startTimestamp: number, endTimestamp: number): Promise<Array<Fees>> => {
+  const tokens = await fetchTokenList()
+
+  const currentBlock = await getBlockNumber()
+  const now = Math.floor(Date.now() / 1000)
+
+  const startBlock = estimateBlockFromTimestamp(currentBlock, now, startTimestamp)
+  const endBlock = estimateBlockFromTimestamp(currentBlock, now, endTimestamp)
+
+  const [balanceAtStart, balanceAtEnd] = await Promise.all([
+    getTotalBalance(startBlock, tokens),
+    getTotalBalance(endBlock, tokens),
+  ]).catch(error => {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`Failed to query ButterSwap balance: ${message}`)
+  })
+
+  const feesForPeriod = balanceAtEnd - balanceAtStart
+
+  if (feesForPeriod <= BigInt(0)) {
+    return []
+  }
+
+  const dates = getDateRange(startTimestamp, endTimestamp)
+  const numDays = dates.length
+
+  const feesPerDay = feesForPeriod / BigInt(numDays)
+  const feesPerDayUsd = Number(feesPerDay) / 10 ** USDT_DECIMALS
+
+  return dates.map((date) => ({
+    service: 'butterswap',
+    amount: feesPerDay.toString(),
+    amountUsd: feesPerDayUsd.toString(),
+    chainId: MAP_CHAIN_ID,
+    assetId: `${MAP_CHAIN_ID}/erc20:${MAP_USDT_ADDRESS}`,
+    timestamp: getDateStartTimestamp(date),
+    txHash: generateSyntheticTxHash('butterswap', date),
+  }))
+}

node/proxy/api/src/affiliateRevenue/butterswap/constants.ts

@@ -0,0 +1,25 @@
+import { BUTTERSWAP_AFFILIATE_ID, BUTTERSWAP_CONTRACT, MAP_CHAIN_ID, MAP_RPC_URL, MAP_USDT_ADDRESS } from '../constants'
+
+export { BUTTERSWAP_AFFILIATE_ID, BUTTERSWAP_CONTRACT, MAP_CHAIN_ID, MAP_RPC_URL, MAP_USDT_ADDRESS }
+
+export const BLOCK_TIME_SECONDS = 5
+export const USDT_DECIMALS = 18
+export const TOKEN_LIST_API = 'https://butterapi.chainservice.io/api/token/bam/list'
+export const TOKEN_CACHE_TTL_MS = 60 * 60 * 1000
+
+export const GET_TOTAL_BALANCE_SELECTOR = '0x47b2f8d9'
+export const API_SUCCESS_CODE = 0
+export const HEX_RADIX = 16
+export const HEX_PREFIX_LENGTH = 2
+export const UINT256_HEX_LENGTH = 66
+
+export const FALLBACK_TOKENS = [
+  '0x05ab928d446d8ce6761e368c8e7be03c3168a9ec',
+  '0x33daba9618a75a7aff103e53afe530fbacf4a3dd',
+  '0x9f722b2cb30093f766221fd0d37964949ed66918',
+  '0xb877e3562a660c7861117c2f1361a26abaf19beb',
+  '0x5de6606ae1250c64560a603b40078de268240fdd',
+  '0xc478a25240d9c072ebec5109b417e0a78a41667c',
+  '0x593a37fe0f6dfd0b6c5a051e9a44aa0f6922a1a2',
+  '0x0e9e7317c7132604c009c9860a259a3da33a3ed3',
+]

node/proxy/api/src/affiliateRevenue/butterswap/index.ts

@@ -0,0 +1 @@
+export { getFees } from './butterswap'

node/proxy/api/src/affiliateRevenue/butterswap/types.ts

@@ -0,0 +1,15 @@
+export type RpcResponse<T> = {
+  jsonrpc: string
+  id: number
+  result: T
+  error?: { code: number; message: string }
+}
+
+export type TokenListResponse = {
+  errno: number
+  message: string
+  data: {
+    items: Array<{ address: string; symbol: string }>
+    total: number
+  }
+}