@vultisig/core-chain 2.37.0 → 2.38.0

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

@@ -0,0 +1,260 @@
+/**
+ * Every program a Kamino Earn transaction is allowed to invoke.
+ *
+ * This is an allow-list, not a catalogue: an instruction whose program is not
+ * one of these is a refusal. That matters because the transaction is built by
+ * Kamino and signed verbatim, so the program set is the outer boundary on what
+ * the user's single signature can authorise. Anything outside it is code we
+ * never agreed to run.
+ */
+export declare const kaminoAllowedPrograms: {
+    readonly system: "11111111111111111111111111111111";
+    readonly token: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+    readonly token2022: "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+    readonly associatedToken: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+    readonly computeBudget: "ComputeBudget111111111111111111111111111111";
+    readonly kvault: "KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd";
+    readonly farms: "FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr";
+    /**
+     * SPL Memo v3, carrying this app's attribution tag. Never present in what
+     * Kamino builds — the app appends it, which is why a memo arriving from the
+     * API is a refusal rather than something to pass through.
+     */
+    readonly memo: "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+};
+/** One of the allow-listed programs, named. */
+export type KaminoAllowedProgram = keyof typeof kaminoAllowedPrograms;
+/** Resolves a program id to its allow-list name, `undefined` when foreign. */
+export declare const kaminoAllowedProgram: (programId: string) => KaminoAllowedProgram | undefined;
+/**
+ * Programs whose instructions Kamino's builder composes itself, rather than
+ * reaching them through a CPI from its own programs.
+ *
+ * The distinction is the crux of the writable-account check. What `kvault` and
+ * `farms` do with the accounts they are handed is the protocol we chose to
+ * trust; what appears at the *top level* of the transaction is whatever the
+ * builder decided to put there, so every account those instructions can write
+ * to has to be one we can name.
+ */
+export declare const isBuilderComposedProgram: (program: KaminoAllowedProgram) => boolean;
+/**
+ * The attribution tag this app writes into every Kamino transaction it builds.
+ *
+ * Kamino's kvault API takes no referrer or partner parameter, so attribution
+ * is client-side: one SPL Memo instruction carrying this literal, appended
+ * after the API has built the transaction and before it is validated and
+ * signed.
+ *
+ * The bytes are the whole point. This tag is the filter every downstream
+ * measurement of Vultisig-originated deposits keys on, and it has to be
+ * byte-identical on every platform. So it is written once, and the injector,
+ * the validator and the verify-screen decoder all read it from here rather
+ * than each spelling it out. It is matched whole and compared as bytes, so it
+ * is case-sensitive: `8K2MZ` is a different memo.
+ */
+export declare const kaminoAttributionMemoTag = "8k2mz";
+/** The tag's exact bytes — what the injector writes and the checks compare. */
+export declare const kaminoAttributionMemoTagBytes: Uint8Array;
+/**
+ * Instruction discriminators for the programs a Kamino Earn transaction uses.
+ *
+ * The Anchor ones are `sha256("global:<name>")[0..8]`, and each was also read
+ * back out of a mainnet-simulated transaction built by the Kamino API, so the
+ * constant and the observation agree. That agreement is the point: a constant
+ * copied out of a captured transaction matches the shape it was copied from
+ * and asserts nothing; one derived from the instruction's name and *then*
+ * found in the bytes says the bytes are that instruction.
+ */
+export declare const kaminoDiscriminators: {
+    /** `kvault::deposit(u64 tokenAmount)`. */
+    readonly kvaultDeposit: Uint8Array<ArrayBuffer>;
+    /**
+     * `kvault::withdraw(u64 shareAmount)` — the argument is in SHARES, the
+     * inverse of deposit's unit. One of TWO instructions a withdraw arrives as;
+     * this is the one the builder emits when the request does not fit the
+     * vault's liquid buffer, because only this one carries the accounts needed
+     * to pull the shortfall out of a lending reserve.
+     */
+    readonly kvaultWithdraw: Uint8Array<ArrayBuffer>;
+    /**
+     * `kvault::withdraw_from_available(u64 shareAmount)` — the same withdraw,
+     * served entirely out of the vault's liquid buffer. Which of the two arrives
+     * is a fact about the VAULT's liquidity at build time, not about the user's
+     * request, and both are in live use — so both are accepted, and both mean
+     * the same thing to the person signing.
+     */
+    readonly kvaultWithdrawFromAvailable: Uint8Array<ArrayBuffer>;
+    /** `farms::initialize_user` — creates the user's farm state. Absent when it already exists. */
+    readonly farmsInitializeUser: Uint8Array<ArrayBuffer>;
+    /** `farms::stake(u64 amount)`. Kamino always passes `u64::MAX`, meaning "stake the whole share balance". */
+    readonly farmsStake: Uint8Array<ArrayBuffer>;
+    /**
+     * `farms::unstake(u128 stakeSharesScaled)` — releases shares from the farm
+     * into the user's pending-withdrawal balance. Its argument is the only
+     * `u128` in this feature, and it is scaled: the farms program holds stake at
+     * `WAD`, so the value is share base units multiplied by `10^18`. Reading
+     * those 16 bytes as a `u64` truncates silently.
+     */
+    readonly farmsUnstake: Uint8Array<ArrayBuffer>;
+    /**
+     * `farms::withdraw_unstaked_deposits` — moves what `unstake` released into
+     * the user's share account, where the vault withdraw can then burn it.
+     * Takes no argument: it always moves the whole pending balance.
+     */
+    readonly farmsWithdrawUnstakedDeposits: Uint8Array<ArrayBuffer>;
+};
+/**
+ * The fixed-point scale the farms program holds stake at: `10^18`. Everything
+ * else in this feature is an integer count of base units; this one is not, so
+ * the conversion is written out rather than inferred at each call site.
+ */
+export declare const kaminoFarmsStakeScale: bigint;
+/** Associated Token Program `CreateIdempotent`. */
+export declare const createIdempotentAtaDiscriminator = 1;
+/** SPL Token `SyncNative` — reconciles a wSOL account's balance with its lamports. */
+export declare const tokenSyncNativeDiscriminator = 17;
+/** SPL Token `CloseAccount` — unwraps wSOL back to native SOL, or reclaims rent. */
+export declare const tokenCloseAccountDiscriminator = 9;
+/** System Program `Transfer`: a 4-byte little-endian enum index. */
+export declare const systemTransferDiscriminator: Uint8Array<ArrayBuffer>;
+/** ComputeBudget `SetComputeUnitLimit` / `SetComputeUnitPrice` one-byte tags. */
+export declare const computeBudgetDiscriminators: {
+    readonly setUnitLimit: 2;
+    readonly setUnitPrice: 3;
+};
+/** Whether `data` starts with the 8-byte Anchor discriminator `prefix`. */
+export declare const hasAnchorDiscriminator: (data: Uint8Array, prefix: Uint8Array) => boolean;
+/** Whether `data` is exactly the attribution tag — matched whole, as bytes. */
+export declare const isAttributionMemoData: (data: Uint8Array) => boolean;
+/**
+ * An Anchor instruction's `u64` argument: the 8 bytes after the
+ * discriminator, little-endian. `undefined` unless the payload is exactly
+ * discriminator + argument.
+ */
+export declare const anchorU64Argument: (data: Uint8Array) => bigint | undefined;
+/**
+ * An Anchor instruction's `u128` argument: the 16 bytes after the
+ * discriminator, little-endian, exact.
+ *
+ * Separate from `anchorU64Argument` and never a fallback for it. A `u128`
+ * argument read through the `u64` reader would take the low 8 bytes of a
+ * 16-byte field and report a plausible-looking number that is not the one on
+ * the wire — so the two readers are keyed on the exact payload length and
+ * neither accepts the other's.
+ */
+export declare const anchorU128Argument: (data: Uint8Array) => bigint | undefined;
+/**
+ * An Anchor instruction that carries no argument at all: exactly the
+ * discriminator and nothing after it. Checked rather than assumed — the
+ * sequence matches on the first eight bytes, so trailing bytes would
+ * otherwise ride along unread.
+ */
+export declare const hasNoAnchorArgument: (data: Uint8Array) => boolean;
+/** `Transfer` payload: the 4-byte discriminant plus a `u64` lamport amount. */
+export declare const systemTransferLamports: (data: Uint8Array) => bigint | undefined;
+/** `SetComputeUnitLimit`'s `u32` argument. */
+export declare const computeUnitLimitArgument: (data: Uint8Array) => number | undefined;
+/**
+ * `SetComputeUnitPrice`'s `u64` argument, in micro-lamports per compute unit.
+ * The fee it produces is `price × limit`, so this is a spend.
+ */
+export declare const computeUnitPriceArgument: (data: Uint8Array) => bigint | undefined;
+/**
+ * The farms program's per-user account, derived rather than trusted.
+ *
+ * `farms::unstake` and `farms::withdraw_unstaked_deposits` both take it, and
+ * it is the account that decides WHICH stake they move. Its address is a
+ * program address over the farm and the owner, so recomputing it locally
+ * binds both instructions to one farm and one user at once — and it does so
+ * offline, which the farm slot itself cannot: the farm is an
+ * address-lookup-table entry in every captured transaction, and the verify
+ * screen has no way to resolve one.
+ */
+export declare const deriveKaminoFarmsUserState: ({ farm, owner }: {
+    farm: string;
+    owner: string;
+}) => string | undefined;
+/**
+ * Positions of the accounts each instruction is checked and decoded on.
+ *
+ * An Anchor instruction's account list is fixed by its IDL — only the
+ * trailing `remaining_accounts` vary, which is why the observed lists differ
+ * in length between vaults while these prefixes do not. Each index was read
+ * out of transactions the Kamino API built for all three launch vaults.
+ *
+ * Shared rather than duplicated: the validator checks against these before
+ * signing and the decoder reads the same slots back out of the signed bytes.
+ * Two copies that drifted would let the verify screen describe a different
+ * instruction from the one that was validated.
+ *
+ * The two withdraw instructions share one map rather than merely agreeing:
+ * the program's IDL declares `withdraw`'s account list as
+ * `withdraw_from_available`'s fourteen accounts followed by the reserve-exit
+ * group, so the first fourteen slots of the longer instruction ARE the
+ * shorter one's, and every pinned index lies inside that shared prefix.
+ */
+export declare const kaminoInstructionAccounts: {
+    readonly kvaultDeposit: {
+        readonly user: 0;
+        readonly vault: 1;
+        readonly tokenMint: 3;
+        readonly sharesMint: 5;
+        readonly userTokenAccount: 6;
+        readonly userShareAccount: 7;
+        readonly minimumCount: 8;
+    };
+    readonly kvaultWithdraw: {
+        readonly user: 0;
+        readonly vault: 1;
+        readonly userTokenAccount: 5;
+        readonly tokenMint: 6;
+        readonly userShareAccount: 7;
+        readonly sharesMint: 8;
+        readonly minimumCount: 9;
+    };
+    readonly farmsInitializeUser: {
+        readonly authority: 0;
+        readonly farm: 5;
+        readonly minimumCount: 6;
+    };
+    readonly farmsStake: {
+        readonly owner: 0;
+        readonly farm: 2;
+        readonly userShareAccount: 4;
+        readonly sharesMint: 5;
+        readonly minimumCount: 6;
+    };
+    readonly farmsUnstake: {
+        readonly owner: 0;
+        readonly userState: 1;
+        readonly farm: 2;
+        readonly minimumCount: 3;
+    };
+    readonly farmsWithdrawUnstakedDeposits: {
+        readonly owner: 0;
+        readonly userState: 1;
+        readonly farm: 2;
+        readonly userShareAccount: 3;
+        readonly minimumCount: 4;
+    };
+    readonly associatedToken: {
+        readonly payer: 0;
+        readonly account: 1;
+        readonly wallet: 2;
+        readonly mint: 3;
+        readonly tokenProgram: 5;
+        readonly count: 6;
+    };
+    readonly systemTransfer: {
+        readonly source: 0;
+        readonly destination: 1;
+        readonly count: 2;
+    };
+    readonly closeAccount: {
+        readonly account: 0;
+        readonly destination: 1;
+        readonly authority: 2;
+        readonly count: 3;
+    };
+};
+//# sourceMappingURL=instructions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/chain/chains/solana/kamino/tx/instructions.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;IAQhC;;;;OAIG;;CAEK,CAAA;AAEV,+CAA+C;AAC/C,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,qBAAqB,CAAA;AAMrE,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,KAAG,oBAAoB,GAAG,SAC/C,CAAA;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,oBAAoB,KAAG,OACgC,CAAA;AAEzG;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,UAAU,CAAA;AAE/C,+EAA+E;AAC/E,eAAO,MAAM,6BAA6B,EAAE,UAA+D,CAAA;AAE3G;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;IAC/B,0CAA0C;;IAE1C;;;;;;OAMG;;IAEH;;;;;;OAMG;;IAEH,+FAA+F;;IAE/F,4GAA4G;;IAE5G;;;;;;OAMG;;IAEH;;;;OAIG;;CAEK,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAa,CAAA;AAE/C,mDAAmD;AACnD,eAAO,MAAM,gCAAgC,IAAI,CAAA;AAEjD,sFAAsF;AACtF,eAAO,MAAM,4BAA4B,KAAK,CAAA;AAE9C,oFAAoF;AACpF,eAAO,MAAM,8BAA8B,IAAI,CAAA;AAE/C,oEAAoE;AACpE,eAAO,MAAM,2BAA2B,yBAAgC,CAAA;AAExE,iFAAiF;AACjF,eAAO,MAAM,2BAA2B;;;CAAgD,CAAA;AAKxF,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB,GAAI,MAAM,UAAU,EAAE,QAAQ,UAAU,KAAG,OACpB,CAAA;AAE1D,+EAA+E;AAC/E,eAAO,MAAM,qBAAqB,GAAI,MAAM,UAAU,KAAG,OAA0D,CAAA;AAUnH;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,SAG7D,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,SAG9D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,UAAU,KAAG,OAA4B,CAAA;AAEnF,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,SAIlE,CAAA;AAED,8CAA8C;AAC9C,eAAO,MAAM,wBAAwB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,SAGpE,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GAAI,MAAM,UAAU,KAAG,MAAM,GAAG,SAGpE,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,GAAI,iBAAiB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,KAAG,MAAM,GAAG,SAUtG,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B5B,CAAA"}

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

@@ -0,0 +1,256 @@
+import { PublicKey } from '@solana/web3.js';
+import { kaminoConfig } from '../config.js';
+/**
+ * Every program a Kamino Earn transaction is allowed to invoke.
+ *
+ * This is an allow-list, not a catalogue: an instruction whose program is not
+ * one of these is a refusal. That matters because the transaction is built by
+ * Kamino and signed verbatim, so the program set is the outer boundary on what
+ * the user's single signature can authorise. Anything outside it is code we
+ * never agreed to run.
+ */
+export const kaminoAllowedPrograms = {
+    system: '11111111111111111111111111111111',
+    token: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+    token2022: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+    associatedToken: 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL',
+    computeBudget: 'ComputeBudget111111111111111111111111111111',
+    kvault: kaminoConfig.programId,
+    farms: kaminoConfig.farmsProgramId,
+    /**
+     * SPL Memo v3, carrying this app's attribution tag. Never present in what
+     * Kamino builds — the app appends it, which is why a memo arriving from the
+     * API is a refusal rather than something to pass through.
+     */
+    memo: 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr',
+};
+const programByAddress = new Map(Object.entries(kaminoAllowedPrograms).map(([name, address]) => [address, name]));
+/** Resolves a program id to its allow-list name, `undefined` when foreign. */
+export const kaminoAllowedProgram = (programId) => programByAddress.get(programId);
+/**
+ * Programs whose instructions Kamino's builder composes itself, rather than
+ * reaching them through a CPI from its own programs.
+ *
+ * The distinction is the crux of the writable-account check. What `kvault` and
+ * `farms` do with the accounts they are handed is the protocol we chose to
+ * trust; what appears at the *top level* of the transaction is whatever the
+ * builder decided to put there, so every account those instructions can write
+ * to has to be one we can name.
+ */
+export const isBuilderComposedProgram = (program) => program === 'system' || program === 'token' || program === 'token2022' || program === 'associatedToken';
+/**
+ * The attribution tag this app writes into every Kamino transaction it builds.
+ *
+ * Kamino's kvault API takes no referrer or partner parameter, so attribution
+ * is client-side: one SPL Memo instruction carrying this literal, appended
+ * after the API has built the transaction and before it is validated and
+ * signed.
+ *
+ * The bytes are the whole point. This tag is the filter every downstream
+ * measurement of Vultisig-originated deposits keys on, and it has to be
+ * byte-identical on every platform. So it is written once, and the injector,
+ * the validator and the verify-screen decoder all read it from here rather
+ * than each spelling it out. It is matched whole and compared as bytes, so it
+ * is case-sensitive: `8K2MZ` is a different memo.
+ */
+export const kaminoAttributionMemoTag = '8k2mz';
+/** The tag's exact bytes — what the injector writes and the checks compare. */
+export const kaminoAttributionMemoTagBytes = new TextEncoder().encode(kaminoAttributionMemoTag);
+/**
+ * Instruction discriminators for the programs a Kamino Earn transaction uses.
+ *
+ * The Anchor ones are `sha256("global:<name>")[0..8]`, and each was also read
+ * back out of a mainnet-simulated transaction built by the Kamino API, so the
+ * constant and the observation agree. That agreement is the point: a constant
+ * copied out of a captured transaction matches the shape it was copied from
+ * and asserts nothing; one derived from the instruction's name and *then*
+ * found in the bytes says the bytes are that instruction.
+ */
+export const kaminoDiscriminators = {
+    /** `kvault::deposit(u64 tokenAmount)`. */
+    kvaultDeposit: Uint8Array.from([0xf2, 0x23, 0xc6, 0x89, 0x52, 0xe1, 0xf2, 0xb6]),
+    /**
+     * `kvault::withdraw(u64 shareAmount)` — the argument is in SHARES, the
+     * inverse of deposit's unit. One of TWO instructions a withdraw arrives as;
+     * this is the one the builder emits when the request does not fit the
+     * vault's liquid buffer, because only this one carries the accounts needed
+     * to pull the shortfall out of a lending reserve.
+     */
+    kvaultWithdraw: Uint8Array.from([0xb7, 0x12, 0x46, 0x9c, 0x94, 0x6d, 0xa1, 0x22]),
+    /**
+     * `kvault::withdraw_from_available(u64 shareAmount)` — the same withdraw,
+     * served entirely out of the vault's liquid buffer. Which of the two arrives
+     * is a fact about the VAULT's liquidity at build time, not about the user's
+     * request, and both are in live use — so both are accepted, and both mean
+     * the same thing to the person signing.
+     */
+    kvaultWithdrawFromAvailable: Uint8Array.from([0x13, 0x83, 0x70, 0x9b, 0xaa, 0xdc, 0x22, 0x39]),
+    /** `farms::initialize_user` — creates the user's farm state. Absent when it already exists. */
+    farmsInitializeUser: Uint8Array.from([0x6f, 0x11, 0xb9, 0xfa, 0x3c, 0x7a, 0x26, 0xfe]),
+    /** `farms::stake(u64 amount)`. Kamino always passes `u64::MAX`, meaning "stake the whole share balance". */
+    farmsStake: Uint8Array.from([0xce, 0xb0, 0xca, 0x12, 0xc8, 0xd1, 0xb3, 0x6c]),
+    /**
+     * `farms::unstake(u128 stakeSharesScaled)` — releases shares from the farm
+     * into the user's pending-withdrawal balance. Its argument is the only
+     * `u128` in this feature, and it is scaled: the farms program holds stake at
+     * `WAD`, so the value is share base units multiplied by `10^18`. Reading
+     * those 16 bytes as a `u64` truncates silently.
+     */
+    farmsUnstake: Uint8Array.from([0x5a, 0x5f, 0x6b, 0x2a, 0xcd, 0x7c, 0x32, 0xe1]),
+    /**
+     * `farms::withdraw_unstaked_deposits` — moves what `unstake` released into
+     * the user's share account, where the vault withdraw can then burn it.
+     * Takes no argument: it always moves the whole pending balance.
+     */
+    farmsWithdrawUnstakedDeposits: Uint8Array.from([0x24, 0x66, 0xbb, 0x31, 0xdc, 0x24, 0x84, 0x43]),
+};
+/**
+ * The fixed-point scale the farms program holds stake at: `10^18`. Everything
+ * else in this feature is an integer count of base units; this one is not, so
+ * the conversion is written out rather than inferred at each call site.
+ */
+export const kaminoFarmsStakeScale = 10n ** 18n;
+/** Associated Token Program `CreateIdempotent`. */
+export const createIdempotentAtaDiscriminator = 1;
+/** SPL Token `SyncNative` — reconciles a wSOL account's balance with its lamports. */
+export const tokenSyncNativeDiscriminator = 17;
+/** SPL Token `CloseAccount` — unwraps wSOL back to native SOL, or reclaims rent. */
+export const tokenCloseAccountDiscriminator = 9;
+/** System Program `Transfer`: a 4-byte little-endian enum index. */
+export const systemTransferDiscriminator = Uint8Array.from([2, 0, 0, 0]);
+/** ComputeBudget `SetComputeUnitLimit` / `SetComputeUnitPrice` one-byte tags. */
+export const computeBudgetDiscriminators = { setUnitLimit: 2, setUnitPrice: 3 };
+const bytesEqual = (a, b) => a.length === b.length && a.every((byte, index) => byte === b[index]);
+/** Whether `data` starts with the 8-byte Anchor discriminator `prefix`. */
+export const hasAnchorDiscriminator = (data, prefix) => data.length >= 8 && bytesEqual(data.slice(0, 8), prefix);
+/** Whether `data` is exactly the attribution tag — matched whole, as bytes. */
+export const isAttributionMemoData = (data) => bytesEqual(data, kaminoAttributionMemoTagBytes);
+const littleEndianBigInt = (bytes) => {
+    let value = 0n;
+    for (let index = bytes.length - 1; index >= 0; index--) {
+        value = (value << 8n) | BigInt(bytes[index]);
+    }
+    return value;
+};
+/**
+ * An Anchor instruction's `u64` argument: the 8 bytes after the
+ * discriminator, little-endian. `undefined` unless the payload is exactly
+ * discriminator + argument.
+ */
+export const anchorU64Argument = (data) => {
+    if (data.length !== 16)
+        return undefined;
+    return littleEndianBigInt(data.slice(8, 16));
+};
+/**
+ * An Anchor instruction's `u128` argument: the 16 bytes after the
+ * discriminator, little-endian, exact.
+ *
+ * Separate from `anchorU64Argument` and never a fallback for it. A `u128`
+ * argument read through the `u64` reader would take the low 8 bytes of a
+ * 16-byte field and report a plausible-looking number that is not the one on
+ * the wire — so the two readers are keyed on the exact payload length and
+ * neither accepts the other's.
+ */
+export const anchorU128Argument = (data) => {
+    if (data.length !== 24)
+        return undefined;
+    return littleEndianBigInt(data.slice(8, 24));
+};
+/**
+ * An Anchor instruction that carries no argument at all: exactly the
+ * discriminator and nothing after it. Checked rather than assumed — the
+ * sequence matches on the first eight bytes, so trailing bytes would
+ * otherwise ride along unread.
+ */
+export const hasNoAnchorArgument = (data) => data.length === 8;
+/** `Transfer` payload: the 4-byte discriminant plus a `u64` lamport amount. */
+export const systemTransferLamports = (data) => {
+    if (data.length !== 12)
+        return undefined;
+    if (!bytesEqual(data.slice(0, 4), systemTransferDiscriminator))
+        return undefined;
+    return littleEndianBigInt(data.slice(4, 12));
+};
+/** `SetComputeUnitLimit`'s `u32` argument. */
+export const computeUnitLimitArgument = (data) => {
+    if (data.length !== 5 || data[0] !== computeBudgetDiscriminators.setUnitLimit)
+        return undefined;
+    return Number(littleEndianBigInt(data.slice(1, 5)));
+};
+/**
+ * `SetComputeUnitPrice`'s `u64` argument, in micro-lamports per compute unit.
+ * The fee it produces is `price × limit`, so this is a spend.
+ */
+export const computeUnitPriceArgument = (data) => {
+    if (data.length !== 9 || data[0] !== computeBudgetDiscriminators.setUnitPrice)
+        return undefined;
+    return littleEndianBigInt(data.slice(1, 9));
+};
+/**
+ * The farms program's per-user account, derived rather than trusted.
+ *
+ * `farms::unstake` and `farms::withdraw_unstaked_deposits` both take it, and
+ * it is the account that decides WHICH stake they move. Its address is a
+ * program address over the farm and the owner, so recomputing it locally
+ * binds both instructions to one farm and one user at once — and it does so
+ * offline, which the farm slot itself cannot: the farm is an
+ * address-lookup-table entry in every captured transaction, and the verify
+ * screen has no way to resolve one.
+ */
+export const deriveKaminoFarmsUserState = ({ farm, owner }) => {
+    try {
+        const [address] = PublicKey.findProgramAddressSync([new TextEncoder().encode('user'), new PublicKey(farm).toBytes(), new PublicKey(owner).toBytes()], new PublicKey(kaminoAllowedPrograms.farms));
+        return address.toBase58();
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Positions of the accounts each instruction is checked and decoded on.
+ *
+ * An Anchor instruction's account list is fixed by its IDL — only the
+ * trailing `remaining_accounts` vary, which is why the observed lists differ
+ * in length between vaults while these prefixes do not. Each index was read
+ * out of transactions the Kamino API built for all three launch vaults.
+ *
+ * Shared rather than duplicated: the validator checks against these before
+ * signing and the decoder reads the same slots back out of the signed bytes.
+ * Two copies that drifted would let the verify screen describe a different
+ * instruction from the one that was validated.
+ *
+ * The two withdraw instructions share one map rather than merely agreeing:
+ * the program's IDL declares `withdraw`'s account list as
+ * `withdraw_from_available`'s fourteen accounts followed by the reserve-exit
+ * group, so the first fourteen slots of the longer instruction ARE the
+ * shorter one's, and every pinned index lies inside that shared prefix.
+ */
+export const kaminoInstructionAccounts = {
+    kvaultDeposit: {
+        user: 0,
+        vault: 1,
+        tokenMint: 3,
+        sharesMint: 5,
+        userTokenAccount: 6,
+        userShareAccount: 7,
+        minimumCount: 8,
+    },
+    kvaultWithdraw: {
+        user: 0,
+        vault: 1,
+        userTokenAccount: 5,
+        tokenMint: 6,
+        userShareAccount: 7,
+        sharesMint: 8,
+        minimumCount: 9,
+    },
+    farmsInitializeUser: { authority: 0, farm: 5, minimumCount: 6 },
+    farmsStake: { owner: 0, farm: 2, userShareAccount: 4, sharesMint: 5, minimumCount: 6 },
+    farmsUnstake: { owner: 0, userState: 1, farm: 2, minimumCount: 3 },
+    farmsWithdrawUnstakedDeposits: { owner: 0, userState: 1, farm: 2, userShareAccount: 3, minimumCount: 4 },
+    associatedToken: { payer: 0, account: 1, wallet: 2, mint: 3, tokenProgram: 5, count: 6 },
+    systemTransfer: { source: 0, destination: 1, count: 2 },
+    closeAccount: { account: 0, destination: 1, authority: 2, count: 3 },
+};
+//# sourceMappingURL=instructions.js.map

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

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

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

@@ -0,0 +1,123 @@
+import { KaminoAllowedProgram } from './instructions.js';
+/**
+ * The instruction shapes each Kamino operation produces, and the walk that
+ * matches a transaction against them.
+ *
+ * Shared by the two places that need it, because they must agree on what a
+ * Kamino transaction is *allowed to contain*: the validator runs it on the
+ * initiating device before signing, followed by account-identity checks that
+ * need the lookup tables resolved; the decoder runs it on ANY device, offline,
+ * before claiming to describe a transaction. Without it the decode would read
+ * one recognised instruction and say nothing about the rest — so a transfer
+ * riding alongside a plausible deposit would be summarised as "Deposit
+ * 1 USDC", which is worse than showing nothing at all.
+ *
+ * A step matches on the program and the instruction discriminator only. Both
+ * are readable without a lookup table (a v0 message's program ids are always
+ * static keys), which is what lets the offline decode use the same template
+ * as the online validator. Everything else about an instruction is checked
+ * after it has been matched, so a wrong ACCOUNT is a refusal rather than a
+ * silent failure to match.
+ */
+export declare const kaminoInstructionKinds: readonly ["computeUnitLimit", "computeUnitPrice", "createTokenAccount", "wrapSolTransfer", "syncNative", "closeTokenAccount", "kvaultDeposit", "kvaultWithdraw", "farmsInitializeUser", "farmsStake", "farmsUnstake", "farmsWithdrawUnstakedDeposits", "attributionMemo"];
+/** One recognised instruction shape. */
+export type KaminoInstructionKind = (typeof kaminoInstructionKinds)[number];
+/** Human-readable step names, used in refusal messages. */
+export declare const kaminoInstructionKindName: Record<KaminoInstructionKind, string>;
+/**
+ * One template step. `pairedWith` names a step this one may only appear
+ * alongside: either both are matched or neither is. Optionality is per-step,
+ * and for two instructions that are halves of ONE operation that is not
+ * enough — `farms::unstake` releases shares into a pending-withdrawal balance
+ * and `farms::withdraw_unstaked_deposits` is what moves them out of it, so an
+ * unstake on its own strands shares somewhere neither the position read nor
+ * the verify screen describes.
+ */
+export type KaminoSequenceStep = {
+    kind: KaminoInstructionKind;
+    isRequired: boolean;
+    isRepeatable: boolean;
+    pairedWith?: KaminoInstructionKind;
+};
+/**
+ * Whether a withdraw is supposed to release shares from the vault's farm.
+ *
+ * The API decides this from the user's position: a request that fits inside
+ * the shares already sitting in their share account is built as a plain
+ * withdraw, and anything above it is built with the farms pair in front. The
+ * three cases are three different claims:
+ *
+ * - `required` — the initiating device, which read the position and sized the
+ *   request against it. A transaction missing the unstake is refused.
+ * - `forbidden` — the same device, for a request that fits the unstaked
+ *   balance. A transaction CARRYING an unstake is refused.
+ * - `unknown` — the offline decode on a co-signing device, which holds no
+ *   position to compare against. Either shape is accepted, and what bounds it
+ *   there is the argument check: the unstake amount may not exceed the shares
+ *   the withdraw itself burns.
+ */
+export type KaminoFarmUnstakeExpectation = 'required' | 'forbidden' | 'unknown';
+/** Why a transaction does not fit the template. */
+export type KaminoSequenceMismatch = {
+    unexpectedInstruction: {
+        index: number;
+    };
+} | {
+    missingInstruction: string;
+} | {
+    incompleteInstructionPair: string;
+};
+type ExpectedSequenceInput = {
+    operation: 'deposit' | 'withdraw';
+    isWrappedSolVault: boolean;
+    hasFarm: boolean;
+    /**
+     * Whether the app's ComputeBudget pair has been injected. The API emits
+     * none, so before injection their presence is a refusal and after it their
+     * absence is.
+     */
+    hasPriorityFee: boolean;
+    /**
+     * Whether the app's attribution memo has been appended. Same contract as
+     * the fee, for the same reason: the API emits no memo, so one arriving
+     * before injection came from somewhere else, and one missing after
+     * injection means the tag this app claims to write is not in the bytes it
+     * is about to sign.
+     */
+    hasAttributionMemo: boolean;
+    /** Ignored for a deposit. */
+    farmUnstake: KaminoFarmUnstakeExpectation;
+};
+/**
+ * The shape `operation` produces against a vault with these properties,
+ * verified by decoding transactions the Kamino API built and simulating them
+ * on mainnet.
+ *
+ * Optional steps are the ones whose absence cannot cost the user anything —
+ * an idempotent account creation that was already done, a farm user that
+ * already exists, a token account that stays open. Everything that decides
+ * where money moves is required, and anything not listed at all is refused.
+ */
+export declare const expectedKaminoSequence: ({ operation, isWrappedSolVault, hasFarm, hasPriorityFee, hasAttributionMemo, farmUnstake, }: ExpectedSequenceInput) => KaminoSequenceStep[];
+/**
+ * The kind of instruction this program and payload are, or `undefined` when
+ * it is none the template knows. Program and discriminator only — see the
+ * module doc for why.
+ */
+export declare const kaminoInstructionKind: (program: KaminoAllowedProgram | undefined, data: Uint8Array) => KaminoInstructionKind | undefined;
+/**
+ * Walks `steps` and `kinds` together. A step that does not match is skipped
+ * only when it is optional; an instruction left over at the end has no place
+ * in this operation at all.
+ *
+ * `kinds` holds one entry per instruction, in order, `undefined` for an
+ * instruction whose program is not allow-listed or whose discriminator is not
+ * one the template names.
+ */
+export declare const matchKaminoSequence: (kinds: (KaminoInstructionKind | undefined)[], steps: KaminoSequenceStep[]) => {
+    matched: KaminoInstructionKind[];
+} | {
+    mismatch: KaminoSequenceMismatch;
+};
+export {};
+//# sourceMappingURL=sequence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sequence.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/core/chain/chains/solana/kamino/tx/sequence.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,oBAAoB,EAKrB,MAAM,gBAAgB,CAAA;AAEvB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,sBAAsB,2QAczB,CAAA;AAEV,wCAAwC;AACxC,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3E,2DAA2D;AAC3D,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAc3E,CAAA;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,qBAAqB,CAAA;IAC3B,UAAU,EAAE,OAAO,CAAA;IACnB,YAAY,EAAE,OAAO,CAAA;IACrB,UAAU,CAAC,EAAE,qBAAqB,CAAA;CACnC,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,4BAA4B,GAAG,UAAU,GAAG,WAAW,GAAG,SAAS,CAAA;AAE/E,mDAAmD;AACnD,MAAM,MAAM,sBAAsB,GAC9B;IAAE,qBAAqB,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC5C;IAAE,kBAAkB,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,yBAAyB,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzC,KAAK,qBAAqB,GAAG;IAC3B,SAAS,EAAE,SAAS,GAAG,UAAU,CAAA;IACjC,iBAAiB,EAAE,OAAO,CAAA;IAC1B,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,cAAc,EAAE,OAAO,CAAA;IACvB;;;;;;OAMG;IACH,kBAAkB,EAAE,OAAO,CAAA;IAC3B,6BAA6B;IAC7B,WAAW,EAAE,4BAA4B,CAAA;CAC1C,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,GAAI,6FAOpC,qBAAqB,KAAG,kBAAkB,EA8D5C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,GAChC,SAAS,oBAAoB,GAAG,SAAS,EACzC,MAAM,UAAU,KACf,qBAAqB,GAAG,SAkD1B,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC,EAAE,EAC5C,OAAO,kBAAkB,EAAE,KAC1B;IAAE,OAAO,EAAE,qBAAqB,EAAE,CAAA;CAAE,GAAG;IAAE,QAAQ,EAAE,sBAAsB,CAAA;CAgD3E,CAAA"}