@elizaos/plugin-wallet 2.0.0-beta.1

package/src/analytics/birdeye/providers/portfolio-factory.ts

@@ -0,0 +1,252 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import type { IAgentRuntime, Memory, Provider, State } from "@elizaos/core";
+import { BIRDEYE_SERVICE_NAME } from "../constants";
+import type { WalletPortfolioResponse } from "../types/api/wallet";
+import { extractChain, formatJsonScalar, formatJsonTable } from "../utils";
+
+type PortfolioService = {
+  fetchWalletTokenList?: (
+    chain: unknown,
+    walletAddr: string,
+    opts: { notOlderThan: number },
+  ) => Promise<unknown>;
+  fetchWalletTxList?: (
+    chain: unknown,
+    walletAddr: string,
+    opts: { notOlderThan: number },
+  ) => Promise<unknown[]>;
+};
+
+export interface BirdeyePortfolioProviderOptions {
+  name: string;
+  description: string;
+  descriptionCompressed: string;
+  includeTrades?: boolean;
+}
+
+function statusJson(name: string, status: string, reason: string): string {
+  return [
+    `${name}:`,
+    `  status: ${formatJsonScalar(status)}`,
+    `  reason: ${formatJsonScalar(reason)}`,
+  ].join("\n");
+}
+
+function normalizePortfolioResponse(response: unknown) {
+  if (response?.data?.items) {
+    return response.data;
+  }
+  return response ?? {};
+}
+
+export const formatPortfolio = (response: WalletPortfolioResponse) => {
+  const portfolio = normalizePortfolioResponse(response);
+  const items = portfolio.items ?? [];
+  if (!items.length) return "holdings[0]: []";
+
+  return formatJsonTable(
+    "holdings",
+    items.map((item) => ({
+      symbol: item.symbol || "unknown",
+      address: item.address || "unknown",
+      amount:
+        typeof item.uiAmount === "number"
+          ? Number(item.uiAmount.toFixed(4))
+          : "unknown",
+      priceUsd:
+        typeof item.priceUsd === "number"
+          ? Number(item.priceUsd.toFixed(6))
+          : "unknown",
+      valueUsd:
+        typeof item.valueUsd === "number"
+          ? Number(item.valueUsd.toFixed(2))
+          : "unknown",
+      chainId: item.chainId || "unknown",
+    })),
+    ["symbol", "address", "amount", "priceUsd", "valueUsd", "chainId"],
+  );
+};
+
+function formatPortfolioProviderText({
+  wallet,
+  chain,
+  portfolio,
+  trades,
+}: {
+  wallet: string;
+  chain: string;
+  portfolio: unknown;
+  trades?: unknown[];
+}): string {
+  const normalized = normalizePortfolioResponse(portfolio);
+  const holdings = normalized.items ?? [];
+  const lines = [
+    "birdeye_wallet_portfolio:",
+    "  status: ok",
+    `  wallet: ${formatJsonScalar(normalized.wallet ?? wallet)}`,
+    `  chain: ${formatJsonScalar(chain)}`,
+    `  totalUsd: ${formatJsonScalar(normalized.totalUsd ?? 0)}`,
+    formatJsonTable(
+      "  holdings",
+      holdings.slice(0, 20).map((item) => ({
+        symbol: item.symbol || "unknown",
+        address: item.address || "unknown",
+        amount:
+          typeof item.uiAmount === "number"
+            ? Number(item.uiAmount.toFixed(4))
+            : "unknown",
+        priceUsd:
+          typeof item.priceUsd === "number"
+            ? Number(item.priceUsd.toFixed(6))
+            : "unknown",
+        valueUsd:
+          typeof item.valueUsd === "number"
+            ? Number(item.valueUsd.toFixed(2))
+            : "unknown",
+        chainId: item.chainId || "unknown",
+      })),
+      ["symbol", "address", "amount", "priceUsd", "valueUsd", "chainId"],
+    ),
+  ];
+
+  if (trades) {
+    lines.push(`  tradeCount: ${trades.length}`);
+    lines.push(
+      formatJsonTable(
+        "  trades",
+        trades.slice(0, 10).map((trade) => ({
+          txHash: trade.txHash ?? "unknown",
+          action: trade.mainAction ?? "unknown",
+          status: trade.status ?? "unknown",
+          blockTime: trade.blockTime ?? "unknown",
+          from: trade.from ?? "unknown",
+          to: trade.to ?? "unknown",
+        })),
+        ["txHash", "action", "status", "blockTime", "from", "to"],
+      ),
+    );
+  }
+
+  return lines.join("\n");
+}
+
+function getPortfolioService(
+  runtime: IAgentRuntime,
+  includeTrades: boolean,
+): PortfolioService | undefined {
+  const beService = runtime.getService(BIRDEYE_SERVICE_NAME) as
+    | PortfolioService
+    | undefined;
+  if (!beService || typeof beService.fetchWalletTokenList !== "function") {
+    return undefined;
+  }
+  if (includeTrades && typeof beService.fetchWalletTxList !== "function") {
+    return undefined;
+  }
+  return beService;
+}
+
+export function createBirdeyePortfolioProvider(
+  options: BirdeyePortfolioProviderOptions,
+): Provider {
+  const includeTrades = options.includeTrades ?? false;
+  return {
+    name: options.name,
+    description: options.description,
+    descriptionCompressed: options.descriptionCompressed,
+    dynamic: true,
+    contexts: ["finance", "crypto", "wallet"],
+    contextGate: { anyOf: ["finance", "crypto", "wallet"] },
+    cacheStable: false,
+    cacheScope: "turn",
+    roleGate: { minRole: "OWNER" },
+    get: async (runtime: IAgentRuntime, _message: Memory, _state?: State) => {
+      try {
+        const walletAddr = runtime.getSetting("BIRDEYE_WALLET_ADDR");
+        if (!walletAddr) {
+          runtime.logger?.error(
+            "BIRDEYE_WALLET_ADDR setting is not configured",
+          );
+          return {
+            values: {},
+            text: statusJson(
+              "birdeye_wallet_portfolio",
+              "error",
+              "missing BIRDEYE_WALLET_ADDR",
+            ),
+            data: {},
+          };
+        }
+
+        const explicitChain = runtime.getSetting("BIRDEYE_CHAIN");
+        const chain = extractChain(walletAddr, explicitChain);
+        const beService = getPortfolioService(runtime, includeTrades);
+        if (!beService) {
+          runtime.logger?.error(
+            "Birdeye service is unavailable or missing required portfolio methods",
+          );
+          return {
+            values: {},
+            text: statusJson(
+              "birdeye_wallet_portfolio",
+              "unavailable",
+              includeTrades
+                ? "missing fetchWalletTokenList or fetchWalletTxList"
+                : "missing fetchWalletTokenList",
+            ),
+            data: {},
+          };
+        }
+
+        const portfolioPromise = beService.fetchWalletTokenList(
+          chain,
+          walletAddr,
+          { notOlderThan: 30 * 1000 },
+        );
+        const tradesPromise = includeTrades
+          ? beService.fetchWalletTxList(chain, walletAddr, {
+              notOlderThan: 30 * 1000,
+            })
+          : Promise.resolve(undefined);
+        const [portfolio, trades] = await Promise.all([
+          portfolioPromise,
+          tradesPromise,
+        ]);
+
+        return {
+          data: includeTrades ? { portfolio, trades } : portfolio,
+          values: {},
+          text: formatPortfolioProviderText({
+            wallet: walletAddr,
+            chain,
+            portfolio,
+            trades,
+          }),
+        };
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        runtime.logger?.error(
+          `Error fetching Birdeye portfolio: ${errorMessage}`,
+        );
+
+        const isConfigError =
+          errorMessage.includes("BIRDEYE_CHAIN") ||
+          errorMessage.includes("address") ||
+          errorMessage.includes("Invalid");
+
+        return {
+          values: {},
+          text: statusJson(
+            "birdeye_wallet_portfolio",
+            "error",
+            isConfigError
+              ? errorMessage
+              : "unable to fetch wallet portfolio data",
+          ),
+          data: {},
+        };
+      }
+    },
+  };
+}

