Gearbox

https://docs.gearbox.finance
Admin
Gearbox is a permissionless lending protocol that enables institutions, asset-issuers, and fintechs...
Tokens:148,178
Snippets:1,626
Trust Score:7.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Complete Gearbox SDK Example

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/setup

A comprehensive example demonstrating SDK initialization, market discovery, credit account service creation, and querying credit accounts. This example finds the USDC market, logs the number of credit managers, and then queries credit accounts for the first credit manager.

```typescript
import { GearboxSDK, createCreditAccountService } from '@gearbox-protocol/sdk';
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';

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

  // Initialize SDK
  const sdk = await GearboxSDK.attach({
    client,
    marketConfigurators: [],
  });

  // Find USDC market
  const usdcMarket = sdk.marketRegister.markets.find(
    m => m.pool.underlying.symbol === 'USDC'
  );

  if (!usdcMarket) throw new Error('USDC market not found');

  // Get credit managers for this market
  const creditManagers = usdcMarket.creditManagers;
  console.log(`Found ${creditManagers.length} credit managers`);

  // Create service for account operations
  const service = createCreditAccountService(sdk, 310);

  // Query accounts
  const accounts = await service.getCreditAccounts(
    { creditManager: creditManagers[0].address },
    sdk.currentBlock
  );
  console.log(`Found ${accounts.length} credit accounts`);
}

main().catch(console.error);
```

--------------------------------

### Execute Bot Operations with TypeScript

Source: https://docs.gearbox.finance/dev/operations/bots

TypeScript example demonstrating how to create a bot client, get a contract instance, and prepare a list of calls for bot operations. It shows how to encode function data for actions like adding collateral and executing swaps.

```TypeScript
// TypeScript: Bot executing operations
const botClient = createWalletClient({
  account: botAccount,
  chain: mainnet,
  transport: http(),
});

const creditFacade = getContract({
  address: facadeAddress,
  abi: creditFacadeV3Abi,
  client: botClient,
});

// Bot-initiated operations
const calls = [
  // Add collateral
  {
    target: facadeAddress,
    callData: encodeFunctionData({
      abi: creditFacadeMulticallAbi,
      functionName: 'addCollateral',
      args: [usdcAddress, parseUnits('1000', 6)]
    })
  },
  // Execute swap via adapter
  {
    target: uniswapAdapterAddress,
    callData: encodeFunctionData({
      abi: uniswapAdapterAbi,
      functionName: 'exactInputSingle',
      args: [swapParams]
    })
  }
];

// Execute as bot
await creditFacade.write.botMulticall([creditAccountAddress, calls]);
```

--------------------------------

### Full Liquidation Step-by-Step Example

Source: https://docs.gearbox.finance/dev/operations/liquidations

An example demonstrating how a liquidation bot might construct the necessary calls and invoke the `liquidateCreditAccount` function.

```APIDOC
## Full Liquidation Execution Example

### Description
This example illustrates the process of identifying an unhealthy account, constructing a multicall for collateral conversion, and calling the `liquidateCreditAccount` function.

### Method
`creditFacade.write.liquidateCreditAccount([
  creditAccountAddress,
  liquidatorAddress,  // receives remaining assets
  calls,
  '0x'  // lossPolicyData
]);`

### Parameters
#### Request Body
* `creditAccountAddress` (address) - The address of the account to be liquidated.
* `liquidatorAddress` (address) - The address of the liquidator who will receive remaining assets.
* `calls` (Array<object>) - An array of objects, each representing a multicall operation. Typically used for swapping collateral tokens to the underlying asset. Example structure:
  ```typescript
  [
    {
      target: uniswapAdapterAddress,
      callData: encodeFunctionData({
        abi: uniswapAdapterAbi,
        functionName: 'exactAllInputSingle',
        args: [{ tokenIn: wbtcAddress, tokenOut: usdcAddress, ... }]
      })
    }
  ]
  ```
* `lossPolicyData` (string) - Hex-encoded data for loss handling policy. Often '0x' if no custom policy is applied.
```

--------------------------------

### Complete Example: Gas-Optimized Multicall

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls/collateral-check-params

A comprehensive example demonstrating a gas-optimized multicall that includes setting collateral check parameters with hints and performing various operations. This setup prioritizes specific tokens for debt coverage to potentially reduce gas costs.

```typescript
import { encodeFunctionData, getContract } from 'viem';
import {
  GearboxSDK,
  createCreditAccountService,
  iCreditFacadeV300MulticallAbi,
  creditManagerAbi,
} from '@gearbox-protocol/sdk';

const sdk = await GearboxSDK.attach({ client, marketConfigurators: [] });
const service = createCreditAccountService(sdk, 310);
const market = sdk.marketRegister.findByCreditManager(cmAddress);

const creditManager = getContract({
  address: market.creditManager.address,
  abi: creditManagerAbi,
  client: publicClient,
});

// Get masks for tokens that will cover the debt
const usdcMask = await creditManager.read.getTokenMaskOrRevert([usdcAddress]);

const calls = [
  // Hints first - USDC will cover most of debt
  {
    target: market.creditFacade.address,
    callData: encodeFunctionData({
      abi: iCreditFacadeV300MulticallAbi,
      functionName: 'setFullCheckParams',
      args: [
        [usdcMask],  // USDC covers debt, check it first
        10500,       // Require 1.05 HF minimum
      ],
    }),
  },

  service.prepareAddCollateral(usdcAddress, 100_000n * 10n ** 6n),
  service.prepareIncreaseDebt(200_000n * 10n ** 6n),

  // Swap some USDC to WETH
  {
    target: uniswapAdapter,
    callData: encodeSwap(/* ... */),
  },
];
```

