@elizaos/plugin-zapper/dist/index.d.ts

ElizaOS plugin for Zapper protocol integration - portfolio tracking, DeFi analytics, and blockchain data across 50+ networks

import { Action, Provider, Content, Plugin } from '@elizaos/core';

declare const getPortfolioAction: Action;

declare const getTokenPriceDataAction: Action;

declare const getNFTCollectionAction: Action;

declare const getTransactionHistoryAction: Action;

declare const getTransactionDetailsAction: Action;

declare const getAccountInfoAction: Action;

declare const getAppPositionsAction: Action;

declare const getCrossChainAssetsAction: Action;

declare const portfolioProvider: Provider;

interface TransactionHistoryContent extends Content {
    address: string;
    perspective?: 'Signer' | 'Receiver' | 'All';
    networks?: string[] | string;
    chainIds?: number[] | number;
    first?: number;
    after?: string;
    tokenAddress?: string[] | string;
    minValue?: number;
    maxValue?: number;
}
interface TransactionData {
    hash: string;
    timestamp: string;
    network: string;
    fromAddress: string;
    toAddress?: string;
    methodSighash?: string;
    value: string;
    gas: string;
    interpretation?: {
        processedDescription: string;
        description: string;
    };
    app?: {
        displayName: string;
        websiteUrl?: string;
    };
    transfers?: TokenTransfer[];
    nftTransfers?: NFTTransfer$1[];
}
interface TokenTransfer {
    tokenAddress: string;
    tokenSymbol: string;
    tokenName: string;
    amount: string;
    amountUSD: number;
    direction: string;
    network: string;
}
interface NFTTransfer$1 {
    tokenAddress: string;
    tokenId: string;
    tokenName?: string;
    collectionName?: string;
    direction: string;
    network: string;
    imageUrl?: string;
    estimatedValue?: number;
}
interface TransactionHistoryData {
    transactions: TransactionData[];
    pageInfo: {
        hasNextPage: boolean;
        endCursor?: string;
    };
    totalCount: number;
}
interface TransactionHistoryResponse {
    transactionHistoryV2: {
        edges: Array<{
            node: {
                hash: string;
                timestamp: string;
                network: string;
                fromAddress: {
                    address: string;
                };
                toAddress?: {
                    address: string;
                };
                methodSighash?: string;
                value: string;
                gas: string;
                interpretation?: {
                    processedDescription: string;
                    description: string;
                };
                app?: {
                    name: string;
                    logo?: string;
                    website?: string;
                };
                transfers?: Array<{
                    tokenAddress: string;
                    tokenSymbol: string;
                    tokenName: string;
                    amount: string;
                    amountUSD: number;
                    direction: string;
                    network: string;
                }>;
                nftTransfers?: Array<{
                    tokenAddress: string;
                    tokenId: string;
                    tokenName?: string;
                    collectionName?: string;
                    direction: string;
                    network: string;
                    imageUrl?: string;
                    estimatedValue?: number;
                }>;
            };
            cursor: string;
        }>;
        pageInfo: {
            hasNextPage: boolean;
            endCursor?: string;
        };
        totalCount: number;
    };
}
type TransactionPerspective = 'Signer' | 'Receiver' | 'All';
interface TransactionFilters {
    network?: string[];
    chainIds?: number[];
    tokenAddress?: string[];
    minValue?: number;
    maxValue?: number;
    orderByDirection?: 'ASC' | 'DESC';
}
interface TransactionDetailsContent extends Content {
    hash: string;
    chainId?: number;
    index?: number;
    subject?: string;
}
interface TransactionDetailsData {
    hash: string;
    chainId: number;
    events: TransactionEventV2[];
    totalEvents: number;
    gasFee: string;
    gasUsed: string;
    gasPrice: string;
    blockNumber: number;
    status: 'success' | 'failed' | 'pending';
    timestamp: string;
    network: string;
}
interface TransactionEventV2 {
    id: string;
    hash: string;
    eventHash: string;
    network: string;
    index: number;
    fromAddress: string;
    toAddress?: string;
    methodSighash: string;
    timestamp: string;
    interpreterId: string;
    value: string;
    rawInput: string;
    gas: string;
    app?: {
        displayName: string;
        websiteUrl?: string;
    };
    interpretation: {
        processedDescription: string;
        description: string;
    };
    perspective: string;
    methodSignature?: string;
    transfers?: TokenTransfer[];
    nftTransfers?: NFTTransfer$1[];
}
interface TransactionDetailsResponse {
    transactionDetailsV2: TransactionEventV2[];
}

