@vultisig/core-chain 2.37.0 → 2.39.0

package/dist/chains/solana/kamino/api.js

@@ -0,0 +1,59 @@
+import { HttpResponseError } from '@vultisig/lib-utils/fetch/HttpResponseError';
+import { queryUrl } from '@vultisig/lib-utils/query/queryUrl';
+import { kaminoConfig } from './config.js';
+import { KaminoServiceError } from './KaminoServiceError.js';
+/**
+ * Read-side REST client for Kamino Earn vaults, against
+ * `https://api.kamino.finance` (public, unauthenticated).
+ *
+ * Kamino's structured error body is converted into `KaminoServiceError` so
+ * callers can branch on `reason.api.code` (`KVAULT_NOT_FOUND`, …) instead of
+ * matching message text. Retries are the caller's concern — the client layers
+ * (react-query, CLI) already own retry policy, and `KaminoServiceError.isRetryable`
+ * tells them whether one is worth it.
+ */
+/**
+ * Timeout for the position read, which gates withdraws. Getting out of a
+ * position is the operation whose failure a user cannot route around, so it
+ * keeps a long limit: cutting the wait converts "slow" into "cannot withdraw"
+ * rather than into a faster answer. Everything else uses `queryUrl`'s 20s
+ * default, which no healthy Kamino call approaches (reads measure ~100ms).
+ */
+const positionsReadTimeoutMs = 60_000;
+const isKaminoErrorBody = (body) => typeof body === 'object' &&
+    body !== null &&
+    typeof body.statusCode === 'number' &&
+    typeof body.message === 'string';
+const kaminoGet = async (path, timeoutMs) => {
+    try {
+        return await queryUrl(`${kaminoConfig.apiBaseUrl}${path}`, timeoutMs === undefined ? undefined : { timeoutMs });
+    }
+    catch (error) {
+        if (error instanceof HttpResponseError && isKaminoErrorBody(error.body)) {
+            throw new KaminoServiceError({
+                api: { status: error.status, code: error.body.code, message: error.body.message },
+            });
+        }
+        throw error;
+    }
+};
+// Path parameters are encoded because nothing in this module enforces that
+// they are pubkeys: a value containing `/`, `?` or `#` would otherwise change
+// which endpoint is called. A base58 string passes through unchanged.
+const segment = encodeURIComponent;
+/** Fetches a vault's live state (`GET /kvaults/vaults/{address}`). */
+export const fetchKaminoVaultState = (address) => kaminoGet(`/kvaults/vaults/${segment(address)}`);
+/** Fetches a vault's metrics (`GET /kvaults/vaults/{address}/metrics`). */
+export const fetchKaminoVaultMetrics = (address) => kaminoGet(`/kvaults/vaults/${segment(address)}/metrics`);
+/**
+ * Fetches every kVault position the owner holds
+ * (`GET /kvaults/users/{owner}/positions`). Uncached and generously timed —
+ * this read gates withdraws.
+ */
+export const fetchKaminoUserPositions = (owner) => kaminoGet(`/kvaults/users/${segment(owner)}/positions`, positionsReadTimeoutMs);
+/**
+ * Fetches lifetime PnL for one position
+ * (`GET /kvaults/users/{owner}/vaults/{vault}/pnl`).
+ */
+export const fetchKaminoPnl = ({ owner, vault }) => kaminoGet(`/kvaults/users/${segment(owner)}/vaults/${segment(vault)}/pnl`);
+//# sourceMappingURL=api.js.map

package/dist/chains/solana/kamino/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,6CAA6C,CAAA;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAE7D,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAQzD;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,MAAM,sBAAsB,GAAG,MAAM,CAAA;AAarC,MAAM,iBAAiB,GAAG,CAAC,IAAa,EAA+B,EAAE,CACvE,OAAO,IAAI,KAAK,QAAQ;IACxB,IAAI,KAAK,IAAI;IACb,OAAQ,IAA4B,CAAC,UAAU,KAAK,QAAQ;IAC5D,OAAQ,IAA4B,CAAC,OAAO,KAAK,QAAQ,CAAA;AAE3D,MAAM,SAAS,GAAG,KAAK,EAAK,IAAY,EAAE,SAAkB,EAAc,EAAE;IAC1E,IAAI,CAAC;QACH,OAAO,MAAM,QAAQ,CAAI,GAAG,YAAY,CAAC,UAAU,GAAG,IAAI,EAAE,EAAE,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAA;IACpH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,iBAAiB,IAAI,iBAAiB,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACxE,MAAM,IAAI,kBAAkB,CAAC;gBAC3B,GAAG,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE;aAClF,CAAC,CAAA;QACJ,CAAC;QACD,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC,CAAA;AAED,2EAA2E;AAC3E,8EAA8E;AAC9E,sEAAsE;AACtE,MAAM,OAAO,GAAG,kBAAkB,CAAA;AAElC,sEAAsE;AACtE,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,OAAe,EAAqC,EAAE,CAC1F,SAAS,CAAC,mBAAmB,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;AAElD,2EAA2E;AAC3E,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,OAAe,EAAuC,EAAE,CAC9F,SAAS,CAAC,mBAAmB,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;AAE1D;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,KAAa,EAAyC,EAAE,CAC/F,SAAS,CAAC,kBAAkB,OAAO,CAAC,KAAK,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAA;AAEjF;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,EAAE,KAAK,EAAE,KAAK,EAAoC,EAA8B,EAAE,CAC/G,SAAS,CAAC,kBAAkB,OAAO,CAAC,KAAK,CAAC,WAAW,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA"}

