@elizaos/plugin-social-alpha 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/clients.js

@@ -0,0 +1,670 @@
+import BigNumber from "bignumber.js";
+import * as dotenv from "dotenv";
+import { BTC_ADDRESS, ETH_ADDRESS, SOL_ADDRESS } from "./config.js";
+dotenv.config();
+let nextRpcRequestId = 1;
+const DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  maxDelay: 3e4,
+  backoffFactor: 2,
+  retryableStatuses: [408, 429, 500, 502, 503, 504]
+};
+class RequestError extends Error {
+  /**
+   *  Constructor for creating a RequestError instance.
+   *
+   * @param {string} message - The error message for the RequestError instance.
+   * @param {Response} [response] - Optional response object associated with the error.
+   */
+  constructor(message, response) {
+    super(message);
+    this.response = response;
+    this.name = "RequestError";
+  }
+  response;
+}
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const calculateDelay = (attempt, options) => {
+  const delay = options.initialDelay * options.backoffFactor ** (attempt - 1);
+  return Math.min(delay, options.maxDelay);
+};
+const isRetryableError = (error) => error instanceof Error && (error.name === "TypeError" || error.name === "AbortError") || error instanceof RequestError;
+const buildUrl = (url, params) => {
+  if (!params) return url;
+  const searchParams = params instanceof URLSearchParams ? params : new URLSearchParams(
+    Object.entries(params).filter(([_, value]) => value != null).map(([key, value]) => [key, String(value)])
+  );
+  const separator = url.includes("?") ? "&" : "?";
+  const queryString = searchParams.toString();
+  return queryString ? `${url}${separator}${queryString}` : url;
+};
+const http = {
+  async request(url, options) {
+    const { params, ...fetchOptions } = options || {};
+    const fullUrl = buildUrl(url, params);
+    const retryOptions = {
+      ...DEFAULT_RETRY_OPTIONS,
+      ...options?.retryOptions
+    };
+    let attempt = 1;
+    while (true) {
+      try {
+        const res = await fetch(fullUrl, fetchOptions);
+        if (!res.ok) {
+          const errorText = await res.text();
+          throw new RequestError(
+            `Request failed with status ${res.status}: ${errorText}`,
+            res
+          );
+        }
+        return res;
+      } catch (error) {
+        if (isRetryableError(error) && attempt < retryOptions.maxRetries) {
+          const delay = calculateDelay(attempt, retryOptions);
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.warn(
+            `Request failed with error: ${errorMessage}. Retrying in ${delay}ms (attempt ${attempt}/${retryOptions.maxRetries})`
+          );
+          await sleep(delay);
+          attempt++;
+          continue;
+        }
+        console.error(`Request failed after ${attempt} attempts:`, error);
+        throw error;
+      }
+    }
+  },
+  async json(url, options) {
+    const res = await this.request(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers
+      }
+    });
+    return await res.json();
+  },
+  get: {
+    async request(url, params, options) {
+      return http.request(url, {
+        ...options,
+        method: "GET",
+        params
+      });
+    },
+    async json(url, params, options) {
+      return http.json(url, {
+        ...options,
+        method: "GET",
+        params
+      });
+    }
+  },
+  post: {
+    async request(url, body, options) {
+      return http.request(url, {
+        ...options,
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    },
+    async json(url, body, options) {
+      return http.json(url, {
+        ...options,
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+    }
+  },
+  async jsonrpc(url, method, params, headers) {
+    return http.post.json(
+      url,
+      {
+        jsonrpc: "2.0",
+        id: nextRpcRequestId++,
+        method,
+        params
+      },
+      { headers }
+    );
+  },
+  async graphql(url, query, variables, headers) {
+    return http.post.json(
+      url,
+      {
+        query,
+        variables
+      },
+      { headers }
+    );
+  }
+};
+class DexscreenerClient {
+  /**
+   * Constructor for the class.
+   * @param {IAgentRuntime} runtime - The runtime passed as a parameter to the constructor.
+   */
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  runtime;
+  /**
+   * Create a new DexscreenerClient instance using the provided agent runtime.
+   *
+   * @param {IAgentRuntime} runtime - The agent runtime to use for creating the DexscreenerClient instance.
+   * @returns {DexscreenerClient} A new instance of DexscreenerClient.
+   */
+  static createFromRuntime(runtime) {
+    return new DexscreenerClient(runtime);
+  }
+  /**
+   * Makes an asynchronous HTTP request to the DexScreener API.
+   *
+   * @template T - The type of data expected to be returned
+   * @param {string} path - The endpoint path for the API request
+   * @param {QueryParams} [params] - Optional query parameters for the request
+   * @param {DexscreenerOptions} [options] - Optional options for the request
+   * @returns {Promise<T>} - A promise that resolves with the data returned from the API
+   */
+  async request(path, params, options) {
+    const cacheKey = [
+      "dexscreener",
+      buildUrl(path, params)
+      // remove first "/"
+    ].filter(Boolean).join("/");
+    if (options?.expires) {
+      const cached = await this.runtime.getCache(cacheKey);
+      if (cached) return cached;
+    }
+    const res = await http.get.json(
+      `https://api.dexscreener.com/${path}`,
+      params
+    );
+    if (options?.expires) {
+      await this.runtime.setCache(cacheKey, res);
+    }
+    return res;
+  }
+  /**
+   * Asynchronously searches for DexScreener data based on the provided address.
+   *
+   * @param {string} address - The address to search for in DexScreener data.
+   * @param {DexscreenerOptions} [options] - Optional parameters for the request.
+   * @returns {Promise<DexScreenerData>} A promise that resolves with the DexScreener data.
+   */
+  async search(address, options) {
+    try {
+      const data = await this.request(
+        "latest/dex/search",
+        {
+          q: address
+        },
+        options
+      );
+      if (!data?.pairs) {
+        throw new Error("No DexScreener data available");
+      }
+      return data;
+    } catch (error) {
+      console.error("Error fetching DexScreener data:", error);
+      return {
+        schemaVersion: "1.0.0",
+        pairs: []
+      };
+    }
+  }
+  /**
+   * Asynchronously searches for the pair with the highest liquidity based on the given address.
+   *
+   * @param {string} address The address to search for liquidity pairs from.
+   * @param {string} [chain] The chain ID to filter the liquidity pairs by.
+   * @param {DexscreenerOptions} [options] Additional options for searching.
+   * @returns {Promise<DexScreenerPair | null>} The pair with the highest liquidity, or null if no pairs were found.
+   */
+  async searchForHighestLiquidityPair(address, chain, options) {
+    let { pairs } = await this.search(address, options);
+    if (pairs.length === 0) {
+      return null;
+    }
+    if (chain) {
+      pairs = pairs.filter((pair) => pair.chainId === chain);
+    }
+    return pairs.sort((a, b) => {
+      const liquidityA = a.liquidity?.usd ?? 0;
+      const liquidityB = b.liquidity?.usd ?? 0;
+      return liquidityB < liquidityA ? -1 : 1;
+    })[0];
+  }
+}
+class HeliusClient {
+  /**
+   * Constructor for initializing an instance of class.
+   *
+   * @param apiKey - The API key to be used for authentication.
+   * @param _runtime - The runtime environment for the agent.
+   */
+  constructor(apiKey, runtime) {
+    this.apiKey = apiKey;
+    this.runtime = runtime;
+  }
+  apiKey;
+  runtime;
+  /**
+   * Creates a new HeliusClient instance using the provided IAgentRuntime.
+   *
+   * @param {IAgentRuntime} runtime - The IAgentRuntime to use for creating the HeliusClient.
+   * @returns {HeliusClient} A new instance of HeliusClient.
+   * @throws {Error} Thrown if HELIUS_API_KEY is missing from the runtime settings.
+   */
+  static createFromRuntime(runtime) {
+    const apiKey = runtime.getSetting("HELIUS_API_KEY");
+    if (!apiKey) {
+      throw new Error("missing HELIUS_API_KEY");
+    }
+    return new HeliusClient(String(apiKey), runtime);
+  }
+  /**
+   * Fetches the list of token holders for a given address asynchronously.
+   * If the option `expires` is provided and there is a cached version available, it returns the cached data.
+   * Otherwise, it fetches the data from the Helius API using the provided address.
+   *
+   * @param {string} address - The address for which to fetch the list of token holders.
+   * @param {Object} [options] - Optional parameters.
+   * @param {string | CacheOptions["expires"]} [options.expires] - The expiration date for caching the data.
+   *
+   * @returns {Promise<HolderData[]>} A promise that resolves to an array of HolderData objects representing the token holders.
+   */
+  async fetchHolderList(address, options) {
+    if (options?.expires) {
+      const cached = await this.runtime.getCache(
+        `helius/token-holders/${address}`
+      );
+      if (cached) return cached;
+    }
+    const allHoldersMap = /* @__PURE__ */ new Map();
+    let page = 1;
+    const limit = 1e3;
+    let cursor;
+    const url = `https://mainnet.helius-rpc.com/?api-key=${this.apiKey}`;
+    try {
+      while (true) {
+        const params = {
+          limit,
+          displayOptions: {},
+          mint: address
+        };
+        if (cursor) {
+          params.cursor = cursor;
+        }
+        if (page > 2) break;
+        const data = await http.jsonrpc(url, "getTokenAccounts", params);
+        if (!data?.result?.token_accounts?.length) break;
+        data.result.token_accounts.forEach((account) => {
+          const owner = account.owner;
+          const balance = Number.parseFloat(String(account.amount ?? 0));
+          if (owner && Number.isFinite(balance)) {
+            allHoldersMap.set(owner, (allHoldersMap.get(owner) || 0) + balance);
+          }
+        });
+        cursor = data.result.cursor;
+        page++;
+      }
+      const holders = Array.from(allHoldersMap.entries()).map(
+        ([address2, balance]) => ({
+          address: address2,
+          balance: balance.toString()
+        })
+      );
+      if (options?.expires)
+        await this.runtime.setCache(
+          `helius/token-holders/${address}`,
+          holders
+        );
+      return holders;
+    } catch (error) {
+      console.error("Error fetching holder list from Helius:", error);
+      throw new Error("Failed to fetch holder list from Helius.");
+    }
+  }
+}
+class CoingeckoClient {
+  /**
+   * Constructor for initializing a new instance of the class.
+   * @param apiKey The API key used for authentication.
+   * @param runtime The agent runtime implementation.
+   */
+  constructor(apiKey, runtime) {
+    this.apiKey = apiKey;
+    this.runtime = runtime;
+  }
+  apiKey;
+  runtime;
+  /**
+   * Creates a new instance of CoingeckoClient using the apiKey retrieved from the provided runtime.
+   * @param {IAgentRuntime} runtime - The runtime object that contains the COINGECKO_API_KEY setting.
+   * @throws {Error} If COINGECKO_API_KEY setting is missing in the runtime object.
+   * @returns {CoingeckoClient} A new instance of CoingeckoClient initialized with the apiKey and runtime.
+   */
+  static createFromRuntime(runtime) {
+    const apiKey = runtime.getSetting("COINGECKO_API_KEY");
+    if (!apiKey) {
+      throw new Error("missing COINGECKO_API_KEY");
+    }
+    return new CoingeckoClient(String(apiKey), runtime);
+  }
+  /**
+   * Makes an asynchronous HTTP request to the Coingecko API.
+   * @template T
+   * @param {string} path - The API endpoint to call.
+   * @param {QueryParams} [params] - Optional query parameters to include in the request.
+   * @param {CoingeckoOptions} [options] - Additional options for the request.
+   * @returns {Promise<T>} The response data from the API.
+   */
+  async request(path, params, options) {
+    const cacheKey = ["coingecko", buildUrl(path, params)].filter(Boolean).join("/");
+    if (options?.expires) {
+      const cached = await this.runtime.getCache(cacheKey);
+      if (cached) return cached;
+    }
+    const res = await http.get.json(
+      `https://api.coingecko.com/api/v3/${path}`,
+      params,
+      {
+        headers: {
+          "x-cg-demo-api-key": this.apiKey
+        }
+      }
+    );
+    if (options?.expires) {
+      await this.runtime.setCache(cacheKey, res);
+    }
+    return res;
+  }
+  /**
+   * Fetches prices for specified cryptocurrencies from the Coingecko API.
+   *
+   * @param {CoingeckoOptions} [options] The options for the Coingecko API request.
+   * @returns {Promise<Prices>} A Promise that resolves to the prices of the specified cryptocurrencies.
+   */
+  async fetchPrices(options) {
+    const prices = await this.request(
+      "simple/price",
+      {
+        ids: "solana,bitcoin,ethereum",
+        vs_currencies: "usd"
+      },
+      options
+    );
+    return prices;
+  }
+  /**
+   * Asynchronously fetches global data.
+   *
+   * @returns {Promise} The promise containing the global data.
+   */
+  async fetchGlobal() {
+    return this.request(
+      "global",
+      {},
+      {
+        expires: "30m"
+      }
+    );
+  }
+  /**
+   * Asynchronously fetches a list of coin categories.
+   * @returns {Promise} The Promise object representing the result of the fetch operation.
+   */
+  async fetchCategories() {
+    return this.request(
+      "coins/categories",
+      {},
+      {
+        expires: "30m"
+      }
+    );
+  }
+}
+class BirdeyeClient {
+  /**
+   * Constructor for initializing a new instance.
+   *
+   * @param apiKey The API key to be used.
+   * @param runtime The agent runtime for handling communication with the runtime environment.
+   */
+  constructor(apiKey, runtime) {
+    this.apiKey = apiKey;
+    this.runtime = runtime;
+  }
+  apiKey;
+  static url = "https://public-api.birdeye.so/";
+  runtime;
+  /**
+   * Send a request to the Birdeye API using the provided API key, path, query parameters, and headers.
+   *
+   * @param {string} apiKey - The API key for authenticating the request.
+   * @param {string} path - The endpoint path to send the request to.
+   * @param {QueryParams} [params] - Optional query parameters to include in the request.
+   * @param {BirdeyeClientHeaders} [headers] - Optional additional headers to include in the request.
+   * @returns {Promise<T>} A Promise that resolves with the data received from the API request.
+   */
+  static async request(apiKey, path, params, headers) {
+    const res = await http.get.json(
+      BirdeyeClient.url + path,
+      params,
+      {
+        headers: {
+          ...headers,
+          "X-API-KEY": apiKey
+        }
+      }
+    );
+    if (!res.success || !res.data) {
+      console.error({ res });
+      throw new Error(`Birdeye request failed:${path}`);
+    }
+    return res.data;
+  }
+  /**
+   * Create a new BirdeyeClient instance using the provided IAgentRuntime object.
+   *
+   * @param {IAgentRuntime} runtime - The IAgentRuntime object that provides access to runtime settings.
+   * @returns {BirdeyeClient} A new instance of BirdeyeClient initialized with the provided API key and runtime.
+   * @throws {Error} Thrown if the BIRDEYE_API_KEY setting is missing in the runtime object.
+   */
+  static createFromRuntime(runtime) {
+    const apiKey = runtime.getSetting("BIRDEYE_API_KEY");
+    if (!apiKey) {
+      throw new Error("missing BIRDEYE_API_KEY");
+    }
+    return new BirdeyeClient(String(apiKey), runtime);
+  }
+  /**
+   * Performs a request to the specified path with given query parameters and options.
+   * @template T
+   * @param {string} path - The path to request.
+   * @param {QueryParams} params - The query parameters to include in the request.
+   * @param {BirdeyeRequestOptions} [options] - Optional request options.
+   * @param {boolean} [forceRefresh] - Flag to force refresh the cache.
+   * @returns {Promise<T>} The response data from the request.
+   */
+  async request(path, params, options, forceRefresh) {
+    const cacheKey = ["birdeye", options?.chain, buildUrl(path, params)].filter(Boolean).join("/");
+    if (options?.expires && !forceRefresh) {
+      const cached = await this.runtime.getCache(cacheKey);
+      if (cached) return cached;
+    }
+    const response = await BirdeyeClient.request(
+      this.apiKey,
+      path,
+      params,
+      options?.chain ? {
+        "x-chain": options.chain
+      } : void 0
+    );
+    if (options?.expires) {
+      await this.runtime.setCache(cacheKey, response);
+    }
+    return response;
+  }
+  /**
+   * Fetches the price for a given address.
+   *
+   * @param {string} address - The address for which to fetch the price.
+   * @param {BirdeyeRequestOptions} [options] - The options for the Birdeye request.
+   * @returns {Promise<number>} The price value fetched for the given address.
+   */
+  async fetchPrice(address, options) {
+    const price = await this.request(
+      "defi/price",
+      { address },
+      options
+    );
+    return price.value;
+  }
+  /**
+   * Fetches the latest prices for Bitcoin, Ethereum, and Solana in USD from the DeFi API.
+   * @returns {Promise<Prices>} The latest prices for Bitcoin, Ethereum, and Solana in USD.
+   */
+  async fetchPrices() {
+    const prices = await this.request(
+      "defi/multi_price",
+      { list_address: [SOL_ADDRESS, ETH_ADDRESS, BTC_ADDRESS].join(",") },
+      {
+        chain: "solana",
+        expires: "5m"
+      }
+    );
+    return {
+      bitcoin: { usd: prices[BTC_ADDRESS].value.toString() },
+      ethereum: { usd: prices[ETH_ADDRESS].value.toString() },
+      solana: { usd: prices[SOL_ADDRESS].value.toString() }
+    };
+  }
+  /**
+   * Fetches token overview for a specific address.
+   *
+   * @param {string} address The address of the token for which overview is to be fetched.
+   * @param {BirdeyeRequestOptions} [options] Additional options for the Birdeye request.
+   * @param {boolean} [forceRefresh=false] Flag to force refresh the data.
+   * @returns {Promise<TokenOverview>} Promise that resolves to the token overview.
+   */
+  async fetchTokenOverview(address, options, forceRefresh = false) {
+    const token = await this.request(
+      "defi/token_overview",
+      { address },
+      options,
+      forceRefresh
+    );
+    return token;
+  }
+  /**
+   * Fetches token security data from the API for a given address.
+   * @param {string} address - The address of the token for which to fetch security data.
+   * @param {BirdeyeRequestOptions} [options] - Optional request options.
+   * @returns {Promise<TokenSecurityData>} A promise that resolves with the token security data.
+   */
+  async fetchTokenSecurity(address, options) {
+    const security = await this.request(
+      "defi/token_security",
+      { address },
+      options
+    );
+    return security;
+  }
+  /**
+   * Fetches token trade data for a specific address.
+   * @param {string} address - The address of the token.
+   * @param {BirdeyeRequestOptions} [options] - Optional request options.
+   * @returns {Promise<TokenTradeData>} - A promise that resolves with the token trade data.
+   */
+  async fetchTokenTradeData(address, options) {
+    const tradeData = await this.request(
+      "defi/v3/token/trade-data/single",
+      { address },
+      options
+    );
+    return tradeData;
+  }
+  /**
+   * Fetches the wallet token list for a given address.
+   *
+   * @param {string} address - The address of the wallet to fetch the token list for.
+   * @param {BirdeyeRequestOptions} [options] - Additional options for the request.
+   * @returns {Promise<WalletTokenList>} The wallet token list for the specified address.
+   */
+  async fetchWalletTokenList(address, options) {
+    const tokenList = await this.request(
+      "v1/wallet/token_list",
+      { wallet: address },
+      options
+    );
+    return tokenList;
+  }
+  /**
+   * Asynchronously fetches the portfolio value for a given address.
+   *
+   * @param {string} address - The address for which to fetch the portfolio value.
+   * @param {BirdeyeRequestOptions} [options] - The optional request options.
+   * @returns {Promise<WalletPortfolio>} - A promise that resolves to the wallet portfolio object containing total USD, total SOL, and portfolio items.
+   * @throws {Error} - If an error occurs while fetching the portfolio value.
+   */
+  async fetchPortfolioValue(address, options) {
+    try {
+      const portfolio = {
+        totalUsd: "0",
+        totalSol: "0",
+        items: []
+      };
+      const tokenList = await this.fetchWalletTokenList(address, options);
+      const totalUsd = new BigNumber(tokenList.totalUsd.toString());
+      const solPriceInUSD = new BigNumber(await this.fetchPrice(SOL_ADDRESS));
+      const items = tokenList.items.map((item) => ({
+        address: item.address,
+        name: item.name || "Unknown",
+        symbol: item.symbol || "Unknown",
+        decimals: item.decimals,
+        valueSol: new BigNumber(item.valueUsd || 0).div(solPriceInUSD).toFixed(6),
+        priceUsd: item.priceUsd?.toString() || "0",
+        valueUsd: item.valueUsd?.toString() || "0",
+        uiAmount: item.uiAmount?.toString() || "0",
+        balance: item.balance?.toString() || "0"
+      }));
+      const totalSol = totalUsd.div(solPriceInUSD);
+      portfolio.totalUsd = totalUsd.toString();
+      portfolio.totalSol = totalSol.toFixed(6);
+      portfolio.items = items.sort(
+        (a, b) => new BigNumber(b.valueUsd).minus(new BigNumber(a.valueUsd)).toNumber()
+      );
+      return portfolio;
+    } catch (error) {
+      console.error("Error fetching portfolio:", error);
+      throw error;
+    }
+  }
+}
+const units = {
+  ms: 1,
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3
+};
+function parseTimeToMs(timeStr) {
+  const match = timeStr.match(/^(\d+)([a-z]+)$/i);
+  if (!match) return 0;
+  const [_, value, unit] = match;
+  return units[unit.toLowerCase()] * Number.parseInt(value, 10);
+}
+function _parseExpires(expires) {
+  return typeof expires === "string" ? parseTimeToMs(expires) : expires;
+}
+export {
+  BirdeyeClient,
+  CoingeckoClient,
+  DexscreenerClient,
+  HeliusClient,
+  http
+};
+//# sourceMappingURL=clients.js.map