@compass-labs/api-sdk 2.2.84 → 2.2.85-rc.1

package/src/funcs/tokenizedAssetsTokenizedAssetsOrderSubmit.ts

@@ -27,20 +27,14 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Submit a signed tokenized-equity order (Ondo)
+ * Submit a signed order
  *
  * @remarks
- * Submit a signed order for settlement.
+ * Submit a signed equity order to the market-maker network for settlement.
  *
- * The body echoes the `order` fields from `/order` (`signed_order`,
- * `extension`, `quote_id`, optionally `order_hash`) plus the owner's
- * signature over `order.safe_message_eip712`. The maker on the order
- * struct is the Tokenized Assets Account, not the owner's wallet —
- * pass `signed_order` back unchanged.
- *
- * Returns the order hash and a server-side ISO 8601 timestamp.
- * Subsequent calls to `GET /order/{order_hash}` track the lifecycle
- * (`pending` → `filled` / `expired` / `cancelled`).
+ * Relays the payload from `/order` plus the owner's signature, and returns the
+ * order hash. Poll `GET /order/{order_hash}` to track its lifecycle (`pending` →
+ * `filled` / `expired` / `cancelled`).
  */
 export function tokenizedAssetsTokenizedAssetsOrderSubmit(
   client: CompassApiSDKCore,

package/src/funcs/tokenizedAssetsTokenizedAssetsPositions.ts

@@ -28,22 +28,16 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Get tokenized-asset positions for an owner
+ * List positions
  *
  * @remarks
- * Get the tokenized-asset holdings for an owner.
+ * Get an owner's tokenized-asset holdings, priced and aggregated.
  *
- * Covers **both** asset families held in the account — Ondo equities and
- * Midas RWA yield tokens (`mTBILL`, `mBASIS`, `mBTC`). The Tokenized Assets
- * Account address is derived deterministically from the `owner` query param;
- * balances are read from that account (proceeds from equity orders and RWA
- * swaps both settle there). Equity positions are priced from the Ondo feed;
- * RWA positions are valued at the latest indexed NAV. Pass `chain=base` for
- * Base holdings (equities are Ethereum-only). Zero balances are omitted, and
- * a `total_usd` aggregate is returned across all priced positions.
- *
- * Returns 400 `ACCOUNT_NOT_DEPLOYED` if the owner has no Tokenized Assets
- * Account deployed yet — create one via `/create_account` first.
+ * Returns positions across every asset family the account holds — Ondo equities,
+ * Midas RWA yield tokens, and IXS managed vaults — each valued in USD (equities
+ * from the Ondo feed, RWA at the latest indexed NAV) with a `total_usd` total.
+ * The account is derived from `owner`; pass `chain` for Base (Midas) or BNB Smart
+ * Chain (IXS) holdings.
  */
 export function tokenizedAssetsTokenizedAssetsPositions(
   client: CompassApiSDKCore,

package/src/funcs/tokenizedAssetsTokenizedAssetsQuote.ts

@@ -27,33 +27,15 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Preview a tokenized-equity buy/sell quote (Ondo)
+ * Quote an order
  *
  * @remarks
  * Preview a buy/sell quote for a tokenized **equity** (Ondo, e.g. `TSLAon`).
  *
- * **Equities only.** RWA yield tokens (Midas — `mTBILL`, `mBASIS`, `mBTC`) are
- * rejected here with 422 `Wrong trade flow`; they have no auction/quote step —
- * buy/sell them directly via `/transact/buy` & `/transact/sell`.
- *
- * Returns the input/output amounts, fees, and slippage tolerance for an order.
- *
- * Read-only: previews the quote without consuming a ``quote_id`` or
- * committing an order. Pair with `POST /order`:
- * surface this preview to the user, and on confirm pass the body plus
- * ``recommended_slippage_bps`` to `/order`.
- *
- * The response carries:
- *
- * - **`quote`** — input/output token amounts, fees, and an
- *   ``est_fill_seconds`` upper bound.
- * - **`recommended_slippage_bps`** — system-derived slippage tolerance
- *   that clears the current auction floor; pass back as
- *   ``slippage_bps`` on `/order` so the build call validates against the
- *   same floor the user was shown.
- * - **`auction_range_bps`** — worst-case bps gap between the auction
- *   end amount and the reference quote amount. Use to surface a
- *   thin-liquidity warning to the user.
+ * Read-only price preview: returns the expected input/output amounts and a
+ * system-recommended slippage tolerance to carry into `/order`. Equities only —
+ * RWA yield tokens (Midas) have no quote step and are rejected with `422 Wrong
+ * trade flow`; trade them via `/transact/buy` and `/transact/sell`.
  */
 export function tokenizedAssetsTokenizedAssetsQuote(
   client: CompassApiSDKCore,

package/src/funcs/tokenizedAssetsTokenizedAssetsRedemptions.ts

@@ -28,21 +28,16 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Get IXS vault redemption requests for an owner
+ * List redemption requests
  *
  * @remarks
- * Get an owner's IXS vault redemption requests (async redemption status).
+ * Get an owner's IXS managed-vault redemption requests and their status.
  *
- * IXS managed-vault **sells** are asynchronous: `/transact/sell` returns a
- * `requestRedeem` transaction, and the vault operator settles it off-chain
- * later. This endpoint reconstructs the owner's requests directly from the
- * vault on every call (Compass persists no async state) — each entry carries
- * its `status` (`pending` | `finalized` | `rejected`), the `shares` requested,
- * and, while `pending`, the `expected_net_assets` it would settle for at the
- * current NAV (a preview, not a guarantee).
- *
- * IXS vaults live on BNB Smart Chain — pass `chain=bsc` (the default) and the
- * `vault` handle (default `ixv1`).
+ * IXS vault sells are asynchronous — `/transact/sell` files a `requestRedeem`
+ * that the vault operator settles off-chain later. This reconstructs the owner's
+ * requests live from the vault (Compass stores no async state), reporting each as
+ * `pending`, `finalized`, or `rejected`. IXS vaults live on BNB Smart Chain
+ * (`chain=bsc`, vault `ixv1`).
  */
 export function tokenizedAssetsTokenizedAssetsRedemptions(
   client: CompassApiSDKCore,

package/src/funcs/tokenizedAssetsTokenizedAssetsTransactBuy.ts

@@ -27,20 +27,18 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Buy an RWA yield token (Midas: mTBILL/mBASIS/mBTC)
+ * Buy an RWA yield token
  *
  * @remarks
- * Buy (mint) an RWA yield asset (e.g. `mTBILL`) inside the product account.
+ * Buy an RWA yield token, or deposit into an IXS managed vault, with a stablecoin
+ * in one transaction.
  *
- * Mints `token_out` directly from Midas with `token_in` (a stablecoin already
- * held by the Tokenized Assets Account — fund it with a plain transfer first).
- * `token_in` must be a payment token the Midas issuance vault accepts (USDC on
- * every supported network; mBASIS also accepts USDT/DAI on Ethereum). Returns
- * an unsigned transaction for the owner to sign, or an EIP-712 payload when
- * `gas_sponsorship` is true.
- *
- * `token_out` must be a Midas RWA asset; equities trade via the order
- * endpoints (`/quote`, `/order`, `/order/submit`).
+ * Set `token_out` to a Midas symbol (`mTBILL`, `mBASIS`, `mBTC`) or to an IXS
+ * **vault address** (its shares aren't a registered symbol). The account spends
+ * a stablecoin it already holds (fund it with a plain transfer first) and
+ * settles inside the product account — an unsigned transaction the owner signs,
+ * or EIP-712 with `gas_sponsorship`. Both paths are instant. Equities use the
+ * order flow (`/quote`, `/order`).
  */
 export function tokenizedAssetsTokenizedAssetsTransactBuy(
   client: CompassApiSDKCore,

package/src/funcs/tokenizedAssetsTokenizedAssetsTransactSell.ts

@@ -27,17 +27,19 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Sell an RWA yield token (Midas: mTBILL/mBASIS/mBTC)
+ * Sell an RWA yield token
  *
  * @remarks
- * Sell (redeem) an RWA yield asset (e.g. `mTBILL`) inside the product account.
+ * Sell an RWA yield token, or redeem from an IXS managed vault, back to a
+ * stablecoin.
  *
- * Redeems `token_in` (a Midas RWA asset held by the Tokenized Assets Account)
- * directly with Midas into `token_out` (USDC). Returns an unsigned transaction
- * for the owner to sign, or an EIP-712 payload when `gas_sponsorship` is true.
- *
- * Instant redemption draws on Midas's on-chain liquidity and is subject to a
- * small redemption fee and daily limit.
+ * Set `token_in` to a Midas symbol (`mTBILL`, `mBASIS`, `mBTC`) or to an IXS
+ * **vault address**. A Midas redemption is instant and settles in the same
+ * transaction; an IXS redemption is **asynchronous** — it files a
+ * `requestRedeem` (`settlement: async`) the vault operator settles off-chain
+ * later, so poll `GET /v2/tokenized_assets/redemptions` for status. The
+ * transaction executes inside the product account (owner signs, or EIP-712 with
+ * `gas_sponsorship`).
  */
 export function tokenizedAssetsTokenizedAssetsTransactSell(
   client: CompassApiSDKCore,

package/src/funcs/tokenizedAssetsTokenizedAssetsTransfer.ts

@@ -27,27 +27,16 @@ import { APICall, APIPromise } from "../types/async.js";
 import { Result } from "../types/fp.js";
 
 /**
- * Deposit to / withdraw from a Tokenized Assets Account
+ * Transfer tokens to/from account
  *
  * @remarks
  * Move tokens between the owner's wallet and their Tokenized Assets Account.
  *
- * Use `DEPOSIT` to fund the account from the owner's wallet, or `WITHDRAW` to
- * send tokens from the account back to the owner. Equity orders settle in
- * USDC; RWA yield assets trade against USDC on Ethereum and Base.
- *
- * With `gas_sponsorship=true` the response is EIP-712 typed data the owner
- * signs off-chain, then submits to `POST /v2/gas_sponsorship/prepare` so the
- * sponsor broadcasts and pays the gas:
- *
- * - **DEPOSIT** returns a Permit2 `PermitTransferFrom`. The owner must first
- *   grant a one-time token->Permit2 allowance (gaslessly via
- *   `POST /v2/gas_sponsorship/approve_transfer`).
- * - **WITHDRAW** returns a Safe transaction the account executes.
- *
- * With `gas_sponsorship=false` a DEPOSIT returns an unsigned ERC-20 transfer
- * the owner broadcasts directly, and a WITHDRAW returns an unsigned Safe
- * `execTransaction` the owner signs and broadcasts.
+ * `DEPOSIT` funds the account from the owner's wallet; `WITHDRAW` sends tokens
+ * back. Supports gas sponsorship: with `gas_sponsorship=true` the owner signs
+ * EIP-712 typed data (a Permit2 permit on deposit, a product-account transaction
+ * on withdrawal) and a sponsor broadcasts; otherwise the owner broadcasts the
+ * transaction directly.
  */
 export function tokenizedAssetsTokenizedAssetsTransfer(
   client: CompassApiSDKCore,

package/src/lib/config.ts

@@ -62,7 +62,7 @@ export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "0.0.1",
   sdkVersion: "2.0.0",
-  genVersion: "2.916.2",
+  genVersion: "2.916.4",
   userAgent:
-    "speakeasy-sdk/typescript 2.0.0 2.916.2 0.0.1 @compass-labs/api-sdk",
+    "speakeasy-sdk/typescript 2.0.0 2.916.4 0.0.1 @compass-labs/api-sdk",
 } as const;

package/src/lib/http.ts

@@ -45,8 +45,10 @@ export class HTTPClient {
   private requestHooks: BeforeRequestHook[] = [];
   private requestErrorHooks: RequestErrorHook[] = [];
   private responseHooks: ResponseHook[] = [];
+  private options: HTTPClientOptions;
 
-  constructor(private options: HTTPClientOptions = {}) {
+  constructor(options: HTTPClientOptions = {}) {
+    this.options = options;
     this.fetcher = options.fetcher || DEFAULT_FETCHER;
   }
 

package/src/lib/security.ts

@@ -12,17 +12,22 @@ type OAuth2PasswordFlow = {
   tokenURL: string;
 };
 
-export enum SecurityErrorCode {
-  Incomplete = "incomplete",
-  UnrecognisedSecurityType = "unrecognized_security_type",
-}
+export const SecurityErrorCode = {
+  Incomplete: "incomplete",
+  UnrecognisedSecurityType: "unrecognized_security_type",
+} as const;
+export type SecurityErrorCode =
+  (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 
 export class SecurityError extends Error {
+  public code: SecurityErrorCode;
+
   constructor(
-    public code: SecurityErrorCode,
+    code: SecurityErrorCode,
     message: string,
   ) {
     super(message);
+    this.code = code;
     this.name = "SecurityError";
   }
 

package/src/models/components/eulermarket.ts

@@ -36,6 +36,14 @@ export type EulerMarket = {
    * Decimals of the borrowable asset.
    */
   assetDecimals: number;
+  /**
+   * USD price of one whole unit of the borrowable asset. Use it to convert USD borrow capacity into token units. Null if the price feed can't quote it.
+   */
+  assetPriceUsd?: string | null | undefined;
+  /**
+   * Symbol of the market's native unit of account (usually USD). The market's own risk engine denominates collateral and debt in this unit.
+   */
+  unitOfAccountSymbol?: string | null | undefined;
   /**
    * Current borrow APY for this market (cost to borrow the asset), in percentage (e.g. 5.25 means 5.25%). Null if the rate is unavailable.
    */
@@ -44,6 +52,30 @@ export type EulerMarket = {
    * Current supply APY for this market (yield for supplying the asset), in percentage (e.g. 3.45 means 3.45%). Null if the rate is unavailable.
    */
   supplyApy?: string | null | undefined;
+  /**
+   * Asset available to borrow right now (vault cash), in token units. A borrow larger than this reverts even if the account is healthy.
+   */
+  availableLiquidity: string;
+  /**
+   * Total asset supplied to this market, in token units.
+   */
+  totalSupplyAssets: string;
+  /**
+   * Total asset borrowed from this market, in token units.
+   */
+  totalBorrowAssets: string;
+  /**
+   * Borrowed share of supplied assets, in percentage 0-100.
+   */
+  utilization: string;
+  /**
+   * Maximum total supply allowed, in token units. Null when the market is uncapped.
+   */
+  supplyCap?: string | null | undefined;
+  /**
+   * Maximum total borrow allowed, in token units. A borrow that would breach this reverts even when cash exists. Null when uncapped.
+   */
+  borrowCap?: string | null | undefined;
   /**
    * Collateral vaults this market accepts (those currently borrowable, LTV > 0), each with its LTVs.
    */
@@ -61,16 +93,31 @@ export const EulerMarket$inboundSchema: z.ZodType<
   asset: z.string(),
   asset_symbol: z.string(),
   asset_decimals: z.number().int(),
+  asset_price_usd: z.nullable(z.string()).optional(),
+  unit_of_account_symbol: z.nullable(z.string()).optional(),
   borrow_apy: z.nullable(z.string()).optional(),
   supply_apy: z.nullable(z.string()).optional(),
+  available_liquidity: z.string(),
+  total_supply_assets: z.string(),
+  total_borrow_assets: z.string(),
+  utilization: z.string(),
+  supply_cap: z.nullable(z.string()).optional(),
+  borrow_cap: z.nullable(z.string()).optional(),
   collaterals: z.array(EulerMarketCollateral$inboundSchema).optional(),
 }).transform((v) => {
   return remap$(v, {
     "vault_symbol": "vaultSymbol",
     "asset_symbol": "assetSymbol",
     "asset_decimals": "assetDecimals",
+    "asset_price_usd": "assetPriceUsd",
+    "unit_of_account_symbol": "unitOfAccountSymbol",
     "borrow_apy": "borrowApy",
     "supply_apy": "supplyApy",
+    "available_liquidity": "availableLiquidity",
+    "total_supply_assets": "totalSupplyAssets",
+    "total_borrow_assets": "totalBorrowAssets",
+    "supply_cap": "supplyCap",
+    "borrow_cap": "borrowCap",
   });
 });
 

package/src/models/components/eulermarketcollateral.ts

@@ -24,6 +24,14 @@ export type EulerMarketCollateral = {
    * Symbol of the collateral's underlying asset (e.g. USDC).
    */
   assetSymbol: string;
+  /**
+   * Decimals of the collateral's underlying asset.
+   */
+  assetDecimals: number;
+  /**
+   * USD price of one whole unit of the collateral asset. Null if the price feed can't quote it (size the supply in token units instead).
+   */
+  assetPriceUsd?: string | null | undefined;
   /**
    * Maximum loan-to-value when borrowing against this collateral, in percentage (e.g. 94 means 94%).
    */
@@ -47,12 +55,16 @@ export const EulerMarketCollateral$inboundSchema: z.ZodType<
   vault: z.string(),
   asset: z.string(),
   asset_symbol: z.string(),
+  asset_decimals: z.number().int(),
+  asset_price_usd: z.nullable(z.string()).optional(),
   borrow_ltv: z.string(),
   liquidation_ltv: z.string(),
   supply_apy: z.nullable(z.string()).optional(),
 }).transform((v) => {
   return remap$(v, {
     "asset_symbol": "assetSymbol",
+    "asset_decimals": "assetDecimals",
+    "asset_price_usd": "assetPriceUsd",
     "borrow_ltv": "borrowLtv",
     "liquidation_ltv": "liquidationLtv",
     "supply_apy": "supplyApy",

package/src/sdk/earn.ts

@@ -141,7 +141,7 @@ export class Earn extends ClientSDK {
   }
 
   /**
-   * Quote a swap (read-only)
+   * Quote a swap
    *
    * @remarks
    * Estimate the output of a swap without building a transaction.