@ember-finance/sdk 2.39.0 → 2.42.0

package/dist/src/solana-vaults/on-chain-calls/tx-builder.js

@@ -0,0 +1,466 @@
+import { SystemProgram, TransactionInstruction } from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID, associatedTokenAddress, deriveDepositRequest, deriveDepositUser, deriveParkingLot, deriveParkingLotEscrow, deriveParkingLotUser, deriveProtocolConfig, deriveVaultAccount, deriveVaultPdas, deriveWithdrawalRequest, deriveWithdrawalUser, eventCpiAccounts, instructionDiscriminator, u128le, u64le } from "../utils/pdas.js";
+/**
+ * Builds the program's user instructions. Pure: it derives addresses and
+ * encodes data, and never touches the network or signs.
+ *
+ * Kept separate from SolanaUserCalls so a caller can batch several of these
+ * into one transaction, add their own instructions around them, or hand the
+ * result to a different sender — the same split the EVM side has.
+ */
+export class SolanaTxBuilder {
+    /**
+     * Creates an associated token account only if it is missing.
+     *
+     * `tokenProgram` is a parameter rather than a constant: an ATA's address
+     * derives from it, so a Token-2022 mint resolves somewhere else entirely
+     * and passing the SPL Token default would create an account at an address
+     * the program will not accept.
+     */
+    static createAtaIdempotent(payer, owner, mint, tokenProgram = TOKEN_PROGRAM_ID) {
+        return new TransactionInstruction({
+            programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+            keys: [
+                { pubkey: payer, isSigner: true, isWritable: true },
+                {
+                    pubkey: associatedTokenAddress(owner, mint, tokenProgram),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: owner, isSigner: false, isWritable: false },
+                { pubkey: mint, isSigner: false, isWritable: false },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                { pubkey: tokenProgram, isSigner: false, isWritable: false }
+            ],
+            // 1 = CreateIdempotent. Unlike 0 (Create), this succeeds when the
+            // account already exists, so a repeat deposit needs no pre-check.
+            data: Buffer.from([1])
+        });
+    }
+    /**
+     * `deposit_asset`: moves collateral in and mints shares at the live rate.
+     *
+     * `minShares` is the slippage floor and is enforced on chain. It matters
+     * only if the rate manager moves the rate between quoting and landing.
+     */
+    static depositAsset(ctx, depositor, amount, minShares) {
+        const pdas = deriveVaultPdas(ctx.programId, ctx.shareMint);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: pdas.vault, isSigner: false, isWritable: true },
+                { pubkey: ctx.collateralMint, isSigner: false, isWritable: false },
+                { pubkey: ctx.shareMint, isSigner: false, isWritable: true },
+                { pubkey: pdas.vaultCollateral, isSigner: false, isWritable: true },
+                { pubkey: depositor, isSigner: true, isWritable: true },
+                {
+                    pubkey: deriveVaultAccount(ctx.programId, pdas.vault, depositor),
+                    isSigner: false,
+                    isWritable: true
+                },
+                {
+                    // The depositor's deposit-allow-list entry, passed whether
+                    // or not it exists: the list is unbounded and lives in one
+                    // PDA per member, so the program reads this account to
+                    // decide. Read-only, and never created here.
+                    pubkey: deriveDepositUser(ctx.programId, pdas.vault, depositor),
+                    isSigner: false,
+                    isWritable: false
+                },
+                {
+                    pubkey: associatedTokenAddress(depositor, ctx.collateralMint, ctx.collateralProgram),
+                    isSigner: false,
+                    isWritable: true
+                },
+                {
+                    pubkey: associatedTokenAddress(depositor, ctx.shareMint, ctx.shareProgram),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: ctx.collateralProgram, isSigner: false, isWritable: false },
+                { pubkey: ctx.shareProgram, isSigner: false, isWritable: false },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            data: Buffer.concat([
+                instructionDiscriminator("deposit_asset"),
+                u64le(amount),
+                u64le(minShares)
+            ])
+        });
+    }
+    /**
+     * `mint_shares`: the same movement expressed the other way round — an exact
+     * share count out, with `maxAmount` capping the collateral it may consume.
+     */
+    static mintShares(ctx, depositor, shares, maxAmount) {
+        const deposit = SolanaTxBuilder.depositAsset(ctx, depositor, shares, maxAmount);
+        return new TransactionInstruction({
+            programId: deposit.programId,
+            keys: deposit.keys,
+            data: Buffer.concat([
+                instructionDiscriminator("mint_shares"),
+                u64le(shares),
+                u64le(maxAmount)
+            ])
+        });
+    }
+    /**
+     * `redeem_shares`: burns nothing yet — it escrows the shares into the
+     * vault's pending account and appends a request to the withdrawal queue.
+     * The operator settles it later, so this returns no collateral.
+     *
+     * `requestIndex` identifies the request account and must be the owner's
+     * next index; SolanaUserCalls reads it so callers do not have to.
+     */
+    static redeemShares(ctx, owner, shares, requestNonce, receiver) {
+        const pdas = deriveVaultPdas(ctx.programId, ctx.shareMint);
+        const vaultAccount = deriveVaultAccount(ctx.programId, pdas.vault, owner);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: pdas.vault, isSigner: false, isWritable: true },
+                { pubkey: ctx.shareMint, isSigner: false, isWritable: false },
+                { pubkey: pdas.vaultPendingShares, isSigner: false, isWritable: true },
+                { pubkey: pdas.withdrawalQueue, isSigner: false, isWritable: true },
+                { pubkey: vaultAccount, isSigner: false, isWritable: true },
+                { pubkey: owner, isSigner: true, isWritable: true },
+                {
+                    pubkey: deriveWithdrawalRequest(ctx.programId, pdas.vault, owner, requestNonce),
+                    isSigner: false,
+                    isWritable: true
+                },
+                {
+                    pubkey: associatedTokenAddress(owner, ctx.shareMint, ctx.shareProgram),
+                    isSigner: false,
+                    isWritable: true
+                },
+                {
+                    // Both ends of the withdrawal allow list. Settlement
+                    // re-checks them, so a request whose owner or receiver was
+                    // de-listed meanwhile is skipped rather than paid.
+                    pubkey: deriveWithdrawalUser(ctx.programId, pdas.vault, owner),
+                    isSigner: false,
+                    isWritable: false
+                },
+                {
+                    pubkey: deriveWithdrawalUser(ctx.programId, pdas.vault, receiver),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: ctx.shareProgram, isSigner: false, isWritable: false },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            // `receiver` is an argument, not an account: the collateral is paid
+            // out later by the operator, so there is nothing to write to now.
+            data: Buffer.concat([
+                instructionDiscriminator("redeem_shares"),
+                u64le(shares),
+                receiver.toBuffer()
+            ])
+        });
+    }
+    /**
+     * `cancel_pending_withdrawal_request`: withdraws the request from the
+     * queue, identified by its `sequenceNumber`.
+     *
+     * Only four accounts, none of them token accounts. The escrowed shares are
+     * not moved here — the request is marked cancelled on the owner's
+     * VaultAccount and the operator returns the shares when it next settles —
+     * so neither the share mint, the pending-shares escrow nor the request's
+     * own account appear. Matches CancelWithdrawalRequest in withdraw.rs: note
+     * that `vault` and `owner` are both read-only.
+     */
+    static cancelPendingWithdrawalRequest(ctx, owner, sequenceNumber) {
+        const pdas = deriveVaultPdas(ctx.programId, ctx.shareMint);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: pdas.vault, isSigner: false, isWritable: false },
+                {
+                    pubkey: deriveVaultAccount(ctx.programId, pdas.vault, owner),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: owner, isSigner: true, isWritable: false },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            // u128, not u64: a queue sequence number, not the request nonce
+            // that seeds the request PDA.
+            data: Buffer.concat([
+                instructionDiscriminator("cancel_pending_withdrawal_request"),
+                u128le(sequenceNumber)
+            ])
+        });
+    }
+    // --- parking lot ------------------------------------------------------
+    //
+    // All nine instructions build here. The three user ones are wired into
+    // SolanaUserCalls; the operator and admin ones have no call class yet
+    // (phases 3-4) but are pure instructions, so a caller can sign and send
+    // them today rather than wait for a surface that only wraps them.
+    /** The lot and its escrow, derived from the vault's share mint. */
+    static lotAccounts(ctx) {
+        const { vault } = deriveVaultPdas(ctx.programId, ctx.shareMint);
+        const parkingLot = deriveParkingLot(ctx.programId, vault);
+        return {
+            vault,
+            parkingLot,
+            escrow: deriveParkingLotEscrow(ctx.programId, parkingLot)
+        };
+    }
+    /**
+     * `parking_lot_deposit`: escrows collateral and queues a request.
+     *
+     * `sequenceNumber` MUST be the lot's current `sequence_number + 1`, since
+     * the program increments before it writes. That makes this racy by
+     * construction — if another park lands first the address is taken and the
+     * transaction fails — so it is read fresh in SolanaUserCalls rather than
+     * cached.
+     *
+     * `receiver` takes the minted shares when the request is forwarded; the
+     * depositor keeps the refund and the rent.
+     */
+    static parkingLotDeposit(ctx, depositor, assets, sequenceNumber, receiver) {
+        const { vault, parkingLot, escrow } = SolanaTxBuilder.lotAccounts(ctx);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: vault, isSigner: false, isWritable: false },
+                { pubkey: parkingLot, isSigner: false, isWritable: true },
+                {
+                    // The lot keeps its OWN allow list, separate from the
+                    // vault's, but the entry is seeded by the vault.
+                    pubkey: deriveParkingLotUser(ctx.programId, vault, depositor),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: escrow, isSigner: false, isWritable: true },
+                { pubkey: ctx.collateralMint, isSigner: false, isWritable: false },
+                {
+                    pubkey: deriveDepositRequest(ctx.programId, parkingLot, sequenceNumber),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: depositor, isSigner: true, isWritable: true },
+                {
+                    pubkey: deriveVaultAccount(ctx.programId, vault, depositor),
+                    isSigner: false,
+                    isWritable: true
+                },
+                {
+                    pubkey: associatedTokenAddress(depositor, ctx.collateralMint, ctx.collateralProgram),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: ctx.collateralProgram, isSigner: false, isWritable: false },
+                { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            data: Buffer.concat([
+                instructionDiscriminator("parking_lot_deposit"),
+                u64le(assets),
+                receiver.toBuffer()
+            ])
+        });
+    }
+    /**
+     * `parking_lot_cancel_deposit`: withdraws a request before it settles and
+     * returns the escrowed collateral, closing the account to refund its rent.
+     *
+     * Takes the request's OWN sequence number, not the lot's next one.
+     */
+    static parkingLotCancelDeposit(ctx, depositor, sequenceNumber) {
+        return SolanaTxBuilder.refundLike(ctx, depositor, sequenceNumber, "parking_lot_cancel_deposit");
+    }
+    /**
+     * `parking_lot_claim_refund`: collects a refund that settlement could not
+     * deliver, for a request whose `claimable` flag is set.
+     *
+     * Identical account list to cancel — same four accounts, same order — so
+     * the two differ only in their discriminator and in what the program will
+     * accept.
+     */
+    static parkingLotClaimRefund(ctx, depositor, sequenceNumber) {
+        return SolanaTxBuilder.refundLike(ctx, depositor, sequenceNumber, "parking_lot_claim_refund");
+    }
+    static refundLike(ctx, depositor, sequenceNumber, instruction) {
+        const { parkingLot, escrow } = SolanaTxBuilder.lotAccounts(ctx);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: parkingLot, isSigner: false, isWritable: true },
+                { pubkey: escrow, isSigner: false, isWritable: true },
+                { pubkey: ctx.collateralMint, isSigner: false, isWritable: false },
+                {
+                    pubkey: deriveDepositRequest(ctx.programId, parkingLot, sequenceNumber),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: depositor, isSigner: true, isWritable: true },
+                {
+                    pubkey: associatedTokenAddress(depositor, ctx.collateralMint, ctx.collateralProgram),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: ctx.collateralProgram, isSigner: false, isWritable: false },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            data: Buffer.concat([
+                instructionDiscriminator(instruction),
+                u128le(sequenceNumber)
+            ])
+        });
+    }
+    /**
+     * `parking_lot_process_deposits`: forwards up to `numRequests` from the
+     * head of the queue into the vault, minting shares to each receiver.
+     *
+     * Operator-signed. The per-request accounts are not listed here: the
+     * program walks the queue from `queue_start_index` and reads each request
+     * through remaining_accounts, which the caller appends.
+     */
+    static parkingLotProcessDeposits(ctx, operator, numRequests, remaining = []) {
+        return SolanaTxBuilder.processLike(ctx, operator, "parking_lot_process_deposits", u64le(numRequests), remaining);
+    }
+    /** `parking_lot_process_deposits_up_to`: the same, bounded by sequence number. */
+    static parkingLotProcessDepositsUpTo(ctx, operator, upToSequenceNumber, remaining = []) {
+        return SolanaTxBuilder.processLike(ctx, operator, "parking_lot_process_deposits_up_to", u128le(upToSequenceNumber), remaining);
+    }
+    static processLike(ctx, operator, instruction, arg, remaining) {
+        const { vault, parkingLot, escrow } = SolanaTxBuilder.lotAccounts(ctx);
+        const pdas = deriveVaultPdas(ctx.programId, ctx.shareMint);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: vault, isSigner: false, isWritable: true },
+                { pubkey: parkingLot, isSigner: false, isWritable: true },
+                { pubkey: escrow, isSigner: false, isWritable: true },
+                { pubkey: ctx.collateralMint, isSigner: false, isWritable: false },
+                { pubkey: ctx.shareMint, isSigner: false, isWritable: true },
+                { pubkey: pdas.vaultCollateral, isSigner: false, isWritable: true },
+                { pubkey: operator, isSigner: true, isWritable: false },
+                { pubkey: ctx.collateralProgram, isSigner: false, isWritable: false },
+                { pubkey: ctx.shareProgram, isSigner: false, isWritable: false },
+                ...eventCpiAccounts(ctx.programId),
+                ...remaining
+            ],
+            data: Buffer.concat([instructionDiscriminator(instruction), arg])
+        });
+    }
+    /**
+     * The four admin settings, which share one account list: config, vault,
+     * the lot, and the signer. They do NOT share one authority — the program
+     * decides, and the shapes being identical hides that:
+     *
+     * - `set_operator` — the vault admin.
+     * - `set_deposits_paused`, `set_cancellations_paused` — the GUARDIAN, via
+     *   `verify_guardian`, which also fails closed while no guardian is set.
+     * - `set_deposit_allow_list` — the lot's operator.
+     *
+     * Signing a pause with the vault admin key is rejected on chain.
+     */
+    static lotSetting(ctx, signer, instruction, arg) {
+        const { vault, parkingLot } = SolanaTxBuilder.lotAccounts(ctx);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: vault, isSigner: false, isWritable: false },
+                { pubkey: parkingLot, isSigner: false, isWritable: true },
+                { pubkey: signer, isSigner: true, isWritable: false },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            data: Buffer.concat([instructionDiscriminator(instruction), arg])
+        });
+    }
+    /** `parking_lot_set_operator`. */
+    static parkingLotSetOperator(ctx, signer, newOperator) {
+        return SolanaTxBuilder.lotSetting(ctx, signer, "parking_lot_set_operator", newOperator.toBuffer());
+    }
+    /** `parking_lot_set_deposits_paused`: blocks new parks only. */
+    static parkingLotSetDepositsPaused(ctx, signer, paused) {
+        return SolanaTxBuilder.lotSetting(ctx, signer, "parking_lot_set_deposits_paused", Buffer.from([paused ? 1 : 0]));
+    }
+    /** `parking_lot_set_cancellations_paused`: blocks cancellation only. */
+    static parkingLotSetCancellationsPaused(ctx, signer, paused) {
+        return SolanaTxBuilder.lotSetting(ctx, signer, "parking_lot_set_cancellations_paused", Buffer.from([paused ? 1 : 0]));
+    }
+    /**
+     * `parking_lot_set_deposit_allow_list`: adds or removes one account.
+     * An empty list means the lot is open to everyone.
+     *
+     * Not built through `lotSetting`, unlike its three siblings: the list is
+     * unbounded, so adding an account CREATES its entry PDA and removing one
+     * closes it. That needs the entry and the system program, and makes the
+     * signer writable - it pays the rent, and is refunded on removal.
+     */
+    static parkingLotSetDepositAllowList(ctx, signer, account, allowed) {
+        const { vault, parkingLot } = SolanaTxBuilder.lotAccounts(ctx);
+        return new TransactionInstruction({
+            programId: ctx.programId,
+            keys: [
+                {
+                    pubkey: deriveProtocolConfig(ctx.programId),
+                    isSigner: false,
+                    isWritable: false
+                },
+                { pubkey: vault, isSigner: false, isWritable: false },
+                { pubkey: parkingLot, isSigner: false, isWritable: true },
+                {
+                    // The entry for the account being listed, not the signer.
+                    pubkey: deriveParkingLotUser(ctx.programId, vault, account),
+                    isSigner: false,
+                    isWritable: true
+                },
+                { pubkey: signer, isSigner: true, isWritable: true },
+                {
+                    pubkey: SystemProgram.programId,
+                    isSigner: false,
+                    isWritable: false
+                },
+                ...eventCpiAccounts(ctx.programId)
+            ],
+            data: Buffer.concat([
+                instructionDiscriminator("parking_lot_set_deposit_allow_list"),
+                account.toBuffer(),
+                Buffer.from([allowed ? 1 : 0])
+            ])
+        });
+    }
+}