package/dist/chains/solana/kamino/baseUnits.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Rendering and bounds shared by the Kamino amount types.
+ */
+/**
+ * Solana instruction arguments are `u64`; anything above that cannot be
+ * expressed on-chain regardless of what the API would accept.
+ */
+export declare const kaminoMaxBaseUnits: bigint;
+/**
+ * Widest decimal scale we are willing to handle. SPL mints are a `u8`, but
+ * nothing legitimate approaches this, and an absurd scale would make the
+ * `10^decimals` factors in the conversions unbounded.
+ */
+export declare const kaminoMaxDecimals = 18;
+/**
+ * Renders base units as a plain human-units decimal string: no grouping, no
+ * trailing zeros, no exponent. This is the form Kamino's request bodies take.
+ */
+export declare const renderKaminoBaseUnits: ({ baseUnits, decimals }: {
+    baseUnits: bigint;
+    decimals: number;
+}) => string;
+//# sourceMappingURL=baseUnits.d.ts.map

package/dist/chains/solana/kamino/baseUnits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseUnits.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/baseUnits.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAiB,CAAA;AAEhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,KAAK,CAAA;AAEnC;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,yBAAyB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAG,MAWxG,CAAA"}

package/dist/chains/solana/kamino/baseUnits.js

@@ -0,0 +1,30 @@
+/**
+ * Rendering and bounds shared by the Kamino amount types.
+ */
+/**
+ * Solana instruction arguments are `u64`; anything above that cannot be
+ * expressed on-chain regardless of what the API would accept.
+ */
+export const kaminoMaxBaseUnits = 2n ** 64n - 1n;
+/**
+ * Widest decimal scale we are willing to handle. SPL mints are a `u8`, but
+ * nothing legitimate approaches this, and an absurd scale would make the
+ * `10^decimals` factors in the conversions unbounded.
+ */
+export const kaminoMaxDecimals = 18;
+/**
+ * Renders base units as a plain human-units decimal string: no grouping, no
+ * trailing zeros, no exponent. This is the form Kamino's request bodies take.
+ */
+export const renderKaminoBaseUnits = ({ baseUnits, decimals }) => {
+    const isNegative = baseUnits < 0n;
+    const digits = (isNegative ? -baseUnits : baseUnits).toString();
+    if (decimals <= 0)
+        return isNegative ? `-${digits}` : digits;
+    const padded = digits.padStart(decimals + 1, '0');
+    const whole = padded.slice(0, padded.length - decimals);
+    const fraction = padded.slice(padded.length - decimals).replace(/0+$/, '');
+    const magnitude = fraction ? `${whole}.${fraction}` : whole;
+    return isNegative ? `-${magnitude}` : magnitude;
+};
+//# sourceMappingURL=baseUnits.js.map

package/dist/chains/solana/kamino/baseUnits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseUnits.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/baseUnits.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,EAAE,IAAI,GAAG,GAAG,EAAE,CAAA;AAEhD;;;;GAIG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,EAAE,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,EAAE,SAAS,EAAE,QAAQ,EAA2C,EAAU,EAAE;IAChH,MAAM,UAAU,GAAG,SAAS,GAAG,EAAE,CAAA;IACjC,MAAM,MAAM,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAA;IAC/D,IAAI,QAAQ,IAAI,CAAC;QAAE,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAA;IAE5D,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,GAAG,CAAC,EAAE,GAAG,CAAC,CAAA;IACjD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAA;IACvD,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,GAAG,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAA;IAE1E,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,KAAK,CAAA;IAC3D,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA;AACjD,CAAC,CAAA"}

