@vultisig/core-chain 2.37.0 → 2.38.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/registry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,4CAA6C,CAAA;AAEzE,yEAAyE;AACzE,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAA;AAE7D;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,MAAM,CAAA;IACf;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,cAAc,EAAE,MAAM,CAAA;IACtB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,cAAc,CAAA;CACzB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,qBAAqB,EAkC/D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,KAAG,qBAAqB,GAAG,SACrB,CAAA"}

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

@@ -0,0 +1,67 @@
+import { kaminoConfig } from './config.js';
+/**
+ * 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 const kaminoRiskTiers = ['conservative', 'privateCredit'];
+/**
+ * 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 const kaminoVaultRegistry = [
+    {
+        address: 'HDsayqAsDWy3QvANGqh2yNraqcD8Fnjgh73Mhb3WRS5E',
+        tokenMint: kaminoConfig.usdcMint,
+        tokenDecimals: 6,
+        sharesMint: '7D8C5pDFxug58L9zkwK7bCiDg4kD4AygzbcZUmf5usHS',
+        sharesDecimals: 6,
+        farm: '9FVjHqduhDPMVqvu3cXiEBjU6nvxvGdCCLRwd9WpVRZj',
+        fallbackName: 'Steakhouse USDC',
+        curator: 'Steakhouse Financial',
+        riskTier: 'conservative',
+    },
+    {
+        address: 'DWSXb18xZApz29vnQpgR2m6MynCT7PznaXt7Ut7M7KaP',
+        tokenMint: kaminoConfig.usdcMint,
+        tokenDecimals: 6,
+        sharesMint: 'DgHN3q3dSYAchNX7V3D4aYiTWMx8RHTgHbfPiwiqBkE9',
+        sharesDecimals: 6,
+        farm: 'ArwyAHmnFmbKbUxC2fnK5VUEpspHrnoFtJ22bvEyriKk',
+        fallbackName: 'RWA USDC',
+        curator: 'RockawayX',
+        riskTier: 'privateCredit',
+    },
+    {
+        address: 'A1so1bPD3W1TfeFwboDh8yfAAVaVtcdAYBYCjhg2mJQ',
+        tokenMint: kaminoConfig.wrappedSolMint,
+        tokenDecimals: 9,
+        sharesMint: 'FiM4VQdXXnTXL7GgChryf9zHNG9cmvKECwf34L2y3CkN',
+        sharesDecimals: 6,
+        farm: 'H6kauPaHmNqpdKtD5U2zw3Eb28ZB7iMeBdHVfLq1i4Kh',
+        fallbackName: 'Allez SOL',
+        curator: 'Allez Labs',
+        riskTier: 'conservative',
+    },
+];
+/**
+ * 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 const getKaminoVaultDescriptor = (address) => kaminoVaultRegistry.find(vault => vault.address === address);
+//# sourceMappingURL=registry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../../../../../../packages/core/chain/chains/solana/kamino/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,cAAc,EAAE,eAAe,CAAU,CAAA;AA0CzE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAqC;IACnE;QACE,OAAO,EAAE,8CAA8C;QACvD,SAAS,EAAE,YAAY,CAAC,QAAQ;QAChC,aAAa,EAAE,CAAC;QAChB,UAAU,EAAE,8CAA8C;QAC1D,cAAc,EAAE,CAAC;QACjB,IAAI,EAAE,8CAA8C;QACpD,YAAY,EAAE,iBAAiB;QAC/B,OAAO,EAAE,sBAAsB;QAC/B,QAAQ,EAAE,cAAc;KACzB;IACD;QACE,OAAO,EAAE,8CAA8C;QACvD,SAAS,EAAE,YAAY,CAAC,QAAQ;QAChC,aAAa,EAAE,CAAC;QAChB,UAAU,EAAE,8CAA8C;QAC1D,cAAc,EAAE,CAAC;QACjB,IAAI,EAAE,8CAA8C;QACpD,YAAY,EAAE,UAAU;QACxB,OAAO,EAAE,WAAW;QACpB,QAAQ,EAAE,eAAe;KAC1B;IACD;QACE,OAAO,EAAE,6CAA6C;QACtD,SAAS,EAAE,YAAY,CAAC,cAAc;QACtC,aAAa,EAAE,CAAC;QAChB,UAAU,EAAE,8CAA8C;QAC1D,cAAc,EAAE,CAAC;QACjB,IAAI,EAAE,8CAA8C;QACpD,YAAY,EAAE,WAAW;QACzB,OAAO,EAAE,YAAY;QACrB,QAAQ,EAAE,cAAc;KACzB;CACF,CAAA;AAED;;;;;GAKG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,OAAe,EAAqC,EAAE,CAC7F,mBAAmB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,OAAO,CAAC,CAAA"}

package/dist/chains/solana/kamino/tx/actions.d.ts

@@ -0,0 +1,22 @@
+import { KaminoShareAmount, KaminoTokenAmount } from '../amount.js';
+/**
+ * Builds an unsigned deposit transaction. The amount is in the vault's
+ * underlying token — the type enforces it. The vault is resolved through the
+ * registry, so an arbitrary address cannot reach Kamino through here.
+ */
+export declare const buildKaminoDepositTransaction: ({ owner, vaultAddress, amount, }: {
+    owner: string;
+    vaultAddress: string;
+    amount: KaminoTokenAmount;
+}) => Promise<string>;
+/**
+ * Builds an unsigned withdraw transaction. The amount is in SHARES — the
+ * inverse of deposit. This asymmetry is the API's, not ours, and the type is
+ * what keeps the two from crossing.
+ */
+export declare const buildKaminoWithdrawTransaction: ({ owner, vaultAddress, shares, }: {
+    owner: string;
+    vaultAddress: string;
+    shares: KaminoShareAmount;
+}) => Promise<string>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/chains/solana/kamino/tx/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/chain/chains/solana/kamino/tx/actions.ts"],"names":[],"mappings":"AAGA,OAAO,EAAqD,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAuFnH;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,GAAU,kCAIjD;IACD,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,iBAAiB,CAAA;CAC1B,KAAG,OAAO,CAAC,MAAM,CAQjB,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,GAAU,kCAIlD;IACD,KAAK,EAAE,MAAM,CAAA;IACb,YAAY,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,iBAAiB,CAAA;CAC1B,KAAG,OAAO,CAAC,MAAM,CAoBjB,CAAA"}