declare const transactionProvider: Provider;

declare const accountProvider: Provider;

declare const defiProvider: Provider;

declare const marketDataProvider: Provider;

interface AccountInfoContent extends Content {
    address?: string;
    ens?: string;
    basename?: string;
    farcasterUsername?: string;
    fid?: number;
}
interface AccountInfoData {
    address: string;
    displayName: {
        value: string;
        source: AccountDisplayNameSource;
    };
    avatar: {
        value: string;
        source: AccountAvatarSource;
    };
    description?: {
        value: string;
        source: AccountDescriptionSource;
    };
    socialLinks: AccountSocialLink[];
    ensRecord?: {
        name: string;
        metadata: {
            name: string;
            description?: string;
            avatar?: string;
            github?: string;
            twitter?: string;
            email?: string;
            website?: string;
        };
    };
    basename?: string;
    lensProfile?: {
        username: string;
        displayName?: string;
        bio?: string;
        avatar?: string;
    };
    farcasterProfile?: {
        username: string;
        fid: number;
        custodyAddress: string;
        connectedAddresses: string[];
        metadata: {
            displayName?: string;
            description?: string;
            imageUrl?: string;
            warpcast?: string;
            xAccount?: {
                username: string;
                url: string;
            };
        };
        followStats?: {
            followerCount: number;
            followingCount: number;
        };
    };
    followStats?: {
        followerCount: number;
        followingCount: number;
    };
    badges?: AccountBadge[];
    isContract: boolean;
    contract?: {
        name?: string;
        symbol?: string;
        decimals?: number;
    };
}
interface AccountSocialLink {
    url: string;
    name: AccountSocialLinkName;
    source: AccountSocialLinkSource;
}
interface AccountBadge {
    tokenId: number;
    badgeName: string;
    claimed: boolean;
    badgeNetwork: string;
}
declare enum AccountDisplayNameSource {
    ENS = "ENS",
    BASENAME = "BASENAME",
    LENS = "LENS",
    FARCASTER = "FARCASTER",
    LABEL = "LABEL",
    ADDRESS = "ADDRESS"
}
declare enum AccountDescriptionSource {
    ENS = "ENS",
    LENS = "LENS",
    FARCASTER = "FARCASTER"
}
declare enum AccountSocialLinkName {
    WEBSITE = "WEBSITE",
    TWITTER = "TWITTER",
    GITHUB = "GITHUB",
    EMAIL = "EMAIL",
    HEY = "HEY",
    WARPCAST = "WARPCAST"
}
declare enum AccountSocialLinkSource {
    ENS = "ENS",
    LENS = "LENS",
    FARCASTER = "FARCASTER"
}
declare enum AccountAvatarSource {
    ZAPPER = "ZAPPER",
    ENS = "ENS",
    LENS = "LENS",
    FARCASTER = "FARCASTER",
    OPEPENS = "OPEPENS",
    BLOCKIES = "BLOCKIES"
}
interface AccountInfoResponse {
    data: {
        accounts: AccountInfoData[];
    };
}
interface FarcasterProfileData {
    username: string;
    fid: number;
    custodyAddress: string;
    connectedAddresses: string[];
    metadata: {
        displayName?: string;
        description?: string;
        imageUrl?: string;
        warpcast?: string;
        xAccount?: {
            username: string;
            url: string;
        };
    };
    followStats?: {
        followerCount: number;
        followingCount: number;
    };
}
interface FarcasterProfileResponse {
    data: {
        farcasterProfile: FarcasterProfileData;
    };
}
interface AccountResolutionResult {
    address: string;
    ens?: string;
    basename?: string;
    farcasterUsername?: string;
    fid?: number;
    displayName: string;
    avatar?: string;
    description?: string;
    socialLinks: AccountSocialLink[];
    followStats?: {
        followerCount: number;
        followingCount: number;
    };
    isContract: boolean;
    badges?: AccountBadge[];
}

