@vultisig/core-chain 2.37.0 → 2.38.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @vultisig/core-chain
 
+## 2.38.0
+
+### Minor Changes
+
+- [#2074](https://github.com/vultisig/vultisig-sdk/pull/2074) [`8929244`](https://github.com/vultisig/vultisig-sdk/commit/8929244cdb3b21059a46eabac6d4d9684e18a633) Thanks [@Ehsan-saradar](https://github.com/Ehsan-saradar)! - Add the Kamino Earn data layer under `chains/solana/kamino`: a REST client for the kVaults API (vault state, metrics, user positions, PnL) with a typed error envelope that separates retryable statuses from permanent refusals; a curated vault registry pinning each launch vault's identity (mints, decimals, farm, curator, risk tier); distinct token- and share-denominated amount types over exact `bigint` base units, with exact-rate conversions that truncate toward zero so a sized withdraw can never over-request (the API rewrites an over-sized withdraw to `u64::MAX` — withdraw everything); vault-info hydration that refuses responses disagreeing with the pinned identity and derives the effective deposit/withdraw minimums the on-chain program actually accepts; and position parsing with a spendable-balance rule that stays strictly below the reported balance.
+
+- [#2124](https://github.com/vultisig/vultisig-sdk/pull/2124) [`514e31f`](https://github.com/vultisig/vultisig-sdk/commit/514e31f084c241792f3a9b2436074c324a909c0f) Thanks [@Ehsan-saradar](https://github.com/Ehsan-saradar)! - Add the Kamino Earn transaction pipeline under `chains/solana/kamino/tx`: build the unsigned deposit/withdraw transactions (with the withdraw-everything sentinel refused before a request leaves the device); inject the attribution memo and the compute-budget pair into the built v0 transaction without disturbing address-lookup-table indexes; replace the recent blockhash immediately before keysign; a fail-closed validator that admits only allow-listed programs, matches the exact instruction sequence each operation produces (both withdraw discriminators, the farms unstake pair, exactly one memo carrying exactly the attribution tag), pins every account that decides where money goes against the registry and local ATA/PDA derivations, pins every spend amount, and refuses unexplained writable accounts; and an offline decoder that lets a co-signing device derive an independent claim about what the bytes do — vault identified through the signer's own share account, both withdraw shapes accepted, the farm release bounded by the withdraw itself.
+
 ## 2.37.0
 
 ### Minor Changes

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

@@ -0,0 +1,63 @@
+/**
+ * Why a Kamino service call was refused or failed, as a record union so
+ * callers can branch with `matchRecordUnion`.
+ */
+export type KaminoServiceErrorReason = {
+    /**
+     * A structured error from the API. `status` is retained alongside the
+     * machine-readable `code` (`KVAULT_NOT_FOUND`, `TRANSACTION_SIZE_ERROR`,
+     * …) because Kamino's error envelope carries a `statusCode` of its own
+     * and a retryable 503 can arrive in the same body shape as a permanent
+     * 400.
+     */
+    api: {
+        status: number;
+        code?: string;
+        message: string;
+    };
+} | {
+    /** A numeric field did not parse under the strict decimal rules. */
+    malformedNumber: {
+        field: string;
+        value: string;
+    };
+} | {
+    /**
+     * An amount could not be sent: non-positive, beyond the `u64` an
+     * on-chain instruction can carry, or at an implausible decimal scale.
+     */
+    invalidAmount: string;
+} | {
+    /**
+     * A vault was described to the service in terms the registry does not
+     * recognise. The curated entry is the app's record of a vault's
+     * identity; anything else cannot be used to size or target a
+     * transaction.
+     */
+    vaultNotInRegistry: string;
+} | {
+    /**
+     * The API described a vault differently from the registry. Mints, their
+     * decimals and the farm are immutable properties of a kVault, so a
+     * disagreement is either the wrong vault or a response that cannot be
+     * trusted to size or target a transaction.
+     */
+    vaultMetadataMismatch: {
+        field: string;
+        expected: string;
+        actual: string;
+    };
+};
+/**
+ * Typed failure from the Kamino service boundary. Carries a structured
+ * `reason` so callers branch on data instead of matching message text, and
+ * `isRetryable` so a transient 429/5xx can be told apart from a permanent
+ * refusal that arrived in the same shape.
+ */
+export declare class KaminoServiceError extends Error {
+    readonly reason: KaminoServiceErrorReason;
+    constructor(reason: KaminoServiceErrorReason);
+    /** Whether retrying the same request could plausibly succeed. */
+    get isRetryable(): boolean;
+}
+//# sourceMappingURL=KaminoServiceError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KaminoServiceError.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/KaminoServiceError.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAChC;IACE;;;;;;OAMG;IACH,GAAG,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;CACxD,GACD;IACE,oEAAoE;IACpE,eAAe,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAClD,GACD;IACE;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAA;CACtB,GACD;IACE;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAA;CAC3B,GACD;IACE;;;;;OAKG;IACH,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3E,CAAA;AAEL;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAA;gBAE7B,MAAM,EAAE,wBAAwB;IAe5C,iEAAiE;IACjE,IAAI,WAAW,IAAI,OAAO,CAIzB;CACF"}

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

@@ -0,0 +1,29 @@
+import { matchRecordUnion } from '@vultisig/lib-utils/matchRecordUnion';
+/**
+ * Typed failure from the Kamino service boundary. Carries a structured
+ * `reason` so callers branch on data instead of matching message text, and
+ * `isRetryable` so a transient 429/5xx can be told apart from a permanent
+ * refusal that arrived in the same shape.
+ */
+export class KaminoServiceError extends Error {
+    reason;
+    constructor(reason) {
+        super(matchRecordUnion(reason, {
+            api: ({ code, message }) => (code ? `${code}: ${message}` : message),
+            malformedNumber: ({ field, value }) => `Malformed Kamino number for ${field}: ${value}`,
+            invalidAmount: detail => `Invalid Kamino amount: ${detail}`,
+            vaultNotInRegistry: address => `Kamino vault not in registry: ${address}`,
+            vaultMetadataMismatch: ({ field, expected, actual }) => `Kamino vault ${field} is "${actual}", registry pins "${expected}"`,
+        }));
+        this.name = 'KaminoServiceError';
+        this.reason = reason;
+    }
+    /** Whether retrying the same request could plausibly succeed. */
+    get isRetryable() {
+        if (!('api' in this.reason))
+            return false;
+        const { status } = this.reason.api;
+        return status === 429 || (status >= 500 && status <= 599);
+    }
+}
+//# sourceMappingURL=KaminoServiceError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KaminoServiceError.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/KaminoServiceError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAA;AA+CvE;;;;;GAKG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAClC,MAAM,CAA0B;IAEzC,YAAY,MAAgC;QAC1C,KAAK,CACH,gBAAgB,CAAC,MAAM,EAAE;YACvB,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC;YACpE,eAAe,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,+BAA+B,KAAK,KAAK,KAAK,EAAE;YACvF,aAAa,EAAE,MAAM,CAAC,EAAE,CAAC,0BAA0B,MAAM,EAAE;YAC3D,kBAAkB,EAAE,OAAO,CAAC,EAAE,CAAC,iCAAiC,OAAO,EAAE;YACzE,qBAAqB,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,CACrD,gBAAgB,KAAK,QAAQ,MAAM,qBAAqB,QAAQ,GAAG;SACtE,CAAC,CACH,CAAA;QACD,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAA;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;IAED,iEAAiE;IACjE,IAAI,WAAW;QACb,IAAI,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,CAAC;YAAE,OAAO,KAAK,CAAA;QACzC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAA;QAClC,OAAO,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC,CAAA;IAC3D,CAAC;CACF"}

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

@@ -0,0 +1,141 @@
+import { KaminoRate } from './rate.js';
+/**
+ * An amount denominated in a vault's **underlying token** (USDC, SOL).
+ *
+ * This is what `POST /ktx/kvault/deposit` expects. Deposit and withdraw take
+ * the same `amount` JSON field with inverted units — deposit in tokens,
+ * withdraw in shares — so the two are separate types on purpose: passing one
+ * where the other belongs is a compile error rather than a silently mis-sized
+ * transaction. The `unit` discriminant is what makes that hold under
+ * structural typing.
+ */
+export type KaminoTokenAmount = {
+    unit: 'kaminoToken';
+    /** The exact on-chain integer; every other form is derived from it. */
+    baseUnits: bigint;
+    decimals: number;
+};
+/**
+ * An amount denominated in a vault's **share token** (kTokens).
+ *
+ * This is what `POST /ktx/kvault/withdraw` expects — see `KaminoTokenAmount`
+ * for why the units are two distinct types.
+ */
+export type KaminoShareAmount = {
+    unit: 'kaminoShare';
+    /** The exact on-chain integer; every other form is derived from it. */
+    baseUnits: bigint;
+    decimals: number;
+};
+/** Either Kamino amount unit; use where behaviour is unit-independent. */
+export type KaminoAmount = KaminoTokenAmount | KaminoShareAmount;
+/** Wraps base units as a token amount. */
+export declare const kaminoTokenAmount: (baseUnits: bigint, decimals: number) => KaminoTokenAmount;
+/** Wraps base units as a share amount. */
+export declare const kaminoShareAmount: (baseUnits: bigint, decimals: number) => KaminoShareAmount;
+/**
+ * Parses a base-unit integer string as it appears in vault state (e.g.
+ * `minDepositAmount = "100000"` for 0.1 USDC). The caller supplies the scale,
+ * because the response never says which of the two mints a figure belongs to.
+ */
+export declare const kaminoTokenAmountFromBaseUnitString: (raw: string, decimals: number) => KaminoTokenAmount | undefined;
+/**
+ * Parses a human-units token decimal string as returned by the metrics
+ * endpoint (e.g. `tokensAvailable = "9581.812345"`), exactly, truncating
+ * toward zero below the mint's scale.
+ */
+export declare const kaminoTokenAmountFromDecimalString: (raw: string, decimals: number) => KaminoTokenAmount | undefined;
+/**
+ * Parses a human-units share decimal string as returned by
+ * `GET /kvaults/users/{owner}/positions` (e.g. `"517536.857982"`), exactly,
+ * truncating toward zero below the mint's scale.
+ */
+export declare const kaminoShareAmountFromDecimalString: (raw: string, decimals: number) => KaminoShareAmount | undefined;
+/**
+ * Whether this amount may be sent to Kamino: strictly positive, expressible as
+ * a `u64`, and at a sane decimal scale. The API accepts anything it can parse
+ * — a below-minimum deposit builds a transaction that fails on-chain, and an
+ * over-sized withdraw is rewritten to `u64::MAX`, meaning withdraw everything
+ * — so bounds are enforced client-side; this is the only gate the API offers.
+ */
+export declare const isValidKaminoRequestAmount: ({ baseUnits, decimals }: KaminoAmount) => boolean;
+/**
+ * The value as Kamino's request bodies want it: a plain human-units decimal
+ * string with no grouping, no trailing zeros and no exponent.
+ */
+export declare const kaminoAmountApiString: ({ baseUnits, decimals }: KaminoAmount) => string;
+/**
+ * Rescales an exact rate to base units at `toDecimals`, truncating toward
+ * zero, plus whether anything was truncated away. `undefined` when the scale
+ * is implausible or the value negative.
+ *
+ * The exactness flag exists for one caller and one reason. `/positions`
+ * reports share balances at up to 14 decimal places while a share mint has 6,
+ * so the truncated figure is *strictly below* the real balance whenever there
+ * were extra digits — and exactly equal to it when there were not. The
+ * withdraw maximum has to be strictly below, so it needs to know which of the
+ * two happened. See `parseKaminoSharePosition`.
+ */
+export declare const scaleKaminoRate: ({ rate, toDecimals, }: {
+    rate: KaminoRate;
+    toDecimals: number;
+}) => {
+    baseUnits: bigint;
+    isExact: boolean;
+} | undefined;
+type ShareToTokenInput = {
+    shares: KaminoShareAmount;
+    /**
+     * Underlying tokens per share — `metrics.tokensPerShare`, never
+     * `metrics.sharePrice`, which is USD-denominated and only coincides with it
+     * on dollar-pegged vaults (Allez SOL: `sharePrice` 0.0794 vs `tokensPerShare`
+     * 0.0010749).
+     */
+    tokensPerShare: KaminoRate;
+    tokenDecimals: number;
+};
+/**
+ * The position's value in the underlying token: `shares × tokensPerShare`,
+ * computed in exact integer arithmetic and truncated toward zero.
+ */
+export declare const kaminoShareToTokenValue: (input: ShareToTokenInput) => KaminoTokenAmount | undefined;
+/**
+ * The same conversion rounded **up**.
+ *
+ * Used for one thing only: rendering a share-denominated *minimum* as an asset
+ * amount, so the displayed figure, converted back, still clears the minimum.
+ * Never use this to size a transaction: rounding up is exactly the direction
+ * that turns a partial withdraw into an over-request.
+ */
+export declare const kaminoShareToTokenValueRoundedUp: (input: ShareToTokenInput) => KaminoTokenAmount | undefined;
+type TokenToShareInput = {
+    tokens: KaminoTokenAmount;
+    /** Underlying tokens per share — see `ShareToTokenInput.tokensPerShare`. */
+    tokensPerShare: KaminoRate;
+    shareDecimals: number;
+};
+/**
+ * Converts a token amount into the share amount a withdraw actually burns:
+ * `shares = tokens / tokensPerShare`, truncated toward zero.
+ *
+ * Exact integer arithmetic, never floating point. Rounding down is a safety
+ * property, not a preference: the API does not validate the amount, and a
+ * withdraw larger than the user's share balance is silently rewritten to
+ * `u64::MAX` — "withdraw everything". A division that rounded up, even by one
+ * base unit at the far end of the mantissa, could turn a partial withdraw into
+ * a full exit. For the same reason a 100% withdraw must send the held share
+ * balance directly and never a number derived from here.
+ */
+export declare const kaminoTokenToShareAmount: (input: TokenToShareInput) => KaminoShareAmount | undefined;
+/**
+ * The same conversion rounded **up**.
+ *
+ * Used for one thing only: turning a token-denominated *minimum* into the
+ * share count a withdraw has to name to clear it. Rounding down there would
+ * produce a share figure worth fractionally less than the minimum, which is
+ * the whole bug this exists to avoid. Never use it to size a transaction —
+ * see `kaminoTokenToShareAmount` for what an over-request becomes.
+ */
+export declare const kaminoTokenToShareAmountRoundedUp: (input: TokenToShareInput) => KaminoShareAmount | undefined;
+export {};
+//# sourceMappingURL=amount.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"amount.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/amount.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,UAAU,EAAmB,MAAM,QAAQ,CAAA;AAE1E;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,aAAa,CAAA;IACnB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EAAE,aAAa,CAAA;IACnB,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,0EAA0E;AAC1E,MAAM,MAAM,YAAY,GAAG,iBAAiB,GAAG,iBAAiB,CAAA;AAEhE,0CAA0C;AAC1C,eAAO,MAAM,iBAAiB,GAAI,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,iBAItE,CAAA;AAEF,0CAA0C;AAC1C,eAAO,MAAM,iBAAiB,GAAI,WAAW,MAAM,EAAE,UAAU,MAAM,KAAG,iBAItE,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,mCAAmC,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,iBAAiB,GAAG,SAGvG,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,iBAAiB,GAAG,SAKtG,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,kCAAkC,GAAI,KAAK,MAAM,EAAE,UAAU,MAAM,KAAG,iBAAiB,GAAG,SAKtG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,GAAI,yBAAyB,YAAY,KAAG,OACkB,CAAA;AAErG;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,yBAAyB,YAAY,KAAG,MAC9B,CAAA;AAEhD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAI,uBAG7B;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;CACnB,KAAG;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,SAU7C,CAAA;AAED,KAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE,iBAAiB,CAAA;IACzB;;;;;OAKG;IACH,cAAc,EAAE,UAAU,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,iBAAiB,KAAG,iBAAiB,GAAG,SAC3D,CAAA;AAE5B;;;;;;;GAOG;AACH,eAAO,MAAM,gCAAgC,GAAI,OAAO,iBAAiB,KAAG,iBAAiB,GAAG,SACrE,CAAA;AAE3B,KAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE,iBAAiB,CAAA;IACzB,4EAA4E;IAC5E,cAAc,EAAE,UAAU,CAAA;IAC1B,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,iBAAiB,KAAG,iBAAiB,GAAG,SAC5D,CAAA;AAE5B;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,OAAO,iBAAiB,KAAG,iBAAiB,GAAG,SACtE,CAAA"}

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

@@ -0,0 +1,156 @@
+import { kaminoMaxBaseUnits, kaminoMaxDecimals, renderKaminoBaseUnits } from './baseUnits.js';
+import { isPositiveKaminoRate, parseKaminoRate } from './rate.js';
+/** Wraps base units as a token amount. */
+export const kaminoTokenAmount = (baseUnits, decimals) => ({
+    unit: 'kaminoToken',
+    baseUnits,
+    decimals,
+});
+/** Wraps base units as a share amount. */
+export const kaminoShareAmount = (baseUnits, decimals) => ({
+    unit: 'kaminoShare',
+    baseUnits,
+    decimals,
+});
+/**
+ * Parses a base-unit integer string as it appears in vault state (e.g.
+ * `minDepositAmount = "100000"` for 0.1 USDC). The caller supplies the scale,
+ * because the response never says which of the two mints a figure belongs to.
+ */
+export const kaminoTokenAmountFromBaseUnitString = (raw, decimals) => {
+    const baseUnits = parseBaseUnitString(raw);
+    return baseUnits === undefined ? undefined : kaminoTokenAmount(baseUnits, decimals);
+};
+/**
+ * Parses a human-units token decimal string as returned by the metrics
+ * endpoint (e.g. `tokensAvailable = "9581.812345"`), exactly, truncating
+ * toward zero below the mint's scale.
+ */
+export const kaminoTokenAmountFromDecimalString = (raw, decimals) => {
+    const rate = parseKaminoRate(raw);
+    if (!rate)
+        return undefined;
+    const scaled = scaleKaminoRate({ rate, toDecimals: decimals });
+    return scaled === undefined ? undefined : kaminoTokenAmount(scaled.baseUnits, decimals);
+};
+/**
+ * Parses a human-units share decimal string as returned by
+ * `GET /kvaults/users/{owner}/positions` (e.g. `"517536.857982"`), exactly,
+ * truncating toward zero below the mint's scale.
+ */
+export const kaminoShareAmountFromDecimalString = (raw, decimals) => {
+    const rate = parseKaminoRate(raw);
+    if (!rate)
+        return undefined;
+    const scaled = scaleKaminoRate({ rate, toDecimals: decimals });
+    return scaled === undefined ? undefined : kaminoShareAmount(scaled.baseUnits, decimals);
+};
+/**
+ * Whether this amount may be sent to Kamino: strictly positive, expressible as
+ * a `u64`, and at a sane decimal scale. The API accepts anything it can parse
+ * — a below-minimum deposit builds a transaction that fails on-chain, and an
+ * over-sized withdraw is rewritten to `u64::MAX`, meaning withdraw everything
+ * — so bounds are enforced client-side; this is the only gate the API offers.
+ */
+export const isValidKaminoRequestAmount = ({ baseUnits, decimals }) => baseUnits > 0n && baseUnits <= kaminoMaxBaseUnits && decimals >= 0 && decimals <= kaminoMaxDecimals;
+/**
+ * The value as Kamino's request bodies want it: a plain human-units decimal
+ * string with no grouping, no trailing zeros and no exponent.
+ */
+export const kaminoAmountApiString = ({ baseUnits, decimals }) => renderKaminoBaseUnits({ baseUnits, decimals });
+/**
+ * Rescales an exact rate to base units at `toDecimals`, truncating toward
+ * zero, plus whether anything was truncated away. `undefined` when the scale
+ * is implausible or the value negative.
+ *
+ * The exactness flag exists for one caller and one reason. `/positions`
+ * reports share balances at up to 14 decimal places while a share mint has 6,
+ * so the truncated figure is *strictly below* the real balance whenever there
+ * were extra digits — and exactly equal to it when there were not. The
+ * withdraw maximum has to be strictly below, so it needs to know which of the
+ * two happened. See `parseKaminoSharePosition`.
+ */
+export const scaleKaminoRate = ({ rate, toDecimals, }) => {
+    if (toDecimals < 0 || toDecimals > kaminoMaxDecimals)
+        return undefined;
+    if (rate.scale < 0 || rate.scale > kaminoMaxDecimals * 4)
+        return undefined;
+    if (rate.numerator < 0n)
+        return undefined;
+    if (toDecimals >= rate.scale) {
+        return { baseUnits: rate.numerator * 10n ** BigInt(toDecimals - rate.scale), isExact: true };
+    }
+    const divisor = 10n ** BigInt(rate.scale - toDecimals);
+    return { baseUnits: rate.numerator / divisor, isExact: rate.numerator % divisor === 0n };
+};
+/**
+ * The position's value in the underlying token: `shares × tokensPerShare`,
+ * computed in exact integer arithmetic and truncated toward zero.
+ */
+export const kaminoShareToTokenValue = (input) => shareToToken(input, false);
+/**
+ * The same conversion rounded **up**.
+ *
+ * Used for one thing only: rendering a share-denominated *minimum* as an asset
+ * amount, so the displayed figure, converted back, still clears the minimum.
+ * Never use this to size a transaction: rounding up is exactly the direction
+ * that turns a partial withdraw into an over-request.
+ */
+export const kaminoShareToTokenValueRoundedUp = (input) => shareToToken(input, true);
+/**
+ * Converts a token amount into the share amount a withdraw actually burns:
+ * `shares = tokens / tokensPerShare`, truncated toward zero.
+ *
+ * Exact integer arithmetic, never floating point. Rounding down is a safety
+ * property, not a preference: the API does not validate the amount, and a
+ * withdraw larger than the user's share balance is silently rewritten to
+ * `u64::MAX` — "withdraw everything". A division that rounded up, even by one
+ * base unit at the far end of the mantissa, could turn a partial withdraw into
+ * a full exit. For the same reason a 100% withdraw must send the held share
+ * balance directly and never a number derived from here.
+ */
+export const kaminoTokenToShareAmount = (input) => tokenToShare(input, false);
+/**
+ * The same conversion rounded **up**.
+ *
+ * Used for one thing only: turning a token-denominated *minimum* into the
+ * share count a withdraw has to name to clear it. Rounding down there would
+ * produce a share figure worth fractionally less than the minimum, which is
+ * the whole bug this exists to avoid. Never use it to size a transaction —
+ * see `kaminoTokenToShareAmount` for what an over-request becomes.
+ */
+export const kaminoTokenToShareAmountRoundedUp = (input) => tokenToShare(input, true);
+const shareToToken = ({ shares, tokensPerShare, tokenDecimals }, roundUp) => {
+    if (!isConvertible(tokensPerShare, shares.baseUnits, [tokenDecimals, shares.decimals]))
+        return undefined;
+    // tokens = shares × rate, in base units:
+    //   tokensBase = sharesBase × numerator × 10^tokenDecimals
+    //                ÷ (10^shareDecimals × 10^rateScale)
+    const numerator = shares.baseUnits * tokensPerShare.numerator * 10n ** BigInt(tokenDecimals);
+    const denominator = 10n ** BigInt(shares.decimals + tokensPerShare.scale);
+    return kaminoTokenAmount(divide(numerator, denominator, roundUp), tokenDecimals);
+};
+const tokenToShare = ({ tokens, tokensPerShare, shareDecimals }, roundUp) => {
+    if (!isConvertible(tokensPerShare, tokens.baseUnits, [shareDecimals, tokens.decimals]))
+        return undefined;
+    // shares = tokens ÷ rate, in base units:
+    //   sharesBase = tokensBase × 10^rateScale × 10^shareDecimals
+    //                ÷ (10^tokenDecimals × numerator)
+    const numerator = tokens.baseUnits * 10n ** BigInt(tokensPerShare.scale + shareDecimals);
+    const denominator = 10n ** BigInt(tokens.decimals) * tokensPerShare.numerator;
+    return kaminoShareAmount(divide(numerator, denominator, roundUp), shareDecimals);
+};
+const isConvertible = (rate, baseUnits, decimalScales) => isPositiveKaminoRate(rate) &&
+    baseUnits >= 0n &&
+    rate.scale >= 0 &&
+    rate.scale <= kaminoMaxDecimals * 4 &&
+    decimalScales.every(decimals => decimals >= 0 && decimals <= kaminoMaxDecimals);
+const divide = (numerator, denominator, roundUp) => roundUp ? (numerator + denominator - 1n) / denominator : numerator / denominator;
+// Unsigned on purpose: base-unit fields are u64 values, so a signed string is
+// a malformed response, not a negative amount.
+const parseBaseUnitString = (raw) => {
+    if (!/^\d+$/.test(raw))
+        return undefined;
+    return BigInt(raw);
+};
+//# sourceMappingURL=amount.js.map

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

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

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

@@ -0,0 +1,20 @@
+import { KaminoPnlResponse, KaminoUserPositionResponse, KaminoVaultMetricsResponse, KaminoVaultStateResponse } from './models.js';
+/** Fetches a vault's live state (`GET /kvaults/vaults/{address}`). */
+export declare const fetchKaminoVaultState: (address: string) => Promise<KaminoVaultStateResponse>;
+/** Fetches a vault's metrics (`GET /kvaults/vaults/{address}/metrics`). */
+export declare const fetchKaminoVaultMetrics: (address: string) => Promise<KaminoVaultMetricsResponse>;
+/**
+ * Fetches every kVault position the owner holds
+ * (`GET /kvaults/users/{owner}/positions`). Uncached and generously timed —
+ * this read gates withdraws.
+ */
+export declare const fetchKaminoUserPositions: (owner: string) => Promise<KaminoUserPositionResponse[]>;
+/**
+ * Fetches lifetime PnL for one position
+ * (`GET /kvaults/users/{owner}/vaults/{vault}/pnl`).
+ */
+export declare const fetchKaminoPnl: ({ owner, vault }: {
+    owner: string;
+    vault: string;
+}) => Promise<KaminoPnlResponse>;
+//# sourceMappingURL=api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/api.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,iBAAiB,EACjB,0BAA0B,EAC1B,0BAA0B,EAC1B,wBAAwB,EACzB,MAAM,UAAU,CAAA;AAyDjB,sEAAsE;AACtE,eAAO,MAAM,qBAAqB,GAAI,SAAS,MAAM,KAAG,OAAO,CAAC,wBAAwB,CACtC,CAAA;AAElD,2EAA2E;AAC3E,eAAO,MAAM,uBAAuB,GAAI,SAAS,MAAM,KAAG,OAAO,CAAC,0BAA0B,CAClC,CAAA;AAE1D;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,GAAI,OAAO,MAAM,KAAG,OAAO,CAAC,0BAA0B,EAAE,CACZ,CAAA;AAEjF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,kBAAkB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAAG,OAAO,CAAC,iBAAiB,CACjC,CAAA"}

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