package/dist/chains/solana/kamino/tx/actions.js

@@ -0,0 +1,85 @@
+import { HttpResponseError } from '@vultisig/lib-utils/fetch/HttpResponseError';
+import { queryUrl } from '@vultisig/lib-utils/query/queryUrl';
+import { isValidKaminoRequestAmount, kaminoAmountApiString } from '../amount.js';
+import { kaminoMaxBaseUnits } from '../baseUnits.js';
+import { kaminoConfig } from '../config.js';
+import { KaminoServiceError } from '../KaminoServiceError.js';
+import { getKaminoVaultDescriptor } from '../registry.js';
+const isKaminoErrorBody = (body) => typeof body === 'object' &&
+    body !== null &&
+    typeof body.statusCode === 'number' &&
+    typeof body.message === 'string';
+const buildTransaction = async (path, body) => {
+    try {
+        const response = await queryUrl(`${kaminoConfig.apiBaseUrl}${path}`, { body });
+        // The type parameter asserts the response shape; it does not check it. A
+        // 200 without a transaction would otherwise surface downstream as an
+        // unreadable-transaction failure instead of naming the real cause.
+        if (typeof response?.transaction !== 'string' || response.transaction.length === 0) {
+            throw new KaminoServiceError({ api: { status: 200, message: `${path} response carried no transaction` } });
+        }
+        return response.transaction;
+    }
+    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;
+    }
+};
+const requireCuratedVault = (vaultAddress) => {
+    const descriptor = getKaminoVaultDescriptor(vaultAddress);
+    if (!descriptor)
+        throw new KaminoServiceError({ vaultNotInRegistry: vaultAddress });
+    return descriptor;
+};
+const requireValidAmount = (amount, label) => {
+    if (!isValidKaminoRequestAmount(amount)) {
+        throw new KaminoServiceError({
+            invalidAmount: `${label} amount ${amount.baseUnits} at ${amount.decimals} decimals is out of range`,
+        });
+    }
+};
+/**
+ * Builds an unsigned deposit transaction. The amount is in the vault's
+ * underlying token — the type enforces it. The vault is resolved through the
+ * registry, so an arbitrary address cannot reach Kamino through here.
+ */
+export const buildKaminoDepositTransaction = async ({ owner, vaultAddress, amount, }) => {
+    const descriptor = requireCuratedVault(vaultAddress);
+    requireValidAmount(amount, 'deposit');
+    return buildTransaction('/ktx/kvault/deposit', {
+        wallet: owner,
+        kvault: descriptor.address,
+        amount: kaminoAmountApiString(amount),
+    });
+};
+/**
+ * Builds an unsigned withdraw transaction. The amount is in SHARES — the
+ * inverse of deposit. This asymmetry is the API's, not ours, and the type is
+ * what keeps the two from crossing.
+ */
+export const buildKaminoWithdrawTransaction = async ({ owner, vaultAddress, shares, }) => {
+    const descriptor = requireCuratedVault(vaultAddress);
+    requireValidAmount(shares, 'withdraw');
+    // u64::MAX is the API's own "withdraw everything" sentinel: it is what a
+    // request AT OR ABOVE the user's balance is silently rewritten to. No
+    // legitimate share balance is 18.4 quintillion base units, so refusing the
+    // value outright costs nothing and closes the one way this app could name
+    // it directly. The spendable-balance rule in `parseKaminoSharePosition` is
+    // what keeps every request strictly below the balance; the validator is
+    // what refuses the response if a sentinel arrives anyway.
+    if (shares.baseUnits >= kaminoMaxBaseUnits) {
+        throw new KaminoServiceError({
+            invalidAmount: `withdraw amount ${shares.baseUnits} is the withdraw-everything sentinel`,
+        });
+    }
+    return buildTransaction('/ktx/kvault/withdraw', {
+        wallet: owner,
+        kvault: descriptor.address,
+        amount: kaminoAmountApiString(shares),
+    });
+};
+//# sourceMappingURL=actions.js.map