interface DeFiPosition {
    id: string;
    label: string;
    symbol: string;
    network: string;
    address: string;
    balance: string;
    balanceUSD: number;
    price: number;
    tokenAddress: string;
    decimals: number;
    type: PositionType;
    protocol: string;
    protocolDisplayName: string;
    protocolIconUrl?: string;
    apr?: number;
    apy?: number;
    rewards?: RewardPosition[];
    metadata?: PositionMetadata;
}
interface RewardPosition {
    symbol: string;
    name: string;
    balance: string;
    balanceUSD: number;
    price: number;
    tokenAddress: string;
    decimals: number;
    network: string;
    type: 'reward' | 'claimable' | 'pending';
}
interface PositionMetadata {
    maturityDate?: string;
    liquidationPrice?: number;
    healthFactor?: number;
    collateralRatio?: number;
    borrowRate?: number;
    supplyRate?: number;
    poolShare?: number;
    totalSupply?: string;
    totalBorrow?: string;
    utilization?: number;
    liquidityToken?: string;
    stakingRewards?: string[];
    yieldTokens?: string[];
    fee?: number;
    volume24h?: number;
    tvl?: number;
    pair?: {
        token0: string;
        token1: string;
        reserve0: string;
        reserve1: string;
    };
}
declare enum PositionType {
    STAKING = "staking",
    VALIDATOR = "validator",
    DELEGATION = "delegation",
    LENDING_SUPPLY = "lending-supply",
    LENDING_BORROW = "lending-borrow",
    LENDING_COLLATERAL = "lending-collateral",
    LIQUIDITY_POOL = "liquidity-pool",
    LIQUIDITY_TOKEN = "liquidity-token",
    FARM = "farm",
    YIELD_FARM = "yield-farm",
    YIELD_VAULT = "yield-vault",
    YIELD_STRATEGY = "yield-strategy",
    GOVERNANCE = "governance",
    VOTING = "voting",
    PERPETUAL = "perpetual",
    OPTION = "option",
    FUTURE = "future",
    INSURANCE = "insurance",
    COVERAGE = "coverage",
    WALLET = "wallet",
    CLAIMABLE = "claimable",
    VESTING = "vesting"
}
interface AppPosition {
    appId: string;
    appName: string;
    appDisplayName: string;
    appIconUrl?: string;
    network: string;
    address: string;
    positions: DeFiPosition[];
    totalValueUSD: number;
    metadata?: AppMetadata;
}
interface AppMetadata {
    description?: string;
    website?: string;
    twitter?: string;
    discord?: string;
    telegram?: string;
    documentation?: string;
    github?: string;
    category?: string;
    tags?: string[];
    verified?: boolean;
    tvl?: number;
    volume24h?: number;
    fees24h?: number;
    users?: number;
    transactions?: number;
    chains?: string[];
    protocols?: string[];
    lastUpdated?: string;
}
interface AppPositionsData {
    address: string;
    totalValueUSD: number;
    networks: string[];
    apps: AppPosition[];
    positionCount: number;
    appCount: number;
    networkCount: number;
    summary: {
        staking: number;
        lending: number;
        liquidity: number;
        farming: number;
        other: number;
    };
}
interface GetAppPositionsContent extends Content {
    address: string;
    networks?: string[] | string;
    appIds?: string[] | string;
    positionTypes?: PositionType[] | PositionType;
    minValueUSD?: number;
    includeRewards?: boolean;
    includeMetadata?: boolean;
}
interface StakingPosition extends DeFiPosition {
    type: PositionType.STAKING | PositionType.VALIDATOR | PositionType.DELEGATION;
    validatorAddress?: string;
    delegationRewards?: RewardPosition[];
    unbondingPeriod?: number;
    slashingRisk?: number;
    commission?: number;
    stakingPeriod?: {
        start: string;
        end?: string;
        duration?: number;
    };
}
interface LendingPosition extends DeFiPosition {
    type: PositionType.LENDING_SUPPLY | PositionType.LENDING_BORROW | PositionType.LENDING_COLLATERAL;
    supplyBalance?: string;
    borrowBalance?: string;
    collateralBalance?: string;
    supplyRate?: number;
    borrowRate?: number;
    healthFactor?: number;
    liquidationThreshold?: number;
    liquidationPrice?: number;
    borrowCapacity?: string;
    borrowCapacityUSD?: number;
}
interface LiquidityPosition extends DeFiPosition {
    type: PositionType.LIQUIDITY_POOL | PositionType.LIQUIDITY_TOKEN | PositionType.FARM;
    token0?: string;
    token1?: string;
    reserve0?: string;
    reserve1?: string;
    poolShare?: number;
    fee?: number;
    volume24h?: number;
    fees24h?: number;
    impermanentLoss?: number;
    lpTokenBalance?: string;
    lpTokenPrice?: number;
}
interface YieldFarmPosition extends DeFiPosition {
    type: PositionType.YIELD_FARM | PositionType.YIELD_VAULT | PositionType.YIELD_STRATEGY;
    stakedBalance?: string;
    stakedBalanceUSD?: number;
    earnedBalance?: string;
    earnedBalanceUSD?: number;
    strategyName?: string;
    strategyDescription?: string;
    autoCompound?: boolean;
    harvestFee?: number;
    performanceFee?: number;
    withdrawalFee?: number;
    lockupPeriod?: number;
}
interface DeFiAppInfo {
    appId: string;
    name: string;
    displayName: string;
    description?: string;
    iconUrl?: string;
    website?: string;
    category: string;
    tags: string[];
    networks: string[];
    protocols: string[];
    verified: boolean;
    tvl?: number;
    volume24h?: number;
    fees24h?: number;
    users?: number;
    transactions?: number;
    lastUpdated: string;
    social?: {
        twitter?: string;
        discord?: string;
        telegram?: string;
        github?: string;
    };
}
interface DeFiProtocolInfo {
    protocolId: string;
    name: string;
    displayName: string;
    description?: string;
    iconUrl?: string;
    website?: string;
    category: string;
    networks: string[];
    tvl?: number;
    volume24h?: number;
    fees24h?: number;
    users?: number;
    verified: boolean;
    risks?: string[];
    audits?: string[];
    lastUpdated: string;
}
interface AppDiscoveryFilter {
    networks?: string[];
    categories?: string[];
    tags?: string[];
    verified?: boolean;
    minTvl?: number;
    minVolume24h?: number;
    hasPositions?: boolean;
    search?: string;
}
interface AppDiscoveryResult {
    apps: DeFiAppInfo[];
    total: number;
    page: number;
    limit: number;
    filters: AppDiscoveryFilter;
}

