Compressors

Compressor contracts aggregate on-chain data efficiently. Instead of dozens of individual reads, a single compressor call returns complete protocol state.

Discovering Compressor Addresses

Use AddressProvider to find compressor addresses:

Solidity Usage

[address compressor] = addressProvider.getLatestAddressByContractType(
    AP_MARKET_COMPRESSOR,
    VERSION_RANGE_310
);

TypeScript Usage

import { AP_MARKET_COMPRESSOR, VERSION_RANGE_310 } from '@gearbox-protocol/sdk';

const [compressor] = sdk.addressProvider.mustGetLatest(
  AP_MARKET_COMPRESSOR,
  VERSION_RANGE_310
);

---

MarketCompressor

The primary data aggregation contract. Returns complete market state including pools, credit managers, and price oracles.

Interface

interface IMarketCompressor {
    function getMarkets(MarketFilter memory filter)
        external view returns (MarketData[] memory);

    function getMarketData(address pool)
        external view returns (MarketData memory);

    function getPoolState(address pool)
        external view returns (PoolState memory);
}

MarketFilter

struct MarketFilter {
    address[] configurators;  // Filter by Risk Curator addresses
    address[] pools;          // Filter by specific pool addresses
    address underlying;       // Filter by underlying token (e.g., USDC)
}

Pass empty arrays and address(0) for no filtering.

Solidity Usage

import {IMarketCompressor} from "@gearbox-protocol/periphery-v3/contracts/interfaces/IMarketCompressor.sol";
import {MarketData, MarketFilter} from "@gearbox-protocol/periphery-v3/contracts/types/MarketData.sol";

IMarketCompressor compressor = IMarketCompressor(MARKET_COMPRESSOR_ADDRESS);

// Get single market
MarketData memory data = compressor.getMarketData(poolAddress);

// Get all USDC markets
MarketFilter memory filter = MarketFilter({
    underlying: USDC,
    configurators: new address[](0),
    pools: new address[](0)
});
MarketData[] memory usdcMarkets = compressor.getMarkets(filter);

TypeScript Usage

import { marketCompressorAbi } from '@gearbox-protocol/sdk';

// Get all markets
const markets = await client.readContract({
  address: compressorAddress,
  abi: marketCompressorAbi,
  functionName: 'getMarkets',
  args: [{
    configurators: [],
    pools: [],
    underlying: '0x0000000000000000000000000000000000000000'
  }],
});

// Get specific pool data
const marketData = await client.readContract({
  address: compressorAddress,
  abi: marketCompressorAbi,
  functionName: 'getMarketData',
  args: [poolAddress],
});

MarketData Structure

struct MarketData {
    PoolState pool;                    // Pool state and rates
    QuotaKeeperState quotaKeeper;      // Quota limits and rates
    CreditSuiteData[] creditManagers;  // All CMs for this market
    PriceOracleState priceOracle;      // Oracle configuration
    TokenData[] tokens;                // Allowed collateral tokens
}

Key fields in PoolState:

Field	Type	Description
baseParams.addr	address	Pool contract address
availableLiquidity	uint256	Borrowable liquidity
dieselRate	uint256	Share price (RAY)
supplyRate	uint256	Lender APY (RAY)
baseInterestRate	uint256	Borrower APR (RAY)
totalAssets	uint256	Total pool value

Key fields in CreditSuiteData:

Field	Type	Description
creditManager	address	Credit Manager address
creditFacade	address	Credit Facade address
creditConfigurator	address	Configurator address
debtLimits	DebtLimits	min/max debt per account
collateralTokens	CollateralToken[]	Allowed tokens + LTs

---

CreditAccountCompressor

Fetches credit account data with filtering and pagination.

Interface

interface ICreditAccountCompressor {
    function getCreditAccounts(
        address creditManager,
        CreditAccountFilter memory filter,
        uint256 offset
    ) external view returns (CreditAccountData[] memory accounts, uint256 total);

    function countCreditAccounts(
        address creditManager,
        CreditAccountFilter memory filter
    ) external view returns (uint256);

    function getCreditAccountData(
        address creditManager,
        address creditAccount
    ) external view returns (CreditAccountData memory);
}

CreditAccountFilter

struct CreditAccountFilter {
    address owner;           // Filter by owner (address(0) = any)
    uint256 minHealthFactor; // Minimum HF (0 = no min)
    uint256 maxHealthFactor; // Maximum HF (type(uint256).max = no max)
    bool includeZeroDebt;    // Include accounts with no debt
    bool reverting;          // Include reverting accounts
}

Solidity Usage

import {ICreditAccountCompressor} from "@gearbox-protocol/periphery-v3/contracts/interfaces/ICreditAccountCompressor.sol";

ICreditAccountCompressor compressor = ICreditAccountCompressor(compressorAddress);

// Get accounts with low health factor (for liquidation)
CreditAccountFilter memory filter = CreditAccountFilter({
    owner: address(0),
    minHealthFactor: 0,
    maxHealthFactor: 10000, // HF < 1.0
    includeZeroDebt: false,
    reverting: false
});