package/dist/chains/solana/kamino/tx/actions.js.map

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

package/dist/chains/solana/kamino/tx/computeBudget.d.ts

@@ -0,0 +1,66 @@
+import { KaminoVaultDescriptor } from '../registry.js';
+/**
+ * Compute-budget parameters for the ComputeBudget instructions the app
+ * injects into Kamino's transactions.
+ *
+ * Kamino builds its transactions with NO ComputeBudget instruction at all,
+ * and ignores fee fields in the request body — the response is byte-identical
+ * with or without them. So the only way a Kamino transaction carries a
+ * priority fee is for the app to inject one, and injecting a price without a
+ * limit would price the fee off the runtime's default limit rather than the
+ * units the transaction actually needs.
+ *
+ * The limits carry roughly a quarter over what each shape measured in mainnet
+ * simulation (`err: null`): USDC deposit 252,146 · SOL deposit 287,029 ·
+ * unstaked withdraw 173,251 · farm-staked withdraw up to 309,310. The margin
+ * absorbs the drift a different account-existence mix causes — a deposit
+ * whose share ATA or farm user account still has to be created does strictly
+ * more work than one whose accounts already exist.
+ */
+export declare const kaminoComputeBudget: {
+    /** Compute-unit limit for a deposit into a token vault. */
+    readonly tokenDepositUnitLimit: 320000;
+    /**
+     * A SOL-vault deposit additionally creates the wSOL account, transfers into
+     * it and syncs it, so it costs more than a token deposit.
+     */
+    readonly nativeDepositUnitLimit: 350000;
+    /**
+     * One limit for BOTH withdraw shapes, sized for the expensive one — the
+     * farm-staked path runs two extra farms instructions and a second account
+     * creation ahead of the vault withdraw. One value per operation keeps the
+     * limit pinnable by the verify screen; the unstaked path pays a few
+     * thousand lamports of headroom in exchange.
+     */
+    readonly withdrawUnitLimit: 400000;
+    /**
+     * Price used when the network's recent-fee sample is unavailable, in
+     * micro-lamports per compute unit. The live median is preferred; this is
+     * the floor beneath it — a sample below it would under-tip a transaction
+     * that has to land before its blockhash expires.
+     */
+    readonly fallbackUnitPriceMicroLamports: 20000n;
+    /**
+     * Ceiling on the live price. The recent-fee sample is a number a remote
+     * node hands us, multiplied by a six-figure compute limit into lamports the
+     * user pays — unbounded, a wrong or hostile sample is an unbounded fee. At
+     * this ceiling and the largest limit the priority fee tops out at 400,000
+     * lamports (0.0004 SOL).
+     */
+    readonly maxUnitPriceMicroLamports: 1000000n;
+};
+/**
+ * The compute-unit limit this app injects for one operation against one
+ * vault. Pinned rather than bounded by the checks: the app injects exactly
+ * one value, so any other one did not come from it.
+ */
+export declare const kaminoExpectedUnitLimit: ({ operation, descriptor, }: {
+    operation: "deposit" | "withdraw";
+    descriptor: KaminoVaultDescriptor;
+}) => number;
+/**
+ * Brings a sampled network price inside `[fallback, max]` — the fallback is a
+ * floor rather than a default.
+ */
+export declare const clampKaminoUnitPrice: (sampled: bigint) => bigint;
+//# sourceMappingURL=computeBudget.d.ts.map