interface HistoricalPriceData {
    timestamp: string;
    price: number;
    priceUSD: number;
    volume?: number;
    volumeUSD?: number;
    marketCap?: number;
    marketCapUSD?: number;
    high?: number;
    low?: number;
    open?: number;
    close?: number;
}
interface TokenMarketData {
    symbol: string;
    name: string;
    address: string;
    network: string;
    currentPrice: number;
    currentPriceUSD: number;
    marketCap?: number;
    marketCapUSD?: number;
    volume24h?: number;
    volume24hUSD?: number;
    priceChange24h?: number;
    priceChangePercent24h?: number;
    volumeChange24h?: number;
    volumeChangePercent24h?: number;
    high24h?: number;
    low24h?: number;
    circulatingSupply?: number;
    totalSupply?: number;
    maxSupply?: number;
    fullyDilutedValuation?: number;
    liquidityScore?: number;
    volatility?: number;
    beta?: number;
    lastUpdated?: string;
}
interface PriceChartData {
    symbol: string;
    network: string;
    timeframe: string;
    interval: string;
    currency: string;
    data: HistoricalPriceData[];
    indicators?: TechnicalIndicators;
}
interface TechnicalIndicators {
    sma20?: number;
    ema20?: number;
    sma?: number[];
    ema?: number[];
    rsi?: number;
    macd?: {
        line: number;
        signal: number;
        histogram: number;
    };
    bollinger?: {
        upper: number;
        middle: number;
        lower: number;
    };
    volume?: number;
    volatility?: number;
}
interface VolumeData {
    timestamp: string;
    volume: number;
    volumeUSD: number;
    transactionCount?: number;
    uniqueUsers?: number;
    averageTransactionSize?: number;
    symbol?: string;
    name?: string;
    address?: string;
    currentPrice?: number;
    priceChange24h?: number;
}
interface LiquidityData {
    pool: string;
    protocol: string;
    network: string;
    tokenA: string;
    tokenB: string;
    liquidityUSD: number;
    volume24h: number;
    volume24hUSD: number;
    fees24h?: number;
    apr?: number;
    apy?: number;
    impermanentLoss?: number;
    reserves?: {
        tokenA: number;
        tokenB: number;
    };
}
interface TokenHolderData {
    address: string;
    balance: number;
    balanceUSD: number;
    percentage: number;
    isContract?: boolean;
    label?: string;
    tags?: string[];
    firstSeen?: string;
    lastActive?: string;
    transactionCount?: number;
}
interface TokenDistribution {
    totalHolders: number;
    concentration: {
        top10: number;
        top50: number;
        top100: number;
    };
    holderTiers: {
        whales: number;
        dolphins: number;
        fish: number;
        shrimp: number;
    };
    holdingPeriods: {
        short: number;
        medium: number;
        long: number;
    };
    topHolders: TokenHolderData[];
}
interface PortfolioPerformance {
    address: string;
    timeframe: TimeFrame;
    startValue: number;
    endValue: number;
    absoluteReturn: number;
    percentageReturn: number;
    realizedPnL: number;
    unrealizedPnL: number;
    totalFees: number;
    gasSpent: number;
    transactionCount: number;
    bestPerformingAsset?: {
        symbol: string;
        return: number;
    };
    worstPerformingAsset?: {
        symbol: string;
        return: number;
    };
    assetAllocation: {
        symbol: string;
        percentage: number;
        value: number;
    }[];
    riskMetrics?: {
        sharpeRatio: number;
        volatility: number;
        maxDrawdown: number;
        beta: number;
    };
}
interface PortfolioPerformanceData {
    currentValue: number;
    initialValue: number;
    returns?: {
        absolute: number;
        percentage: number;
        annualized: number;
        realizedGains?: number;
        unrealizedGains?: number;
    };
    allocation?: {
        symbol: string;
        name: string;
        value: number;
        percentage: number;
        change24h?: number;
        priceChange24h?: number;
    }[];
    risk?: {
        volatility?: number;
        sharpeRatio?: number;
        maxDrawdown?: number;
        beta?: number;
        valueAtRisk?: number;
    };
    benchmark?: {
        return: number;
        alpha: number;
        beta: number;
        trackingError: number;
        correlation?: number;
    };
}
interface MarketMetrics {
    totalMarketCap: number;
    totalVolume24h: number;
    defiTVL: number;
    btcDominance: number;
    ethDominance: number;
    activeTokens: number;
    topGainers: TokenMarketData[];
    topLosers: TokenMarketData[];
    trending: TokenMarketData[];
    newListings: TokenMarketData[];
    marketSentiment?: 'extremely_fearful' | 'fearful' | 'neutral' | 'greedy' | 'extremely_greedy';
    fearGreedIndex?: number;
}
declare enum TimeFrame {
    ONE_HOUR = "1h",
    ONE_DAY = "1d",
    ONE_WEEK = "1w",
    ONE_MONTH = "1m",
    THREE_MONTHS = "3m",
    SIX_MONTHS = "6m",
    ONE_YEAR = "1y",
    ALL_TIME = "all"
}
declare enum DataInterval {
    MINUTE = "1m",
    FIVE_MINUTES = "5m",
    FIFTEEN_MINUTES = "15m",
    THIRTY_MINUTES = "30m",
    ONE_HOUR = "1h",
    FOUR_HOURS = "4h",
    ONE_DAY = "1d",
    ONE_WEEK = "1w",
    ONE_MONTH = "1M"
}
interface GetHistoricalPriceContent extends Content {
    symbol: string;
    network?: string;
    timeframe: TimeFrame;
    interval?: DataInterval;
    from?: string;
    to?: string;
    includeVolume?: boolean | string;
    includeMarketCap?: boolean | string;
    includeIndicators?: boolean | string;
    currency?: string;
}
interface GetMarketDataContent extends Content {
    symbols?: string[];
    network?: string;
    includeMetrics?: boolean;
    includeHolders?: boolean;
    includePerformance?: boolean;
    timeframe?: TimeFrame;
    limit?: number;
    offset?: number;
}
interface GetTokenHoldersContent extends Content {
    symbol: string;
    network?: string;
    limit?: number;
    offset?: number;
    includeDistribution?: boolean;
    includeAnalytics?: boolean;
    minBalance?: number;
}
interface GetLiquidityDataContent extends Content {
    symbol?: string;
    protocol?: string;
    network?: string;
    includeHistorical?: boolean;
    timeframe?: TimeFrame;
    limit?: number;
    offset?: number;
}