--------------------------------

### Complete Example: Leveraging a Position

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls

A full example demonstrating how to open a credit account, add collateral, borrow, set quotas, and execute the transaction using the Gearbox SDK.

```typescript
import {
  GearboxSDK,
  createCreditAccountService,
  iCreditFacadeV300MulticallAbi,
} from '@gearbox-protocol/sdk';
import { encodeFunctionData, createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';

async function leveragePosition() {
  const publicClient = createPublicClient({
    chain: mainnet,
    transport: http(),
  });

  const sdk = await GearboxSDK.attach({
    client: publicClient,
    marketConfigurators: [],
  });

  const service = createCreditAccountService(sdk, 310);

  // Find market
  const market = sdk.marketRegister.findByCreditManager(cmAddress);

  // Build multicall
  const calls = [
    // Add collateral
    service.prepareAddCollateral(usdcAddress, 10_000n * 10n ** 6n),

    // Borrow
    service.prepareIncreaseDebt(40_000n * 10n ** 6n),

    // Set quota for final token
    service.prepareUpdateQuota(targetToken, 50_000n * 10n ** 6n, 50_000n * 10n ** 6n),
  ];

  // Execute
  const walletClient = createWalletClient({
    chain: mainnet,
    transport: http(),
    account: myAccount,
  });

  const hash = await walletClient.writeContract({
    address: market.creditFacade.address,
    abi: creditFacadeAbi,
    functionName: 'openCreditAccount',
    args: [myAccount.address, calls, 0n],
  });

  console.log(`Transaction: ${hash}`);
}
```

--------------------------------

### Complete Example: Market Overview

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/reading-data

A comprehensive example demonstrating the initialization of the viem client and Gearbox SDK, followed by iterating through all markets to log key information like underlying symbol, pool address, total assets, available liquidity, and supply APY.

```typescript
import { GearboxSDK } from '@gearbox-protocol/sdk';
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';

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

  const sdk = await GearboxSDK.attach({
    client,
    marketConfigurators: [],
  });

  const RAY = 10n ** 27n;

  for (const market of sdk.marketRegister.markets) {
    const pool = market.pool;

    console.log(`\n=== ${pool.underlying.symbol} Market ===`);
    console.log(`Pool: ${pool.address}`);
    console.log(`Total assets: ${pool.totalAssets}`);
    console.log(`Available: ${pool.availableLiquidity}`);

    const supplyAPY = Number(pool.supplyRate * 10000n / RAY) / 100;
    console.log(`Supply APY: ${supplyAPY.toFixed(2)}%`);

    console.log(`Credit Managers: ${market.creditManagers.length}`);
  }
}

getMarketOverview().catch(console.error);
```

--------------------------------

### Complete Example: Simple Liquidation Bot

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/use-cases/liquidation-bots

This is a full example of a liquidation bot. It continuously monitors credit accounts for liquidation opportunities, filters them by profitability, and executes liquidations. Requires environment variable PRIVATE_KEY to be set.