package/dist/chains/solana/kamino/tx/computeBudget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeBudget.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/chain/chains/solana/kamino/tx/computeBudget.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAEnD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB;IAC9B,2DAA2D;;IAE3D;;;OAGG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;;;;;OAMG;;CAEK,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,GAAI,4BAGrC;IACD,SAAS,EAAE,SAAS,GAAG,UAAU,CAAA;IACjC,UAAU,EAAE,qBAAqB,CAAA;CAClC,KAAG,MAKH,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,MAAM,KAAG,MAItD,CAAA"}

package/dist/chains/solana/kamino/tx/computeBudget.js

@@ -0,0 +1,73 @@
+import { kaminoConfig } from '../config.js';
+/**
+ * Compute-budget parameters for the ComputeBudget instructions the app
+ * injects into Kamino's transactions.
+ *
+ * Kamino builds its transactions with NO ComputeBudget instruction at all,
+ * and ignores fee fields in the request body — the response is byte-identical
+ * with or without them. So the only way a Kamino transaction carries a
+ * priority fee is for the app to inject one, and injecting a price without a
+ * limit would price the fee off the runtime's default limit rather than the
+ * units the transaction actually needs.
+ *
+ * The limits carry roughly a quarter over what each shape measured in mainnet
+ * simulation (`err: null`): USDC deposit 252,146 · SOL deposit 287,029 ·
+ * unstaked withdraw 173,251 · farm-staked withdraw up to 309,310. The margin
+ * absorbs the drift a different account-existence mix causes — a deposit
+ * whose share ATA or farm user account still has to be created does strictly
+ * more work than one whose accounts already exist.
+ */
+export const kaminoComputeBudget = {
+    /** Compute-unit limit for a deposit into a token vault. */
+    tokenDepositUnitLimit: 320_000,
+    /**
+     * A SOL-vault deposit additionally creates the wSOL account, transfers into
+     * it and syncs it, so it costs more than a token deposit.
+     */
+    nativeDepositUnitLimit: 350_000,
+    /**
+     * One limit for BOTH withdraw shapes, sized for the expensive one — the
+     * farm-staked path runs two extra farms instructions and a second account
+     * creation ahead of the vault withdraw. One value per operation keeps the
+     * limit pinnable by the verify screen; the unstaked path pays a few
+     * thousand lamports of headroom in exchange.
+     */
+    withdrawUnitLimit: 400_000,
+    /**
+     * Price used when the network's recent-fee sample is unavailable, in
+     * micro-lamports per compute unit. The live median is preferred; this is
+     * the floor beneath it — a sample below it would under-tip a transaction
+     * that has to land before its blockhash expires.
+     */
+    fallbackUnitPriceMicroLamports: 20000n,
+    /**
+     * Ceiling on the live price. The recent-fee sample is a number a remote
+     * node hands us, multiplied by a six-figure compute limit into lamports the
+     * user pays — unbounded, a wrong or hostile sample is an unbounded fee. At
+     * this ceiling and the largest limit the priority fee tops out at 400,000
+     * lamports (0.0004 SOL).
+     */
+    maxUnitPriceMicroLamports: 1000000n,
+};
+/**
+ * The compute-unit limit this app injects for one operation against one
+ * vault. Pinned rather than bounded by the checks: the app injects exactly
+ * one value, so any other one did not come from it.
+ */
+export const kaminoExpectedUnitLimit = ({ operation, descriptor, }) => {
+    if (operation === 'withdraw')
+        return kaminoComputeBudget.withdrawUnitLimit;
+    return descriptor.tokenMint === kaminoConfig.wrappedSolMint
+        ? kaminoComputeBudget.nativeDepositUnitLimit
+        : kaminoComputeBudget.tokenDepositUnitLimit;
+};
+/**
+ * Brings a sampled network price inside `[fallback, max]` — the fallback is a
+ * floor rather than a default.
+ */
+export const clampKaminoUnitPrice = (sampled) => {
+    const { fallbackUnitPriceMicroLamports, maxUnitPriceMicroLamports } = kaminoComputeBudget;
+    const floored = sampled > fallbackUnitPriceMicroLamports ? sampled : fallbackUnitPriceMicroLamports;
+    return floored < maxUnitPriceMicroLamports ? floored : maxUnitPriceMicroLamports;
+};
+//# sourceMappingURL=computeBudget.js.map

