Stake DAO API

This repository is meant to be used as API endpoints, with periodical updates through GitHub workflows

Data

Lockers data

Endpoint : /api/lockers

Data type :

{
parsed: {
id: string;
order: number;
symbol: string;
protocol: string;
protocolDescription: string;
website: string;
logoUrl: string;
chainId: number;
rgb: string;
token: {
id: string;
name: string;
address: string;
symbol: string;
decimals: number;
chainId: number;
logoURI: string;
tags: string[];
extensions: {
coingeckoSlug?: string;
underlying?: string;
};
distribution?: string;
origin?: string;
};
sdToken?: {
id: string;
name: string;
address: string;
symbol: string;
decimals: number;
chainId: number;
logoURI: string;
tags: string[];
extensions: {
underlying: string;
coingeckoSlug?: string;
};
};
rewards?: {
token: {
id: string;
name: string;
address: string;
symbol: string;
decimals: number;
chainId: number;
logoURI: string;
tags: string[];
extensions: {
coingeckoSlug: string;
};
distribution: string;
origin: string;
};
price: number;
apr: number;
streaming: boolean;
periodFinish: number;
rate: string;
lastUpdate: string;
}[];
modules?: {
depositor: string;
locker: string;
veToken: string;
gauge: string;
accumulator: string;
};
secondaryMarket?: {
label: string;
poolKey: string;
pool: string;
pegBase: number;
};
voteBooster?: {
booster: string;
vSdToken: string;
balance: {
token: string;
sdToken: string;
staked: string;
working: string;
};
boost: number;
};
autoCompounder?: {
aSdToken: string;
};
alternativeYields?: Record<string, {
label: string;
platform: string;
href: string;
}>;
fees?: {
label: {
key: string;
variable?: string;
};
value: number;
key: string;
}[];
extensions?: {
coingeckoBaseSlug?: string;
strategyGauge?: string;
};
tokenLocked?: string;
veBalanceOfLocker?: string;
totalTokenLocked?: string;
veTotalSupply?: string;
lockIncentive?: string;
incentiveAmountInToken?: string;
gaugeWorkingSupply?: string;
totalSupplyStaked?: string;
amountTokenNotLock?: string;
bribeRewards?: {
bribeMinApr: number;
bribeMaxApr: number;
bribeAverageApr: number;
minBoost: string;
maxBoost: string;
token: string;
};
apr: number[];
streaming: boolean;
veTokenRate: string;
tvl: number;
peg: string;
tokenPriceInUsd: number;
sdTokenPriceInUsd: number;
}[];
sdt: {
lockersSdtPerBlock: string;
lockersSdtPerSecond: string;
stratsSdtPerBlock: string;
stratsSdtPerSecond: string;
};
fetched: boolean;
};

Strategies data

Strategies data are available on the endpoints /api/strategies/{protocol}

Available protocols :

• curve
• pendle
• pancakeswap
• balancer

The chain id can be selected by adding {chainId}.json at the end of the endpoint. e.g. Curve strategies on Ethereum can be fetched through the endpoint : /api/strategies/curve/1.json

export type Coin = {
name: string
symbol: string
address: string
decimals: number
}
export type AprDetail = {
total: number
details: {
label: string
value: number[]
}[]
}
export type OnlyBoostAprDetail = {
projected: {
baseToken: number
}
}
export type OnlyBoostProtocolData = {
tvl: number
supply: string
boost: number
optimal: {
supply: string
boost: number
share: number
}
claimable?: {
token: string
claimable: string
}[]
}
export type OnlyBoostData = {
active: boolean
implementations: {
key: string
address: string
}[]
totalSupply: string
boost: number
optimalBoost: number
stakeDao: OnlyBoostProtocolData
convex: OnlyBoostProtocolData
}
export type SdGauge = {
address: string
totalSupply: string
relativeWeight: string
weight: string
futureWeight: string
workingSupply: string
}
export type Fees = {
veSdt: number
perf: number
accumulator: number
claimer: number
}
export type VaultFees = {
keeper: number
accumulated: string
}
export type SdtApr = {
sdtUserApr: number
sdtFuturUserApr: number
sdtMinApr: number
sdtFuturMinApr: number
sdtMaxApr: number
sdtFuturMaxApr: number
sdtBoost: number
}
export type RewardsData = {
token: Coin
price: number
apr: number
streaming: boolean
periodFinish: number
rate: string
lastUpdate: string
claimablePendingRewards: string
}
export type Strategy = {
key: string
type: string
protocol: string
chainId: number
isMetapool?: boolean
isLending?: boolean
vault: string
lpToken: Coin
gaugeAddress: string
gaugeToken?: Coin & { version: number }
coins: Coin[]
underlyingCoins?: Coin[]
rewards: RewardsData[]
name: string
tradingApy: number
underlyingApy?: number
minApr: number
maxApr: number
lpPriceInUsd: number
convexPool?: {
id: number
token: string
gauge: string
crvRewards: string
stash: string
shutdown: boolean
usdTotal: number
}
tvl: number
apr: {
boost: number
current: AprDetail
projected: AprDetail
onlyboost?: {
convex: OnlyBoostAprDetail
optimal: OnlyBoostAprDetail
}
}
sdtApr?: SdtApr
vaultHoldings: string
totalSupply: string
strategyHoldings: string
workingBalance: string
sdGauge: SdGauge
vaultFees: VaultFees
onlyboost?: OnlyBoostData | { active: boolean }
}
// GLOBAL DATA TYPE
export type CurveGlobalData = {
totalGaugeWeights: string
nextEffectiveTimestamp: string
cvxTotalSupply: string
veCrvTotalSupply: string
stakeDaoVeBoost: string
convexVeBoost: string
fees: Fees
}
export type YearnGlobalData = {
totalGaugeWeights: string
fees: Fees
}
export type Global = CurveGlobalData | YearnGlobalData
export type StrategyData = {
global?: Global
deployed: Strategy[]
notDeployed: any
fetched: boolean
}
export type BuiltStrat = {
key: string
type: string
protocol: string
chainId: number
isMetapool?: boolean
isLending?: boolean
vault: string
lpToken: Coin
gaugeAddress: string
gaugeToken?: Coin & { version: number }
coins: Coin[]
underlyingCoins?: Coin[]
sdGauge: string
rewards: Coin[]
underlyingReward?: Coin
}

