@elizaos/plugin-social-alpha 2.0.0-alpha.3

package/dist/clients.d.ts

@@ -0,0 +1,382 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { DexScreenerData, DexScreenerPair, HolderData, Prices, TokenOverview, TokenSecurityData, TokenTradeData, WalletPortfolio } from "./types";
+/**
+ * Represents the valid types that can be used for query parameters in a URL.
+ * It can either be a key-value pair object with string, number, boolean, null or undefined values,
+ * or an instance of the URLSearchParams class.
+ */
+type QueryParams = Record<string, string | number | boolean | null | undefined> | URLSearchParams;
+/**
+ * Interface representing retry options for a retry mechanism.
+ * @typedef {Object} RetryOptions
+ * @property {number} [maxRetries] - The maximum number of retries allowed.
+ * @property {number} [initialDelay] - The initial delay in milliseconds before the first retry.
+ * @property {number} [maxDelay] - The maximum delay in milliseconds between retries.
+ * @property {number} [backoffFactor] - The factor by which the delay increases between retries.
+ * @property {number[]} [retryableStatuses] - The array of HTTP status codes that are retryable.
+ */
+interface RetryOptions {
+    maxRetries?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    backoffFactor?: number;
+    retryableStatuses?: number[];
+}
+/**
+ * Interface for defining options that can be passed in a request.
+ * @template RequestOptions
+ * @property {RetryOptions} [retryOptions] - Options for retrying the request
+ * @property {QueryParams} [params] - Query parameters for the request
+ */
+interface RequestOptions extends RequestInit {
+    retryOptions?: RetryOptions;
+    params?: QueryParams;
+}
+/**
+ * HTTP utility functions for making requests and handling responses.
+ * @namespace http
+ */
+export declare const http: {
+    request(url: string, options?: RequestOptions): Promise<Response>;
+    json<T = any>(url: string, options?: RequestOptions): Promise<T>;
+    get: {
+        request(url: string, params?: QueryParams, options?: RequestInit): Promise<Response>;
+        json<T = any>(url: string, params?: QueryParams, options?: RequestInit): Promise<T>;
+    };
+    post: {
+        request(url: string, body: object, options?: RequestOptions): Promise<Response>;
+        json<ReturnType = any, Body extends object = object>(url: string, body: Body, options?: RequestOptions): Promise<ReturnType>;
+    };
+    jsonrpc<_ReturnType = any, Params extends object = object>(url: string, method: string, params: Params, headers?: HeadersInit): Promise<any>;
+    graphql<_ReturnType = any, Variables extends object = object>(url: string, query: string, variables: Variables, headers?: HeadersInit): Promise<any>;
+};
+/**
+ * Class representing a client for interacting with the Jupiter API for swapping tokens.
+ */
+export declare class JupiterClient {
+    static baseUrl: string;
+    static xApiKey: string;
+    /**
+     * Fetches a quote for a given input and output mint, amount, and slippage.
+     * @param {string} inputMint The mint of the input token.
+     * @param {string} outputMint The mint of the output token.
+     * @param {string} amount The amount to be swapped.
+     * @param {number} [slippageBps=50] The slippage tolerance in basis points (default: 50).
+     * @returns {Promise<{inputMint: string, outputMint: string, inAmount: string, outAmount: string, routePlan: unknown[]} | {error: unknown}>} The quote object or an error object.
+     */
+    static getQuote(inputMint: string, outputMint: string, amount: string, slippageBps?: number): Promise<{
+        inputMint: string;
+        outputMint: string;
+        inAmount: string;
+        outAmount: string;
+        routePlan: unknown[];
+    }>;
+    /**
+     * Perform a swap operation using the provided quote data and user's wallet public key.
+     * @param {any} quoteData - The data required for the swap operation.
+     * @param {string} walletPublicKey - The public key of the user's wallet.
+     * @returns {Promise<any>} The result of the swap operation.
+     */
+    static swap(quoteData: any, walletPublicKey: string): Promise<any>;
+}
+/**
+ * Options for Dexscreener.
+ * @typedef {Object} DexscreenerOptions
+ * @property {string|CacheOptions["expires"]} [expires] - The expiration time for the cache.
+ */
+type DexscreenerOptions = {
+    expires?: string;
+};
+/**
+ * Client for interacting with DexScreener API.
+ */
+export declare class DexscreenerClient {
+    private runtime;
+    /**
+     * Constructor for the class.
+     * @param {IAgentRuntime} runtime - The runtime passed as a parameter to the constructor.
+     */
+    constructor(runtime: IAgentRuntime);
+    /**
+     * 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: IAgentRuntime): DexscreenerClient;
+    /**
+     * 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
+     */
+    request<T = any>(path: string, params?: QueryParams, options?: DexscreenerOptions): Promise<T>;
+    /**
+     * 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.
+     */
+    search(address: string, options?: DexscreenerOptions): Promise<DexScreenerData>;
+    /**
+     * 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.
+     */
+    searchForHighestLiquidityPair(address: string, chain?: string, options?: DexscreenerOptions): Promise<DexScreenerPair | null>;
+}
+/**
+ * Represents a client for interacting with the Helius API.
+ */
+export declare class HeliusClient {
+    private readonly apiKey;
+    private runtime;
+    /**
+     * 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: string, runtime: IAgentRuntime);
+    /**
+     * 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: IAgentRuntime): HeliusClient;
+    /**
+     * 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.
+     */
+    fetchHolderList(address: string, options?: {
+        expires?: string;
+    }): Promise<HolderData[]>;
+}
+/**
+ * Options for Coingecko API.
+ * @typedef {Object} CoingeckoOptions
+ * @property {string | CacheOptions["expires"]} [expires] - The expiration date for the cache.
+ */
+type CoingeckoOptions = {
+    expires?: string;
+};
+/**
+ * CoingeckoClient class for interacting with the Coingecko API.
+ * @constructor
+ * @param { string } apiKey - The API key required for accessing the Coingecko API.
+ * @param { IAgentRuntime } runtime - The IAgentRuntime object for accessing runtime settings.
+ */
+export declare class CoingeckoClient {
+    private readonly apiKey;
+    private readonly runtime;
+    /**
+     * 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: string, runtime: IAgentRuntime);
+    /**
+     * 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: IAgentRuntime): CoingeckoClient;
+    /**
+     * 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.
+     */
+    request<T = any>(path: string, params?: QueryParams, options?: CoingeckoOptions): Promise<T>;
+    /**
+     * 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.
+     */
+    fetchPrices(options?: CoingeckoOptions): Promise<Prices>;
+    /**
+     * Asynchronously fetches global data.
+     *
+     * @returns {Promise} The promise containing the global data.
+     */
+    fetchGlobal(): Promise<any>;
+    /**
+     * Asynchronously fetches a list of coin categories.
+     * @returns {Promise} The Promise object representing the result of the fetch operation.
+     */
+    fetchCategories(): Promise<any>;
+}
+/**
+ * Represents an item in a wallet token list with details such as address, name, symbol, decimals, balance, UI amount, chain ID, logo URI, price in USD, and value in USD.
+ * @typedef {Object} WalletTokenListItem
+ * @property {string} address - The address of the token
+ * @property {string} name - The name of the token
+ * @property {string} symbol - The symbol of the token
+ * @property {number} decimals - The decimals of the token
+ * @property {number} balance - The balance of the token
+ * @property {number} uiAmount - The UI amount of the token
+ * @property {string} chainId - The chain ID of the token
+ * @property {string} logoURI - The logo URI of the token
+ * @property {number} priceUsd - The price of the token in USD
+ * @property {number} valueUsd - The value of the token in USD
+ */
+type WalletTokenListItem = {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    balance: number;
+    uiAmount: number;
+    chainId: string;
+    logoURI: string;
+    priceUsd: number;
+    valueUsd: number;
+};
+/**
+ * Defines the structure of a WalletTokenList object, which includes the wallet name, total USD balance,
+ * and an array of WalletTokenListItem objects.
+ */
+type WalletTokenList = {
+    wallet: string;
+    totalUsd: number;
+    items: WalletTokenListItem[];
+};
+/**
+ * Represents a type that can either be "solana" or "ethereum" for the BirdeyeXChain.
+ */
+type BirdeyeXChain = "solana" | "ethereum";
+/**
+ * Type representing headers for BirdeyeClient.
+ * @typedef {Object} BirdeyeClientHeaders
+ * @property {BirdeyeXChain} ["x-chain"] - Optional header for BirdeyeXChain.
+ */
+type BirdeyeClientHeaders = {
+    "x-chain"?: BirdeyeXChain;
+};
+/**
+ * Options for making a Birdeye API request.
+ * @typedef {Object} BirdeyeRequestOptions
+ * @property {BirdeyeXChain} [chain] - The BirdeyeX chain.
+ * @property {string | CacheOptions["expires"]} [expires] - The expiration date for the request.
+ */
+type BirdeyeRequestOptions = {
+    chain?: BirdeyeXChain;
+    expires?: string;
+};
+/**
+ * Class representing a client for interacting with the BirdEye API.
+ */
+export declare class BirdeyeClient {
+    private readonly apiKey;
+    static readonly url = "https://public-api.birdeye.so/";
+    private 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 request<T = any>(apiKey: string, path: string, params?: QueryParams, headers?: BirdeyeClientHeaders): Promise<T>;
+    /**
+     * 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: string, runtime: IAgentRuntime);
+    /**
+     * 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: IAgentRuntime): BirdeyeClient;
+    /**
+     * 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.
+     */
+    request<T = any>(path: string, params: QueryParams, options?: BirdeyeRequestOptions, forceRefresh?: boolean): Promise<T>;
+    /**
+     * 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.
+     */
+    fetchPrice(address: string, options?: BirdeyeRequestOptions): Promise<number>;
+    /**
+     * 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.
+     */
+    fetchPrices(): Promise<Prices>;
+    /**
+     * 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.
+     */
+    fetchTokenOverview(address: string, options?: BirdeyeRequestOptions, forceRefresh?: boolean): Promise<TokenOverview>;
+    /**
+     * 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.
+     */
+    fetchTokenSecurity(address: string, options?: BirdeyeRequestOptions): Promise<TokenSecurityData>;
+    /**
+     * 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.
+     */
+    fetchTokenTradeData(address: string, options?: BirdeyeRequestOptions): Promise<TokenTradeData>;
+    /**
+     * 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.
+     */
+    fetchWalletTokenList(address: string, options?: BirdeyeRequestOptions): Promise<WalletTokenList>;
+    /**
+     * 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.
+     */
+    fetchPortfolioValue(address: string, options?: BirdeyeRequestOptions): Promise<WalletPortfolio>;
+}
+export {};