package/dist/chains/solana/kamino/tx/computeBudget.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeBudget.js","sourceRoot":"","sources":["../../../../../../../../packages/core/chain/chains/solana/kamino/tx/computeBudget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AAGxC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,2DAA2D;IAC3D,qBAAqB,EAAE,OAAO;IAC9B;;;OAGG;IACH,sBAAsB,EAAE,OAAO;IAC/B;;;;;;OAMG;IACH,iBAAiB,EAAE,OAAO;IAC1B;;;;;OAKG;IACH,8BAA8B,EAAE,MAAO;IACvC;;;;;;OAMG;IACH,yBAAyB,EAAE,QAAU;CAC7B,CAAA;AAEV;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,EACtC,SAAS,EACT,UAAU,GAIX,EAAU,EAAE;IACX,IAAI,SAAS,KAAK,UAAU;QAAE,OAAO,mBAAmB,CAAC,iBAAiB,CAAA;IAC1E,OAAO,UAAU,CAAC,SAAS,KAAK,YAAY,CAAC,cAAc;QACzD,CAAC,CAAC,mBAAmB,CAAC,sBAAsB;QAC5C,CAAC,CAAC,mBAAmB,CAAC,qBAAqB,CAAA;AAC/C,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,OAAe,EAAU,EAAE;IAC9D,MAAM,EAAE,8BAA8B,EAAE,yBAAyB,EAAE,GAAG,mBAAmB,CAAA;IACzF,MAAM,OAAO,GAAG,OAAO,GAAG,8BAA8B,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,8BAA8B,CAAA;IACnG,OAAO,OAAO,GAAG,yBAAyB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,yBAAyB,CAAA;AAClF,CAAC,CAAA"}