Pendle Holders data

Base endpoint : /api/strategies/pendle/holders

Available endpoints

Endpoint	Description
/api/strategies/pendle/holders	Get all holders data (all gauges)
/api/strategies/pendle/holders/gauges	List all gauge IDs
/api/strategies/pendle/holders/current	Get current holders snapshot
/api/strategies/pendle/holders/historical?gauge=0x...&include_events=true	Get historical data
/api/strategies/pendle/holders/period?start_date=2024-01-01&end_date=2024-12-31&gauge=0x...&min_duration_days=30	Period analysis
/api/strategies/pendle/holders/analytics?gauge=0x...	Get holder analytics
/api/strategies/pendle/holders/user/:address	Get user history across all gauges
/api/strategies/pendle/holders/:gaugeId	Get single gauge data

Main endpoint data type (/api/strategies/pendle/holders)

{
"metadata": {
"snapshot_date": string, // ISO 8601 timestamp of data snapshot
"pendle_locker": string, // Pendle locker address
"total_gauges": number, // Total number of gauges
"total_current_holders": number, // Total current holders across all gauges
"total_unique_users": number, // Total unique users across all gauges
"average_holding_duration_days": number, // Average holding duration in days
"gauges_summary": [ // Summary of all gauges
{
"gauge": string, // Gauge address
"symbol": string, // PT token symbol
"current_holders": number, // Current number of holders
"total_users": number, // Total unique users (current + past)
"current_supply": string // Current total supply
}
]
},
"gauges": [
{
"gauge_id": string, // Gauge address
"vault_id": string, // Vault address (if available)
"token": {
"address": string, // PT token address
"symbol": string // PT token symbol
},
"stats": {
"total_deposited": string, // Total amount ever deposited
"total_withdrawn": string, // Total amount ever withdrawn
"current_supply": string, // Current total supply
"current_holders": number, // Current number of holders
"total_users": number // Total unique users (current + past)
},
"current_holders": { // Map of current holders (address -> balance)
"[user_address]": string
},
"user_histories": { // Map of all user histories
"[user_address]": {
"first_seen": number, // Unix timestamp when first seen
"last_seen": number, // Unix timestamp when last seen
"entry_timestamp": number, // Unix timestamp of first entry
"exit_timestamp": number, // Unix timestamp of exit (if applicable)
"entry_block": number, // Block number of first entry
"exit_block": number, // Block number of exit (if applicable)
"max_balance": number, // Maximum balance ever held
"holding_periods": [ // Array of holding periods
{
"entry_timestamp": number,
"exit_timestamp": number,
"entry_block": number,
"exit_block": number,
"duration": number, // Duration in seconds
"entry_date": string, // ISO 8601 date
"exit_date": string, // ISO 8601 date
"duration_days": number // Duration in days
}
],
"total_holding_duration": number, // Total duration in seconds
"is_current_holder": boolean, // Whether user currently holds tokens
"events": [ // Array of all deposit/withdraw events
{
"type": string, // "DEPOSIT" or "WITHDRAW"
"amount": string, // Amount deposited/withdrawn
"balance_after": string, // Balance after the event
"block": number, // Block number
"timestamp": number, // Unix timestamp
"datetime": string // ISO 8601 datetime
}
],
"first_seen_date": string, // ISO 8601 date
"last_seen_date": string, // ISO 8601 date
"total_holding_duration_days": number // Total duration in days
}
}
}
]
}

Single gauge endpoint (/api/strategies/pendle/holders/:gaugeId)

Returns the same structure as a single gauge object from the main endpoint - useful for fetching data for a specific gauge without loading all gauges.

User history endpoint (/api/strategies/pendle/holders/user/:address)

{
"address": string,
"total_gauges": number,
"gauges": [
{
"gauge_id": string,
"token": { "address": string, "symbol": string },
"history": { ... } // Same as user_histories object above
}
]
}

This endpoint provides comprehensive data about Pendle gauge holders, including:

• Metadata with overall statistics and gauge summaries
• Current holders with their balances
• Complete user histories with entry/exit tracking
• Detailed event logs for all deposits and withdrawals
• Holding period analysis with duration calculations
• Maximum balances held by each user