```typescript
import { createPublicClient, createWalletClient, http, parseGwei } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';
import {
  GearboxSDK,
  creditAccountCompressorAbi,
  AP_CREDIT_ACCOUNT_COMPRESSOR,
  VERSION_RANGE_310,
} from '@gearbox-protocol/sdk';

const MIN_PROFIT_USD = 100n * 10n ** 6n; // $100 minimum profit

async function runLiquidationBot(creditManagerAddress: `0x${string}`) {
  const client = createPublicClient({
    chain: mainnet,
    transport: http(),
  });

  const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
  const walletClient = createWalletClient({
    account,
    chain: mainnet,
    transport: http(),
  });

  const sdk = await GearboxSDK.attach({
    client,
    marketConfigurators: [],
  });

  const [accountCompressor] = sdk.addressProvider.mustGetLatest(
    AP_CREDIT_ACCOUNT_COMPRESSOR,
    VERSION_RANGE_310
  );

  const market = sdk.marketRegister.findByCreditManager(creditManagerAddress);

  console.log(`Monitoring ${market.creditManagers[0].address}`);
  console.log(`Liquidator: ${account.address}`);

  while (true) {
    try {
      // Find liquidatable accounts
      const [accounts] = await client.readContract({
        address: accountCompressor,
        abi: creditAccountCompressorAbi,
        functionName: 'getCreditAccounts',
        args: [
          creditManagerAddress,
          {
            owner: '0x0000000000000000000000000000000000000000',
            minHealthFactor: 0n,
            maxHealthFactor: 10000n,
            includeZeroDebt: false,
            reverting: false,
          },
          0n,
        ],
      });

      const liquidatable = accounts.filter(a => a.isLiquidatable);

      if (liquidatable.length > 0) {
        console.log(`Found ${liquidatable.length} liquidatable accounts`);

        for (const target of liquidatable) {
          const totalValue = target.tokens.reduce(
            (sum, t) => sum + t.balanceInUnderlying,
            0n
          );

          const estimatedProfit = totalValue - target.debt;

          if (estimatedProfit > MIN_PROFIT_USD) {
            console.log(`Profitable opportunity: ${target.addr}`);
            console.log(`  Debt: ${target.debt}`);
            console.log(`  Value: ${totalValue}`);
            console.log(`  Est. Profit: ${estimatedProfit}`);

            // Build and execute liquidation
            // (simplified - real bot would compute optimal swaps)
            const calls = buildLiquidationCalls(target, market);

            try {
              // Simulate
              await client.simulateContract({
                address: market.creditFacade.address,
                abi: creditFacadeAbi,
                functionName: 'liquidateCreditAccount',
                args: [target.addr, account.address, calls],
                account: account.address,
              });

              // Execute
              const hash = await walletClient.writeContract({
                address: market.creditFacade.address,
                abi: creditFacadeAbi,
                functionName: 'liquidateCreditAccount',
                args: [target.addr, account.address, calls],
                maxPriorityFeePerGas: parseGwei('2'),
              });

              console.log(`Liquidation submitted: ${hash}`);
            } catch (error) {
              console.log(`Failed to liquidate ${target.addr}:`, error);
            }
          }
        }
      }
    } catch (error) {
      console.error('Loop error:', error);
    }

    // Poll every 3 seconds
    await new Promise(resolve => setTimeout(resolve, 3000));
  }
}

function buildLiquidationCalls(
  account: CreditAccountData,
  market: MarketData
): Array<{ target: `0x${string}`; callData: `0x${string}` }> {
  const calls: Array<{ target: `0x${string}`; callData: `0x${string}` }> = [];
  const creditFacade = market.creditFacade.address;
  const underlying = market.pool.underlying.address;

  // 1. Swap each non-underlying collateral token to underlying via adapter
  for (const token of account.tokens) {
    if (token.balance <= 1n) continue; // skip dust
    if (token.token === underlying) continue; // skip underlying itself

    // Use Uniswap V3 adapter for swaps (simplified: hardcoded router)
    const uniswapAdapter = market.adapters?.['UNISWAP_V3_ROUTER'];
    if (!uniswapAdapter) continue;

    // exactAllInputSingle swaps entire balance minus 1 wei
    calls.push({
      target: uniswapAdapter,
      callData: encodeFunctionData({
        abi: uniswapV3AdapterAbi,
        functionName: 'exactAllInputSingle',
        args: [{
          tokenIn: token.token,
          tokenOut: underlying,
          fee: 3000, // 0.3% pool (use 500 for stablecoin pairs)
          deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
          rateMinRAY: 0n, // No slippage protection (simplified)

```

--------------------------------

### Querying Documentation Dynamically

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/debt-management

Shows how to perform an HTTP GET request to query documentation dynamically using the `ask` query parameter. Use this to get answers not explicitly present on the page.

```http
GET https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/debt-management.md?ask=<question>
```

--------------------------------

### Complete Example: Swap with Slippage Protection

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls/making-external-calls

A comprehensive example demonstrating how to add collateral, borrow, set slippage protection using Credit Facade's 'storeExpectedBalances' and 'compareBalances', and execute a swap via a Uniswap V3 adapter. It also shows how to use SDK helpers for common operations.

```typescript
import {
  encodeFunctionData
} from 'viem';
import {
  GearboxSDK,
  createCreditAccountService,
  iCreditFacadeV300MulticallAbi,
} from '@gearbox-protocol/sdk';

const sdk = await GearboxSDK.attach({ client, marketConfigurators: [] });
const service = createCreditAccountService(sdk, 310);
const market = sdk.marketRegister.findByCreditManager(cmAddress);

// Get adapter
const uniswapV3Adapter = await market.creditManager.read.contractToAdapter([
  UNISWAP_V3_ROUTER,
]);

const calls = [
  // Add collateral (SDK helper)
  service.prepareAddCollateral(usdcAddress, 50_000n * 10n ** 6n),

  // Borrow (SDK helper)
  service.prepareIncreaseDebt(200_000n * 10n ** 6n),

  // Slippage protection start
  {
    target: market.creditFacade.address,
    callData: encodeFunctionData({
      abi: iCreditFacadeV300MulticallAbi,
      functionName: 'storeExpectedBalances',
      args: [[{ token: wethAddress, amount: 99n * 10n ** 18n }]], // Expect ~100 WETH
    }),
  },

  // Swap via adapter (manual encoding)
  {
    target: uniswapV3Adapter,
    callData: encodeFunctionData({
      abi: uniswapV3AdapterAbi,
      functionName: 'exactInputSingle',
      args: [swapParams],
    }),
  },

  // Slippage protection end
  {
    target: market.creditFacade.address,
    callData: encodeFunctionData({
      abi: iCreditFacadeV300MulticallAbi,
      functionName: 'compareBalances',
      args: [],
    }),
  },

  // Set quota for received token (SDK helper)
  service.prepareUpdateQuota(wethAddress, 250_000n * 10n ** 6n, 250_000n * 10n ** 6n),
];

// Approve collateral to Credit Manager
await usdcContract.write.approve([market.creditManager.address, 50_000n * 10n ** 6n]);

// Execute
await market.creditFacade.write.openCreditAccount([ownerAddress, calls, 0n]);
```