interface NetworkInfo {
    id: string;
    name: string;
    displayName: string;
    chainId: number;
    nativeCurrency: {
        name: string;
        symbol: string;
        decimals: number;
    };
    rpcUrls: string[];
    blockExplorers?: {
        name: string;
        url: string;
    }[];
    testnet?: boolean;
    isActive: boolean;
    features: NetworkFeature[];
    logo?: string;
    color?: string;
    description?: string;
    totalValueLocked?: number;
    totalValueLockedUSD?: number;
    gasPrice?: NetworkGasPrice;
    blockTime?: number;
    lastBlockNumber?: number;
    lastBlockTimestamp?: string;
    status: NetworkStatus;
    health: NetworkHealth;
}
interface NetworkFeature {
    name: string;
    supported: boolean;
    description?: string;
    version?: string;
    endpoints?: string[];
}
interface NetworkGasPrice {
    standard: number;
    fast: number;
    instant: number;
    unit: string;
    currency: string;
    lastUpdated: string;
}
interface NetworkStatus {
    isOnline: boolean;
    lastChecked: string;
    uptime: number;
    syncStatus: 'synced' | 'syncing' | 'out_of_sync';
    blockHeight?: number;
    peersConnected?: number;
    responseTime?: number;
}
interface NetworkHealth {
    overall: 'healthy' | 'degraded' | 'unhealthy';
    rpcHealth: 'healthy' | 'degraded' | 'unhealthy';
    explorerHealth: 'healthy' | 'degraded' | 'unhealthy';
    metrics: {
        successRate: number;
        avgResponseTime: number;
        errorRate: number;
        lastError?: string;
    };
}
interface CrossChainAsset {
    symbol: string;
    name: string;
    totalBalance: number;
    totalBalanceUSD: number;
    networks: CrossChainAssetNetwork[];
    bridgeSupport: BridgeSupport[];
    priceData: {
        price: number;
        priceUSD: number;
        change24h: number;
        marketCap?: number;
        volume24h?: number;
    };
}
interface CrossChainAssetNetwork {
    networkId: string;
    networkName: string;
    contractAddress: string;
    balance: number;
    balanceUSD: number;
    locked?: number;
    lockedUSD?: number;
    bridgeable?: boolean;
    transferFee?: number;
    transferFeeUSD?: number;
}
interface BridgeSupport {
    protocol: string;
    fromNetworks: string[];
    toNetworks: string[];
    supported: boolean;
    fees: {
        fixed?: number;
        percentage?: number;
        gas?: number;
    };
    timeEstimate?: string;
    minAmount?: number;
    maxAmount?: number;
}
interface BlockExplorer {
    name: string;
    url: string;
    apiUrl?: string;
    type: 'etherscan' | 'blockscout' | 'subscan' | 'other';
    features: string[];
    rateLimit?: {
        requests: number;
        window: string;
    };
}
interface NetworkMapper {
    chainId: number;
    networkId: string;
    name: string;
    aliases: string[];
    rpcUrls: string[];
    explorers: BlockExplorer[];
    testnet: boolean;
    deprecated?: boolean;
    parentChain?: string;
    layer: 1 | 2 | 3;
}
interface GetNetworkInfoContent extends Content {
    networkId?: string;
    chainId?: number | string;
    includeFeatures?: boolean | string;
    includeHealth?: boolean | string;
    includeGasPrice?: boolean | string;
    includeExplorers?: boolean | string;
    includeAll?: boolean | string;
}
interface GetCrossChainAssetsContent extends Content {
    address: string;
    networks?: string[] | string;
    includeBalances?: boolean | string;
    includeBridgeSupport?: boolean | string;
    includePriceData?: boolean | string;
    minBalance?: number | string;
    sortBy?: string;
    limit?: number | string;
}
interface GetGasPriceContent extends Content {
    networkId?: string;
    chainId?: number | string;
    transactionType?: string;
    priority?: string;
    includeHistory?: boolean | string;
    timeframe?: string;
}
interface GetBlockExplorerContent extends Content {
    networkId?: string;
    chainId?: number | string;
    type?: string;
    includeApi?: boolean | string;
    includeFeatures?: boolean | string;
    transactionHash?: string;
    address?: string;
    blockNumber?: number | string;
}
interface NetworkMetrics {
    tvl: number;
    tvlUSD: number;
    volume24h: number;
    volume24hUSD: number;
    transactions24h: number;
    uniqueUsers24h: number;
    avgGasPrice: number;
    avgBlockTime: number;
    congestionLevel: 'low' | 'medium' | 'high';
    popularProtocols: string[];
    topTokens: string[];
}
interface NetworkComparison {
    networks: {
        id: string;
        name: string;
        metrics: NetworkMetrics;
        score: number;
        rank: number;
    }[];
    comparison: {
        tvl: NetworkComparisonMetric;
        volume: NetworkComparisonMetric;
        transactions: NetworkComparisonMetric;
        gasPrice: NetworkComparisonMetric;
        blockTime: NetworkComparisonMetric;
    };
}
interface NetworkComparisonMetric {
    best: string;
    worst: string;
    average: number;
    median: number;
    trend: 'up' | 'down' | 'stable';
}
interface NetworkAlert {
    type: 'health' | 'performance' | 'security' | 'maintenance';
    severity: 'low' | 'medium' | 'high' | 'critical';
    title: string;
    description: string;
    networkId: string;
    timestamp: string;
    resolved: boolean;
    estimatedResolution?: string;
    impact: string[];
}