package/dist/config.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Configuration for the Community Trader Plugin
+ *
+ * This file centralizes all configuration options for the trading system.
+ */
+import type { UUID } from "./types";
+/**
+ * Buy amount configuration
+ */
+export interface BuyAmountConfig {
+    baseAmount: number;
+    minAmount: number;
+    maxAmount: number;
+    trustScoreMultiplier: number;
+    convictionMultiplier: number;
+}
+/**
+ * Trading configuration
+ */
+export interface TradingConfig {
+    slippageBps: number;
+    forceSimulation: boolean;
+    defaultChain: string;
+    maxPositionsPerToken: number;
+    maxPositionsPerRecommender: number;
+    minLiquidityUsd: number;
+    maxMarketCapUsd: number;
+    buyAmountConfig: BuyAmountConfig;
+}
+/**
+ * Database configuration
+ */
+export interface DatabaseConfig {
+    schemaVersion: string;
+    enableCaching: boolean;
+    cacheTimeout: number;
+}
+/**
+ * Memory configuration
+ */
+export interface MemoryConfig {
+    embeddingModel: string;
+    embeddingDimension: number;
+    similarityThreshold: number;
+    cacheTimeout: number;
+}
+/**
+ * Default trading configuration
+ */
+export declare const DEFAULT_TRADING_CONFIG: TradingConfig;
+/**
+ * Default database configuration
+ */
+export declare const DEFAULT_DATABASE_CONFIG: DatabaseConfig;
+/**
+ * Default memory configuration
+ */
+export declare const DEFAULT_MEMORY_CONFIG: MemoryConfig;
+/**
+ * Conviction levels for recommendations
+ * IMPORTANT: Must match the enum in types.ts
+ */
+export declare enum Conviction {
+    NONE = "NONE",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    HIGH = "HIGH",
+    VERY_HIGH = "VERY_HIGH",
+    NEUTRAL = "NEUTRAL"
+}
+/**
+ * Recommendation types
+ * IMPORTANT: Must match the enum in types.ts
+ */
+export declare enum RecommendationType {
+    BUY = "BUY",
+    DONT_BUY = "DONT_BUY",
+    SELL = "SELL",
+    DONT_SELL = "DONT_SELL",
+    NONE = "NONE",
+    HOLD = "HOLD"
+}
+/**
+ * Transaction types
+ * IMPORTANT: Must match the enum in types.ts
+ */
+export declare enum TransactionType {
+    BUY = "BUY",
+    SELL = "SELL",
+    TRANSFER_IN = "transfer_in",
+    TRANSFER_OUT = "transfer_out"
+}
+/**
+ * Buy signal message interface
+ */
+export interface BuySignalMessage {
+    tokenAddress: string;
+    chain?: string;
+    walletAddress?: string;
+    isSimulation?: boolean;
+    entityId: UUID;
+    recommendationId?: UUID;
+    conviction?: Conviction;
+    price?: string;
+    marketCap?: string;
+    liquidity?: string;
+    type?: RecommendationType;
+}
+/**
+ * Sell signal message interface
+ */
+export interface SellSignalMessage {
+    positionId: UUID;
+    tokenAddress: string;
+    sellRecommenderId: UUID;
+    walletAddress?: string;
+    isSimulation?: boolean;
+}
+/**
+ * Utility functions for configuration
+ */
+/**
+ * Get conviction multiplier
+ */
+export declare function getConvictionMultiplier(conviction: Conviction): number;
+/**
+ * Get liquidity multiplier
+ */
+export declare function getLiquidityMultiplier(liquidity: number): number;
+/**
+ * Get market cap multiplier
+ */
+export declare function getMarketCapMultiplier(marketCap: number): number;
+/**
+ * Get volume multiplier
+ */
+export declare function getVolumeMultiplier(volume: number): number;
+export declare const SOLANA_NETWORK_ID = 1399811149;
+export declare const SOL_ADDRESS = "So11111111111111111111111111111111111111112";
+export declare const USDC_ADDRESS = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export declare const BTC_ADDRESS = "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh";
+export declare const ETH_ADDRESS = "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs";
+export declare const TRUST_LEADERBOARD_WORLD_SEED = "trust-leaderboard-world-v1";