(CreditAccountData[] memory accounts, uint256 total) =
    compressor.getCreditAccounts(creditManager, filter, 0);

TypeScript Usage

import { creditAccountCompressorAbi } from '@gearbox-protocol/sdk';

// Get all accounts with debt
const [accounts, total] = await client.readContract({
  address: compressorAddress,
  abi: creditAccountCompressorAbi,
  functionName: 'getCreditAccounts',
  args: [
    creditManagerAddress,
    {
      owner: '0x0000000000000000000000000000000000000000',
      minHealthFactor: 0n,
      maxHealthFactor: BigInt('0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'),
      includeZeroDebt: false,
      reverting: false,
    },
    0n, // offset
  ],
});

console.log(`Found ${total} accounts, fetched ${accounts.length}`);

CreditAccountData Structure

struct CreditAccountData {
    address addr;                    // Credit Account address
    address owner;                   // Account owner
    address creditManager;           // Parent Credit Manager
    uint256 debt;                    // Total debt (principal + interest)
    uint256 cumulativeIndexLastUpdate;
    uint256 cumulativeQuotaInterest;
    uint128 quotaFees;
    uint256 enabledTokensMask;       // Bitmask of enabled tokens
    uint256 healthFactor;            // Current HF (10000 = 1.0)
    TokenInfo[] tokens;              // Token balances and values
    bool isLiquidatable;
}

Pagination

Large result sets are paginated. Use offset to fetch subsequent pages:

const PAGE_SIZE = 100n;
let offset = 0n;
let allAccounts: CreditAccountData[] = [];

while (true) {
  const [accounts, total] = await compressor.read.getCreditAccounts([
    creditManager,
    filter,
    offset,
  ]);

  allAccounts.push(...accounts);
  offset += BigInt(accounts.length);

  if (offset >= total) break;
}

---

PriceFeedCompressor

Aggregates price feed state for oracle updates.

Interface

interface IPriceFeedCompressor {
    function getUpdatablePriceFeeds(address priceOracle)
        external view returns (PriceFeedData[] memory);

    function loadPriceFeedTree(address priceOracle, address token)
        external view returns (PriceFeedTreeNode memory);
}

TypeScript Usage

// Get all feeds that need updating
const feeds = await client.readContract({
  address: priceFeedCompressor,
  abi: priceFeedCompressorAbi,
  functionName: 'getUpdatablePriceFeeds',
  args: [priceOracleAddress],
});

// Filter for stale feeds
const staleFeeds = feeds.filter(f => f.needsUpdate);

---

When to Use Compressors vs SDK

Scenario	Approach
General market data	SDK marketRegister
Credit account queries	SDK services
Custom filtering logic	Direct compressor calls
Liquidation bots	Direct compressor (gas-optimized)
On-chain integration	Direct compressor (no SDK in contracts)
Real-time monitoring	Direct compressor with specific filters

The SDK uses compressors internally. Use direct compressor calls when you need:

• Custom filter combinations not exposed by SDK

• Pagination control

• Gas-optimized queries for bots

• On-chain access (Solidity contracts)

---

Complete Example

TypeScript

import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import {
  marketCompressorAbi,
  creditAccountCompressorAbi,
} from '@gearbox-protocol/sdk';

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

async function getMarketOverview() {
  const marketCompressor = '0x...'; // From AddressProvider

  const markets = await client.readContract({
    address: marketCompressor,
    abi: marketCompressorAbi,
    functionName: 'getMarkets',
    args: [{ configurators: [], pools: [], underlying: '0x0000000000000000000000000000000000000000' }],
  });

  for (const market of markets) {
    console.log(`Pool: ${market.pool.baseParams.addr}`);
    console.log(`  Available: ${market.pool.availableLiquidity}`);
    console.log(`  Supply Rate: ${market.pool.supplyRate}`);
  }
}

async function findLiquidatableAccounts(creditManager: `0x${string}`) {
  const accountCompressor = '0x...'; // From AddressProvider

  const [accounts] = await client.readContract({
    address: accountCompressor,
    abi: creditAccountCompressorAbi,
    functionName: 'getCreditAccounts',
    args: [
      creditManager,
      {
        owner: '0x0000000000000000000000000000000000000000',
        minHealthFactor: 0n,
        maxHealthFactor: 10000n, // HF < 1.0
        includeZeroDebt: false,
        reverting: false,
      },
      0n,
    ],
  });

  return accounts.filter(a => a.isLiquidatable);
}

Solidity

function getMarketData(address pool) external view returns (MarketData memory) {
    return IMarketCompressor(MARKET_COMPRESSOR).getMarketData(pool);
}

function findLiquidatableAccounts(address creditManager)
    external view returns (CreditAccountData[] memory)
{
    CreditAccountFilter memory filter = CreditAccountFilter({
        owner: address(0),
        minHealthFactor: 0,
        maxHealthFactor: 10000,
        includeZeroDebt: false,
        reverting: false
    });

    (CreditAccountData[] memory accounts,) =
        ICreditAccountCompressor(ACCOUNT_COMPRESSOR).getCreditAccounts(
            creditManager,
            filter,
            0
        );

    return accounts;
}