package/dist/src/solana-vaults/on-chain-calls/user.d.ts

@@ -0,0 +1,200 @@
+import { type Connection, PublicKey, type TransactionInstruction } from "@solana/web3.js";
+import { type ISolanaDepositRequest, type ISolanaWithdrawalRequest } from "../interfaces/index.js";
+import { type SolanaSigner } from "../signers/solana-signer.js";
+import { SolanaDeploymentParser } from "../utils/deployment-parser.js";
+/** What a write returns. */
+export interface ISolanaTxResponse {
+    /** The transaction signature, base58. Also its explorer id. */
+    signature: string;
+    /** Compute units the simulation reported, when one ran. */
+    unitsConsumed?: number;
+}
+export interface ISolanaWriteOptions {
+    /**
+     * Simulate before sending. On by default: a failed simulation costs one
+     * round trip and reports the program's error, where a failed send costs a
+     * fee and reports a bare "custom program error".
+     */
+    simulate?: boolean;
+    /** Extra instructions to run before the vault call, e.g. a compute budget. */
+    preInstructions?: TransactionInstruction[];
+    /** Overrides the signer supplied to the constructor, for this call only. */
+    signer?: SolanaSigner;
+}
+/**
+ * Redemptions, and only redemptions, take a receiver.
+ *
+ * `deposit_asset` and `mint_shares` have no receiver argument and mint into the
+ * depositor's own associated token account, so a `receiver` on those options
+ * would be accepted and silently ignored. It is kept off their type rather than
+ * rejected at runtime, so the mistake does not compile.
+ */
+export interface ISolanaRedeemOptions extends ISolanaWriteOptions {
+    /** Who receives the collateral at settlement. Defaults to the signer. */
+    receiver?: PublicKey | string;
+}
+/**
+ * Amounts accept the shapes the Sui and EVM surfaces accept, not just bigint.
+ *
+ * `EmberVaults.user` is a union of the three chains' call classes, so a shared
+ * call site resolves each parameter to the INTERSECTION of their types. Sui's
+ * `NumStr` is `number | string` and EVM's is `string | number | bigint`;
+ * intersected with a bigint-only Solana that is `never`, so before this type
+ * existed `ember.user.redeemShares(vault, x)` failed to compile for every x —
+ * `100`, `"100"` and `100n` alike.
+ *
+ * `100n` through `ember.user` is still rejected, because Sui's `NumStr` has no
+ * bigint. That is pre-existing and unrelated to Solana; a bigint works on a
+ * narrowed instance (`asSolana().user`, or a `SolanaUserCalls` directly).
+ */
+export type SolanaAmount = bigint | number | string;
+/**
+ * The user-facing writes: deposit, mint, redeem and cancel.
+ *
+ * Each method reads only what it needs to build a correct instruction — the
+ * mints' token programs and, for a redeem, the owner's request nonce — then
+ * signs and sends. The instruction building itself lives in SolanaTxBuilder,
+ * so a caller who wants to batch or route differently can use that directly.
+ */
+export declare class SolanaUserCalls {
+    private readonly connection;
+    /**
+     * Optional so one instance can serve a page that has not connected a
+     * wallet yet; every write then takes its own signer.
+     */
+    private readonly signer?;
+    private parser;
+    private readonly reader;
+    constructor(connection: Connection, parser: SolanaDeploymentParser, 
+    /**
+     * Optional so one instance can serve a page that has not connected a
+     * wallet yet; every write then takes its own signer.
+     */
+    signer?: SolanaSigner);
+    /** Swap in a newer deployment without rebuilding the caller. */
+    updateDeployment(parser: SolanaDeploymentParser): void;
+    private key;
+    private resolveSigner;
+    /**
+     * The mints and their owning token programs.
+     *
+     * The programs come from the deployment manifest when it records them and
+     * from the mint accounts otherwise. They are not assumed equal: a vault's
+     * collateral and share mints may sit under SPL Token and Token-2022
+     * respectively, and the ATA addresses differ between the two.
+     */
+    private vaultContext;
+    private tokenProgram;
+    /**
+     * Signs, sends and confirms. Simulation runs first unless turned off, and
+     * its error is surfaced in place of the send's: the program's own message
+     * is in the simulation logs, while a failed send gives only a code.
+     */
+    private send;
+    /**
+     * Deposits collateral and mints shares at the vault's live rate.
+     *
+     * `minShares` is the on-chain slippage floor; it bites only if the rate
+     * manager moves the rate between quoting and landing. Quote it with
+     * `SolanaVaultReader.previewDeposit`.
+     *
+     * The depositor's share account is created here when missing, so a first
+     * deposit is still a single transaction.
+     */
+    depositAsset(shareMint: PublicKey | string, amount: SolanaAmount, minShares: SolanaAmount, options?: ISolanaWriteOptions): Promise<ISolanaTxResponse>;
+    /**
+     * Mints an exact share count, spending at most `maxAmount` of collateral.
+     * The mirror of depositAsset, for a caller who wants a round share figure.
+     */
+    mintShares(shareMint: PublicKey | string, shares: SolanaAmount, maxAmount: SolanaAmount, options?: ISolanaWriteOptions): Promise<ISolanaTxResponse>;
+    /**
+     * The idempotent ATA instruction, but only when the account is actually
+     * missing: including it unconditionally costs a few hundred compute units
+     * on every repeat deposit for nothing.
+     */
+    private ensureShareAccount;
+    /**
+     * Parks a deposit: escrows collateral and queues a request for the
+     * operator to forward into the vault later. No shares are minted here.
+     *
+     * THIS CALL IS RACY BY CONSTRUCTION. The request's account address is
+     * seeded with the lot's `sequence_number + 1`, and the program increments
+     * before it writes, so two parks landing in the same slot collide and the
+     * loser fails its address check. The lot is read immediately before
+     * building to keep the window small, but it cannot be closed from here —
+     * on `ParkingLotSequenceTaken` the caller should simply call again, which
+     * re-reads and takes the next slot.
+     *
+     * No automatic retry: a resend after a failed SEND (rather than a failed
+     * simulation) could double-park if the first transaction actually landed.
+     *
+     * `receiver` takes the minted shares when the request is forwarded. The
+     * depositor keeps the refund and the account's rent either way.
+     */
+    parkDeposit(shareMint: PublicKey | string, assets: SolanaAmount, options?: ISolanaRedeemOptions): Promise<ISolanaTxResponse & {
+        sequenceNumber: bigint;
+    }>;
+    /**
+     * Cancels a parked deposit before it settles, returning the escrowed
+     * collateral and the account's rent.
+     *
+     * Takes the request's own sequence number — from `getParkedDeposits` —
+     * not the lot's next one.
+     */
+    cancelParkedDeposit(shareMint: PublicKey | string, sequenceNumber: SolanaAmount, options?: ISolanaWriteOptions): Promise<ISolanaTxResponse>;
+    /**
+     * Claims a refund that settlement could not deliver.
+     *
+     * Only for a request whose `claimable` flag is set — the request settled
+     * but the collateral could not be returned, so it waits in escrow under
+     * the lot's `totalClaimableAssets`. `getParkedDeposits` separates these
+     * from the ones still pending.
+     */
+    claimParkedRefund(shareMint: PublicKey | string, sequenceNumber: SolanaAmount, options?: ISolanaWriteOptions): Promise<ISolanaTxResponse>;
+    /**
+     * This depositor's parked deposits, split into those still queued and
+     * those whose refund is waiting to be claimed.
+     *
+     * Found by filtering on the request accounts themselves rather than by
+     * walking the queue: a claimable request has already settled, so it sits
+     * BELOW the lot's head and no scan of the pending window would see it.
+     */
+    getParkedDeposits(shareMint: PublicKey | string, owner?: PublicKey | string): Promise<{
+        pending: ISolanaDepositRequest[];
+        claimable: ISolanaDepositRequest[];
+    }>;
+    /**
+     * Queues a withdrawal. This does NOT return collateral: the shares are
+     * escrowed and a request is appended to the vault's queue, which the
+     * operator settles later. Watch it with `getPendingWithdrawals`.
+     *
+     * The request's account is seeded by the owner's next nonce, which is read
+     * here — a caller passing a stale one would collide with their own earlier
+     * request.
+     */
+    redeemShares(shareMint: PublicKey | string, shares: SolanaAmount, options?: ISolanaRedeemOptions): Promise<ISolanaTxResponse>;
+    /**
+     * Cancels a queued withdrawal by its queue `sequenceNumber` — not the
+     * request nonce that seeds the request account. Take it from
+     * `getPendingWithdrawals`.
+     */
+    cancelPendingWithdrawalRequest(shareMint: PublicKey | string, sequenceNumber: SolanaAmount, options?: ISolanaWriteOptions): Promise<ISolanaTxResponse>;
+    /**
+     * An owner's live queued withdrawals, each carrying the `sequenceNumber`
+     * that `cancelPendingWithdrawalRequest` takes.
+     *
+     * CANCELLED REQUESTS ARE EXCLUDED, and that filter is not cosmetic.
+     * `cancel_pending_withdrawal_request` does not remove the entry: it pushes
+     * the sequence number onto the account's `cancel_withdraw_request` list and
+     * leaves the request in place, for the operator to skip when it settles
+     * (see withdraw.rs). Returning the raw list would therefore show a
+     * withdrawal the user already cancelled as still pending, indefinitely.
+     */
+    getPendingWithdrawals(shareMint: PublicKey | string, owner?: PublicKey | string): Promise<ISolanaWithdrawalRequest[]>;
+    /**
+     * The requests this owner has cancelled that the operator has not yet
+     * settled. They still occupy a slot on the account until it does.
+     */
+    getCancelledWithdrawals(shareMint: PublicKey | string, owner?: PublicKey | string): Promise<ISolanaWithdrawalRequest[]>;
+    private accountState;
+}