package/dist/chains/solana/kamino/config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Constants for Kamino Earn vaults (kVaults) on Solana.
+ *
+ * The REST API is public and unauthenticated — the action endpoints build an
+ * unsigned transaction from the caller's wallet address alone, which is why
+ * every built transaction must be validated on-device before it is signed.
+ */
+export declare const kaminoConfig: {
+    /** Kamino's public REST API. No key, no auth header. */
+    readonly apiBaseUrl: "https://api.kamino.finance";
+    /** The kVaults program every deposit and withdraw invokes. */
+    readonly programId: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd";
+    /**
+     * Kamino's farms program. Every launch vault has a farm attached, so a
+     * deposit ends with `initializeUser` + `stake` against this program and the
+     * shares never land in the user's wallet.
+     */
+    readonly farmsProgramId: "FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr";
+    /**
+     * Wrapped SOL. The SOL vault's underlying token is this mint, not native
+     * SOL, which is why its deposits carry a wrap prefix.
+     */
+    readonly wrappedSolMint: "So11111111111111111111111111111111111111112";
+    /** Circle's USDC — the underlying token of both dollar vaults. */
+    readonly usdcMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/chains/solana/kamino/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;IACvB,wDAAwD;;IAGxD,8DAA8D;;IAG9D;;;;OAIG;;IAGH;;;OAGG;;IAGH,kEAAkE;;CAE1D,CAAA"}

package/dist/chains/solana/kamino/config.js

@@ -0,0 +1,27 @@
+/**
+ * Constants for Kamino Earn vaults (kVaults) on Solana.
+ *
+ * The REST API is public and unauthenticated — the action endpoints build an
+ * unsigned transaction from the caller's wallet address alone, which is why
+ * every built transaction must be validated on-device before it is signed.
+ */
+export const kaminoConfig = {
+    /** Kamino's public REST API. No key, no auth header. */
+    apiBaseUrl: 'https://api.kamino.finance',
+    /** The kVaults program every deposit and withdraw invokes. */
+    programId: 'KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd',
+    /**
+     * Kamino's farms program. Every launch vault has a farm attached, so a
+     * deposit ends with `initializeUser` + `stake` against this program and the
+     * shares never land in the user's wallet.
+     */
+    farmsProgramId: 'FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr',
+    /**
+     * Wrapped SOL. The SOL vault's underlying token is this mint, not native
+     * SOL, which is why its deposits carry a wrap prefix.
+     */
+    wrappedSolMint: 'So11111111111111111111111111111111111111112',
+    /** Circle's USDC — the underlying token of both dollar vaults. */
+    usdcMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+};
+//# sourceMappingURL=config.js.map

package/dist/chains/solana/kamino/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/config.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B,wDAAwD;IACxD,UAAU,EAAE,4BAA4B;IAExC,8DAA8D;IAC9D,SAAS,EAAE,6CAA6C;IAExD;;;;OAIG;IACH,cAAc,EAAE,8CAA8C;IAE9D;;;OAGG;IACH,cAAc,EAAE,6CAA6C;IAE7D,kEAAkE;IAClE,QAAQ,EAAE,8CAA8C;CAChD,CAAA"}

package/dist/chains/solana/kamino/decimal.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Strict-format parsing for Kamino's numeric JSON, which arrives as decimal
+ * strings (`"0.03994268764493801732"`, `"1.0536041812651029025"`).
+ *
+ * The format is validated rather than coerced: grouping separators, exponents
+ * and whitespace are rejected instead of being silently mis-read. What this
+ * does not guarantee is exactness — a JS `number` holds ~16 significant digits
+ * and Kamino publishes longer values. That is acceptable for the display
+ * values `parseKaminoDisplayDecimal` is used on (APY, PnL, prices). Anything
+ * that sizes a transaction must use `KaminoRate`, which is exact.
+ */
+/**
+ * Whether `raw` is a plain decimal string: optional leading `-`, ASCII digits,
+ * at most one `.`, at least one digit. Everything else — grouping separators,
+ * exponents, whitespace, non-ASCII digits — is rejected.
+ */
+export declare const isPlainKaminoDecimal: (raw: string) => boolean;
+/**
+ * Parses a display-only value (APY, price, PnL) after strict format
+ * validation, or `undefined` when the format is not a plain decimal. Never use
+ * the result to size a transaction — it round-trips through a binary double.
+ */
+export declare const parseKaminoDisplayDecimal: (raw: string) => number | undefined;
+//# sourceMappingURL=decimal.d.ts.map

package/dist/chains/solana/kamino/decimal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/decimal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,KAAK,MAAM,KAAG,OAmBlD,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GAAI,KAAK,MAAM,KAAG,MAAM,GAAG,SAGhE,CAAA"}

package/dist/chains/solana/kamino/decimal.js

@@ -0,0 +1,52 @@
+/**
+ * Strict-format parsing for Kamino's numeric JSON, which arrives as decimal
+ * strings (`"0.03994268764493801732"`, `"1.0536041812651029025"`).
+ *
+ * The format is validated rather than coerced: grouping separators, exponents
+ * and whitespace are rejected instead of being silently mis-read. What this
+ * does not guarantee is exactness — a JS `number` holds ~16 significant digits
+ * and Kamino publishes longer values. That is acceptable for the display
+ * values `parseKaminoDisplayDecimal` is used on (APY, PnL, prices). Anything
+ * that sizes a transaction must use `KaminoRate`, which is exact.
+ */
+/**
+ * Whether `raw` is a plain decimal string: optional leading `-`, ASCII digits,
+ * at most one `.`, at least one digit. Everything else — grouping separators,
+ * exponents, whitespace, non-ASCII digits — is rejected.
+ */
+export const isPlainKaminoDecimal = (raw) => {
+    if (!raw)
+        return false;
+    let hasDigit = false;
+    let hasSeparator = false;
+    for (let index = 0; index < raw.length; index++) {
+        const character = raw[index];
+        if (character === '-') {
+            if (index !== 0)
+                return false;
+        }
+        else if (character === '.') {
+            if (hasSeparator)
+                return false;
+            hasSeparator = true;
+        }
+        else if (character >= '0' && character <= '9') {
+            hasDigit = true;
+        }
+        else {
+            return false;
+        }
+    }
+    return hasDigit;
+};
+/**
+ * Parses a display-only value (APY, price, PnL) after strict format
+ * validation, or `undefined` when the format is not a plain decimal. Never use
+ * the result to size a transaction — it round-trips through a binary double.
+ */
+export const parseKaminoDisplayDecimal = (raw) => {
+    if (!isPlainKaminoDecimal(raw))
+        return undefined;
+    return Number(raw);
+};
+//# sourceMappingURL=decimal.js.map

package/dist/chains/solana/kamino/decimal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/decimal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,GAAW,EAAW,EAAE;IAC3D,IAAI,CAAC,GAAG;QAAE,OAAO,KAAK,CAAA;IAEtB,IAAI,QAAQ,GAAG,KAAK,CAAA;IACpB,IAAI,YAAY,GAAG,KAAK,CAAA;IACxB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QAChD,MAAM,SAAS,GAAG,GAAG,CAAC,KAAK,CAAC,CAAA;QAC5B,IAAI,SAAS,KAAK,GAAG,EAAE,CAAC;YACtB,IAAI,KAAK,KAAK,CAAC;gBAAE,OAAO,KAAK,CAAA;QAC/B,CAAC;aAAM,IAAI,SAAS,KAAK,GAAG,EAAE,CAAC;YAC7B,IAAI,YAAY;gBAAE,OAAO,KAAK,CAAA;YAC9B,YAAY,GAAG,IAAI,CAAA;QACrB,CAAC;aAAM,IAAI,SAAS,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG,EAAE,CAAC;YAChD,QAAQ,GAAG,IAAI,CAAA;QACjB,CAAC;aAAM,CAAC;YACN,OAAO,KAAK,CAAA;QACd,CAAC;IACH,CAAC;IACD,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,GAAW,EAAsB,EAAE;IAC3E,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC;QAAE,OAAO,SAAS,CAAA;IAChD,OAAO,MAAM,CAAC,GAAG,CAAC,CAAA;AACpB,CAAC,CAAA"}

package/dist/chains/solana/kamino/models.d.ts

@@ -0,0 +1,148 @@
+import { KaminoShareAmount, KaminoTokenAmount } from './amount.js';
+import { KaminoRate } from './rate.js';
+import { KaminoVaultDescriptor } from './registry.js';
+/**
+ * `GET /kvaults/vaults/{address}`. Every numeric field arrives as a string;
+ * nothing here may be consumed without going through the typed amounts.
+ */
+export type KaminoVaultStateResponse = {
+    address: string;
+    programId: string;
+    state: {
+        name: string;
+        tokenMint: string;
+        tokenMintDecimals: number;
+        sharesMint: string;
+        /**
+         * Share decimals are independent of token decimals — across the live vault
+         * set the pairs include (6,6), (6,9), (8,8) and (9,9). Never assume they
+         * match.
+         */
+        sharesMintDecimals: number;
+        /**
+         * Base units of the **underlying token**. Correctly denominated, unlike
+         * `minWithdrawAmount` — but still not a figure the program accepts: a
+         * deposit at exactly this amount is refused. Only the effective-minimum
+         * derivation in `fetchKaminoVaultInfo` may read it.
+         */
+        minDepositAmount: string;
+        /**
+         * Base units of the **underlying token**, despite naming the unit the
+         * withdraw endpoint takes. Reading it as a share count is a silent error on
+         * a dollar vault (the rate is near 1) and a ~930× one on the SOL vault. It
+         * is also not the floor the program enforces — see the effective-minimum
+         * derivation in `fetchKaminoVaultInfo`, which is what forms should use.
+         * Nothing but that derivation may read this field.
+         */
+        minWithdrawAmount: string;
+        /** Address lookup table the built transactions reference. */
+        vaultLookupTable: string;
+        /**
+         * When set, deposits auto-stake the shares into this farm and they never
+         * appear in the user's associated token account.
+         */
+        vaultFarm: string;
+        performanceFeeBps: number;
+        managementFeeBps: number;
+    };
+};
+/**
+ * `GET /kvaults/vaults/{address}/metrics`. Every numeric field is a decimal
+ * string; APYs are fractions (`"0.0391"` = 3.91%), not percentages.
+ */
+export type KaminoVaultMetricsResponse = {
+    apy30d: string;
+    /** Underlying tokens per share — the rate for valuing a position. */
+    tokensPerShare: string;
+    /** USD per share. NOT interchangeable with `tokensPerShare`. */
+    sharePrice: string;
+    tokenPrice: string;
+    tokensAvailable: string;
+    tokensInvested: string;
+};
+/**
+ * One element of `GET /kvaults/users/{owner}/positions`. Shares only — the
+ * endpoint returns no token or fiat value.
+ */
+export type KaminoUserPositionResponse = {
+    vaultAddress: string;
+    /**
+     * Shares held inside the vault's farm. For a farmed vault this is where a
+     * deposit lands, so it is normally the whole position.
+     */
+    stakedShares: string;
+    /** Shares sitting in the user's associated token account. */
+    unstakedShares: string;
+    totalShares: string;
+};
+/** `GET /kvaults/users/{owner}/vaults/{vault}/pnl`. */
+export type KaminoPnlResponse = {
+    totalCostBasis: KaminoPnlAmounts;
+    totalPnl: KaminoPnlAmounts;
+};
+/** One PnL figure expressed in the three denominations the API reports. */
+export type KaminoPnlAmounts = {
+    token: string;
+    sol: string;
+    usd: string;
+};
+/**
+ * A launch vault after its registry entry has been merged with live API state
+ * and metrics. This is what the feature layer consumes; the raw responses stay
+ * at the service boundary. The vault's identity (mints, decimals, farm) is
+ * read from `descriptor` — the registry's record — never from the response: a
+ * transaction built by the API cannot be validated against values the same API
+ * supplied.
+ */
+export type KaminoVaultInfo = {
+    descriptor: KaminoVaultDescriptor;
+    /** On-chain vault name (`"Steakhouse USDC"`). */
+    name: string;
+    /**
+     * The smallest deposit a form may offer.
+     *
+     * DERIVED: the published `minDepositAmount` plus a margin, because the
+     * program refuses a deposit at exactly the published figure. See
+     * `fetchKaminoVaultInfo`.
+     */
+    minDeposit: KaminoTokenAmount;
+    /**
+     * The smallest withdraw a form may offer, in SHARE base units.
+     *
+     * DERIVED, not `state.minWithdrawAmount` read at face value: that field is
+     * denominated in the underlying token and the program's own floor is higher
+     * than it. Because the derivation goes through `tokensPerShare`, this figure
+     * moves with the rate, and it is hydrated in the same response.
+     */
+    minWithdraw: KaminoShareAmount;
+    /**
+     * The address lookup table the built transactions reference.
+     *
+     * Live rather than pinned: unlike the mints and the farm, Kamino can
+     * legitimately repoint a vault at a new table. A substituted table renames
+     * an account into a mismatch rather than out of one, so no transaction check
+     * rests on it.
+     */
+    lookupTable: string;
+    /** 30-day APY as a fraction (0.0391 = 3.91%). Display-only. */
+    apy30d: number;
+    /**
+     * Underlying tokens per share, kept exact: this rate sizes a withdraw, and a
+     * rounding error in it can over-request shares.
+     */
+    tokensPerShare: KaminoRate;
+    /** USD price of the underlying token. Display-only. */
+    tokenPriceUsd: number;
+    /**
+     * The underlying balance the vault currently holds liquid, rather than
+     * invested in lending reserves. `undefined` when the metrics response did
+     * not carry a readable value.
+     *
+     * Advisory only — it says what a withdraw is likely to be able to settle
+     * immediately, and nothing sizes a transaction from it. The measured ratio
+     * is well under 1% of the launch vaults, so a withdraw above this buffer is
+     * the ordinary case, not an exception.
+     */
+    tokensAvailable?: KaminoTokenAmount;
+};
+//# sourceMappingURL=models.d.ts.map

package/dist/chains/solana/kamino/models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/models.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAC/D,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAElD;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAA;QACZ,SAAS,EAAE,MAAM,CAAA;QACjB,iBAAiB,EAAE,MAAM,CAAA;QACzB,UAAU,EAAE,MAAM,CAAA;QAClB;;;;WAIG;QACH,kBAAkB,EAAE,MAAM,CAAA;QAC1B;;;;;WAKG;QACH,gBAAgB,EAAE,MAAM,CAAA;QACxB;;;;;;;WAOG;QACH,iBAAiB,EAAE,MAAM,CAAA;QACzB,6DAA6D;QAC7D,gBAAgB,EAAE,MAAM,CAAA;QACxB;;;WAGG;QACH,SAAS,EAAE,MAAM,CAAA;QACjB,iBAAiB,EAAE,MAAM,CAAA;QACzB,gBAAgB,EAAE,MAAM,CAAA;KACzB,CAAA;CACF,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,qEAAqE;IACrE,cAAc,EAAE,MAAM,CAAA;IACtB,gEAAgE;IAChE,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,YAAY,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,cAAc,EAAE,gBAAgB,CAAA;IAChC,QAAQ,EAAE,gBAAgB,CAAA;CAC3B,CAAA;AAED,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,UAAU,EAAE,qBAAqB,CAAA;IACjC,iDAAiD;IACjD,IAAI,EAAE,MAAM,CAAA;IACZ;;;;;;OAMG;IACH,UAAU,EAAE,iBAAiB,CAAA;IAC7B;;;;;;;OAOG;IACH,WAAW,EAAE,iBAAiB,CAAA;IAC9B;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,+DAA+D;IAC/D,MAAM,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,cAAc,EAAE,UAAU,CAAA;IAC1B,uDAAuD;IACvD,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,iBAAiB,CAAA;CACpC,CAAA"}

package/dist/chains/solana/kamino/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/chains/solana/kamino/models.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"models.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/models.ts"],"names":[],"mappings":""}