package/dist/events.d.ts

@@ -0,0 +1,4 @@
+import { type MessageReceivedHandlerParams } from "@elizaos/core";
+export declare const events: {
+    MESSAGE_RECEIVED: (({ runtime, message, callback, onComplete, }: MessageReceivedHandlerParams) => Promise<void>)[];
+};

package/dist/frontend/LeaderboardTable.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { LeaderboardEntry } from "../types";
+interface LeaderboardTableProps {
+    data: LeaderboardEntry[];
+}
+export declare const LeaderboardTable: React.FC<LeaderboardTableProps>;
+export {};

package/dist/frontend/index.d.ts

@@ -0,0 +1,3 @@
+import "./index.css";
+declare function LeaderboardPanelPage(): import("react/jsx-runtime").JSX.Element;
+export default LeaderboardPanelPage;

package/dist/frontend/loader.d.ts

@@ -0,0 +1 @@
+export default function Loader(): import("react/jsx-runtime").JSX.Element;

package/dist/frontend/ui/badge.d.ts

@@ -0,0 +1,11 @@
+import type { VariantProps } from "class-variance-authority";
+import type * as React from "react";
+import type { HTMLAttributes } from "react";
+declare const badgeVariants: (props?: ({
+    variant?: "default" | "success" | "secondary" | "destructive" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BadgeProps extends HTMLAttributes<HTMLDivElement>, VariantProps<typeof badgeVariants> {
+    children?: React.ReactNode;
+}
+declare function Badge({ className, variant, ...props }: BadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/frontend/ui/button.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+import React from "react";
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/dist/frontend/ui/card.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const Card: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardTitle: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardDescription: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardContent: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+declare const CardFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent, };

package/dist/frontend/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input };

package/dist/frontend/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/frontend/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import * as TabsPrimitive from "@radix-ui/react-tabs";
+import * as React from "react";
+declare const Tabs: React.ForwardRefExoticComponent<TabsPrimitive.TabsProps & React.RefAttributes<HTMLDivElement>>;
+declare const TabsList: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsListProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const TabsTrigger: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TabsContent: React.ForwardRefExoticComponent<Omit<TabsPrimitive.TabsContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/frontend/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import type { Plugin } from "@elizaos/core";
+export { socialAlphaProvider } from "./providers/socialAlphaProvider";
+export * from "./types";
+export interface AgentPanel {
+    name: string;
+    path: string;
+    component: string;
+    icon?: string;
+    public?: boolean;
+}
+/**
+ * Social Alpha Plugin for ElizaOS.
+ *
+ * Tracks token recommendations ("shills") and criticisms ("FUD") made by
+ * users in chat. Builds trust scores for each recommender based on whether
+ * following their calls would have been profitable — accounting for:
+ *
+ *   - Buy calls that mooned vs dumped
+ *   - Sell/FUD calls on tokens that were scams (good call) vs tokens that rallied (bad call)
+ *   - Conviction level, recency, and consistency
+ *
+ * Exposes a **Social Alpha Provider** that injects trust data (win rate,
+ * rank, P&L history) into the agent's context so it can weigh advice
+ * from different users.
+ */
+export declare const socialAlphaPlugin: Plugin;
+/** @deprecated Use `socialAlphaPlugin` instead. */
+export declare const communityInvestorPlugin: Plugin;
+export declare const panels: AgentPanel[];
+export default socialAlphaPlugin;

package/dist/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Agent Plugin View</title>
+    <script type="module" crossorigin src="./assets/index-DU6B6kWr.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-D088W50X.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/dist/mockPriceService.d.ts

@@ -0,0 +1 @@
+export * from "./__tests__/mocks/mockPriceService";