package/src/analytics/birdeye/providers/trending.ts

@@ -0,0 +1,365 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import type { IAgentRuntime, Memory, Provider, State } from "@elizaos/core";
+import { formatJsonScalar, formatJsonTable } from "../utils";
+
+const TRENDING_ROW_LIMIT = 18;
+
+interface TrendingToken {
+  address: string;
+  symbol: string;
+  price: number;
+  volume24hUSD: number;
+  price24hChangePercent: number;
+  liquidity: number;
+}
+
+export async function getCacheTimed<T>(
+  runtime: IAgentRuntime,
+  key: string,
+  options: { notOlderThan?: number } = {},
+): Promise<T | false> {
+  const wrapper = await runtime.getCache<{ data: T; setAt: number }>(key);
+  if (!wrapper) return false;
+  if (options.notOlderThan) {
+    const diff = Date.now() - wrapper.setAt;
+    //console.log('checking notOlderThan', diff + 'ms', 'setAt', wrapper.setAt, 'asking', options.notOlderThan)
+    if (diff > options.notOlderThan) {
+      // no data
+      return false;
+    }
+  }
+  // return data
+  return wrapper.data;
+}
+
+/**
+ * Provider for Birdeye trending coins
+ *
+ * @typedef {import('./Provider').Provider} Provider
+ * @typedef {import('./Runtime').IAgentRuntime} IAgentRuntime
+ * @typedef {import('./Memory').Memory} Memory
+ * @typedef {import('./State').State} State
+ * @typedef {import('./Action').Action} Action
+ *
+ * @type {Provider}
+ * @property {string} name - The name of the provider
+ * @property {string} description - Description of the provider
+ * @property {number} position - The position of the provider
+ * @property {Function} get - Asynchronous function to get actions that validate for a given message
+ *
+ * @param {IAgentRuntime} runtime - The agent runtime
+ * @param {Memory} message - The message memory
+ * @param {State} state - The state of the agent
+ * @returns {Object} Object containing data, values, and text related to actions
+ */
+export const trendingProvider: Provider = {
+  name: "BIRDEYE_TRENDING_CRYPTOCURRENCY",
+  description: "Birdeye's trending cryptocurrencies",
+  descriptionCompressed: "Read Birdeye trending cryptocurrency tokens.",
+  dynamic: true,
+  contexts: ["finance", "crypto", "wallet"],
+  contextGate: { anyOf: ["finance", "crypto", "wallet"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  roleGate: { minRole: "USER" },
+  //position: -1,
+  get: async (runtime: IAgentRuntime, _message: Memory, _state: State) => {
+    try {
+      runtime.logger?.log("birdeye:provider:trending - get birdeye");
+      // Get all sentiments
+
+      /*
+      const chains = ['solana', 'eth', 'base'];
+      const tokenData = []
+      for(const chain of chains) {
+        tokenData = [...tokenData, ...(await runtime.getCache<IToken[]>('tokens_' + chain)) || []];
+      }
+      console.log('tokenData', tokenData)
+      */
+      const solanaCache = await runtime.getCache<{
+        data: TrendingToken[];
+        setAt: number;
+      }>("tokens_v2_solana");
+      if (!solanaCache?.data) {
+        runtime.logger?.warn(
+          "birdeye:provider:trending - no birdeye token data found",
+        );
+        return {
+          values: {},
+          text: [
+            "birdeye_trending_tokens:",
+            "  status: empty",
+            "  reason: no cached Solana trending token data",
+          ].join("\n"),
+          data: {},
+        };
+      }
+      const solanaTokens = solanaCache.data;
+      //console.log('intel:provider - birdeye data', tokens)
+      if (!solanaTokens.length) {
+        runtime.logger?.warn(
+          "birdeye:provider:trending - no birdeye token data found",
+        );
+        return {
+          values: {},
+          text: [
+            "birdeye_trending_tokens:",
+            "  status: empty",
+            "  reason: no Solana trending tokens",
+          ].join("\n"),
+          data: {},
+        };
+      }
+
+      //console.log('birdeye:provider:trending - birdeye token data', tokens)
+      /*
+      name: "Bitcoin",
+      rank: 1,
+      chain: "L1",
+      price: 93768.60351119141,
+      symbol: "BTC",
+      address: "bitcoin",
+      logoURI: "https://s2.coinmarketcap.com/static/img/coins/128x128/1.png",
+      decimals: null,
+      provider: "coinmarketcap",
+      liquidity: null,
+      marketcap: 0,
+      last_updated: "2025-04-23T22:50:00.000Z",
+      volume24hUSD: 43588891208.92652,
+      price24hChangePercent: 1.17760374,
+      */
+
+      const rows = [];
+
+      const solanaService = runtime.getService("chain_solana") as
+        | {
+            getSupply?: (addresses: string[]) => Promise<
+              Record<
+                string,
+                {
+                  human?: {
+                    multipliedBy: (n: number) => {
+                      toFixed: (p: number) => string;
+                    };
+                  };
+                }
+              >
+            >;
+          }
+        | undefined;
+      if (!solanaService) {
+        runtime.logger?.warn(
+          "no chain_solana service found - market cap calculation will be skipped for Solana tokens",
+        );
+      }
+
+      const topSolanaTokens = solanaTokens.slice(0, 33);
+      let tokens = [...topSolanaTokens];
+
+      // Try to get supply data if solanaService is available
+      let supplies: Record<
+        string,
+        {
+          human?: {
+            multipliedBy: (n: number) => { toFixed: (p: number) => string };
+          };
+        }
+      > = {};
+      if (solanaService) {
+        try {
+          const CAs = topSolanaTokens.map((t) => t.address);
+          supplies = await solanaService.getSupply(CAs);
+        } catch (error) {
+          runtime.logger?.warn(
+            `Failed to get supply data from Solana service: ${error instanceof Error ? error.message : String(error)}`,
+          );
+        }
+      }
+
+      for (const token of topSolanaTokens) {
+        // has a marketcap but seems to always be 0
+        //console.log('token', token)
+        const rugKey = `rugcheck_solana_${token.address}`;
+        const rugCache = await getCacheTimed(runtime, rugKey, {
+          notOlderThan: 6 * 60 * 60 * 1000,
+        });
+        //console.log('rugKey', rugKey, 'rugCache', rugCache)
+
+        // Damnatio memoriae
+        if (rugCache && rugCache === "rug") {
+          runtime.logger?.log("omitting", token.address, "because in rugCache");
+          continue;
+        }
+
+        // Calculate market cap if supply data is available
+        let mcapValue = "?";
+        if (supplies[token.address]?.human) {
+          const supply = supplies[token.address].human;
+          const mcap = supply.multipliedBy(token.price);
+          mcapValue = mcap.toFixed(0);
+          //console.log('Hum supply', supply.toFormat(), 'price', token.price, 'mcap', mcap.toFormat(2))
+          //console.log('Mac supply', supply, 'price', token.price, 'mcap', mcap.toFixed(0))
+        }
+
+        rows.push({
+          chain: "solana",
+          address: token.address,
+          symbol: token.symbol,
+          priceUsd: token.price.toFixed(4),
+          marketCapUsd: mcapValue,
+          volume24hUsd: token.volume24hUSD.toFixed(0),
+          change24hPct: token.price24hChangePercent.toFixed(2),
+          liquidityUsd: token.liquidity.toFixed(2),
+        });
+      }
+      // if in cache, then it's a lot of data, maybe too much
+      const ethCache = await runtime.getCache<{
+        data: TrendingToken[];
+        setAt: number;
+      }>("tokens_v2_ethereum");
+      if (ethCache?.data) {
+        const ethTokens = ethCache.data.slice(0, 33);
+        tokens = [...tokens, ...ethTokens];
+        for (const token of ethTokens) {
+          // has a marketcap but seems to always be 0
+          //console.log('token', token)
+          /*
+          const rugKey = 'rugcheck_eth_' + token.address
+          const rugCache = await getCacheTimed(runtime, rugKey, { notOlderThan: 6 * 60 * 60 * 1000 })
+          //console.log('rugKey', rugKey, 'rugCache', rugCache)
+
+          // Damnatio memoriae
+          if (rugCache && rugCache === 'rug') {
+            console.log('omitting', token.address, 'because in rugCache')
+            continue
+          }
+          */
+          rows.push({
+            chain: "ethereum",
+            address: token.address,
+            symbol: token.symbol,
+            priceUsd: token.price?.toFixed(4) || "0",
+            marketCapUsd: "unknown",
+            volume24hUsd: token.volume24hUSD?.toFixed(0) || "0",
+            change24hPct: token.price24hChangePercent?.toFixed(2) || "0",
+            liquidityUsd: token.liquidity?.toFixed(2) || "0",
+          });
+        }
+      }
+      const baseCache = await runtime.getCache<{
+        data: TrendingToken[];
+        setAt: number;
+      }>("tokens_v2_base");
+      if (baseCache?.data) {
+        const baseTokens = baseCache.data.slice(0, 33);
+        tokens = [...tokens, ...baseTokens];
+        for (const token of baseTokens) {
+          // has a marketcap but seems to always be 0
+          //console.log('token', token)
+          /*
+          const rugKey = 'rugcheck_eth_' + token.address
+          const rugCache = await getCacheTimed(runtime, rugKey, { notOlderThan: 6 * 60 * 60 * 1000 })
+          //console.log('rugKey', rugKey, 'rugCache', rugCache)
+
+          // Damnatio memoriae
+          if (rugCache && rugCache === 'rug') {
+            console.log('omitting', token.address, 'because in rugCache')
+            continue
+          }
+          */
+          rows.push({
+            chain: "base",
+            address: token.address,
+            symbol: token.symbol,
+            priceUsd: token.price?.toFixed(4) || "0",
+            marketCapUsd: "unknown",
+            volume24hUsd: token.volume24hUSD?.toFixed(0) || "0",
+            change24hPct: token.price24hChangePercent?.toFixed(2) || "0",
+            liquidityUsd: token.liquidity?.toFixed(2) || "0",
+          });
+        }
+      }
+
+      /*
+      let idx = 1;
+      // maybe filter by active chains
+      const reduceTokens = tokens.map((t) => {
+        const obj = {
+          name: t.name,
+          rank: t.rank,
+          chain: t.chain,
+          priceUsd: t.price,
+          symbol: t.symbol,
+          address: t.address,
+          // skip logo, decimals
+          // liquidity/marketcap are optimal
+          // last_updated
+          volume24hUSD: t.volume24hUSD,
+          price24hChangePercent: t.price24hChangePercent,
+        };
+        // optional fields
+        if (t.liquidity !== null) obj.liquidity = t.liquidity;
+        if (t.marketcap !== 0) obj.marketcap = t.marketcap;
+        return obj;
+      });
+      */
+
+      /*
+      for (const t of tokens) {
+        if (!sentiment?.occuringTokens?.length) continue;
+        sentiments += `ENTRY ${idx}\nTIME: ${sentiment.timeslot}\nTOKEN ANALYSIS:\n`;
+        for (const token of sentiment.occuringTokens) {
+          sentiments += `${token.token} - Sentiment: ${token.sentiment}\n${token.reason}\n`;
+        }
+        latestTxt += '\n-------------------\n';
+        idx++;
+      }
+      */
+      //latestTxt += '\n' + JSON.stringify(reduceTokens) + '\n';
+
+      //console.log('intel:provider - cmc token text', rows)
+
+      const boundedRows = rows.slice(0, TRENDING_ROW_LIMIT);
+      const data = {
+        tokens: tokens.slice(0, TRENDING_ROW_LIMIT),
+      };
+
+      const values = {};
+
+      // Combine all text sections
+      const text = [
+        "birdeye_trending_tokens:",
+        "  status: ok",
+        formatJsonTable("  tokens", boundedRows, [
+          "chain",
+          "address",
+          "symbol",
+          "priceUsd",
+          "marketCapUsd",
+          "volume24hUsd",
+          "change24hPct",
+          "liquidityUsd",
+        ]),
+      ].join("\n");
+
+      return {
+        data,
+        values,
+        text,
+      };
+    } catch (error) {
+      runtime.logger?.error(
+        `Error fetching trending data: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      return {
+        values: {},
+        text: [
+          "birdeye_trending_tokens:",
+          "  status: error",
+          `  reason: ${formatJsonScalar(error instanceof Error ? error.message : String(error))}`,
+        ].join("\n"),
+        data: {},
+      };
+    }
+  },
+};

package/src/analytics/birdeye/providers/wallet.ts

@@ -0,0 +1,14 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import { createBirdeyePortfolioProvider } from "./portfolio-factory";
+
+/**
+ * Optional wallet trade provider. It shares wallet, chain, service, error, and JSON
+ * formatting behavior with the agent portfolio provider through the portfolio factory.
+ */
+export const tradePortfolioProvider = createBirdeyePortfolioProvider({
+  name: "BIRDEYE_TRADE_PORTFOLIO",
+  description: "Birdeye wallet portfolio and recent trade history",
+  descriptionCompressed:
+    "Read Birdeye wallet portfolio and recent trade history.",
+  includeTrades: true,
+});