package/dist/chains/solana/kamino/position.d.ts

@@ -0,0 +1,79 @@
+import { KaminoShareAmount } from './amount.js';
+import { KaminoUserPositionResponse } from './models.js';
+/**
+ * The user's share balance in one vault, split the way `/positions` reports
+ * it.
+ *
+ * Shares, never tokens: the withdraw endpoint takes shares and the balance a
+ * full withdraw must send is a share count. The token figure a form is
+ * denominated in is a projection of these at the current rate, and it is
+ * derived — never the other way round.
+ */
+export type KaminoSharePosition = {
+    staked: KaminoShareAmount;
+    unstaked: KaminoShareAmount;
+    total: KaminoShareAmount;
+    /**
+     * The largest share amount `POST /ktx/kvault/withdraw` will size as a share
+     * count rather than rewriting to `u64::MAX` — its *withdraw everything*
+     * sentinel.
+     *
+     * The sentinel fires at greater-than-**or-equal-to** the spendable balance,
+     * not merely above it. That was measured, not assumed, on wallets whose
+     * balance is an exact `u64` in a token account, so there is no rounding
+     * anywhere in the comparison. So "the whole balance" is not a request this
+     * API accepts, and the maximum has to be the largest amount strictly
+     * beneath it.
+     *
+     * Truncating the reported string is necessary and NOT sufficient. It gives a
+     * value strictly below the balance only when there were digits past the
+     * mint's scale to throw away; when the balance is exactly representable the
+     * truncation IS the balance, and asking for it is asking for everything. So
+     * the exact case gives up one base unit — `10^-6` of a share, worth about a
+     * ten-thousandth of a cent on the launch vaults — and the inexact case does
+     * not have to.
+     */
+    spendable: KaminoShareAmount;
+    /**
+     * Whether the two reported parts add up to the reported total.
+     *
+     * A response whose total exceeds its parts has shares it has not accounted
+     * for, and a withdraw flow has to know exactly how the position is split:
+     * the unstaked half is what decides how many shares the farm is asked to
+     * release, and a request built against a wrong split is one the API will
+     * answer with a different transaction from the one being checked for.
+     *
+     * Compared at the API's OWN precision, never at the share mint's scale.
+     * Truncating three strings to six decimals and adding two of them can miss
+     * the third by a base unit with nothing wrong — `0.9445485 + 0.9595935`
+     * truncates to `944548 + 959593`, one short of `1904142` — and refusing a
+     * real position over a last decimal place is not a guard, it is a bug.
+     */
+    accountsForItsTotal: boolean;
+    /**
+     * Whether the three reported numbers can all be true at once. A response
+     * whose parts sum past its total says the user holds more shares than they
+     * hold — figures that cannot be spent as a balance, and spending a balance
+     * that is too large is precisely the mistake the API turns into `u64::MAX`.
+     * The sum is compared at the API's own precision, like
+     * `accountsForItsTotal`: each part can sit below the total while the pair
+     * still exceeds it, and a truncated comparison could mask a real excess.
+     */
+    isPlausible: boolean;
+};
+/**
+ * Parses one `/positions` element at the vault's pinned share scale.
+ * `undefined` when any of the three values is not a plain decimal — a value
+ * that is present and unreadable is a failed read, not a zero balance.
+ *
+ * Every value is TRUNCATED to the share mint's own decimals on the way in.
+ * The endpoint reports up to 14 decimal places for a 6-decimal mint, and the
+ * extra digits are not a balance anyone can spend: handing the reported
+ * string straight back as an amount asks for more than the position holds,
+ * which the API rewrites to its withdraw-everything sentinel.
+ */
+export declare const parseKaminoSharePosition: ({ position, shareDecimals, }: {
+    position: KaminoUserPositionResponse;
+    shareDecimals: number;
+}) => KaminoSharePosition | undefined;
+//# sourceMappingURL=position.d.ts.map

