@compass-labs/api-sdk 2.2.106 → 2.2.108-rc.0

package/src/sdk/riskyield.ts

@@ -1,377 +0,0 @@
-/*
- * 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,
-    ));
-  }
-}