@compass-labs/api-sdk 2.2.105 → 2.2.106

package/src/sdk/riskyield.ts

@@ -0,0 +1,377 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { riskYieldRiskYieldCollect } from "../funcs/riskYieldRiskYieldCollect.js";
+import { riskYieldRiskYieldCreateAccount } from "../funcs/riskYieldRiskYieldCreateAccount.js";
+import { riskYieldRiskYieldDecrease } from "../funcs/riskYieldRiskYieldDecrease.js";
+import { riskYieldRiskYieldIncrease } from "../funcs/riskYieldRiskYieldIncrease.js";
+import { riskYieldRiskYieldMint } from "../funcs/riskYieldRiskYieldMint.js";
+import { riskYieldRiskYieldPools } from "../funcs/riskYieldRiskYieldPools.js";
+import { riskYieldRiskYieldPoolsPoolId } from "../funcs/riskYieldRiskYieldPoolsPoolId.js";
+import { riskYieldRiskYieldPositions } from "../funcs/riskYieldRiskYieldPositions.js";
+import { riskYieldRiskYieldRebalance } from "../funcs/riskYieldRiskYieldRebalance.js";
+import { riskYieldRiskYieldRiskScenarios } from "../funcs/riskYieldRiskYieldRiskScenarios.js";
+import { riskYieldRiskYieldSwap } from "../funcs/riskYieldRiskYieldSwap.js";
+import { riskYieldRiskYieldTokens } from "../funcs/riskYieldRiskYieldTokens.js";
+import { riskYieldRiskYieldTransfer } from "../funcs/riskYieldRiskYieldTransfer.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as components from "../models/components/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class RiskYield extends ClientSDK {
+  /**
+   * List tokens
+   *
+   * @remarks
+   * The assets that trade on Robinhood Chain.
+   *
+   * Tokenized stocks carry their issuer metadata, including the corporate-action
+   * multiplier — balances do not rebase on a split, so a quote for the
+   * underlying only becomes a token price once that is applied.
+   *
+   * Memecoins carry the launch they came from. Every price carries the source it
+   * was resolved from and a confidence: below 0.6 it came from a pool shallow
+   * enough that one trade moves it, and every dollar figure derived from it is
+   * indicative.
+   */
+  async riskYieldTokens(
+    request: operations.V2RiskYieldTokensRequest,
+    options?: RequestOptions,
+  ): Promise<components.DexTokensResponse> {
+    return unwrapAsync(riskYieldRiskYieldTokens(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List pools
+   *
+   * @remarks
+   * Pools you could provide liquidity to, ranked by what you would keep.
+   *
+   * **Read `lp_earns_fees` first.** The launchpad that dominates this chain
+   * graduates tokens into pools whose hook takes the swap fee, so they trade
+   * enormously and pay an external liquidity provider nothing. Those pools are
+   * listed — they carry the memecoin's price and volume — with a fee APR of
+   * exactly zero and a note saying why. Pass `lp_earns_fees=true` to hide them.
+   *
+   * The default ordering is `il_adjusted_apr_7d`: the fee APR less the expected
+   * impermanent-loss drag from the pair's own volatility. A pool paying 200% on
+   * an asset that moves 400% is not a better position than one paying 20% on an
+   * asset that moves 30%, and sorting on the raw APR would say it was.
+   *
+   * Pools too thin for a rate to mean anything — under 20 swaps a day, or under
+   * $1,000 of liquidity — are served with `ranked: false` and always sort last.
+   */
+  async riskYieldPools(
+    request: operations.V2RiskYieldPoolsRequest,
+    options?: RequestOptions,
+  ): Promise<components.DexPoolsResponse> {
+    return unwrapAsync(riskYieldRiskYieldPools(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get pool detail
+   *
+   * @remarks
+   * One pool, with its price history and the caveats that apply to it.
+   *
+   * For a pool holding a tokenized stock, `stock_reference` compares the pool's
+   * price against the stock's own. They drift: the pool trades around the clock
+   * while the stock trades in a session, and that gap is what a liquidity
+   * provider is quoting against overnight.
+   */
+  async riskYieldPoolsPoolId(
+    request: operations.V2RiskYieldPoolsPoolIdRequest,
+    options?: RequestOptions,
+  ): Promise<components.DexPoolDetailResponse> {
+    return unwrapAsync(riskYieldRiskYieldPoolsPoolId(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * List LP positions
+   *
+   * @remarks
+   * Your liquidity positions: what they hold, what they cost, what they paid.
+   *
+   * Only the first of those is on chain. A position reports its liquidity and
+   * its range; it does not report the amounts that opened it or what has already
+   * been collected. Those come from recorded events, and where there are none
+   * `cost_basis.source` is `unavailable` and the PnL fields are null rather than
+   * guessed — an invented cost basis would make every number derived from it
+   * wrong in the same direction.
+   *
+   * `hold_value_usd` is what the deposited amounts would be worth if they had
+   * simply been held. The gap between that and `value_usd` is impermanent loss,
+   * and it is the number that decides whether the fees were worth it.
+   *
+   * `needs_rebalance` and `rebalance_reasons` say what the API would look at, not
+   * what it will do: rebalancing realizes the loss, pays gas twice and a swap,
+   * and puts the position back at risk from a new price.
+   */
+  async riskYieldPositions(
+    request: operations.V2RiskYieldPositionsRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldPositionsResponse> {
+    return unwrapAsync(riskYieldRiskYieldPositions(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Model impermanent loss
+   *
+   * @remarks
+   * What this position would do if the price moved — and how likely that is.
+   *
+   * A fee APR on a memecoin pair means nothing without the loss it is paid
+   * against, which is what this measures.
+   *
+   * Each scenario takes **two** independent moves, and keeping them apart is the
+   * point. `ratio_move_pct` is how far the pair's ratio travels, and that is
+   * what causes impermanent loss. `quote_usd_move_pct` is how far the stock
+   * moves in dollars, which scales what the position is worth without touching
+   * the ratio at all — a stock-only move produces an impermanent loss of exactly
+   * zero. "NVDA drops 10%" and "the memecoin drops 10% against NVDA" are
+   * different questions, and one number cannot ask both.
+   *
+   * The two most useful columns are `breakeven_fee_apr_pct` — what this position
+   * would have to earn for the loss to be worth taking, which you can compare
+   * against the pool's actual fee APR — and `days_of_fees_to_recover_il`, which
+   * is null when the pool pays liquidity providers nothing, because no amount of
+   * time fixes that.
+   *
+   * `probabilistic` runs the pair's own measured volatility through a driftless
+   * simulation. Driftless deliberately: nobody knows which way a memecoin goes,
+   * and a model that assumed one would be predicting returns rather than
+   * measuring risk. It is absent when the pair has no measured volatility —
+   * which a pool with a few hours of history does not — because a distribution
+   * built on zero would report that nothing can happen.
+   */
+  async riskYieldRiskScenarios(
+    request: components.RiskScenariosRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskScenariosResponse> {
+    return unwrapAsync(riskYieldRiskYieldRiskScenarios(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create account
+   *
+   * @remarks
+   * Create the Risk Yield Account that will hold your LP positions.
+   *
+   * Liquidity is provided from an account, not from your wallet, so this comes
+   * first. The address is deterministic from the `owner`, and it is the **same
+   * account as your Earn Account** on this chain — if you already have one,
+   * this returns it with `transaction: null` and nothing needs to be signed.
+   *
+   * **If the owner pays gas:** set `sender` to the owner's address.
+   *
+   * **If someone else pays:** set `sender` to whoever will broadcast.
+   */
+  async riskYieldCreateAccount(
+    request: components.CreateRiskYieldAccountRequest,
+    options?: RequestOptions,
+  ): Promise<components.CreateRiskYieldAccountResponse> {
+    return unwrapAsync(riskYieldRiskYieldCreateAccount(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Transfer tokens to/from account
+   *
+   * @remarks
+   * Move tokens between your wallet and your Risk Yield Account.
+   *
+   * `DEPOSIT` pulls from the owner's wallet into the account; `WITHDRAW` sends
+   * them back. Native ETH is supported, which matters here because many pools on
+   * this chain are quoted in it.
+   *
+   * The account is shared with Earn, so a deposit made through either product is
+   * available to both.
+   */
+  async riskYieldTransfer(
+    request: components.RiskYieldTransferRequest,
+    options?: RequestOptions,
+  ): Promise<components.EarnTransferResponse> {
+    return unwrapAsync(riskYieldRiskYieldTransfer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Swap tokens
+   *
+   * @remarks
+   * Trade one token for another from inside your Risk Yield Account.
+   *
+   * Mostly used to reach the ratio a range needs before opening a position:
+   * a range fixes the proportion of the two assets, and a caller holding one of
+   * them has to swap to it.
+   *
+   * There is no aggregator on this chain, so the route is a Uniswap v3 pool. The
+   * API quotes every enabled fee tier and takes whichever returns the most — a
+   * 1% pool with depth beats a 0.05% pool with none, which here is the common
+   * case rather than the corner one.
+   *
+   * The transaction is simulated before it is returned. A failing simulation is
+   * a 422 rather than something to sign: on this chain a token may tax
+   * transfers, block an address or be paused, and none of that is visible until
+   * the call is actually made.
+   */
+  async riskYieldSwap(
+    request: components.RiskYieldSwapRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldSwapResponse> {
+    return unwrapAsync(riskYieldRiskYieldSwap(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Open a position
+   *
+   * @remarks
+   * Provide liquidity to a pool over a price range.
+   *
+   * The range you ask for is not quite the range you get: ticks are discrete, so
+   * a 30% band becomes the usable ticks that bracket it — snapped outward, never
+   * inward, because a position that stops earning sooner than you expected is
+   * the worse surprise. The `range` in the response is what will actually be
+   * opened.
+   *
+   * A range also fixes the proportion of the two assets, so a deposit rarely
+   * uses all of both. What does not fit is reported as `leftover` and stays in
+   * your account rather than being quietly swept.
+   *
+   * Set `preview` to see the plan and its simulation without building anything.
+   */
+  async riskYieldMint(
+    request: components.RiskYieldMintRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldLiquidityResponse> {
+    return unwrapAsync(riskYieldRiskYieldMint(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Add to a position
+   *
+   * @remarks
+   * Add liquidity to a position you already hold, over its existing range.
+   */
+  async riskYieldIncrease(
+    request: components.RiskYieldIncreaseRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldLiquidityResponse> {
+    return unwrapAsync(riskYieldRiskYieldIncrease(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Withdraw from a position
+   *
+   * @remarks
+   * Take liquidity back out of a position.
+   *
+   * The collect is bundled in by default and should stay that way:
+   * `decreaseLiquidity` only *credits* the tokens to the position, it does not
+   * move them. Without the collect the position looks emptied while the funds
+   * sit in the position manager.
+   */
+  async riskYieldDecrease(
+    request: components.RiskYieldDecreaseRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldLiquidityResponse> {
+    return unwrapAsync(riskYieldRiskYieldDecrease(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Collect fees
+   *
+   * @remarks
+   * Sweep the fees a position has earned into your account.
+   */
+  async riskYieldCollect(
+    request: components.RiskYieldCollectRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldLiquidityResponse> {
+    return unwrapAsync(riskYieldRiskYieldCollect(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Rebalance a position
+   *
+   * @remarks
+   * Move a position to a new range, in one transaction.
+   *
+   * **`NOOP` is a real answer and often the right one.** Rebalancing realizes
+   * the impermanent loss the position has taken so far, pays gas twice and a
+   * swap, and puts the position back at risk from a new price. If the position
+   * is already centred at the requested width, that is what you will get.
+   *
+   * When there is something to do, the transaction unwinds the old position,
+   * sweeps it together with the fees, opens the new range and burns the empty
+   * NFT. Every leg is sized from the **floor** the previous one guarantees
+   * rather than from its quote — they execute in the same transaction, and a
+   * mint sized from a quote reverts when the decrease comes back a wei short,
+   * leaving the owner having paid gas to dismantle a position. `estimated_dust`
+   * is what that safety costs.
+   *
+   * The default `vol_scaled` strategy sizes the new range from the pair's own
+   * measured volatility: two standard deviations over the horizon. A range
+   * narrower than the asset's ordinary movement spends most of its life out of
+   * range earning nothing, which is the most common way to lose money doing
+   * this on purpose.
+   */
+  async riskYieldRebalance(
+    request: components.RiskYieldRebalanceRequest,
+    options?: RequestOptions,
+  ): Promise<components.RiskYieldRebalanceResponse> {
+    return unwrapAsync(riskYieldRiskYieldRebalance(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -14,6 +14,7 @@ import { GasSponsorship } from "./gassponsorship.js";
 import { Morpho } from "./morpho.js";
 import { Pendle } from "./pendle.js";
 import { PerpetualTrading } from "./perpetualtrading.js";
+import { RiskYield } from "./riskyield.js";
 import { Sky } from "./sky.js";
 import { SmartAccount } from "./smartaccount.js";
 import { Swap } from "./swap.js";
@@ -126,4 +127,9 @@ export class CompassApiSDK extends ClientSDK {
   get tokenizedAssets(): TokenizedAssets {
     return (this._tokenizedAssets ??= new TokenizedAssets(this._options));
   }
+
+  private _riskYield?: RiskYield;
+  get riskYield(): RiskYield {
+    return (this._riskYield ??= new RiskYield(this._options));
+  }
 }