package/dist/chains/solana/kamino/position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAA0E,MAAM,UAAU,CAAA;AACpH,OAAO,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAA;AAGrD;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,iBAAiB,CAAA;IACzB,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,KAAK,EAAE,iBAAiB,CAAA;IACxB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,EAAE,iBAAiB,CAAA;IAC5B;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,EAAE,OAAO,CAAA;IAC5B;;;;;;;;OAQG;IACH,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,GAAI,8BAGtC;IACD,QAAQ,EAAE,0BAA0B,CAAA;IACpC,aAAa,EAAE,MAAM,CAAA;CACtB,KAAG,mBAAmB,GAAG,SAqBzB,CAAA"}

package/dist/chains/solana/kamino/position.js

@@ -0,0 +1,52 @@
+import { kaminoShareAmount, kaminoShareAmountFromDecimalString, scaleKaminoRate } from './amount.js';
+import { compareKaminoRates, kaminoRateEquals, parseKaminoRate, sumKaminoRates } from './rate.js';
+/**
+ * Parses one `/positions` element at the vault's pinned share scale.
+ * `undefined` when any of the three values is not a plain decimal — a value
+ * that is present and unreadable is a failed read, not a zero balance.
+ *
+ * Every value is TRUNCATED to the share mint's own decimals on the way in.
+ * The endpoint reports up to 14 decimal places for a 6-decimal mint, and the
+ * extra digits are not a balance anyone can spend: handing the reported
+ * string straight back as an amount asks for more than the position holds,
+ * which the API rewrites to its withdraw-everything sentinel.
+ */
+export const parseKaminoSharePosition = ({ position, shareDecimals, }) => {
+    const staked = kaminoShareAmountFromDecimalString(position.stakedShares, shareDecimals);
+    const unstaked = kaminoShareAmountFromDecimalString(position.unstakedShares, shareDecimals);
+    const total = kaminoShareAmountFromDecimalString(position.totalShares, shareDecimals);
+    const spendable = spendableShares(position.totalShares, shareDecimals);
+    if (!staked || !unstaked || !total || !spendable)
+        return undefined;
+    const reportedSum = sumKaminoRates(position.stakedShares, position.unstakedShares);
+    const reportedTotal = parseKaminoRate(position.totalShares);
+    return {
+        staked,
+        unstaked,
+        total,
+        spendable,
+        accountsForItsTotal: reportedSum ? kaminoRateEquals(reportedSum, position.totalShares) : false,
+        // The amounts above parsed, so the parts are non-negative; what remains to
+        // check is that together they do not exceed the total.
+        isPlausible: reportedSum !== undefined && reportedTotal !== undefined && compareKaminoRates(reportedSum, reportedTotal) <= 0,
+    };
+};
+/**
+ * The spendable rule: truncate to the mint's scale, and give up one base unit
+ * only when the truncation was exact (see `KaminoSharePosition.spendable`).
+ * Refusing the sentinel is the point of the whole withdraw guard, so it is
+ * never accepted to make a 100% withdraw work — the dust is the price of the
+ * sentinel being indistinguishable, in the bytes, from an amount the user
+ * never asked for.
+ */
+const spendableShares = (totalShares, shareDecimals) => {
+    const rate = parseKaminoRate(totalShares);
+    if (!rate)
+        return undefined;
+    const scaled = scaleKaminoRate({ rate, toDecimals: shareDecimals });
+    if (!scaled)
+        return undefined;
+    const baseUnits = scaled.isExact ? scaled.baseUnits - 1n : scaled.baseUnits;
+    return kaminoShareAmount(baseUnits < 0n ? 0n : baseUnits, shareDecimals);
+};
+//# sourceMappingURL=position.js.map