declare function isGetPortfolioContent(content: Content): content is GetPortfolioContent;
declare function isGetTokenPriceContent(content: Content): content is GetTokenPriceContent;
declare function isGetNFTsContent(content: Content): content is GetNFTsContent;
declare function isGetNetworkInfoContent(content: Content): content is GetNetworkInfoContent;
declare function isGetCrossChainAssetsContent(content: Content): content is GetCrossChainAssetsContent;
declare function isGetGasPriceContent(content: Content): content is GetGasPriceContent;
declare function isGetBlockExplorerContent(content: Content): content is GetBlockExplorerContent;
declare function isGetTransactionHistoryContent(content: Content): content is TransactionHistoryContent;
declare function isGetTransactionDetailsContent(content: Content): content is TransactionDetailsContent;
declare function isGetAccountInfoContent(content: Content): content is AccountInfoContent;
declare function isGetAppPositionsContent(content: Content): content is GetAppPositionsContent;
declare function isGetHistoricalPriceContent(content: Content): content is GetHistoricalPriceContent;
declare function isGetPriceChartDataContent(content: Content): content is GetPriceChartDataContent;
declare function isGetVolumeAndLiquidityContent(content: Content): content is GetVolumeAndLiquidityContent;
declare function isGetPortfolioPerformanceContent(content: Content): content is GetPortfolioPerformanceContent;

