@loyal-labs/private-transactions 0.2.8 → 0.2.9

package/dist/src/LoyalPrivateTransactionsClient.d.ts

@@ -1,7 +1,7 @@
 import { Connection, PublicKey } from "@solana/web3.js";
 import { Program } from "@coral-xyz/anchor";
 import type { TelegramPrivateTransfer } from "./idl/telegram_private_transfer.ts";
-import type { WalletLike, ClientConfig, DepositData, UsernameDepositData, InitializeDepositParams, ModifyBalanceParams, ModifyBalanceResult, GetKaminoShieldedBalanceQuoteParams, GetKaminoCollateralSharesForLiquidityAmountParams, KaminoReserveSnapshot, KaminoShieldedBalanceQuote, CreatePermissionParams, CreateUsernamePermissionParams, DelegateDepositParams, DelegateUsernameDepositParams, UndelegateDepositParams, UndelegateUsernameDepositParams, TransferDepositParams, TransferToUsernameDepositParams, InitializeUsernameDepositParams, ClaimUsernameDepositToDepositParams, DelegationStatusResponse } from "./types";
+import type { WalletLike, ClientConfig, DepositData, UsernameDepositData, InitializeDepositParams, CloseDepositParams, CloseUsernameDepositParams, ModifyBalanceParams, ModifyBalanceResult, GetKaminoShieldedBalanceQuoteParams, GetKaminoCollateralSharesForLiquidityAmountParams, KaminoReserveSnapshot, KaminoShieldedBalanceQuote, BuildShieldFlowTransactionPlanParams, BuildShieldTokensTransactionPlanParams, BuildUnshieldTokensTransactionPlanParams, ExecuteShieldFlowTransactionPlanParams, ExecuteShieldTokensTransactionPlanParams, ExecuteUnshieldTokensTransactionPlanParams, EstimateShieldFlowFeeParams, EstimateShieldTokensFeeParams, EstimateUnshieldTokensFeeParams, ShieldFlowExecutionResult, ShieldFlowFeeEstimate, ShieldFlowPlan, ShieldTokensClientParams, UnshieldTokensClientParams, CreatePermissionParams, CreateUsernamePermissionParams, DelegateDepositParams, DelegateUsernameDepositParams, UndelegateDepositParams, UndelegateUsernameDepositParams, TransferDepositParams, TransferToUsernameDepositParams, InitializeUsernameDepositParams, ClaimUsernameDepositToDepositParams, DelegationStatusResponse } from "./types";
 export declare function waitForAccountOwnerChange(connection: Connection, account: PublicKey, expectedOwner: PublicKey, timeoutMs?: number, intervalMs?: number): {
     wait: () => Promise<void>;
     cancel: () => Promise<void>;
@@ -44,11 +44,24 @@ export declare class LoyalPrivateTransactionsClient {
      * Verifies TEE RPC integrity and obtains an auth token automatically.
      */
     static fromConfig(config: ClientConfig): Promise<LoyalPrivateTransactionsClient>;
+    shieldTokens(params: ShieldTokensClientParams): Promise<string>;
+    unshieldTokens(params: UnshieldTokensClientParams): Promise<string>;
+    buildShieldFlowTransactionPlan(params: BuildShieldFlowTransactionPlanParams): Promise<ShieldFlowPlan>;
+    buildShieldTokensTransactionPlan(params: BuildShieldTokensTransactionPlanParams): Promise<ShieldFlowPlan>;
+    buildUnshieldTokensTransactionPlan(params: BuildUnshieldTokensTransactionPlanParams): Promise<ShieldFlowPlan>;
+    estimateShieldFlowFee(params: EstimateShieldFlowFeeParams): Promise<ShieldFlowFeeEstimate>;
+    estimateShieldTokensFee(params: EstimateShieldTokensFeeParams): Promise<ShieldFlowFeeEstimate>;
+    estimateUnshieldTokensFee(params: EstimateUnshieldTokensFeeParams): Promise<ShieldFlowFeeEstimate>;
+    executeShieldFlowTransactionPlan(params: ExecuteShieldFlowTransactionPlanParams): Promise<ShieldFlowExecutionResult>;
+    executeShieldTokensTransactionPlan(params: ExecuteShieldTokensTransactionPlanParams): Promise<ShieldFlowExecutionResult>;
+    executeUnshieldTokensTransactionPlan(params: ExecuteUnshieldTokensTransactionPlanParams): Promise<ShieldFlowExecutionResult>;
     /**
      * Initialize a deposit account for a user and token mint
      */
     initializeDeposit(params: InitializeDepositParams): Promise<string>;
     initializeUsernameDeposit(params: InitializeUsernameDepositParams): Promise<string>;
+    closeDeposit(params: CloseDepositParams): Promise<string>;
+    closeUsernameDeposit(params: CloseUsernameDepositParams): Promise<string>;
     /**
      * Modify the balance of a user's deposit account
      */
@@ -57,7 +70,7 @@ export declare class LoyalPrivateTransactionsClient {
     /**
      * Create a permission for a deposit account (required for PER)
      */
-    createPermission(params: CreatePermissionParams): Promise<string | null>;
+    createPermission(params: CreatePermissionParams): Promise<string>;
     /**
      * Create a permission for a username-based deposit account
      */
@@ -138,7 +151,6 @@ export declare class LoyalPrivateTransactionsClient {
      * Get the program ID
      */
     getProgramId(): PublicKey;
-    private validateUsername;
     private permissionAccountExists;
     private isAccountAlreadyInUse;
     private ensureNotDelegated;

package/dist/src/actions/shieldTokens.d.ts

@@ -0,0 +1,69 @@
+import { type AccountInfo, type PublicKey, type TransactionInstruction } from "@solana/web3.js";
+import type { FeeEstimateCluster, InstructionCheck, RpcOptions } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+import type { Program } from "@coral-xyz/anchor";
+export type LabeledTransactionInstruction = {
+    label: string;
+    ix: TransactionInstruction;
+    rentLamports?: number;
+    nativeLamports?: number;
+};
+export type LabeledTransactionPlan = {
+    label: string;
+    cluster: FeeEstimateCluster;
+    instructions: LabeledTransactionInstruction[];
+    checks: InstructionCheck[];
+};
+export type ShieldTokensInstructionPlan = {
+    instructions: LabeledTransactionInstruction[];
+    checks: InstructionCheck[];
+    needsUndelegate: boolean;
+    context: {
+        isNativeSol: boolean;
+        validator: PublicKey;
+        depositPda: PublicKey;
+        permissionPda: PublicKey;
+        depositAccountInfo: AccountInfo<Buffer> | null;
+        permissionAccountInfo: AccountInfo<Buffer> | null;
+    };
+};
+export type ShieldTokensTransactionPlan = {
+    preUndelegateTransaction: LabeledTransactionPlan | null;
+    baseTransaction: LabeledTransactionPlan;
+    context: ShieldTokensInstructionPlan["context"];
+};
+export declare function labelTransactionInstructions(prefix: string, instructions: TransactionInstruction[]): LabeledTransactionInstruction[];
+export declare function buildShieldTokensInstructionPlan(params: {
+    user: PublicKey;
+    payer: PublicKey;
+    tokenMint: PublicKey;
+    amount: bigint;
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    validator?: PublicKey;
+}): Promise<ShieldTokensInstructionPlan>;
+export declare function buildShieldTokensTransactionPlan(params: {
+    user: PublicKey;
+    payer: PublicKey;
+    tokenMint: PublicKey;
+    amount: bigint;
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    validator?: PublicKey;
+    sessionToken?: PublicKey | null;
+    magicProgram?: PublicKey;
+    magicContext?: PublicKey;
+}): Promise<ShieldTokensTransactionPlan>;
+export declare function shieldTokens(params: {
+    user: PublicKey;
+    payer: PublicKey;
+    tokenMint: PublicKey;
+    amount: bigint;
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    validator?: PublicKey;
+    sessionToken?: PublicKey | null;
+    magicProgram?: PublicKey;
+    magicContext?: PublicKey;
+    rpcOptions?: RpcOptions;
+}): Promise<string>;

package/dist/src/actions/undelegateDeposit.d.ts

@@ -0,0 +1,25 @@
+import type { Program } from "@coral-xyz/anchor";
+import { type PublicKey, type TransactionInstruction } from "@solana/web3.js";
+import type { InstructionCheck, RpcOptions, UndelegateDepositParams } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+export type PlannedUndelegateDepositTransaction = {
+    label: string;
+    instructions: {
+        ix: TransactionInstruction;
+    }[];
+    checks: InstructionCheck[];
+};
+export declare function sendPlannedUndelegateDepositTransaction(params: {
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    transaction: PlannedUndelegateDepositTransaction;
+    user: PublicKey;
+    tokenMint: PublicKey;
+    rpcOptions?: RpcOptions;
+}): Promise<string>;
+/**
+ * Undelegate a deposit account from the ephemeral rollup.
+ * Waits for both base and ephemeral connections to confirm the deposit
+ * is owned by PROGRAM_ID before returning.
+ */
+export declare function undelegateDeposit(baseProgram: Program<TelegramPrivateTransfer>, perProgram: Program<TelegramPrivateTransfer>, params: UndelegateDepositParams): Promise<string>;

package/dist/src/actions/unshieldTokens.d.ts

@@ -0,0 +1,62 @@
+import { type PublicKey } from "@solana/web3.js";
+import type { Program } from "@coral-xyz/anchor";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+import type { InstructionCheck, RpcOptions } from "../types";
+import { type LabeledTransactionInstruction, type LabeledTransactionPlan } from "./shieldTokens";
+export type UnshieldTokensInstructionPlan = {
+    instructions: LabeledTransactionInstruction[];
+    checks: InstructionCheck[];
+    needsUndelegate: boolean;
+    shouldRedelegate: boolean;
+    context: {
+        isNativeSol: boolean;
+        validator: PublicKey;
+        depositPda: PublicKey;
+        currentDepositAmount: bigint | null;
+    };
+};
+export type UnshieldTokensTransactionPlan = {
+    preUndelegateTransaction: LabeledTransactionPlan | null;
+    baseTransaction: LabeledTransactionPlan;
+    shouldRedelegate: boolean;
+    context: UnshieldTokensInstructionPlan["context"];
+};
+export declare function buildUnshieldTokensInstructionPlan(params: {
+    user: PublicKey;
+    payer: PublicKey;
+    tokenMint: PublicKey;
+    amount: bigint;
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    validator?: PublicKey;
+}): Promise<UnshieldTokensInstructionPlan>;
+export declare function buildUnshieldTokensTransactionPlan(params: {
+    user: PublicKey;
+    payer: PublicKey;
+    tokenMint: PublicKey;
+    amount: bigint;
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    validator?: PublicKey;
+    sessionToken?: PublicKey | null;
+    magicProgram?: PublicKey;
+    magicContext?: PublicKey;
+}): Promise<UnshieldTokensTransactionPlan>;
+/**
+ * Unshield tokens: move from a Loyal private deposit back to a regular wallet.
+ * If the deposit is delegated, this first commits it back to base, then sends
+ * one base transaction for withdraw/native-SOL close/redelegate.
+ */
+export declare function unshieldTokens(params: {
+    user: PublicKey;
+    payer: PublicKey;
+    tokenMint: PublicKey;
+    amount: bigint;
+    baseProgram: Program<TelegramPrivateTransfer>;
+    perProgram: Program<TelegramPrivateTransfer>;
+    validator?: PublicKey;
+    sessionToken?: PublicKey | null;
+    magicProgram?: PublicKey;
+    magicContext?: PublicKey;
+    rpcOptions?: RpcOptions;
+}): Promise<string>;

package/dist/src/checks/enshureChecks.d.ts

@@ -0,0 +1,5 @@
+import type { AccountInfo, Connection, PublicKey } from "@solana/web3.js";
+import type { InstructionCheck } from "../types";
+export declare function processEnsureChecks(baseConnection: Connection, perConnection: Connection, ensure: InstructionCheck[]): Promise<void>;
+export declare function getMultipleAccountsInfoWithRetry(connection: Connection, accounts: PublicKey[], label: string): Promise<(AccountInfo<Buffer> | null)[]>;
+export declare function runEnsureFetchWithRetry<T>(label: string, task: () => Promise<T>): Promise<T>;

package/dist/src/constants.d.ts

@@ -9,7 +9,7 @@ export declare const ER_VALIDATOR_MAINNET: PublicKey;
  */
 export declare const ER_VALIDATOR: PublicKey;
 export declare function getErValidatorForSolanaEnv(env: string): PublicKey;
-export declare function getErValidatorForRpcEndpoint(rpcEndpoint: string): PublicKey;
+export declare function getErValidatorForRpcEndpoint(perRpcEndpoint: string): PublicKey;
 export declare function getKaminoModifyBalanceAccountsForTokenMint(tokenMint: PublicKey): KaminoModifyBalanceAccounts | null;
 /**
  * Telegram Private Transfer program ID

package/dist/src/enumerate-deposits.d.ts

@@ -0,0 +1,23 @@
+import { type Connection, PublicKey } from "@solana/web3.js";
+import type { DepositData } from "./types";
+/**
+ * Enumerate every Deposit account belonging to `user` across the base program
+ * and (optionally) the ephemeral program. Read-only — no signer required.
+ *
+ * Three sources are merged:
+ *   1. Base, owned by the deposit program — undelegated deposits (Anchor).
+ *   2. Base, owned by the delegation program — delegated deposits whose data
+ *      bytes are still readable on base. Required when no authenticated
+ *      ephemeral connection is available (e.g. browser wallet UI).
+ *   3. Ephemeral, owned by the deposit program — delegated deposits with the
+ *      live balance (Anchor). Wins over (2) for the same PDA when present.
+ *
+ * Used by wallet UIs to discover shielded holdings even when the user has no
+ * matching base-chain token balance — e.g. after fully shielding an SPL mint,
+ * where Helius `getAssetsByOwner` no longer surfaces it.
+ */
+export declare function enumerateDepositsByUser(args: {
+    user: PublicKey;
+    baseConnection: Connection;
+    ephemeralConnection?: Connection;
+}): Promise<DepositData[]>;

package/dist/src/fee-estimate.d.ts

@@ -0,0 +1,25 @@
+import { type Commitment, type Connection, type PublicKey, type TransactionInstruction } from "@solana/web3.js";
+import type { FeeEstimateCluster, InstructionCostEstimate, ShieldFlowTransactionFeeEstimate } from "./types";
+export type FeeEstimateInstructionPlan = {
+    label: string;
+    ix: TransactionInstruction;
+    rentLamports?: number;
+    nativeLamports?: number;
+};
+export type FeeEstimateTransactionPlan = {
+    label: string;
+    cluster: FeeEstimateCluster;
+    connection: Connection;
+    feePayer: PublicKey;
+    instructions: FeeEstimateInstructionPlan[];
+};
+export declare function estimatePlannedTransactionFees(params: {
+    transactions: FeeEstimateTransactionPlan[];
+    commitment?: Commitment;
+}): Promise<{
+    transactions: ShieldFlowTransactionFeeEstimate[];
+    instructions: InstructionCostEstimate[];
+    totalFeeLamports: number;
+    totalRentLamports: number;
+    totalNativeLamports: number;
+}>;

package/dist/src/idl/telegram_private_transfer.d.ts

@@ -94,6 +94,107 @@ export type TelegramPrivateTransfer = {
                 }
             ];
         },
+        {
+            "name": "closeDeposit";
+            "docs": [
+                "Closes an empty user deposit account and returns its rent to the deposit owner."
+            ];
+            "discriminator": [
+                200,
+                19,
+                254,
+                192,
+                15,
+                110,
+                209,
+                179
+            ];
+            "accounts": [
+                {
+                    "name": "user";
+                    "writable": true;
+                    "signer": true;
+                    "relations": [
+                        "deposit"
+                    ];
+                },
+                {
+                    "name": "deposit";
+                    "writable": true;
+                    "pda": {
+                        "seeds": [
+                            {
+                                "kind": "const";
+                                "value": [
+                                    100,
+                                    101,
+                                    112,
+                                    111,
+                                    115,
+                                    105,
+                                    116,
+                                    95,
+                                    118,
+                                    50
+                                ];
+                            },
+                            {
+                                "kind": "account";
+                                "path": "user";
+                            },
+                            {
+                                "kind": "account";
+                                "path": "tokenMint";
+                            }
+                        ];
+                    };
+                },
+                {
+                    "name": "tokenMint";
+                    "relations": [
+                        "deposit"
+                    ];
+                }
+            ];
+            "args": [];
+        },
+        {
+            "name": "closeUsernameDeposit";
+            "docs": [
+                "Closes an empty username deposit account after verified username ownership."
+            ];
+            "discriminator": [
+                238,
+                181,
+                185,
+                209,
+                149,
+                161,
+                124,
+                79
+            ];
+            "accounts": [
+                {
+                    "name": "authority";
+                    "writable": true;
+                    "signer": true;
+                },
+                {
+                    "name": "deposit";
+                    "writable": true;
+                },
+                {
+                    "name": "tokenMint";
+                    "relations": [
+                        "deposit"
+                    ];
+                },
+                {
+                    "name": "session";
+                }
+            ];
+            "args": [];
+        },
         {
             "name": "createPermission";
             "docs": [
@@ -806,10 +907,20 @@ export type TelegramPrivateTransfer = {
         {
             "name": "modifyBalance";
             "docs": [
-                "Modifies the balance of a user's deposit account by transferring tokens in or out.",
+                "Modifies a user's deposit balance and the backing vault position for the given mint.",
+                "",
+                "For non-USDC mints, this is a direct vault transfer: if `args.increase` is true, `args.amount`",
+                "is transferred from the user's token account to the vault token account and added to",
+                "`deposit.amount`. If false, `args.amount` is transferred from the vault token account back to",
+                "the user's token account and subtracted from `deposit.amount`.",
                 "",
-                "If `args.increase` is true, tokens are transferred from the user's token account to the deposit account.",
-                "If false, tokens are transferred from the deposit account back to the user's token account."
+                "For USDC, liquidity is routed through Kamino Lending instead of being left idle in the vault.",
+                "If `args.increase` is true, `args.amount` USDC is transferred into the vault token account,",
+                "supplied to the configured Kamino reserve, and `deposit.amount` is increased by the Kamino",
+                "reserve collateral shares (kTokens) minted to the vault. If false, `args.amount` is",
+                "interpreted as the Kamino share amount to redeem; the reserve returns the corresponding USDC",
+                "at the current exchange rate, that USDC is transferred from the vault token account to the",
+                "user's token account, and `deposit.amount` is decreased by the burned share amount."
             ];
             "discriminator": [
                 148,
@@ -1646,6 +1757,11 @@ export type TelegramPrivateTransfer = {
             "code": 6013;
             "name": "invalidAmount";
             "msg": "Invalid amount";
+        },
+        {
+            "code": 6014;
+            "name": "nonZeroDeposit";
+            "msg": "Deposit account must have zero amount before it can be closed";
         }
     ];
     "types": [

package/dist/src/instructions/closeDeposit.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { CheckedTransactionInstruction, CloseDepositParams } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+export declare function closeDepositIx(program: Program<TelegramPrivateTransfer>, params: CloseDepositParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/closePermission.d.ts

@@ -0,0 +1,2 @@
+import type { CheckedTransactionInstruction, ClosePermissionParams } from "../types";
+export declare function closePermissionIx(params: ClosePermissionParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/closeUsernameDeposit.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { CheckedTransactionInstruction, CloseUsernameDepositParams } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+export declare function closeUsernameDepositIx(program: Program<TelegramPrivateTransfer>, params: CloseUsernameDepositParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/createPermission.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+import type { CheckedTransactionInstruction, CreatePermissionParams } from "../types";
+export declare function createPermissionIx(program: Program<TelegramPrivateTransfer>, params: CreatePermissionParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/delegateDeposit.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { CheckedTransactionInstruction, DelegateDepositParams } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+export declare function delegateDepositIx(program: Program<TelegramPrivateTransfer>, params: DelegateDepositParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/initializeDeposit.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+import type { CheckedTransactionInstruction, InitializeDepositParams } from "../types";
+export declare function initializeDepositIx(program: Program<TelegramPrivateTransfer>, params: InitializeDepositParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/initializeUsernameDeposit.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { CheckedTransactionInstruction, InitializeUsernameDepositParams } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+export declare function initializeUsernameDepositIx(program: Program<TelegramPrivateTransfer>, params: InitializeUsernameDepositParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/modifyBalance.d.ts

@@ -0,0 +1,4 @@
+import { type Program } from "@coral-xyz/anchor";
+import type { CheckedTransactionInstruction, ModifyBalanceParams } from "../types";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+export declare function modifyBalanceIx(program: Program<TelegramPrivateTransfer>, params: ModifyBalanceParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/undelegateDeposit.d.ts

@@ -0,0 +1,4 @@
+import type { Program } from "@coral-xyz/anchor";
+import type { TelegramPrivateTransfer } from "../idl/telegram_private_transfer";
+import type { CheckedTransactionInstruction, UndelegateDepositParams } from "../types";
+export declare function undelegateDepositIx(perProgram: Program<TelegramPrivateTransfer>, params: UndelegateDepositParams): Promise<CheckedTransactionInstruction>;

package/dist/src/instructions/undelegatePermission.d.ts

@@ -0,0 +1,2 @@
+import type { CheckedTransactionInstruction, UndelegatePermissionParams } from "../types";
+export declare function undelegatePermissionIx(params: UndelegatePermissionParams): Promise<CheckedTransactionInstruction>;

package/dist/src/kamino.d.ts

@@ -2,7 +2,7 @@ import { Connection, PublicKey } from "@solana/web3.js";
 import { type KaminoModifyBalanceAccounts } from "./constants";
 import type { KaminoPositionYieldInfo, KaminoReserveSnapshot } from "./types";
 export declare function parseKaminoReserveSnapshotFromAccountData(args: {
-    data: Buffer;
+    data: Buffer | Uint8Array;
     reserve: PublicKey;
     tokenMint: PublicKey;
 }): KaminoReserveSnapshot;

package/dist/src/rent-estimate.d.ts

@@ -0,0 +1,46 @@
+import type { Connection, PublicKey } from "@solana/web3.js";
+export declare const MAGICBLOCK_UNDELEGATE_SESSION_FEE_LAMPORTS = 300000;
+export declare const DEPOSIT_ACCOUNT_SIZE: number;
+export declare const VAULT_ACCOUNT_SIZE: number;
+export declare const PERMISSION_ACCOUNT_SIZE = 567;
+export declare const DELEGATION_RECORD_ACCOUNT_SIZE: number;
+export type RentAccountEstimate = {
+    address: PublicKey;
+    space: number;
+    forceCreate?: boolean;
+};
+export declare function estimateNewAccountRentLamports(params: {
+    connection: Connection;
+    accounts: RentAccountEstimate[];
+}): Promise<number>;
+export declare function estimateExistingAccountLamports(params: {
+    connection: Connection;
+    accounts: PublicKey[];
+}): Promise<number>;
+export declare function estimateDepositRentLamports(params: {
+    connection: Connection;
+    depositPda: PublicKey;
+    forceCreate?: boolean;
+}): Promise<number>;
+export declare function estimateModifyBalanceRentLamports(params: {
+    connection: Connection;
+    user: PublicKey;
+    tokenMint: PublicKey;
+    isNativeSol: boolean;
+}): Promise<number>;
+export declare function estimatePermissionRentLamports(params: {
+    connection: Connection;
+    permissionPda: PublicKey;
+    forceCreate?: boolean;
+}): Promise<number>;
+export declare function estimateDepositDelegationRentLamports(params: {
+    connection: Connection;
+    user: PublicKey;
+    tokenMint: PublicKey;
+    depositPda: PublicKey;
+    forceCreate?: boolean;
+}): Promise<number>;
+export declare function estimateDepositDelegationRentCreditLamports(params: {
+    connection: Connection;
+    depositPda: PublicKey;
+}): Promise<number>;

package/dist/src/transaction-debug.d.ts

@@ -0,0 +1,40 @@
+import { Connection, Transaction, type Signer } from "@solana/web3.js";
+import type { Provider } from "@coral-xyz/anchor";
+import type { RpcOptions } from "./types";
+export declare function logFailedTransactionDiagnostics(params: {
+    label: string;
+    connection: Connection;
+    tx: Transaction;
+    error: unknown;
+    extraContext?: Record<string, unknown>;
+}): Promise<void>;
+/**
+ * Sign, broadcast, and verify a transaction while keeping the
+ * signature in hand across confirmation hiccups.
+ *
+ * The previous implementation delegated to `provider.sendAndConfirm`,
+ * which in turn called `connection.confirmTransaction({signature,
+ * blockhash, lastValidBlockHeight})`. With Seeker / Seed Vault the
+ * user may spend 5–30s between tapping our preview sheet and
+ * biometric-confirming on device; by the time Anchor starts its
+ * confirmation poll, the RPC node's poll window has often lapsed and
+ * `confirmTransaction` throws `TransactionExpiredBlockheightExceeded`
+ * — even though the tx is on chain and has moved funds. Anchor
+ * re-throws and the signature is lost, so callers surface "Shield
+ * failed" on what was actually a success.
+ *
+ * We handle the send + confirm ourselves:
+ *   1. Stamp blockhash + fee payer, sign via the provider's wallet.
+ *   2. Broadcast via `sendRawTransaction` — we now own the signature.
+ *   3. Poll `getSignatureStatuses` until landed / failed / dropped.
+ * This keeps real failures loud while immunizing callers from the
+ * "on-chain but our poll timed out" race.
+ */
+export declare function sendAndConfirmWithDiagnostics(params: {
+    label: string;
+    provider: Provider;
+    tx: Transaction;
+    signers?: Signer[];
+    rpcOptions?: RpcOptions;
+    extraContext?: Record<string, unknown>;
+}): Promise<string>;