package/dist/chains/solana/kamino/position.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"position.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/position.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,iBAAiB,EAAE,kCAAkC,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAEpH,OAAO,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAgE9F;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,EACvC,QAAQ,EACR,aAAa,GAId,EAAmC,EAAE;IACpC,MAAM,MAAM,GAAG,kCAAkC,CAAC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,CAAA;IACvF,MAAM,QAAQ,GAAG,kCAAkC,CAAC,QAAQ,CAAC,cAAc,EAAE,aAAa,CAAC,CAAA;IAC3F,MAAM,KAAK,GAAG,kCAAkC,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,CAAA;IACrF,MAAM,SAAS,GAAG,eAAe,CAAC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,CAAA;IACtE,IAAI,CAAC,MAAM,IAAI,CAAC,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS;QAAE,OAAO,SAAS,CAAA;IAElE,MAAM,WAAW,GAAG,cAAc,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAA;IAClF,MAAM,aAAa,GAAG,eAAe,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAA;IAE3D,OAAO;QACL,MAAM;QACN,QAAQ;QACR,KAAK;QACL,SAAS;QACT,mBAAmB,EAAE,WAAW,CAAC,CAAC,CAAC,gBAAgB,CAAC,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK;QAC9F,2EAA2E;QAC3E,uDAAuD;QACvD,WAAW,EACT,WAAW,KAAK,SAAS,IAAI,aAAa,KAAK,SAAS,IAAI,kBAAkB,CAAC,WAAW,EAAE,aAAa,CAAC,IAAI,CAAC;KAClH,CAAA;AACH,CAAC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,eAAe,GAAG,CAAC,WAAmB,EAAE,aAAqB,EAAiC,EAAE;IACpG,MAAM,IAAI,GAAG,eAAe,CAAC,WAAW,CAAC,CAAA;IACzC,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAA;IAC3B,MAAM,MAAM,GAAG,eAAe,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC,CAAA;IACnE,IAAI,CAAC,MAAM;QAAE,OAAO,SAAS,CAAA;IAE7B,MAAM,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAA;IAC3E,OAAO,iBAAiB,CAAC,SAAS,GAAG,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,EAAE,aAAa,CAAC,CAAA;AAC1E,CAAC,CAAA"}