--------------------------------

### Query Documentation Dynamically

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/setup

Perform an HTTP GET request to a documentation URL with an 'ask' query parameter to get dynamic answers and relevant excerpts from the documentation.

```http
GET https://docs.gearbox.finance/dev/sdk-guide-typescript/setup.md?ask=<question>
```

--------------------------------

### Install Gearbox SDK and viem

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/setup

Install the necessary packages for Gearbox SDK and viem using npm.

```typescript
npm install @gearbox-protocol/sdk viem
```

--------------------------------

### Querying Documentation Dynamically

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls

Perform an HTTP GET request on the current page URL with the `ask` query parameter to get dynamic documentation answers. The question should be specific and self-contained.

```http
GET https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls.md?ask=<question>
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/curator-docs/advanced-configuration/configure-a-market

Perform an HTTP GET request to the current page URL with the `ask` query parameter to get dynamic answers to your questions. The question should be specific and self-contained.

```http
GET https://docs.gearbox.finance/curator-docs/advanced-configuration/configure-a-market.md?ask=<question>
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/user-docs/user-guides

Perform an HTTP GET request on the current page URL with the `ask` query parameter to dynamically query the documentation. Use this when information is not explicitly present, requires clarification, or needs related sections.

```http
GET https://docs.gearbox.finance/user-docs/user-guides.md?ask=<question>
```

--------------------------------

### Query Documentation with `ask` Parameter

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/updating-price-feeds

Use this GET request format to query the documentation dynamically. Include your question as the value for the `ask` query parameter.

```http
GET https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/updating-price-feeds.md?ask=<question>
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/dev/operations

Perform an HTTP GET request to the current page URL with the 'ask' query parameter to dynamically query the documentation. Use this when information is not explicitly present or for clarification.

```http
GET https://docs.gearbox.finance/dev/operations.md?ask=<question>
```

--------------------------------

### Slippage Protection Setup

Source: https://docs.gearbox.finance/dev/concepts/multicall-system

Demonstrates the pattern for slippage protection using `storeExpectedBalances` before a swap and `compareBalances` after to verify the transaction outcome.

```solidity
callData.push(creditFacade.interface.encodeFunctionCall(creditFacade.storeExpectedBalances, [token, amount]));
// ... swap operation ...
callData.push(creditFacade.interface.encodeFunctionCall(creditFacade.compareBalances, [token, amount]));
```

--------------------------------

### Query Documentation with GET Request

Source: https://docs.gearbox.finance/introduction

Perform an HTTP GET request to the current page URL with the 'ask' query parameter to dynamically query the documentation. Use this when the answer is not explicitly present, for clarification, or to retrieve related sections.

```http
GET https://docs.gearbox.finance/introduction.md?ask=<question>
```

--------------------------------

### Querying Documentation via HTTP GET

Source: https://docs.gearbox.finance/curator-docs/protocol-roles/emergency-admin

Perform an HTTP GET request on a documentation page URL with the `ask` query parameter to dynamically query for information. The question should be specific and self-contained.

```HTTP
GET https://docs.gearbox.finance/curator-docs/protocol-roles/emergency-admin.md?ask=<question>
```

--------------------------------

### Query Documentation Dynamically

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript

Perform an HTTP GET request on a documentation page URL with the 'ask' query parameter to get dynamic answers. The question should be specific and self-contained. Use this for clarification or retrieving related information not explicitly present.

```http
GET https://docs.gearbox.finance/dev/sdk-guide-typescript.md?ask=<question>
```

--------------------------------

### Query Documentation Dynamically

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/use-cases/liquidation-bots

Use this GET request format to query the documentation dynamically with a specific question. This is useful for retrieving answers not explicitly present on the current page or for getting additional context.

```http
GET https://docs.gearbox.finance/dev/sdk-guide-typescript/use-cases/liquidation-bots.md?ask=<question>
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/about-gearbox/core-architecture/credit-suite

Perform an HTTP GET request on a documentation page URL with the `ask` query parameter to dynamically query for information. The question should be specific and in natural language. Use this when the answer is not explicitly present, for clarification, or to retrieve related documentation.

```HTTP
GET https://docs.gearbox.finance/about-gearbox/core-architecture/credit-suite.md?ask=<question>
```

--------------------------------

### Complete 8-Call Multicall Strategy Example

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls

This example demonstrates a complex 8-call strategy involving price updates, collateral management, borrowing, slippage checks, swaps, and deposits. Ensure price updates are first and use `storeExpectedBalances` before swaps and `compareBalances` after for slippage protection. Token approvals should be directed to the Credit Manager.