package/dist/chains/solana/kamino/tx/decode.d.ts

@@ -0,0 +1,121 @@
+import { VersionedTransaction } from '@solana/web3.js';
+import { KaminoVaultDescriptor } from '../registry.js';
+import { KaminoPriorityFee } from './validate.js';
+/**
+ * What a Kamino transaction does, read back out of the bytes that will be
+ * signed.
+ *
+ * Every field is derived from the wire message plus values the app already
+ * holds — the vault registry and the associated-token-account derivation.
+ * Nothing here is taken from a payload field, a summary, or the API, because
+ * the point of this type is to be an INDEPENDENT reading: the initiator and a
+ * co-signing device run the same decode over the same bytes and must arrive
+ * at the same claim. A claim that agreed only because both devices were told
+ * the same thing would establish nothing.
+ */
+export type KaminoDecodedTransaction = {
+    operation: 'deposit' | 'withdraw';
+    /** The curated vault, resolved from the registry — never a raw address the bytes named. */
+    descriptor: KaminoVaultDescriptor;
+    /**
+     * The `u64` the kvault instruction carries, in the operation's own unit:
+     * underlying-token base units for a deposit, SHARE base units for a
+     * withdraw.
+     */
+    amountBaseUnits: bigint;
+    /** The sole signer and fee payer — the account that authorises this. */
+    signer: string;
+    /**
+     * A deposit into the wrapped-SOL vault opens a wSOL account this
+     * transaction never closes, so its rent stays locked up until the user
+     * withdraws.
+     */
+    strandsWrappedSolRent: boolean;
+    /**
+     * The ComputeBudget pair the bytes actually carry, or `undefined` when they
+     * carry none. Read from the message rather than taken from the payload, so
+     * the two can be COMPARED: the payload says what the initiating device
+     * injected, the bytes say what will be charged.
+     */
+    priorityFee?: KaminoPriorityFee;
+};
+/**
+ * Whether a withdraw carries the `u64::MAX` sentinel, which the kVaults
+ * program reads as *withdraw everything* rather than as a share count. This
+ * app never produces one — the builder refuses to request it and the
+ * validator pins the instruction's `u64` — but neither of those runs on a
+ * co-signing device, which holds only the relayed bytes. Rendering 18.4
+ * quintillion shares would be literally true and would say nothing about
+ * what the transaction does.
+ */
+export declare const withdrawsEntireKaminoPosition: (decoded: KaminoDecodedTransaction) => boolean;
+/** The scale `amountBaseUnits` is expressed at, from the registry. */
+export declare const kaminoDecodedAmountDecimals: (decoded: KaminoDecodedTransaction) => number;
+/** The amount as plain human units — no grouping, no exponent, no locale. */
+export declare const kaminoDecodedAmountString: (decoded: KaminoDecodedTransaction) => string;
+/**
+ * Whether these bytes invoke the kVaults program at all. Separate from
+ * `decodeKaminoTransaction` on purpose: a transaction that invokes `kvault`
+ * but cannot be decoded must be surfaced as unreadable rather than as an
+ * ordinary Solana transaction. Program ids are always static keys, so this
+ * needs no lookup table.
+ */
+export declare const invokesKaminoVaultProgram: (transaction: VersionedTransaction) => boolean;
+/**
+ * Whether bytes this app cannot parse nonetheless mention the kVaults
+ * program.
+ *
+ * The structured check above needs a v0 message, but a raw signing path signs
+ * wire bytes verbatim without caring what version they are — so a LEGACY
+ * transaction invoking kVaults would parse to nothing and, without this, be
+ * classified as an ordinary Solana payload and sail past the signing guards.
+ * A program id is a 32-byte account key in the message under either format,
+ * so scanning for those bytes answers the only question that matters here:
+ * is this something we must refuse to stay quiet about?
+ *
+ * Deliberately coarse, and coarse in the safe direction: a payload that
+ * happens to contain these 32 bytes without invoking the program would be
+ * refused; a payload that invokes the program cannot escape.
+ */
+export declare const mentionsKaminoVaultProgram: (base64Transaction: string) => boolean;
+/**
+ * Decodes the single kvault deposit or withdraw these bytes perform, or
+ * `undefined` when they do not perform exactly one that this app recognises.
+ *
+ * `undefined` is a refusal to describe, never a "probably fine". This runs
+ * offline — the verify and join screens render before any network call is
+ * guaranteed to have happened — so lookup tables cannot be resolved, and the
+ * vault is identified the other way round: by deriving each curated vault's
+ * share account for this signer and matching it against the instruction's
+ * share slot, which is a static key in every observed transaction. That
+ * derivation is local, which makes it a stronger identification than reading
+ * an address out of the bytes would have been.
+ *
+ * What this establishes: every instruction fits the shape the named
+ * operation produces, the amount is the `u64` the kvault instruction
+ * carries, the authority is the transaction's own signer, and the share
+ * account that instruction spends or credits is the one this signer owns for
+ * the named vault's share mint. Every instruction argument that is a spend
+ * and is readable without a lookup table is also checked. What it does not
+ * establish is the account identities that live in the lookup table — the
+ * initiating device closes that gap by resolving the tables and running the
+ * full validator before the payload exists.
+ *
+ * One residue is specific to the farm-staked withdraw: how many shares a
+ * withdraw legitimately releases from the farm is `requested −
+ * alreadyUnstaked`, and the second term is a balance that is not in the
+ * bytes. So offline the release is bounded by the withdraw itself and no
+ * further — while the release provably acts on this signer's own position,
+ * in this vault's own farm, into the signer's own share account, with the
+ * stranding and misdirection shapes refused by the template and the
+ * derivations.
+ */
+export declare const decodeKaminoTransaction: (transaction: VersionedTransaction) => KaminoDecodedTransaction | undefined;
+/**
+ * Convenience over a raw payload: exactly one transaction, parseable as a v0
+ * message. More than one is refused rather than summarised from the first —
+ * describing one of several would put a claim on screen that is true of only
+ * part of what gets signed.
+ */
+export declare const decodeKaminoRawTransactions: (rawTransactions: string[]) => KaminoDecodedTransaction | undefined;
+//# sourceMappingURL=decode.d.ts.map