package/dist/chains/solana/kamino/rate.d.ts

@@ -0,0 +1,57 @@
+/**
+ * An exact decimal value from the API, held as `numerator / 10^scale`.
+ *
+ * This exists because floating-point (and any fixed-precision decimal)
+ * arithmetic rounds. A share rate drives how many shares a withdraw burns, and
+ * the API does not validate amounts — it rewrites an over-sized withdraw to
+ * `u64::MAX`, meaning *withdraw everything*. A division that rounded up at the
+ * far end of the mantissa could therefore turn a partial withdraw into a full
+ * exit. Integer arithmetic removes the question.
+ */
+export type KaminoRate = {
+    numerator: bigint;
+    /** Denominator exponent: the value is `numerator / 10^scale`. */
+    scale: number;
+};
+/**
+ * Parses Kamino's decimal-string form exactly, with no intermediate binary or
+ * fixed-precision representation. `undefined` when the string is not a plain
+ * decimal.
+ */
+export declare const parseKaminoRate: (raw: string) => KaminoRate | undefined;
+/** Whether the rate names a value strictly above zero. */
+export declare const isPositiveKaminoRate: (rate: KaminoRate) => boolean;
+/**
+ * This value's numerator at `targetScale` decimal places, or `undefined` when
+ * the target is too coarse to hold it without loss.
+ */
+export declare const kaminoRateNumeratorAtScale: (rate: KaminoRate, targetScale: number) => bigint | undefined;
+/**
+ * The exact sum of two API decimal strings, or `undefined` when either is not
+ * one.
+ *
+ * Exists so two reported figures can be added at the precision they were
+ * reported at, rather than after each has been truncated to a mint's scale.
+ * See `parseKaminoSharePosition` for why that distinction is the difference
+ * between a guard and a false refusal.
+ */
+export declare const sumKaminoRates: (lhs: string, rhs: string) => KaminoRate | undefined;
+/**
+ * Whether `raw` names exactly the same number as `rate`. `false` when it is
+ * not a plain decimal at all — an unreadable figure is never equal to a
+ * readable one.
+ */
+export declare const kaminoRateEquals: (rate: KaminoRate, raw: string) => boolean;
+/**
+ * Orders two exact rates: negative when `lhs < rhs`, zero when equal,
+ * positive when `lhs > rhs`. Both values are brought to a common scale first,
+ * so the comparison happens at full reported precision rather than after a
+ * truncation that could mask a one-base-unit difference.
+ */
+export declare const compareKaminoRates: (lhs: KaminoRate, rhs: KaminoRate) => number;
+/**
+ * Renders the rate back to its plain decimal-string form (no trailing zeros,
+ * no exponent).
+ */
+export declare const renderKaminoRate: (rate: KaminoRate) => string;
+//# sourceMappingURL=rate.d.ts.map

package/dist/chains/solana/kamino/rate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/rate.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,KAAK,MAAM,KAAG,UAAU,GAAG,SAgB1D,CAAA;AAED,0DAA0D;AAC1D,eAAO,MAAM,oBAAoB,GAAI,MAAM,UAAU,KAAG,OAA8B,CAAA;AAEtF;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GAAI,MAAM,UAAU,EAAE,aAAa,MAAM,KAAG,MAAM,GAAG,SAG3F,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,UAAU,GAAG,SAWtE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,UAAU,EAAE,KAAK,MAAM,KAAG,OAQhE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,KAAK,UAAU,EAAE,KAAK,UAAU,KAAG,MAMrE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,UAAU,KAAG,MACwB,CAAA"}