```solidity
address accountOwner;
address creditManager;
address creditFacade;
address usdc;
address weth;
address yvWETH;
address uniswapV3Router;
bytes memory yvWETH_priceData;

// Assume exchange rate: 2000 USDC/yvWETH

MultiCall[] memory calls = new MultiCall[](8);

// 1. On-demand price update (must be first)
calls[0] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.onDemandPriceUpdate,
        (yvWETH, false, yvWETH_priceData)
    )
});

// 2. Add collateral
calls[1] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.addCollateral,
        (usdc, 10_000 * 10**6)
    )
});

// 3. Borrow
calls[2] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.increaseDebt,
        (40_000 * 10**6)
    )
});

// 4. Store expected balances for slippage check
// Min output: (50000 / 2000) * 0.995 = 24.875 yvWETH
BalanceDelta[] memory deltas = new BalanceDelta[](1);
deltas[0] = BalanceDelta({
    token: yvWETH,
    amount: (25 * 10**18) * 995 / 1000
});

calls[3] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.storeExpectedBalances,
        (deltas)
    )
});

// 5. Swap via Uniswap
address uniswapV3Adapter = ICreditManagerV3(creditManager).contractToAdapter(uniswapV3Router);

ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
    tokenIn: usdc,
    tokenOut: weth,
    fee: 500,
    recipient: address(0), // Adapter overrides
    deadline: block.timestamp + 3600,
    amountIn: 50_000 * 10**6,
    amountOutMinimum: 0, // Using Gearbox slippage check
    sqrtPriceLimitX96: 0
});

calls[4] = MultiCall({
    target: uniswapV3Adapter,
    callData: abi.encodeCall(IUniswapV3Adapter.exactInputSingle, (params))
});

// 6. Deposit to Yearn using diff pattern
address yvWETHAdapter = ICreditManagerV3(creditManager).contractToAdapter(yvWETH);

calls[5] = MultiCall({
    target: yvWETHAdapter,
    callData: abi.encodeCall(IYearnV2Adapter.depositDiff, (1)) // Leave 1 wei
});

// 7. Compare balances (slippage check)
calls[6] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(ICreditFacadeV3Multicall.compareBalances, ())
});

// 8. Set quota for yvWETH
calls[7] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.updateQuota,
        (yvWETH, 50_000 * 10**6, 50_000 * 10**6)
    )
});

// Approve collateral to Credit Manager (not Facade!)
IERC20(usdc).approve(creditManager, 10_000 * 10**6);

// Execute
ICreditFacadeV3(creditFacade).openCreditAccount(accountOwner, calls, 0);

```

--------------------------------

### TypeScript Usage: Get Updatable Price Feeds

Source: https://docs.gearbox.finance/dev/utilities/compressors

Demonstrates fetching updatable price feeds using the Gearbox SDK in TypeScript. The example shows how to filter for feeds that require an update.

```typescript
// 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);
```

--------------------------------

### Example: Open Credit Account - Solidity

Source: https://docs.gearbox.finance/dev/solidity-guide/credit-accounts

Demonstrates how to open a credit account by first building a multicall array for initial operations like adding collateral and increasing debt. It also shows the necessary approval step for the collateral.

```solidity
ICreditFacadeV3 facade = ICreditFacadeV3(facadeAddress);
ICreditManagerV3 creditManager = ICreditManagerV3(facade.creditManager());
address underlying = creditManager.underlying();

// Build initial multicall: add collateral + increase debt
MultiCall[] memory calls = new MultiCall[](2);
calls[0] = MultiCall({
    target: facadeAddress,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.addCollateral,
        (underlying, 10_000e6)
    )
});
calls[1] = MultiCall({
    target: facadeAddress,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.increaseDebt,
        (40_000e6)
    )
});

// Approve collateral to Credit Manager (not Facade!)
IERC20(underlying).approve(address(creditManager), 10_000e6);

// Open account
address creditAccount = facade.openCreditAccount(
    msg.sender,  // onBehalfOf
    calls,       // initial operations
    0            // referralCode
);
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/user-docs/opportunities

To get additional information not directly available on a page, perform an HTTP GET request with the `ask` query parameter. The question should be specific and self-contained. Use this to get answers, clarifications, or related documentation.

```http
GET https://docs.gearbox.finance/user-docs/opportunities.md?ask=<question>
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/about-gearbox/reference/usecase-faster-rwa-settlement-with-leverage

To get additional information not directly present on a page, perform an HTTP GET request to the page URL with an 'ask' query parameter containing your question.

```http
GET https://docs.gearbox.finance/about-gearbox/reference/usecase-faster-rwa-settlement-with-leverage.md?ask=<question>
```

--------------------------------

### Complete Gas-Optimized Strategy

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/collateral-check-params

A comprehensive example demonstrating a gas-optimized strategy using `setFullCheckParams` with hints, adding collateral, borrowing, and performing a swap. It requires specific addresses and adapter interfaces.

