@vultisig/core-chain 2.36.0 → 2.38.0

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

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

@@ -0,0 +1,458 @@
+import { PublicKey } from '@solana/web3.js';
+import { kaminoMaxBaseUnits, renderKaminoBaseUnits } from '../baseUnits.js';
+import { kaminoConfig } from '../config.js';
+import { kaminoVaultRegistry } from '../registry.js';
+import { clampKaminoUnitPrice, kaminoComputeBudget, kaminoExpectedUnitLimit } from './computeBudget.js';
+import { anchorU64Argument, anchorU128Argument, computeUnitLimitArgument, computeUnitPriceArgument, deriveKaminoFarmsUserState, hasNoAnchorArgument, kaminoAllowedProgram, kaminoFarmsStakeScale, kaminoInstructionAccounts, systemTransferLamports, } from './instructions.js';
+import { expectedKaminoSequence, kaminoInstructionKind, matchKaminoSequence } from './sequence.js';
+import { kaminoUserTokenAccounts } from './validate.js';
+import { isUnsignedSingleSigner, parseKaminoWireTransaction } from './wire.js';
+/**
+ * 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 const withdrawsEntireKaminoPosition = (decoded) => decoded.operation === 'withdraw' && decoded.amountBaseUnits === kaminoMaxBaseUnits;
+/** The scale `amountBaseUnits` is expressed at, from the registry. */
+export const kaminoDecodedAmountDecimals = (decoded) => decoded.operation === 'deposit' ? decoded.descriptor.tokenDecimals : decoded.descriptor.sharesDecimals;
+/** The amount as plain human units — no grouping, no exponent, no locale. */
+export const kaminoDecodedAmountString = (decoded) => renderKaminoBaseUnits({ baseUnits: decoded.amountBaseUnits, decimals: kaminoDecodedAmountDecimals(decoded) });
+/**
+ * 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 const invokesKaminoVaultProgram = (transaction) => {
+    const accounts = transaction.message.staticAccountKeys.map(key => key.toBase58());
+    return transaction.message.compiledInstructions.some(instruction => accounts[instruction.programIdIndex] === kaminoConfig.programId);
+};
+/**
+ * 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 const mentionsKaminoVaultProgram = (base64Transaction) => {
+    let bytes;
+    try {
+        bytes = Buffer.from(base64Transaction, 'base64');
+    }
+    catch {
+        return false;
+    }
+    const needle = new PublicKey(kaminoConfig.programId).toBytes();
+    return bytes.indexOf(Buffer.from(needle)) !== -1;
+};
+const staticAddress = (accounts, index) => index === undefined ? undefined : accounts[index];
+/**
+ * The curated vault whose share account for `owner` is `account`. The share
+ * mint is pinned per vault in the registry and the ATA is a program-derived
+ * address, so this is a local computation over a three-element allow-list.
+ */
+const descriptorForShareAccount = (account, owner) => kaminoVaultRegistry.find(descriptor => kaminoUserTokenAccounts({ owner, mint: descriptor.sharesMint }).has(account));
+/**
+ * Whether a farms instruction acts on THIS signer's position in THIS vault's
+ * farm. The user state is a program address over the farm and the owner, so
+ * recomputing it locally binds the instruction to one farm and one user at
+ * once — offline, which the farm slot itself cannot be: the farm is a
+ * lookup-table entry in every captured transaction. The user state is a
+ * static key in every captured transaction, which is what makes this
+ * checkable here at all; one that is not static, or not the derived address,
+ * is a refusal. The farm slot is compared too whenever it happens to resolve
+ * statically.
+ */
+const actsOnSignersFarmPosition = ({ accounts, userStateIndex, farmIndex, signer, descriptor, }) => {
+    const farm = descriptor.farm;
+    if (!farm)
+        return false;
+    const expected = deriveKaminoFarmsUserState({ farm, owner: signer });
+    if (!expected)
+        return false;
+    if (staticAddress(accounts, userStateIndex) !== expected)
+        return false;
+    return namesThisVaultsFarm({ accounts, index: farmIndex, descriptor });
+};
+/**
+ * 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 const decodeKaminoTransaction = (transaction) => {
+    const accounts = transaction.message.staticAccountKeys.map(key => key.toBase58());
+    const signer = accounts[0];
+    if (!signer)
+        return undefined;
+    // The shape this app is willing to SIGN, not merely one it can read: a
+    // single required signature, still an empty placeholder, paid for by slot
+    // 0. A relayed transaction never passed through the initiator's checks, and
+    // the raw signing path splices a signature into slot 0 without inspecting
+    // how many the message requires — so a payload carrying a second required
+    // signer would otherwise be summarised as an ordinary deposit.
+    if (!isUnsignedSingleSigner(transaction, signer))
+        return undefined;
+    const instructions = transaction.message.compiledInstructions;
+    const programs = instructions.map(instruction => kaminoAllowedProgram(accounts[instruction.programIdIndex] ?? ''));
+    const kinds = instructions.map((instruction, position) => kaminoInstructionKind(programs[position], instruction.data));
+    // Exactly one kvault instruction. Two would mean two amounts and two
+    // vaults, and picking either to display would be a guess.
+    const vaultPositions = kinds.flatMap((kind, position) => kind === 'kvaultDeposit' || kind === 'kvaultWithdraw' ? [position] : []);
+    if (vaultPositions.length !== 1)
+        return undefined;
+    const position = vaultPositions[0];
+    const operation = kinds[position] === 'kvaultDeposit' ? 'deposit' : 'withdraw';
+    const instruction = instructions[position];
+    const amount = anchorU64Argument(instruction.data);
+    if (amount === undefined)
+        return undefined;
+    const layout = operation === 'deposit' ? kaminoInstructionAccounts.kvaultDeposit : kaminoInstructionAccounts.kvaultWithdraw;
+    const indexes = instruction.accountKeyIndexes;
+    if (indexes.length < layout.minimumCount)
+        return undefined;
+    // The authority slot must be this transaction's own signer. Without it the
+    // amount and the vault would describe an instruction that some other
+    // account authorises, which is not what the user is being asked to approve.
+    if (staticAddress(accounts, indexes[layout.user]) !== signer)
+        return undefined;
+    const shareAccount = staticAddress(accounts, indexes[layout.userShareAccount]);
+    if (!shareAccount)
+        return undefined;
+    const descriptor = descriptorForShareAccount(shareAccount, signer);
+    if (!descriptor)
+        return undefined;
+    // When the vault slot happens to be a static key, it must be the vault the
+    // share account identified. It is a lookup-table entry in every captured
+    // transaction, but an attacker who moved it into the static keys must not
+    // thereby escape the comparison.
+    const namedVault = staticAddress(accounts, indexes[layout.vault]);
+    if (namedVault !== undefined && namedVault !== descriptor.address)
+        return undefined;
+    // EVERY instruction must fit the shape this operation produces — not just
+    // the one that was recognised. This is the check that stops a transfer
+    // riding alongside a plausible deposit: the decode either accounts for the
+    // whole transaction or it describes none of it. The fee/memo expectations
+    // are read from the bytes rather than assumed, because this device did not
+    // build the transaction; the memo's CONTENT is not read leniently — the
+    // kind matcher takes the tag whole, so any other memo is already
+    // unrecognisable here and the template refuses it.
+    const steps = expectedKaminoSequence({
+        operation,
+        isWrappedSolVault: descriptor.tokenMint === kaminoConfig.wrappedSolMint,
+        hasFarm: descriptor.farm !== undefined,
+        hasPriorityFee: kinds.includes('computeUnitLimit') || kinds.includes('computeUnitPrice'),
+        hasAttributionMemo: kinds.includes('attributionMemo'),
+        // Which of the two withdraw shapes this is depends on how the signer's
+        // position was split when the request was built, and this device holds no
+        // position at all. So both shapes are accepted and the unstake is bounded
+        // by its ARGUMENT instead — see below.
+        farmUnstake: 'unknown',
+    });
+    const outcome = matchKaminoSequence(kinds, steps);
+    if ('mismatch' in outcome)
+        return undefined;
+    const priorityFee = readArguments({
+        matched: outcome.matched,
+        transaction,
+        accounts,
+        signer,
+        operation,
+        amount,
+        descriptor,
+        shareAccount,
+    });
+    if (!priorityFee)
+        return undefined;
+    return {
+        operation,
+        descriptor,
+        amountBaseUnits: amount,
+        signer,
+        strandsWrappedSolRent: operation === 'deposit' && descriptor.tokenMint === kaminoConfig.wrappedSolMint,
+        priorityFee: priorityFee.fee,
+    };
+};
+/**
+ * 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 const decodeKaminoRawTransactions = (rawTransactions) => {
+    if (rawTransactions.length !== 1)
+        return undefined;
+    const transaction = parseKaminoWireTransaction(rawTransactions[0]);
+    return transaction ? decodeKaminoTransaction(transaction) : undefined;
+};
+/**
+ * Checks every instruction contract that can be judged offline, and reads
+ * out the priority fee the presentation cross-checks. Three kinds of check,
+ * all of which the online validator also makes — the point is that a
+ * co-signing device should refuse what the initiating device would have
+ * refused, minus only what genuinely needs the network: amounts that are
+ * spends, arguments that encode behaviour (`farms::stake` must carry
+ * `u64::MAX`), and account cardinality.
+ */
+const readArguments = (input) => {
+    const { matched, transaction, ...shared } = input;
+    const fee = {};
+    for (let position = 0; position < matched.length; position++) {
+        const { data, accountKeyIndexes } = transaction.message.compiledInstructions[position];
+        const accepted = argumentChecks[matched[position]]({ ...shared, data, indexes: accountKeyIndexes }, fee);
+        if (!accepted)
+            return undefined;
+    }
+    // Both halves or neither. The template already enforces that, but the pair
+    // is what the fee is, so it is assembled rather than assumed.
+    const { unitLimit, unitPriceMicroLamports } = fee;
+    if (unitLimit !== undefined && unitPriceMicroLamports !== undefined) {
+        return { fee: { unitLimit, unitPriceMicroLamports } };
+    }
+    if (unitLimit === undefined && unitPriceMicroLamports === undefined)
+        return {};
+    return undefined;
+};
+const accountLayout = kaminoInstructionAccounts;
+/**
+ * Bounded on BOTH sides, because the producer clamps into exactly this range:
+ * above the ceiling is SOL spent for nothing, below the floor is a
+ * transaction that will not land before its blockhash expires — and either
+ * way a price this app never chooses.
+ */
+const readComputeUnitPrice = ({ data, indexes }, fee) => {
+    const value = computeUnitPriceArgument(data);
+    if (indexes.length > 0 ||
+        value === undefined ||
+        value < kaminoComputeBudget.fallbackUnitPriceMicroLamports ||
+        value > kaminoComputeBudget.maxUnitPriceMicroLamports ||
+        value !== clampKaminoUnitPrice(value)) {
+        return false;
+    }
+    fee.unitPriceMicroLamports = value;
+    return true;
+};
+const readComputeUnitLimit = ({ data, indexes, operation, descriptor }, fee) => {
+    const value = computeUnitLimitArgument(data);
+    if (indexes.length > 0 || value === undefined || value !== kaminoExpectedUnitLimit({ operation, descriptor })) {
+        return false;
+    }
+    fee.unitLimit = value;
+    return true;
+};
+const checkWrapSolTransfer = ({ data, indexes, accounts, signer, operation, amount, descriptor, }) => {
+    const lamports = systemTransferLamports(data);
+    if (operation !== 'deposit' ||
+        lamports === undefined ||
+        lamports !== amount ||
+        indexes.length < accountLayout.systemTransfer.count ||
+        staticAddress(accounts, indexes[accountLayout.systemTransfer.source]) !== signer) {
+        return false;
+    }
+    // The destination is the user's own wrapped-SOL account whenever it
+    // resolves statically — and it does in every captured transaction.
+    const destination = staticAddress(accounts, indexes[accountLayout.systemTransfer.destination]);
+    return (destination === undefined || kaminoUserTokenAccounts({ owner: signer, mint: descriptor.tokenMint }).has(destination));
+};
+/**
+ * Bound to the signer's own wrapped-SOL account whenever the slot resolves
+ * statically — the derivation needs no network, so leaving this looser than
+ * the initiating validator would be an unnecessary asymmetry between the two
+ * devices' refusals.
+ */
+const checkSyncNative = ({ indexes, accounts, signer, descriptor }) => {
+    if (indexes.length === 0)
+        return false;
+    const syncedAccount = staticAddress(accounts, indexes[0]);
+    return (syncedAccount === undefined ||
+        kaminoUserTokenAccounts({ owner: signer, mint: descriptor.tokenMint }).has(syncedAccount));
+};
+/**
+ * The stake that makes a deposit's shares invisible in the wallet, bound to
+ * the signer, to this vault's farm and to the same share account the deposit
+ * credited. All three derive offline, so leaving them unchecked would let a
+ * stake naming another authority — or another vault's farm, which parks the
+ * position somewhere this app never reads — pass a co-signing device that the
+ * initiating validator refuses.
+ *
+ * Kamino stakes the whole share balance rather than the freshly minted
+ * amount, so the argument is the u64 sentinel; a different value is a
+ * behaviour change rather than a variation.
+ */
+const checkFarmsStake = ({ data, indexes, accounts, signer, descriptor, shareAccount }) => {
+    const layout = accountLayout.farmsStake;
+    if (indexes.length < layout.minimumCount || anchorU64Argument(data) !== kaminoMaxBaseUnits)
+        return false;
+    if (staticAddress(accounts, indexes[layout.owner]) !== signer)
+        return false;
+    if (!namesThisVaultsFarm({ accounts, index: indexes[layout.farm], descriptor }))
+        return false;
+    const staked = staticAddress(accounts, indexes[layout.userShareAccount]);
+    return staked === undefined || staked === shareAccount;
+};
+/**
+ * Creating the farm user state costs the payer rent and decides whose
+ * position the later stake lands in, so the authority and the farm are bound
+ * the same way as the stake's.
+ */
+const checkFarmsInitializeUser = ({ indexes, accounts, signer, descriptor }) => {
+    const layout = accountLayout.farmsInitializeUser;
+    return (indexes.length >= layout.minimumCount &&
+        staticAddress(accounts, indexes[layout.authority]) === signer &&
+        namesThisVaultsFarm({ accounts, index: indexes[layout.farm], descriptor }));
+};
+/**
+ * Whether a farm slot names this vault's farm. The farm is a lookup-table
+ * entry in every captured transaction and cannot be resolved offline, so an
+ * unresolvable slot is accepted — the initiating validator resolves the
+ * tables and pins it. One that DOES resolve statically must match, so moving
+ * the farm into the static keys is not a way past the check.
+ */
+const namesThisVaultsFarm = ({ accounts, index, descriptor, }) => {
+    if (!descriptor.farm)
+        return false;
+    const named = staticAddress(accounts, index);
+    return named === undefined || named === descriptor.farm;
+};
+/**
+ * The u128 WAD-scaled release amount. The exact figure is `requested −
+ * unstaked`, and the unstaked half is a balance this device cannot read — so
+ * what is checked here is the BOUND: a withdraw cannot legitimately take more
+ * out of the farm than it burns. The authority is checked too, and that is
+ * the half that matters most: whatever amount is released, it is released
+ * from THIS signer's own farm position and nobody else's.
+ */
+const checkFarmsUnstake = ({ data, indexes, accounts, signer, operation, amount, descriptor, }) => {
+    const scaled = anchorU128Argument(data);
+    if (operation !== 'withdraw' ||
+        indexes.length < accountLayout.farmsUnstake.minimumCount ||
+        staticAddress(accounts, indexes[accountLayout.farmsUnstake.owner]) !== signer ||
+        scaled === undefined ||
+        scaled <= 0n ||
+        scaled % kaminoFarmsStakeScale !== 0n ||
+        scaled > amount * kaminoFarmsStakeScale) {
+        return false;
+    }
+    return actsOnSignersFarmPosition({
+        accounts,
+        userStateIndex: indexes[accountLayout.farmsUnstake.userState],
+        farmIndex: indexes[accountLayout.farmsUnstake.farm],
+        signer,
+        descriptor,
+    });
+};
+/**
+ * Where the released shares LAND. It has to be the same share account the
+ * vault withdraw then burns from — the one already proven to be this signer's,
+ * for this vault's share mint — or the release and the withdraw are two
+ * unrelated movements presented as one.
+ */
+const checkFarmsWithdrawUnstakedDeposits = ({ data, indexes, accounts, signer, operation, descriptor, shareAccount, }) => {
+    const layout = accountLayout.farmsWithdrawUnstakedDeposits;
+    if (operation !== 'withdraw' ||
+        indexes.length < layout.minimumCount ||
+        !hasNoAnchorArgument(data) ||
+        staticAddress(accounts, indexes[layout.owner]) !== signer ||
+        staticAddress(accounts, indexes[layout.userShareAccount]) !== shareAccount) {
+        return false;
+    }
+    return actsOnSignersFarmPosition({
+        accounts,
+        userStateIndex: indexes[layout.userState],
+        farmIndex: indexes[layout.farm],
+        signer,
+        descriptor,
+    });
+};
+/**
+ * Creating an account is not free — the PAYER funds its rent — and the step
+ * is repeatable, so an extra creation for a stranger's wallet would otherwise
+ * ride along unremarked and spend the signer's SOL. Both slots that decide
+ * who pays and who owns are static keys. The mint and the derived address
+ * need the lookup table; the initiating validator pins those.
+ */
+const checkCreateTokenAccount = ({ indexes, accounts, signer }) => indexes.length >= accountLayout.associatedToken.count &&
+    staticAddress(accounts, indexes[accountLayout.associatedToken.payer]) === signer &&
+    staticAddress(accounts, indexes[accountLayout.associatedToken.wallet]) === signer;
+/**
+ * Closing an account SENDS its rent somewhere. Where it lands, and who
+ * authorised the close, decide whether that is the signer reclaiming their
+ * own lamports or a third party collecting them.
+ */
+const checkCloseTokenAccount = ({ indexes, accounts, signer }) => indexes.length >= accountLayout.closeAccount.count &&
+    staticAddress(accounts, indexes[accountLayout.closeAccount.destination]) === signer &&
+    staticAddress(accounts, indexes[accountLayout.closeAccount.authority]) === signer;
+/**
+ * The tag itself was matched whole by the sequence. What is left to check is
+ * that it attests to nobody: a memo carrying account indexes is the Memo
+ * program asserting those accounts signed.
+ */
+const checkAttributionMemo = ({ indexes }) => indexes.length === 0;
+/**
+ * Every instruction contract that can be judged offline, one entry per
+ * template step. Three kinds of check, all of which the online validator also
+ * makes — the point is that a co-signing device should refuse what the
+ * initiating device would have refused, minus only what genuinely needs the
+ * network: amounts that are spends, arguments that encode behaviour
+ * (`farms::stake` must carry `u64::MAX`), and account cardinality.
+ *
+ * A record rather than a switch so each check stands alone and the set stays
+ * exhaustive: a template step added without a check is a type error.
+ */
+const argumentChecks = {
+    computeUnitPrice: readComputeUnitPrice,
+    computeUnitLimit: readComputeUnitLimit,
+    wrapSolTransfer: checkWrapSolTransfer,
+    syncNative: checkSyncNative,
+    farmsStake: checkFarmsStake,
+    farmsInitializeUser: checkFarmsInitializeUser,
+    farmsUnstake: checkFarmsUnstake,
+    farmsWithdrawUnstakedDeposits: checkFarmsWithdrawUnstakedDeposits,
+    createTokenAccount: checkCreateTokenAccount,
+    closeTokenAccount: checkCloseTokenAccount,
+    attributionMemo: checkAttributionMemo,
+    // Already read by the caller: the amount, the authority and the share account.
+    kvaultDeposit: () => true,
+    kvaultWithdraw: () => true,
+};
+//# sourceMappingURL=decode.js.map

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

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