export { O as OnTransactionConfirmed, P as PollingBasedTransactionForwarderConfig, a as PollingBasedTransactionForwarderDeps, b as PollingTransactionForwardOptions, R as RpcBasedAccountInfoProviderConfig, c as RpcBasedBlockhashProviderConfig, d as RpcBasedBlockhashProviderDeps, e as RpcBasedEpochInfoProviderConfig, f as RpcBasedEpochInfoProviderDeps, T as TransactionConfirmedInfo, g as TransactionForwardOptions, W as WebsocketBasedTransactionForwarderConfig, h as WebsocketBasedTransactionForwarderDeps, i as createInMemorySigner, j as createSignerFromKeyPair, k as createSignerFromPrivateKeyBytes, l as createSignerFromWalletAccount, m as getPollingTransactionForwarder, n as getRpcAccountInfoProvider, o as getRpcBlockhashProvider, p as getRpcEpochInfoProvider, q as getWebsocketTransactionForwarder } from '../transaction-forwarder-5mAMTjw6.js';
import { Address } from '@solana/kit';
import { A as AltEntry } from '../networks-RMd3abPE.js';
import '../client-V4AF6Bz9.js';
import '../types-C_V_CaKK.js';
import '../cryptography-BFSJcvi6.js';
import '../types-CxfTIpN9.js';
import '../versions-BRlR36EA.js';
import '../types-D1jDUjfN.js';
import '@wallet-standard/core';

/**
 * Address Lookup Table utilities for transaction compression.
 *
 * Address Lookup Tables (ALTs) are Solana on-chain accounts that store a list of
 * public keys. When building versioned (v0) transactions, ALTs allow instructions
 * to reference accounts by their index in the table rather than including the full
 * 32-byte public key inline. This reduces transaction size and allows a single
 * transaction to reference more accounts than the standard per-transaction limit.
 *
 * This module provides helpers for converting the SDK's internal {@link AltEntry}
 * representation into the record format that `@solana/kit`'s
 * `compressTransactionMessageUsingAddressLookupTables` expects.
 *
 * @remarks
 * ALTs must be pre-loaded on-chain before they can be used in transactions. The
 * Umbra SDK stores pre-baked ALT addresses and their contents in {@link NetworkConfig}
 * so clients do not need to fetch ALT account data at runtime — the addresses are
 * already known at build time.
 *
 * @see {@link AltEntry} for the SDK's internal ALT representation
 * @see {@link buildAltAddressesRecord} for converting an ALT entry to the kit-compatible format
 *
 * @packageDocumentation
 */

/**
 * Converts an {@link AltEntry} into the record format expected by
 * `compressTransactionMessageUsingAddressLookupTables`.
 *
 * The `@solana/kit` function `compressTransactionMessageUsingAddressLookupTables`
 * accepts a `Record<Address, Address[]>` where each key is an ALT account address
 * and each value is the ordered list of addresses stored within that table. This
 * function performs that conversion from the SDK's {@link AltEntry} shape.
 *
 * @remarks
 * The returned record is a shallow copy of the addresses array — mutations to the
 * original {@link AltEntry} after this call will not affect the returned record.
 *
 * When a transaction message is compressed using this record, `@solana/kit` will
 * replace any account references that match entries in the ALT with the
 * corresponding table index, shrinking the serialized transaction size.
 *
 * @param altEntry - The pre-baked ALT entry sourced from {@link NetworkConfig}.
 *   Contains the on-chain ALT address and the ordered list of addresses it holds.
 * @returns A `Record` mapping the ALT account address to the ordered array of
 *   addresses stored in the table. This format is consumed directly by
 *   `compressTransactionMessageUsingAddressLookupTables`.
 *
 * @example
 * ```typescript
 * import { buildAltAddressesRecord } from "./alt-utils";
 * import { compressTransactionMessageUsingAddressLookupTables } from "@solana/kit";
 * import { MAINNET_CONFIG } from "../constants/networks";
 *
 * const altRecord = buildAltAddressesRecord(MAINNET_CONFIG.alt);
 *
 * const compressedMessage = compressTransactionMessageUsingAddressLookupTables(
 *   transactionMessage,
 *   altRecord,
 * );
 * ```
 *
 * @example
 * Combining multiple ALT entries into one record:
 * ```typescript
 * import { buildAltAddressesRecord } from "./alt-utils";
 *
 * const combinedAltRecord = {
 *   ...buildAltAddressesRecord(MAINNET_CONFIG.umbraAlt),
 *   ...buildAltAddressesRecord(MAINNET_CONFIG.arciumAlt),
 * };
 * ```
 *
 * @see {@link AltEntry} for the input type definition
 * @public
 */
declare function buildAltAddressesRecord(altEntry: AltEntry): Record<Address, Address[]>;
/**
 * Looks up an ALT entry from the nested address lookup tables structure.
 *
 * The lookup tables are keyed by cluster offset (number), then by instruction
 * name (string). Returns `undefined` if no ALT exists for the given cluster
 * offset or instruction name.
 *
 * @param addressLookupTables - The nested ALT structure from {@link NetworkConfig}.
 * @param clusterOffset - The Arcium cluster offset (fetched from the on-chain MXE account).
 * @param instructionName - The snake_case instruction name.
 * @returns The matching {@link AltEntry}, or `undefined` if not found.
 *
 * @public
 */
declare function lookupAltEntry(addressLookupTables: Readonly<Record<number, Readonly<Record<string, AltEntry>>>>, clusterOffset: number, instructionName: string): AltEntry | undefined;

export { buildAltAddressesRecord, lookupAltEntry };