```Solidity
address creditManager;
address usdc;
address uniswapAdapter;

// Get mask for primary collateral token
uint256 usdcMask = ICreditManagerV3(creditManager).getTokenMaskOrRevert(usdc);

uint256[] memory hints = new uint256[](1);
hints[0] = usdcMask;

MultiCall[] memory calls = new MultiCall[](4);

// 1. Hints first - USDC will cover most of debt
calls[0] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.setFullCheckParams,
        (hints, 10500)  // Require 1.05 HF minimum
    )
});

// 2. Add collateral
calls[1] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.addCollateral,
        (usdc, 100_000 * 10**6)
    )
});

// 3. Borrow
calls[2] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.increaseDebt,
        (200_000 * 10**6)
    )
});

// 4. Swap some USDC to WETH
calls[3] = MultiCall({
    target: uniswapAdapter,
    callData: abi.encodeCall(
        IUniswapV3Adapter.exactInputSingle,
        (swapParams)
    )
});

ICreditFacadeV3(creditFacade).multicall(creditAccount, calls);
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/curator-docs/advanced-configuration/configure-fee-split

To get more information not present on the page, perform an HTTP GET request to the current page URL with the `ask` query parameter. The question should be specific and self-contained.

```http
GET https://docs.gearbox.finance/curator-docs/advanced-configuration/configure-fee-split.md?ask=<question>
```

--------------------------------

### Build a Simple Liquidation Bot

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/use-cases/liquidation-bots

This example demonstrates the core logic for constructing a basic liquidation bot. It outlines the necessary calls and configurations for monitoring and executing liquidations.

```typescript
async function getLiquidationCalls(provider: Provider, gearbox: Gearbox) {
  const calls: Call[] = [];
  const { network } = provider;
  const { config } = gearbox;

  // Check if the network is supported
  if (!config.supportedNetworks.includes(network.chainId)) {
    console.warn(`Network ${network.chainId} is not supported.`);
    return calls;
  }

  // Get all open credit accounts
  const creditAccounts = await gearbox.getCreditAccounts();

  // Iterate over credit accounts and check for liquidation
  for (const creditAccount of creditAccounts) {
    const { address, health, lastSlippage, borrowed } = creditAccount;

    // Check if the credit account is at risk of liquidation
    if (health < 1000 && lastSlippage > 0.05) {
      console.log(`Credit account ${address} is at risk of liquidation. Health: ${health}, Slippage: ${lastSlippage}`);

      // Determine the optimal liquidation amount
      const liquidationAmount = borrowed * lastSlippage;

      // Add a liquidation call to the list
      calls.push({
        target: gearbox.contract.address,
        callData: gearbox.contract.interface.encodeFunctionData("liquidate", [
          address,
          liquidationAmount,
        ]),
        value: 0,
      });
    }
  }

  // If there are liquidation calls, execute them
  if (calls.length > 0) {
    console.log(`Executing ${calls.length} liquidation calls.`);
    await gearbox.multicall(calls);
  }

  return calls;
}

// Example usage:
// const provider = new ethers.providers.JsonRpcProvider("YOUR_RPC_URL");
// const gearbox = new Gearbox(provider, "YOUR_GEARBOX_ADDRESS");
// getLiquidationCalls(provider, gearbox).then(calls => {
//   console.log("Liquidation calls executed:", calls);
// }).catch(error => {
//   console.error("Error executing liquidation calls:", error);
// });

```

--------------------------------

### Querying Documentation via GET Request

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/making-external-calls

To get additional information not directly present on the page, perform an HTTP GET request to the current page URL with the `ask` query parameter. The question should be specific and self-contained.

```http
GET https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/making-external-calls.md?ask=<question>
```

--------------------------------

### Full Liquidation Entry Point

Source: https://docs.gearbox.finance/dev/operations/liquidations

This function is the entry point for initiating a full liquidation of a credit account. It requires the credit account address, the recipient of remaining assets, a multicall array for collateral conversion, and custom data for loss handling.

```solidity
function liquidateCreditAccount(
    address creditAccount,
    address to,
    MultiCall[] calldata calls,
    bytes memory lossPolicyData
)
```

--------------------------------

### Dynamic Documentation Query Mechanism

Source: https://docs.gearbox.finance/dev/utilities/automated-insurance

Demonstrates how to query documentation dynamically using an HTTP GET request with an 'ask' query parameter. This is useful for retrieving specific information not explicitly present on the page or for clarification.

```http
GET https://docs.gearbox.finance/dev/utilities/automated-insurance.md?ask=<question>
```

--------------------------------

### Fetch Off-Chain Price Data (Redstone Example)

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls/updating-price-feeds

Retrieve price data payload from the Redstone oracle. This is a simplified example and must be handled by your contract or frontend.

```typescript
// Redstone example (simplified)
const redstonePayload = await getRedstonePayload([tokenSymbol]);
```

--------------------------------

### Basic Usage with Hints

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/collateral-check-params

Configure collateral check parameters with token hints and a minimum health factor of 1.0. Ensure you have the necessary interfaces and addresses before use.

```Solidity
import {ICreditFacadeV3Multicall} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3Multicall.sol";
import {MultiCall} from "@gearbox-protocol/core-v3/contracts/interfaces/ICreditFacadeV3.sol";