interface ZapperConfig {
    apiKey: string;
    apiUrl: string;
}
interface TokenBalance {
    symbol: string;
    name: string;
    balance: string;
    balanceUSD: number;
    network: string;
    address: string;
}
interface PortfolioData {
    totalValueUSD: number;
    tokenBalances: TokenBalance[];
    networks: string[];
}
interface NFTMetadata {
    name: string;
    description: string;
    image: string;
    collection: string;
    tokenId: string;
    network: string;
    estimatedValue?: number;
    traits?: NFTTrait[];
    rarity?: NFTRarity;
    lastSale?: NFTSale;
    contractAddress?: string;
    collectionMetadata?: NFTCollectionMetadata;
}
interface NFTTrait {
    trait_type: string;
    value: string | number;
    display_type?: string;
    rarity?: number;
}
interface NFTRarity {
    rank?: number;
    score?: number;
    total_supply?: number;
}
interface NFTSale {
    price?: number;
    priceUSD?: number;
    currency?: string;
    marketplace?: string;
    date?: string;
    buyer?: string;
    seller?: string;
}
interface NFTCollectionMetadata {
    name: string;
    description?: string;
    image?: string;
    banner?: string;
    website?: string;
    twitter?: string;
    discord?: string;
    opensea?: string;
    verified?: boolean;
    totalSupply?: number;
    floorPrice?: number;
    floorPriceUSD?: number;
    volumeTraded?: number;
    volumeTradedUSD?: number;
    owners?: number;
    createdAt?: string;
}
interface NFTMarketplaceData {
    marketplace: string;
    listing?: {
        price: number;
        priceUSD: number;
        currency: string;
        seller: string;
        expiresAt?: string;
    };
    lastSale?: NFTSale;
    priceHistory?: NFTSale[];
    offers?: {
        price: number;
        priceUSD: number;
        currency: string;
        buyer: string;
        expiresAt?: string;
    }[];
}
interface NFTOwnershipData {
    owner: string;
    ownedSince?: string;
    quantity?: number;
    previousOwners?: string[];
    transferHistory?: NFTTransfer[];
}
interface NFTTransfer {
    from: string;
    to: string;
    transactionHash: string;
    blockNumber: number;
    timestamp: string;
    marketplace?: string;
    price?: number;
    priceUSD?: number;
    currency?: string;
}
interface NFTAnalytics {
    collection: string;
    floorPrice?: number;
    floorPriceUSD?: number;
    averagePrice?: number;
    averagePriceUSD?: number;
    totalVolume?: number;
    totalVolumeUSD?: number;
    sales24h?: number;
    salesVolume24h?: number;
    owners?: number;
    totalSupply?: number;
    marketCap?: number;
    priceChange24h?: number;
    volumeChange24h?: number;
    trending?: boolean;
    topSales?: NFTSale[];
    holderDistribution?: {
        address: string;
        quantity: number;
        percentage: number;
    }[];
}
interface GetPortfolioContent extends Content {
    address: string;
    networks?: string[] | string;
}
interface GetTokenPriceContent extends Content {
    symbol: string;
    network?: string;
}
interface GetNFTsContent extends Content {
    address: string;
    network?: string;
    includeTraits?: boolean | string;
    includeMarketplace?: boolean | string;
    includeOwnership?: boolean | string;
    includeTransfers?: boolean | string;
    collections?: string[];
    limit?: number | string;
    offset?: number | string;
}
interface ZapperResponse<T> {
    data: T;
    errors?: Array<{
        message: string;
        locations?: Array<{
            line: number;
            column: number;
        }>;
    }>;
}
interface GraphQLVariables {
    [key: string]: any;
}
interface GetPriceChartDataContent extends Content {
    symbol: string;
    network?: string;
    timeframe?: string;
    interval?: string;
    includeVolume?: boolean | string;
    includeMarketCap?: boolean | string;
    includeIndicators?: boolean | string;
    indicatorTypes?: string;
    currency?: string;
}
interface GetVolumeAndLiquidityContent extends Content {
    symbol?: string;
    network?: string;
    timeframe?: string;
    includeVolume?: boolean | string;
    includeLiquidity?: boolean | string;
    includePoolData?: boolean | string;
    includeProtocolBreakdown?: boolean | string;
    minLiquidity?: number | string;
    sortBy?: string;
    limit?: number | string;
}
interface GetPortfolioPerformanceContent extends Content {
    address: string;
    networks?: string;
    timeframe?: string;
    includeReturns?: boolean | string;
    includeAllocation?: boolean | string;
    includeRisk?: boolean | string;
    includeComparison?: boolean | string;
    benchmarkSymbol?: string;
    currency?: string;
}