package/dist/chains/solana/kamino/tx/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/chain/chains/solana/kamino/tx/decode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,oBAAoB,EAAE,MAAM,iBAAiB,CAAA;AAIjE,OAAO,EAAE,qBAAqB,EAAuB,MAAM,aAAa,CAAA;AAgBxE,OAAO,EAAE,iBAAiB,EAA2B,MAAM,YAAY,CAAA;AAGvE;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,SAAS,EAAE,SAAS,GAAG,UAAU,CAAA;IACjC,2FAA2F;IAC3F,UAAU,EAAE,qBAAqB,CAAA;IACjC;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAA;IACvB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAA;IACd;;;;OAIG;IACH,qBAAqB,EAAE,OAAO,CAAA;IAC9B;;;;;OAKG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAA;CAChC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,GAAI,SAAS,wBAAwB,KAAG,OACE,CAAA;AAEpF,sEAAsE;AACtE,eAAO,MAAM,2BAA2B,GAAI,SAAS,wBAAwB,KAAG,MACwB,CAAA;AAExG,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,GAAI,SAAS,wBAAwB,KAAG,MACiC,CAAA;AAE/G;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,GAAI,aAAa,oBAAoB,KAAG,OAK7E,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,GAAI,mBAAmB,MAAM,KAAG,OAStE,CAAA;AA8CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,uBAAuB,GAAI,aAAa,oBAAoB,KAAG,wBAAwB,GAAG,SAiGtG,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,GAAI,iBAAiB,MAAM,EAAE,KAAG,wBAAwB,GAAG,SAIlG,CAAA"}