@elizaos/plugin-wallet 2.0.0-beta.1 → 2.0.3-beta.5

package/src/analytics/birdeye/service.ts

@@ -1,5 +1,3 @@
-// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
-
 import {
   type RouteSpec,
   resolveCloudRoute,
@@ -13,6 +11,25 @@ import {
 import Birdeye from "./birdeye-task";
 import { BIRDEYE_ENDPOINTS, BIRDEYE_SERVICE_NAME } from "./constants";
 import { searchBirdeyeTokens } from "./search-category";
+import type { DefiMultiPriceResponse } from "./types/api/defi";
+import type {
+  TokenMarketSearchParams,
+  TokenMarketSearchResponse,
+} from "./types/api/search";
+import type {
+  TokenMarketDataParams,
+  TokenMarketDataResponse,
+  TokenOverviewParams,
+  TokenOverviewResponse,
+  TokenSecurityParams,
+  TokenSecurityResponse,
+  TokenTradeDataSingleParams,
+  TokenTradeDataSingleResponse,
+} from "./types/api/token";
+import type {
+  WalletPortfolioResponse,
+  WalletTransactionHistoryResponse,
+} from "./types/api/wallet";
 import type {
   BirdeyeSupportedChain,
   GetCacheTimedOptions,
@@ -34,6 +51,8 @@ const CACHE_DEFAULTS = {
   TOKEN_TRADE_DATA_TTL: 30 * 60 * 1000,
   // Token security data cache (30 minutes)
   TOKEN_SECURITY_DATA_TTL: 30 * 60 * 1000,
+  // Token price/liquidity cache (30 seconds)
+  TOKEN_MARKET_DATA_TTL: 30 * 1000,
 };
 
 // 'solana' | 'base' | 'ethereum'
@@ -43,6 +62,44 @@ type CacheWrapper<T> = {
   data: T;
   setAt: number;
 };
+
+type BirdeyeHeaders = { headers?: Record<string, string> };
+
+type BirdeyeMultiPriceItem = NonNullable<
+  DefiMultiPriceResponse["data"][string]
+> & {
+  priceInNative?: number;
+  liquidity?: number;
+  market_cap?: number;
+  marketcap?: number;
+  mc?: number;
+  realMc?: number;
+};
+
+type BirdeyeMultiPriceResponse = Omit<DefiMultiPriceResponse, "data"> & {
+  data: Record<string, BirdeyeMultiPriceItem | undefined>;
+};
+
+export interface BirdeyeTokenMarketSnapshot {
+  symbol?: string;
+  priceUsd: number;
+  priceSol?: number;
+  liquidity: number;
+  priceChange24h: number;
+  marketCapUsd?: number;
+}
+
+type WalletTransaction =
+  WalletTransactionHistoryResponse["data"][string][number];
+
+function firstFiniteNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+  }
+}
+
 export class BirdeyeService extends Service {
   static serviceType: string = BIRDEYE_SERVICE_NAME;
   capabilityDescription = "BirdEye data access";
@@ -84,11 +141,11 @@ export class BirdeyeService extends Service {
     };
   }
 
-  private async fetchBirdeyeJson(
+  private async fetchBirdeyeJson<T>(
     path: string,
-    params: Record<string, unknown> = {},
+    params: object = {},
     options: { headers?: Record<string, string> } = {},
-  ) {
+  ): Promise<T> {
     const chain = options.headers?.["x-chain"] ?? "solana";
     const cleanParams = Object.fromEntries(
       Object.entries(params).filter(([, value]) => value !== undefined),
@@ -111,12 +168,14 @@ export class BirdeyeService extends Service {
         `Birdeye API error ${response.status}: ${errorText || response.statusText}`,
       );
     }
-    return response.json();
+    return response.json() as Promise<T>;
   }
 
-  async fetchSearchTokenMarketData(params: Record<string, unknown>) {
+  async fetchSearchTokenMarketData(
+    params: TokenMarketSearchParams,
+  ): Promise<TokenMarketSearchResponse> {
     const chain = typeof params.chain === "string" ? params.chain : "solana";
-    return this.fetchBirdeyeJson(
+    return this.fetchBirdeyeJson<TokenMarketSearchResponse>(
       BIRDEYE_ENDPOINTS.search.token_market,
       params,
       {
@@ -126,10 +185,10 @@ export class BirdeyeService extends Service {
   }
 
   async fetchTokenOverview(
-    params: Record<string, unknown>,
-    options: { headers?: Record<string, string> } = {},
-  ) {
-    return this.fetchBirdeyeJson(
+    params: TokenOverviewParams,
+    options: BirdeyeHeaders = {},
+  ): Promise<TokenOverviewResponse> {
+    return this.fetchBirdeyeJson<TokenOverviewResponse>(
       BIRDEYE_ENDPOINTS.token.overview,
       params,
       options,
@@ -137,10 +196,10 @@ export class BirdeyeService extends Service {
   }
 
   async fetchTokenMarketData(
-    params: Record<string, unknown>,
-    options: { headers?: Record<string, string> } = {},
-  ) {
-    return this.fetchBirdeyeJson(
+    params: TokenMarketDataParams,
+    options: BirdeyeHeaders = {},
+  ): Promise<TokenMarketDataResponse> {
+    return this.fetchBirdeyeJson<TokenMarketDataResponse>(
       BIRDEYE_ENDPOINTS.token.market_data,
       params,
       options,
@@ -148,10 +207,10 @@ export class BirdeyeService extends Service {
   }
 
   async fetchTokenSecurityByAddress(
-    params: Record<string, unknown>,
-    options: { headers?: Record<string, string> } = {},
-  ) {
-    return this.fetchBirdeyeJson(
+    params: TokenSecurityParams,
+    options: BirdeyeHeaders = {},
+  ): Promise<TokenSecurityResponse> {
+    return this.fetchBirdeyeJson<TokenSecurityResponse>(
       BIRDEYE_ENDPOINTS.token.security,
       params,
       options,
@@ -159,10 +218,10 @@ export class BirdeyeService extends Service {
   }
 
   async fetchTokenTradeDataSingle(
-    params: Record<string, unknown>,
-    options: { headers?: Record<string, string> } = {},
-  ) {
-    return this.fetchBirdeyeJson(
+    params: TokenTradeDataSingleParams,
+    options: BirdeyeHeaders = {},
+  ): Promise<TokenTradeDataSingleResponse> {
+    return this.fetchBirdeyeJson<TokenTradeDataSingleResponse>(
       BIRDEYE_ENDPOINTS.token.trade_data_single,
       params,
       options,
@@ -197,15 +256,15 @@ export class BirdeyeService extends Service {
     try {
       validatedChain = extractChain(undefined, chain);
     } catch (error) {
-      this.runtime.logger?.warn(
+      this.runtime.logger.warn(
         `getTrendingTokensForChain: ${error instanceof Error ? error.message : String(error)}`,
       );
       return { data: [], setAt: Date.now() };
     }
 
-    // Don't allow 'evm' as a trending chain (it's just a placeholder)
+    // Don't allow 'evm' as a trending chain; callers must choose a concrete chain.
     if (validatedChain === "evm") {
-      this.runtime.logger?.warn(
+      this.runtime.logger.warn(
         `getTrendingTokensForChain: 'evm' is not a specific chain. Use ethereum, arbitrum, polygon, etc.`,
       );
       return { data: [], setAt: Date.now() };
@@ -291,7 +350,7 @@ export class BirdeyeService extends Service {
 
     const byKey = new Map<string, IToken>();
     for (const t of fetched) {
-      const key = t.address?.toLowerCase?.() || `${t.chain}:${t.rank}`;
+      const key = t.address.toLowerCase() || `${t.chain}:${t.rank}`;
       if (!byKey.has(key)) {
         byKey.set(key, t);
       }
@@ -303,7 +362,7 @@ export class BirdeyeService extends Service {
     try {
       await this.runtime.setCache<CacheWrapper<IToken[]>>(cacheKey, output);
     } catch (e) {
-      this.runtime.logger?.warn(
+      this.runtime.logger.warn(
         `setCache failed for ${chain}: ${e instanceof Error ? e.message : String(e)}`,
       );
     }
@@ -330,15 +389,17 @@ export class BirdeyeService extends Service {
 
       return out;
     } catch (error) {
-      this.runtime.logger?.error(
+      this.runtime.logger.error(
         `Failed to sync trending tokens: ${error instanceof Error ? error.message : String(error)}`,
       );
       throw error;
     }
   }
 
-  // FIXME: add chain param
-  async getTokenMarketData(tokenAddress: string): Promise<
+  async getTokenMarketData(
+    tokenAddress: string,
+    chain = "solana",
+  ): Promise<
     | {
         price: number;
         marketCap: number;
@@ -356,15 +417,15 @@ export class BirdeyeService extends Service {
       const [response, volResponse, priceHistoryResponse] = await Promise.all([
         fetch(
           `${this.birdeyeUrl("defi/v3/token/market-data")}?address=${tokenAddress}`,
-          this.getBirdeyeFetchOptions(),
+          this.getBirdeyeFetchOptions(chain),
         ),
         fetch(
           `${this.birdeyeUrl("defi/price_volume/single")}?address=${tokenAddress}&type=24h`,
-          this.getBirdeyeFetchOptions(),
+          this.getBirdeyeFetchOptions(chain),
         ),
         fetch(
           `${this.birdeyeUrl("defi/history_price")}?address=${tokenAddress}&address_type=token&type=15m`,
-          this.getBirdeyeFetchOptions(),
+          this.getBirdeyeFetchOptions(chain),
         ),
       ]);
 
@@ -415,8 +476,8 @@ export class BirdeyeService extends Service {
   // has a lot of data
 
   /*
-  async getTokensTradeData(chain: string, tokenAddresses: string[]): Promise<any> {
-    const tokenDb: Record<string, any> = {};
+  async getTokensTradeData(chain: string, tokenAddresses: string[]): Promise<unknown> {
+    const tokenDb: Record<string, unknown> = {};
     const chunkArray = (arr: string[], size: number) =>
       arr.map((_, i) => (i % size === 0 ? arr.slice(i, i + size) : null)).filter(Boolean);
     const twenties = chunkArray(tokenAddresses, 20);
@@ -437,14 +498,16 @@ export class BirdeyeService extends Service {
     tokenAddress: string,
     frames = "2h,8h,24h",
     options: GetCacheTimedOptions = {},
-  ): Promise<unknown> {
+  ): Promise<TokenTradeDataSingleResponse | false> {
     const key = `birdeye_tokenTradeData_${chain}_${tokenAddress}_${frames}`;
     const tsInMs = options.tsInMs ?? CACHE_DEFAULTS.TOKEN_TRADE_DATA_TTL;
     const notOlderThan =
       options.notOlderThan ?? CACHE_DEFAULTS.TOKEN_TRADE_DATA_TTL;
 
     // Check cache
-    const cached = await this.getCacheTimed<unknown>(key, { notOlderThan });
+    const cached = await this.getCacheTimed<TokenTradeDataSingleResponse>(key, {
+      notOlderThan,
+    });
     if (cached) {
       return cached;
     }
@@ -455,13 +518,13 @@ export class BirdeyeService extends Service {
         `${this.birdeyeUrl("defi/v3/token/trade-data/single")}?address=${tokenAddress}&frames=${frames}`,
         this.getBirdeyeFetchOptions(chain),
       );
-      const data = await resp.json();
+      const data = (await resp.json()) as TokenTradeDataSingleResponse;
       if (data) {
         this.setCacheTimed(key, data, tsInMs);
       }
       return data;
     } catch (e) {
-      this.runtime.logger?.error(
+      this.runtime.logger.error(
         `birdeye:getTokenTradeData - ${e instanceof Error ? e.message : String(e)}`,
       );
       return false;
@@ -472,8 +535,8 @@ export class BirdeyeService extends Service {
   // https://public-api.birdeye.so/defi/price_volume/multi
   // getting 500s
   /*
-  async getTokensPriceVolume(tokenAddresses: string[], type = '24h'): Promise<any> {
-    const tokenDb: Record<string, any> = {};
+  async getTokensPriceVolume(tokenAddresses: string[], type = '24h'): Promise<unknown> {
+    const tokenDb: Record<string, unknown> = {};
     const chunkArray = (arr: string[], size: number) =>
       arr.map((_, i) => (i % size === 0 ? arr.slice(i, i + size) : null)).filter(Boolean);
     const fities = chunkArray(tokenAddresses, 50);
@@ -509,31 +572,60 @@ export class BirdeyeService extends Service {
   // [Defi] Price - Multiple max 100 (all)
   // https://public-api.birdeye.so/defi/multi_price
   // Batch CU Cost = N^0.8 × 5 (base cost of a single call) (n_max: 100)
-  // FIXME: caching
   async getTokensMarketData(
     chain: string,
     tokenAddresses: string[],
-  ): Promise<Record<string, IToken | undefined>> {
-    const tokenDb: Record<string, IToken | undefined> = {};
+    options: GetCacheTimedOptions = {},
+  ): Promise<Record<string, BirdeyeTokenMarketSnapshot | undefined>> {
+    const tokenDb: Record<string, BirdeyeTokenMarketSnapshot | undefined> = {};
+    const notOlderThan =
+      options.notOlderThan ?? CACHE_DEFAULTS.TOKEN_MARKET_DATA_TTL;
+    const tsInMs = options.tsInMs ?? Date.now();
+    const cacheKeyFor = (address: string) =>
+      `birdeye_tokens_${chain}_${address}`;
 
     // Initialize all token addresses as undefined so we know they were checked
     for (const ca of tokenAddresses) {
       tokenDb[ca] = undefined;
     }
 
-    //console.log('beSrv:getTokensMarketData chain', chain, 'tokenAddresses', tokenAddresses)
+    try {
+      const cacheEntries = await Promise.all(
+        tokenAddresses.map(async (address) => {
+          const wrapper = await this.runtime.getCache<
+            CacheWrapper<BirdeyeTokenMarketSnapshot | undefined>
+          >(cacheKeyFor(address));
+          if (!wrapper) {
+            return { address, cached: false, data: undefined };
+          }
+          const isFresh = Date.now() - wrapper.setAt <= notOlderThan;
+          return {
+            address,
+            cached: isFresh,
+            data: isFresh ? wrapper.data : undefined,
+          };
+        }),
+      );
+
+      const uncachedAddresses: string[] = [];
+      for (const entry of cacheEntries) {
+        if (entry.cached) {
+          tokenDb[entry.address] = entry.data;
+        } else {
+          uncachedAddresses.push(entry.address);
+        }
+      }
 
-    // no real cache because pricing
-    // 1-60s cache might have some benefits tho
-    // usually called only once every sell signal (1m atm)
+      if (!uncachedAddresses.length) {
+        return tokenDb;
+      }
 
-    try {
-      const chunkArray = (arr: string[], size: number) =>
+      const chunkArray = (arr: string[], size: number): string[][] =>
         arr
           .map((_, i) => (i % size === 0 ? arr.slice(i, i + size) : null))
-          .filter(Boolean);
+          .filter((chunk): chunk is string[] => chunk !== null);
 
-      const hundos = chunkArray(tokenAddresses, 100);
+      const hundos = chunkArray(uncachedAddresses, 100);
       //console.log('getTokensMarketData hundos', hundos)
 
       // Track batches with their addresses for cache management
@@ -560,7 +652,9 @@ export class BirdeyeService extends Service {
         batchesWithAddresses.map((b) => b.promise),
       );
       const multipriceData = await Promise.all(
-        multipriceResps.map((resp) => resp.json()),
+        multipriceResps.map(
+          (resp) => resp.json() as Promise<BirdeyeMultiPriceResponse>,
+        ),
       );
 
       //const now = Date.now()
@@ -571,16 +665,16 @@ export class BirdeyeService extends Service {
 
         // Guard against undefined/null mpd or missing data
         if (!mpd?.data || !mpd.success) {
-          this.runtime.logger?.warn(
+          this.runtime.logger.warn(
             `birdeye:getTokensMarketData - batch failed (${batchAddresses.length} addresses), caching all as failed`,
           );
 
-          // Cache all addresses in this failed batch
           for (const ca of batchAddresses) {
-            await this.runtime.setCache(`birdeye_tokens_solana_${ca}`, {
+            await this.runtime.setCache<
+              CacheWrapper<BirdeyeTokenMarketSnapshot | undefined>
+            >(cacheKeyFor(ca), {
               data: undefined,
-              setAt: Date.now(),
-              ttl: 5 * 60 * 1000, // 5 minutes for failed batch lookups
+              setAt: tsInMs,
             });
           }
           continue;
@@ -590,7 +684,7 @@ export class BirdeyeService extends Service {
         for (const ca of batchAddresses) {
           const t = mpd.data[ca];
 
-          if (t) {
+          if (t && typeof t.value === "number") {
             /*
             t {
               isScaledUiToken: false,
@@ -602,36 +696,43 @@ export class BirdeyeService extends Service {
               liquidity: 1323844.6216610295,
             }
             */
-            tokenDb[ca] = {
+            const marketSnapshot: BirdeyeTokenMarketSnapshot = {
               //provider: 'birdeye',
               //chain: 'solana',
               //address: ca,
               priceUsd: t.value,
               priceSol: t.priceInNative,
-              liquidity: t.liquidity,
-              priceChange24h: t.priceChange24h,
-              //marketcap
+              liquidity: t.liquidity ?? 0,
+              priceChange24h: t.priceChange24h ?? 0,
+              marketCapUsd: firstFiniteNumber(
+                t.market_cap,
+                t.marketcap,
+                t.mc,
+                t.realMc,
+              ),
               //volume24hUSD
             };
-            const test: IToken = tokenDb[ca];
-            this.runtime.logger?.debug(
+            tokenDb[ca] = marketSnapshot;
+            this.runtime.logger.debug(
               `birdeye:getTokensMarketData - caching token ${ca}`,
             );
             // Cache successful lookups with full TTL
-            await this.runtime.setCache<IToken>(
-              `birdeye_tokens_solana_${ca}`,
-              test,
-            );
+            await this.runtime.setCache<
+              CacheWrapper<BirdeyeTokenMarketSnapshot>
+            >(cacheKeyFor(ca), {
+              data: marketSnapshot,
+              setAt: tsInMs,
+            });
           } else {
             // Token was in batch but has no valid data (or not in response)
-            this.runtime.logger?.warn(
+            this.runtime.logger.warn(
               `${ca} no valid data in response: ${JSON.stringify(t)}`,
             );
-            // Cache failed lookups with shorter TTL to avoid re-fetching bad addresses
-            await this.runtime.setCache(`birdeye_tokens_solana_${ca}`, {
+            await this.runtime.setCache<
+              CacheWrapper<BirdeyeTokenMarketSnapshot | undefined>
+            >(cacheKeyFor(ca), {
               data: undefined,
-              setAt: Date.now(),
-              ttl: 5 * 60 * 1000, // 5 minutes for failed lookups
+              setAt: tsInMs,
             });
           }
         }
@@ -653,14 +754,16 @@ export class BirdeyeService extends Service {
     chain: string,
     tokenAddress: string,
     options: GetCacheTimedOptions = {},
-  ): Promise<unknown> {
+  ): Promise<TokenSecurityResponse | false> {
     const key = `birdeye_tokenSecurityData_${chain}_${tokenAddress}`;
     const tsInMs = options.tsInMs ?? CACHE_DEFAULTS.TOKEN_SECURITY_DATA_TTL;
     const notOlderThan =
       options.notOlderThan ?? CACHE_DEFAULTS.TOKEN_SECURITY_DATA_TTL;
 
     // Check cache
-    const cached = await this.getCacheTimed<unknown>(key, { notOlderThan });
+    const cached = await this.getCacheTimed<TokenSecurityResponse>(key, {
+      notOlderThan,
+    });
     if (cached) {
       return cached;
     }
@@ -671,13 +774,13 @@ export class BirdeyeService extends Service {
         `${this.birdeyeUrl("defi/token_security")}?address=${tokenAddress}`,
         this.getBirdeyeFetchOptions(chain),
       );
-      const data = await resp.json();
+      const data = (await resp.json()) as TokenSecurityResponse;
       if (data) {
         this.setCacheTimed(key, data, tsInMs);
       }
       return data;
     } catch (e) {
-      this.runtime.logger?.error(
+      this.runtime.logger.error(
         `birdeye:getTokenSecurityData - ${e instanceof Error ? e.message : String(e)}`,
       );
       return false;
@@ -696,14 +799,16 @@ export class BirdeyeService extends Service {
     chain: string,
     ca: string,
     options: GetCacheTimedOptions = {},
-  ) {
+  ): Promise<BirdeyeTokenMarketSnapshot | undefined> {
     try {
       const key = `birdeye_token_${chain}_${ca}`;
       const tsInMs = options.tsInMs ?? Date.now(); // only syscall if absolutely needed
       const notOlderThan = options.notOlderThan ?? 30 * 1000; // a reasonable length (in ms)
 
       // check cache
-      const cache = await this.getCacheTimed<unknown>(key, { notOlderThan });
+      const cache = await this.getCacheTimed<BirdeyeTokenMarketSnapshot>(key, {
+        notOlderThan,
+      });
       if (cache) {
         this.runtime.logger.debug("birdeye:lookupToken - HIT");
         return cache;
@@ -718,7 +823,7 @@ export class BirdeyeService extends Service {
 
       return data;
     } catch (e) {
-      this.runtime.logger?.error(
+      this.runtime.logger.error(
         `birdeyeSvr:lookupToken - err: ${e instanceof Error ? e.message : String(e)}`,
       );
       throw e;
@@ -728,7 +833,7 @@ export class BirdeyeService extends Service {
   async lookupTokens(
     chainAndAddresses: Array<{ chain: string; address: string }>,
     options: GetCacheTimedOptions = {},
-  ) {
+  ): Promise<Record<string, BirdeyeTokenMarketSnapshot | undefined>> {
     try {
       // Lookup all tokens in parallel
       const results = await Promise.all(
@@ -738,7 +843,10 @@ export class BirdeyeService extends Service {
       );
 
       // Transform results into keyed object: key = `${chain}_${address}`
-      const keyedResults: Record<string, unknown> = {};
+      const keyedResults: Record<
+        string,
+        BirdeyeTokenMarketSnapshot | undefined
+      > = {};
       chainAndAddresses.forEach((cAA, index) => {
         const key = `${cAA.chain}_${cAA.address}`;
         keyedResults[key] = results[index];
@@ -746,7 +854,7 @@ export class BirdeyeService extends Service {
 
       return keyedResults;
     } catch (e) {
-      this.runtime.logger?.error(
+      this.runtime.logger.error(
         `birdeyeSvr:lookupTokens - err: ${e instanceof Error ? e.message : String(e)}`,
       );
       throw e;
@@ -757,28 +865,30 @@ export class BirdeyeService extends Service {
     chain: string,
     _params: unknown,
     _options: GetCacheTimedOptions = {},
-  ) {
+  ): Promise<TokenMarketSearchResponse> {
     const birdeyeFetchOptions: RequestInit = this.getBirdeyeFetchOptions(chain);
     const res = await fetch(
       `${this.birdeyeUrl("defi/v3/search")}`,
       birdeyeFetchOptions,
     );
-    const resp = await res.json();
-    this.runtime.logger.log("resp", resp);
+    const resp = (await res.json()) as TokenMarketSearchResponse;
+    this.runtime.logger.log("resp", JSON.stringify(resp));
     return resp;
   }
 
   async lookupSymbolAllChains(
     symbol: string,
     options: GetCacheTimedOptions = {},
-  ) {
+  ): Promise<TokenMarketSearchResponse["data"]["items"] | false> {
     // set up cache
     const key = `birdeye_symbol_${symbol}`;
     const tsInMs = options.tsInMs ?? Date.now();
     const notOlderThan = options.notOlderThan ?? 30 * 1000;
 
     // check cache
-    const cache = await this.getCacheTimed<unknown>(key, { notOlderThan });
+    const cache = await this.getCacheTimed<
+      TokenMarketSearchResponse["data"]["items"]
+    >(key, { notOlderThan });
     if (cache) {
       return cache;
     }
@@ -789,7 +899,7 @@ export class BirdeyeService extends Service {
       `${this.birdeyeUrl("defi/v3/search")}?chain=all&target=token&keyword=${encodeURIComponent(symbol)}`,
       birdeyeFetchOptions,
     );
-    const resp = await res.json();
+    const resp = (await res.json()) as TokenMarketSearchResponse;
     const data = resp.data.items;
     if (data) {
       this.setCacheTimed(key, data, tsInMs);
@@ -801,7 +911,7 @@ export class BirdeyeService extends Service {
     chain: BirdeyeSupportedChain,
     publicKey: string,
     options: GetCacheTimedOptions = {},
-  ) {
+  ): Promise<WalletPortfolioResponse["data"] | false> {
     // Get entire portfolio
     // set up cache
     const key = `birdeye_walletTokenList_${chain}_${publicKey}`;
@@ -809,7 +919,10 @@ export class BirdeyeService extends Service {
     const notOlderThan = options.notOlderThan ?? 30 * 1000;
 
     // check cache
-    const cache = await this.getCacheTimed<unknown>(key, { notOlderThan });
+    const cache = await this.getCacheTimed<WalletPortfolioResponse["data"]>(
+      key,
+      { notOlderThan },
+    );
     if (cache) {
       return cache;
     }
@@ -820,8 +933,8 @@ export class BirdeyeService extends Service {
       birdeyeFetchOptions,
     );
 
-    const resp = await res.json();
-    const data = resp?.data;
+    const resp = (await res.json()) as WalletPortfolioResponse;
+    const data = resp.data;
     if (data) {
       this.setCacheTimed(key, data, tsInMs);
     }
@@ -832,14 +945,16 @@ export class BirdeyeService extends Service {
     chain: BirdeyeSupportedChain,
     publicKey: string,
     options: GetCacheTimedOptions = {},
-  ) {
+  ): Promise<WalletTransaction[] | false> {
     // set up cache
     const key = `birdeye_walletTxList_${chain}_${publicKey}`;
     const tsInMs = options.tsInMs ?? Date.now();
     const notOlderThan = options.notOlderThan ?? 30 * 1000;
 
     // check cache
-    const cache = await this.getCacheTimed<unknown>(key, { notOlderThan });
+    const cache = await this.getCacheTimed<WalletTransaction[]>(key, {
+      notOlderThan,
+    });
     if (cache) {
       return cache;
     }
@@ -849,8 +964,8 @@ export class BirdeyeService extends Service {
       `${this.birdeyeUrl("v1/wallet/tx_list")}?wallet=${publicKey}&limit=100`,
       birdeyeFetchOptions,
     );
-    const resp = await res.json();
-    const data = resp?.data?.[chain] || [];
+    const resp = (await res.json()) as WalletTransactionHistoryResponse;
+    const data = resp.data[chain] || [];
     if (data) {
       this.setCacheTimed(key, data, tsInMs);
     }
@@ -881,7 +996,7 @@ export class BirdeyeService extends Service {
           const birdeye = new Birdeye(runtime);
           runtime.registerTaskWorker({
             name: "BIRDEYE_SYNC_WALLET",
-            validate: async () => true,
+            shouldRun: async () => true,
             execute: async (rt) => {
               try {
                 await birdeye.syncWallet();
@@ -928,7 +1043,7 @@ export class BirdeyeService extends Service {
           !infoService ||
           typeof infoService.registerDataProvder !== "function"
         ) {
-          runtime.logger?.debug(
+          runtime.logger.debug(
             "INTEL_DATAPROVIDER service not available, skipping Birdeye data provider registration",
           );
           return;
@@ -939,12 +1054,12 @@ export class BirdeyeService extends Service {
           trendingService: BIRDEYE_SERVICE_NAME,
           lookupService: BIRDEYE_SERVICE_NAME,
         });
-        runtime.logger?.log(
+        runtime.logger.log(
           "Birdeye data provider registered with INTEL_DATAPROVIDER",
         );
       })
       .catch((e) => {
-        runtime.logger?.debug(
+        runtime.logger.debug(
           `Birdeye service load failed; skipping data provider registration: ${e instanceof Error ? e.message : String(e)}`,
         );
       });
@@ -963,7 +1078,7 @@ export class BirdeyeService extends Service {
   }
 
   async stop(): Promise<void> {
-    this.runtime.logger?.log("BirdEye service shutdown");
+    this.runtime.logger.log("BirdEye service shutdown");
   }
 
   async getCacheTimed<T>(key: string, options: GetCacheTimedOptions = {}) {