declare const zapperPlugin: Plugin;

export { AccountAvatarSource, type AccountBadge, AccountDescriptionSource, AccountDisplayNameSource, type AccountInfoContent, type AccountInfoData, type AccountInfoResponse, type AccountResolutionResult, type AccountSocialLink, AccountSocialLinkName, AccountSocialLinkSource, type AppDiscoveryFilter, type AppDiscoveryResult, type AppMetadata, type AppPosition, type AppPositionsData, type BlockExplorer, type BridgeSupport, type CrossChainAsset, type CrossChainAssetNetwork, DataInterval, type DeFiAppInfo, type DeFiPosition, type DeFiProtocolInfo, type FarcasterProfileData, type FarcasterProfileResponse, type GetAppPositionsContent, type GetBlockExplorerContent, type GetCrossChainAssetsContent, type GetGasPriceContent, type GetHistoricalPriceContent, type GetLiquidityDataContent, type GetMarketDataContent, type GetNFTsContent, type GetNetworkInfoContent, type GetPortfolioContent, type GetPortfolioPerformanceContent, type GetPriceChartDataContent, type GetTokenHoldersContent, type GetTokenPriceContent, type GetVolumeAndLiquidityContent, type GraphQLVariables, type HistoricalPriceData, type LendingPosition, type LiquidityData, type LiquidityPosition, type MarketMetrics, type NFTAnalytics, type NFTCollectionMetadata, type NFTMarketplaceData, type NFTMetadata, type NFTOwnershipData, type NFTRarity, type NFTSale, type NFTTrait, type NFTTransfer, type NetworkAlert, type NetworkComparison, type NetworkComparisonMetric, type NetworkFeature, type NetworkGasPrice, type NetworkHealth, type NetworkInfo, type NetworkMapper, type NetworkMetrics, type NetworkStatus, type PortfolioData, type PortfolioPerformance, type PortfolioPerformanceData, type PositionMetadata, PositionType, type PriceChartData, type RewardPosition, type StakingPosition, type TechnicalIndicators, TimeFrame, type TokenBalance, type TokenDistribution, type TokenHolderData, type TokenMarketData, type TokenTransfer, type TransactionData, type TransactionDetailsContent, type TransactionDetailsData, type TransactionDetailsResponse, type TransactionEventV2, type TransactionFilters, type TransactionHistoryContent, type TransactionHistoryData, type TransactionHistoryResponse, type TransactionPerspective, type VolumeData, type YieldFarmPosition, type ZapperConfig, type ZapperResponse, accountProvider, zapperPlugin as default, defiProvider, getAccountInfoAction, getAppPositionsAction, getCrossChainAssetsAction, getNFTCollectionAction, getPortfolioAction, getTokenPriceDataAction, getTransactionDetailsAction, getTransactionHistoryAction, isGetAccountInfoContent, isGetAppPositionsContent, isGetBlockExplorerContent, isGetCrossChainAssetsContent, isGetGasPriceContent, isGetHistoricalPriceContent, isGetNFTsContent, isGetNetworkInfoContent, isGetPortfolioContent, isGetPortfolioPerformanceContent, isGetPriceChartDataContent, isGetTokenPriceContent, isGetTransactionDetailsContent, isGetTransactionHistoryContent, isGetVolumeAndLiquidityContent, marketDataProvider, portfolioProvider, transactionProvider, zapperPlugin };