address creditFacade;
address creditAccount;
address creditManager;
address usdc;
address weth;

// Get token masks (each token has a unique bitmask)
uint256 usdcMask = ICreditManagerV3(creditManager).getTokenMaskOrRevert(usdc);
uint256 wethMask = ICreditManagerV3(creditManager).getTokenMaskOrRevert(weth);

// Build hints array
uint256[] memory hints = new uint256[](2);
hints[0] = usdcMask;
hints[1] = wethMask;

MultiCall[] memory calls = new MultiCall[](2);

// Set hints at the start of multicall
calls[0] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.setFullCheckParams,
        (
            hints,   // Check these tokens first
            10000    // minHealthFactor: 1.0 (10000 bps)
        )
    )
});

// Rest of your multicall operations
calls[1] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.addCollateral,
        (usdc, 100_000 * 10**6)
    )
});

ICreditFacadeV3(creditFacade).multicall(creditAccount, calls);
```

--------------------------------

### Query Documentation via HTTP GET

Source: https://docs.gearbox.finance/curator-docs/curation-step-by-step/create-a-new-curator-market-configurator

Perform an HTTP GET request on a documentation page URL with the 'ask' query parameter to retrieve specific information or clarifications.

```HTTP
GET https://docs.gearbox.finance/curator-docs/curation-step-by-step/create-a-new-curator-market-configurator.md?ask=<question>
```

--------------------------------

### Combined Strategy: Add Collateral + Borrow

Source: https://docs.gearbox.finance/dev/solidity-guide/multicalls/multicalls/debt-management

This pattern demonstrates opening a credit account by first adding collateral and then increasing debt against it. Remember to approve the collateral to the Credit Manager before executing the calls.

```Solidity
MultiCall[] memory calls = new MultiCall[](2);

// 1. Add initial collateral
calls[0] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.addCollateral,
        (usdc, 10_000 * 10**6)  // 10k USDC as collateral
    )
});

// 2. Borrow against it
calls[1] = MultiCall({
    target: creditFacade,
    callData: abi.encodeCall(
        ICreditFacadeV3Multicall.increaseDebt,
        (40_000 * 10**6)  // Borrow 40k USDC (4x leverage)
    )
});

// Approve collateral to Credit Manager first
IERC20(usdc).approve(creditManager, 10_000 * 10**6);

// Open account with collateral and debt
ICreditFacadeV3(creditFacade).openCreditAccount(owner, calls, 0);
```

--------------------------------

### Run Health Monitor Service

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/use-cases/health-factor-monitoring

This example demonstrates a complete health monitor service. It continuously polls credit accounts for their health factor, logs alerts for liquidatable, critical, or warning states, and handles potential errors. It requires setting up viem and the Gearbox SDK.

```typescript
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import {
  GearboxSDK,
  creditAccountCompressorAbi,
  AP_CREDIT_ACCOUNT_COMPRESSOR,
  VERSION_RANGE_310,
} from '@gearbox-protocol/sdk';

const WARNING_HF = 1.15;
const CRITICAL_HF = 1.05;
const POLL_INTERVAL = 10_000; // 10 seconds

async function runHealthMonitor(
  creditManagerAddress: `0x${string}`,
  ownerAddress: `0x${string}`
) {
  const client = createPublicClient({
    chain: mainnet,
    transport: http(),
  });

  const sdk = await GearboxSDK.attach({
    client,
    marketConfigurators: [],
  });

  const [accountCompressor] = sdk.addressProvider.mustGetLatest(
    AP_CREDIT_ACCOUNT_COMPRESSOR,
    VERSION_RANGE_310
  );

  let previousHFs = new Map<string, number>();

  while (true) {
    try {
      const [accounts] = await client.readContract({
        address: accountCompressor,
        abi: creditAccountCompressorAbi,
        functionName: 'getCreditAccounts',
        args: [
          creditManagerAddress,
          {
            owner: ownerAddress,
            minHealthFactor: 0n,
            maxHealthFactor: 65535n,
            includeZeroDebt: false,
            reverting: false,
          },
          0n,
        ],
      });

      for (const account of accounts) {
        const hf = Number(account.healthFactor) / 10000;
        const prevHF = previousHFs.get(account.addr);
        previousHFs.set(account.addr, hf);

        // Determine direction
        const direction = prevHF !== undefined
          ? (hf > prevHF ? 'improving' : hf < prevHF ? 'declining' : 'stable')
          : 'initial';

        // Classify and alert
        if (hf < 1.0) {
          console.log(`LIQUIDATABLE: ${account.addr} HF=${hf.toFixed(4)} [${direction}]`);
        } else if (hf < CRITICAL_HF) {
          console.log(`CRITICAL: ${account.addr} HF=${hf.toFixed(4)} [${direction}]`);
        } else if (hf < WARNING_HF) {
          console.log(`WARNING: ${account.addr} HF=${hf.toFixed(4)} [${direction}]`);
        } else if (direction !== 'stable') {
          console.log(`OK: ${account.addr} HF=${hf.toFixed(4)} [${direction}]`);
        }
      }
    } catch (error) {
      console.error('Monitor error:', error);
    }

    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL));
  }
}

