@vultisig/core-chain 2.37.0 → 2.38.0

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"}

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

@@ -0,0 +1,88 @@
+import { renderKaminoBaseUnits } from './baseUnits.js';
+import { isPlainKaminoDecimal } from './decimal.js';
+/**
+ * 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 const parseKaminoRate = (raw) => {
+    if (!isPlainKaminoDecimal(raw))
+        return undefined;
+    const separatorIndex = raw.indexOf('.');
+    const whole = separatorIndex === -1 ? raw : raw.slice(0, separatorIndex);
+    const fraction = separatorIndex === -1 ? '' : raw.slice(separatorIndex + 1);
+    // isPlainKaminoDecimal guarantees at least one digit, so `digits` is never
+    // empty even for forms like ".5" or "-.5".
+    const sign = whole.startsWith('-') ? -1n : 1n;
+    const digits = (whole.startsWith('-') ? whole.slice(1) : whole) + fraction;
+    return {
+        numerator: sign * BigInt(digits),
+        scale: fraction.length,
+    };
+};
+/** Whether the rate names a value strictly above zero. */
+export const isPositiveKaminoRate = (rate) => rate.numerator > 0n;
+/**
+ * This value's numerator at `targetScale` decimal places, or `undefined` when
+ * the target is too coarse to hold it without loss.
+ */
+export const kaminoRateNumeratorAtScale = (rate, targetScale) => {
+    if (targetScale < rate.scale)
+        return undefined;
+    return rate.numerator * 10n ** BigInt(targetScale - rate.scale);
+};
+/**
+ * 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 const sumKaminoRates = (lhs, rhs) => {
+    const left = parseKaminoRate(lhs);
+    const right = parseKaminoRate(rhs);
+    if (!left || !right)
+        return undefined;
+    const scale = Math.max(left.scale, right.scale);
+    const a = kaminoRateNumeratorAtScale(left, scale);
+    const b = kaminoRateNumeratorAtScale(right, scale);
+    if (a === undefined || b === undefined)
+        return undefined;
+    return { numerator: a + b, scale };
+};
+/**
+ * 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 const kaminoRateEquals = (rate, raw) => {
+    const other = parseKaminoRate(raw);
+    if (!other)
+        return false;
+    const scale = Math.max(rate.scale, other.scale);
+    const a = kaminoRateNumeratorAtScale(rate, scale);
+    const b = kaminoRateNumeratorAtScale(other, scale);
+    return a !== undefined && b !== undefined && a === b;
+};
+/**
+ * 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 const compareKaminoRates = (lhs, rhs) => {
+    const scale = Math.max(lhs.scale, rhs.scale);
+    const a = lhs.numerator * 10n ** BigInt(scale - lhs.scale);
+    const b = rhs.numerator * 10n ** BigInt(scale - rhs.scale);
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+};
+/**
+ * Renders the rate back to its plain decimal-string form (no trailing zeros,
+ * no exponent).
+ */
+export const renderKaminoRate = (rate) => renderKaminoBaseUnits({ baseUnits: rate.numerator, decimals: rate.scale });
+//# sourceMappingURL=rate.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rate.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/rate.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,70 @@
+/**
+ * Relative risk of a launch vault, used to order and label them.
+ *
+ * This is curation, not API data — Kamino exposes no risk or curator field
+ * anywhere, so both live here and travel with the allow-list.
+ *
+ * `conservative` is plain over-collateralised lending against liquid crypto
+ * collateral. `privateCredit` lends against tokenized private credit —
+ * reinsurance, receivables and corporate bonds — which is materially different
+ * risk and must not be presented as government-backed.
+ */
+export declare const kaminoRiskTiers: readonly ["conservative", "privateCredit"];
+/** One of the curated risk-tier labels a launch vault is shown under. */
+export type KaminoRiskTier = (typeof kaminoRiskTiers)[number];
+/**
+ * A curated vault the app offers.
+ *
+ * This carries everything a transaction is checked against, because a value
+ * fetched from the API cannot be used to validate a transaction built by the
+ * same API — the check would be circular, and a compromised response could
+ * supply a matching pair. The fields below are all immutable properties of the
+ * vault: a kVault's mints, their decimals and its farm are fixed at creation.
+ * Everything that legitimately moves — name, minimums, APY, rates, the lookup
+ * table — stays live, and the vault-info hydration refuses a response that
+ * disagrees with the pinned identity.
+ */
+export type KaminoVaultDescriptor = {
+    address: string;
+    /**
+     * The vault's underlying token mint. Pinned: the deposit source and the
+     * withdraw destination are derived from it.
+     */
+    tokenMint: string;
+    /**
+     * Pinned because it scales every amount. A wrong scale mis-sizes the
+     * transfer by a power of ten while every other check still passes.
+     */
+    tokenDecimals: number;
+    sharesMint: string;
+    sharesDecimals: number;
+    /**
+     * The farm a deposit stakes into, or `undefined` when the vault has none.
+     * Pinned because `farms::stake` moves the whole share balance into it.
+     */
+    farm?: string;
+    /** Shown until live state arrives, and as the fallback if it never does. */
+    fallbackName: string;
+    curator: string;
+    riskTier: KaminoRiskTier;
+};
+/**
+ * The curated set of Kamino Earn vaults the app exposes.
+ *
+ * Kamino runs 160+ vaults; `GET /kvaults/vaults` returns all of them as a
+ * single ~340 KB payload. The allow-list both curates and keeps the fetch
+ * small — the three entries are hydrated with three ~2.8 KB per-vault requests
+ * instead.
+ *
+ * The share scale is independent of the token scale — 6 against 9 on the SOL
+ * vault — so nothing may assume the two match.
+ */
+export declare const kaminoVaultRegistry: readonly KaminoVaultDescriptor[];
+/**
+ * Resolves the curated entry for a vault address, or `undefined` for any
+ * address the registry does not carry. The returned descriptor is the app's
+ * record of the vault's identity — always resolve through here rather than
+ * accepting descriptor-shaped data from elsewhere.
+ */
+export declare const getKaminoVaultDescriptor: (address: string) => KaminoVaultDescriptor | undefined;
+//# sourceMappingURL=registry.d.ts.map