> For the complete documentation index, see [llms.txt](https://docs.chamberfi.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.chamberfi.com/build/sdk.md).

# SDK

The Chamber SDK is the TypeScript wrapper over the vault contracts. It covers vault creation, deposits, withdrawals, trading across supported protocols, and LP/lending/perp operations, all composed into guard-compliant transactions.

**Package:** `@dhedge/v2-sdk` (npm name is staying; code identifiers don't rebrand) **Install:** `npm install @dhedge/v2-sdk` **Requires:** `ethers` v5 with a signer connected to an RPC for a supported chain.

## Supported chains

The SDK tracks contract deployments but typically trails by a release. If you need a chain, asset, or protocol that's live in the contracts but not in the installed SDK version, call the contracts directly. The [deployment matrix](/build/deployment-matrix.md), [contract addresses](/build/contract-addresses.md), and [Guard System](/build/guard-system.md) pages are the authoritative sources for what Chamber supports, not the SDK.

The SDK's `Network` enum currently covers **Polygon, Optimism, Arbitrum, Base, Ethereum, Plasma, and HyperEVM** (exposed in code as `Network.HYPERLIQUID`). Pin a version and verify the enum on it before targeting newer chains.

## Quick start

```ts
import { Dhedge, Dapp, Network, ethers } from "@dhedge/v2-sdk";

const provider = new ethers.providers.JsonRpcProvider(providerUrl);
const wallet = new ethers.Wallet(privateKey, provider);
const chamber = new Dhedge(wallet, Network.POLYGON);
```

The `Dhedge` client needs a wallet with a connected provider. A read-only provider is not enough for state-changing calls.

## Creating a vault

```ts
const vault = await chamber.createPool(
  "Alice", // manager name (display)
  "My Vault", // vault name
  "MVLT", // token symbol
  [
    // enabled assets: [address, isDepositAsset]
    [usdcAddress, true],
    [wethAddress, false],
  ],
  10, // performance fee (percent, 0–50)
  2, // management fee (percent/yr, 0–3)
  0, // entry fee (percent, 0–2)
  0, // exit fee (percent, 0–2)
);
```

See [create a vault](/manage/create-a-vault.md) for the manager-facing walkthrough of what these parameters mean. Fees are entered as percentages (e.g. `10` = 10%, matching the UI). Respect the [fee caps](/manage/fees-performance.md#fee-caps).

There's no denomination parameter. Every Chamber vault accounts in USD. The `isDepositAsset` flag marks which enabled assets users can deposit; it doesn't set an accounting currency. See [denomination asset](/manage/denomination-asset.md).

## Loading an existing vault

```ts
const vault = await chamber.loadPool(vaultAddress);
```

For non-Chamber contracts (other pools not created by the factory), pass a second argument: `loadPool(address, false)`.

## Core vault operations

Every method returns either a sent transaction or, when you pass `sdkOptions`, the prepared calldata so you can sign externally.

**Composition and state**

```ts
await vault.getComposition();     // current holdings
await vault.changeAssets([...]);  // add/remove tradeable assets (manager only)
await vault.setTrader(address);   // delegate trading to another EOA (manager only)
```

A few manager-side contract functions don't yet have SDK wrappers, notably `setMaxSupplyCap` (deposit limit) and `setPoolLogic`. Use the contracts directly for those; the [Chamber app](https://chamberfi.com/) UI also exposes them. See [permissions & access](/manage/permissions-access.md) and [create a vault](/manage/create-a-vault.md).

**Deposits and withdrawals**

```ts
await vault.approveDeposit(usdcAddress, amount);
await vault.deposit(usdcAddress, amount);
await vault.withdraw(shareAmount);
```

`deposit` and `withdraw` wrap the vault's underlying `deposit` / `withdraw` calls. The SDK's `withdraw` returns a pro-rata slice of the vault's holdings. For withdrawals that involve complex assets (LPs, perps, lending positions), you currently need to call `withdrawSafe` on the contract directly with an encoded `ComplexAsset[]` argument. The SDK doesn't yet wrap this. See [Lockup & withdrawals](/deposit/lockup-withdrawals.md) for the underlying semantics.

**Trading**

```ts
await vault.trade(Dapp.ONE_INCH, fromAsset, toAsset, amountIn, slippagePercent);
```

The `Dapp` enum covers the aggregators, DEXes, and protocols the SDK wraps, currently including Uniswap V3, 1inch, Odos, KyberSwap, CoW Swap, Pendle, Aave (V2 and V3), Compound V3, Fluid (via the Compound V3 surface), Velodrome (V2 and CL), Aerodrome (and CL), PancakeSwap CL, Toros, and Hyperliquid.

**Flat Money** has contract-level guards but isn't yet wrapped in the SDK. Trades on it go through the contracts directly.

Each SDK route is composed into a guard-compliant call. Check `Dapp` in the installed version for the exact list, and the [Guard System](/build/guard-system.md) page for the full set of protocols Chamber allows at the contract level.

**LP, lending, perps**

* `addLiquidityUniswapV3`: concentrated liquidity mint (Uniswap V3, Velodrome CL, Aerodrome CL, Pancake CL)
* `addLiquidityV2`: Velodrome V2, Aerodrome
* `lend` / `withdrawDeposit` / `borrow` / `repay`: Aave V2 / V3
* `lendCompoundV3` / `withdrawCompoundV3` / `harvestCompoundV3Rewards`: Compound V3 and Fluid
* `depositHyperliquid` / `perpToSpotHyperliquid` / `spotToPerpHyperliquid` / `withdrawHyperliquid`: Hyperliquid wallet/bridge ops
* `openMarketOrderHyperliquid` / `closePositionHyperliquid`: Hyperliquid perps
* `approveTorosLimitOrder` / `createTorosLimitOrder` / `modifyTorosLimitOrder` / `deleteTorosLimitOrder`: Toros stop-loss / take-profit
* `mintUnitViaFlatMoney` / `redeemUnitViaFlatMoney` / `cancelOrderViaFlatMoney`: Flat Money

Method surface and supported protocols move with releases. Check the SDK's exported types on the installed version.

## Getting calldata without sending

Most methods take a trailing `sdkOptions` argument for dry-runs. On `trade` it's the **7th** argument. The 6th is a generic tx-`options` slot (gas overrides, etc.); pass `null` there if you don't need it:

```ts
const txData = await vault.trade(Dapp.ODOS, fromAsset, toAsset, amountIn, 0.5, null, {
  estimateGas: true,
  onlyGetTxData: true,
});
```

Pass `onlyGetTxData: true` to return the encoded transaction rather than broadcasting it. This is how you'd integrate the SDK into a multisig flow, or hand the calldata to a user's wallet to sign.

## Version pinning

* The SDK tracks the contracts repo's version tags. Pin to a minor version in production and test across upgrades.
* Breaking changes to method signatures are documented in the repo's `CHANGELOG.md`.

## See also

* [Contract addresses](/build/contract-addresses.md): underlying contracts the SDK calls
* [Guard system](/build/guard-system.md): what the SDK's composed calls need to satisfy
* [Integration examples](/build/integration-examples.md): end-to-end SDK flows