runHealthMonitor('0x...', '0x...').catch(console.error);
```

--------------------------------

### Perform HTTP GET Request with `ask` Parameter

Source: https://docs.gearbox.finance/dev/concepts/pools

Use this method to query the documentation dynamically. The question should be specific and self-contained. The response will include a direct answer and relevant excerpts.

```http
GET https://docs.gearbox.finance/dev/concepts/pools.md?ask=<question>
```

--------------------------------

### Security Modifier: creditFacadeOnly

Source: https://docs.gearbox.finance/dev/solidity-guide/use-cases/adapter-development

Illustrates the correct usage of the `creditFacadeOnly` modifier to restrict external function calls to the CreditFacade. The WRONG example shows an unprotected function, while the CORRECT example enforces the modifier.

```solidity
// WRONG - allows anyone to call
function deposit(uint256 amount) external returns (uint256) { ... }

// CORRECT - only CreditFacade can call
function deposit(uint256 amount) external creditFacadeOnly returns (uint256) { ... }
```

--------------------------------

### MarketCompressor Usage (Solidity)

Source: https://docs.gearbox.finance/dev/utilities/compressors

Demonstrates how to instantiate and use MarketCompressor to fetch single market data or all markets for a specific underlying token.

```solidity
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);
```

--------------------------------

### Perform HTTP GET Request with `ask` Parameter

Source: https://docs.gearbox.finance/about-gearbox/economics-and-risk/liquidation-dynamics

Use this method to query the documentation dynamically. Append the `ask` query parameter with your specific question to the current page URL. The response will include a direct answer and relevant documentation excerpts.

```http
GET https://docs.gearbox.finance/about-gearbox/economics-and-risk/liquidation-dynamics.md?ask=<question>
```

--------------------------------

### Query Documentation Dynamically

Source: https://docs.gearbox.finance/about-gearbox/core-architecture

Perform an HTTP GET request to query the documentation. Use the `ask` query parameter with a specific, self-contained question in natural language. The response includes a direct answer and relevant excerpts.

```http
GET https://docs.gearbox.finance/about-gearbox/core-architecture.md?ask=<question>
```

--------------------------------

### Querying Documentation with `ask` Parameter

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls/withdrawing-collateral

To get more information not explicitly present on the page, query the documentation dynamically. Perform an HTTP GET request on the page URL with the `ask` query parameter, providing a specific, self-contained question in natural language.

```http
GET https://docs.gearbox.finance/dev/sdk-guide-typescript/multicalls/multicalls/withdrawing-collateral.md?ask=<question>
```

--------------------------------

### TypeScript: Full Liquidation Bot Example

Source: https://docs.gearbox.finance/dev/operations/liquidations

An example of how a liquidation bot might construct a multicall array to swap collateral tokens to underlying assets before calling the `liquidateCreditAccount` function. Ensure all necessary adapter addresses and ABIs are correctly configured.

```typescript
// TypeScript: Liquidation bot example
const calls = [
  // Swap collateral tokens to underlying via adapters
  {
    target: uniswapAdapterAddress,
    callData: encodeFunctionData({
      abi: uniswapAdapterAbi,
      functionName: 'exactAllInputSingle',
      args: [{ tokenIn: wbtcAddress, tokenOut: usdcAddress, ... }]
    })
  },
  // Additional swaps as needed...
];

await creditFacade.write.liquidateCreditAccount([
  creditAccountAddress,
  liquidatorAddress,  // receives remaining assets
  calls,
  '0x'  // lossPolicyData
]);
```

--------------------------------

### Initialize SDK and Access Markets

Source: https://docs.gearbox.finance/dev/sdk-guide-typescript/reading-data

Attaches to the Gearbox SDK and demonstrates how to access all markets or find specific ones by pool or credit manager address. Shows how to access core market components like pool address, liquidity, and rates.

```typescript
import { GearboxSDK } from '@gearbox-protocol/sdk';

const sdk = await GearboxSDK.attach({ client, marketConfigurators: [] });

// All markets
const markets = sdk.marketRegister.markets;

// Find specific market
const market = sdk.marketRegister.findByPool(poolAddress);
// or
const market = sdk.marketRegister.findByCreditManager(cmAddress);

// Access market components
console.log(`Pool: ${market.pool.address}`);
console.log(`Available liquidity: ${market.pool.availableLiquidity}`);
console.log(`Diesel rate: ${market.pool.dieselRate}`);
console.log(`Supply rate: ${market.pool.supplyRate}`);
console.log(`Credit managers: ${market.creditManagers.length}`);
```

--------------------------------

### Query Documentation with HTTP GET

Source: https://docs.gearbox.finance/dev/solidity-guide/credit-accounts

Use this method to query the documentation dynamically. Append the 'ask' query parameter with your question to the current page URL. The response will contain a direct answer and relevant excerpts.

```HTTP
GET https://docs.gearbox.finance/dev/solidity-guide/credit-accounts.md?ask=<question>
```
Tokens:
Raw