@rialo/ts-cdk 0.1.2 → 0.1.4

package/dist/index.d.mts

@@ -135,6 +135,89 @@ declare class RialoError extends Error {
     static serialization(message: string): RialoError;
 }
 
+interface HttpTransportConfig {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Base delay for exponential backoff (ms) */
+    retryBaseDelay?: number;
+    /** Maximum retry delay (ms) */
+    retryMaxDelay?: number;
+    /** Custom headers to include in requests */
+    headers?: Record<string, string>;
+}
+/**
+ * HTTP transport with built-in retry logic and timeout handling.
+ *
+ * Features:
+ * - Automatic retries with exponential backoff
+ * - Request timeouts using AbortController
+ * - Network error recovery
+ * - Rate limit handling
+ * - Proper HTTP status code handling
+ */
+declare class HttpTransport {
+    private readonly url;
+    private readonly config;
+    constructor(url: string, config?: HttpTransportConfig);
+    /**
+     * Makes an HTTP request with automatic retry logic.
+     *
+     * Retries are attempted for network errors and server errors (5xx).
+     * Uses exponential backoff between retry attempts.
+     */
+    request(body: string, requestDetails?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Make a single HTTP request with timeout
+     */
+    private makeRequest;
+    /**
+     * Handle HTTP error responses.
+     *
+     * Parses the response body to extract JSON-RPC error details when available,
+     * regardless of HTTP status code. Falls back to HTTP status-based error handling.
+     */
+    private handleHttpError;
+    /**
+     * Parse error response body to extract message and RPC error code.
+     *
+     * Handles multiple formats:
+     * - JSON-RPC error: { error: { code, message, data? } }
+     * - Simple JSON: { message: "..." }
+     * - Non-JSON responses
+     */
+    private parseErrorResponse;
+    /**
+     * Returns the configured RPC endpoint URL.
+     */
+    getUrl(): string;
+}
+
+type IdentifierString = `${string}:${string}`;
+type RialoNetwork = "mainnet" | "devnet" | "testnet" | "localnet";
+interface ChainDefinition {
+    /** * The Wallet Standard Chain Identifier.
+     * e.g., 'rialo:mainnet', 'rialo:devnet'
+     */
+    id: IdentifierString;
+    /** Human-readable name for UI */
+    name: string;
+    /** The default RPC URL for this chain */
+    rpcUrl: string;
+}
+/**
+ * Configuration for the Rialo Client.
+ */
+interface RialoClientConfig {
+    /**
+     * The Chain Definition.
+     * Can be a preset (RIALO_MAINNET) or a custom object.
+     */
+    chain: ChainDefinition;
+    transport?: HttpTransportConfig;
+}
+
 /** Default number of accounts to derive in HD wallets */
 declare const DEFAULT_NUM_ACCOUNTS: number;
 /** Rialo mainnet RPC URL */
@@ -145,6 +228,10 @@ declare const URL_TESTNET: string;
 declare const URL_DEVNET: string;
 /** Rialo localnet RPC URL */
 declare const URL_LOCALNET: string;
+declare const RIALO_MAINNET_CHAIN: ChainDefinition;
+declare const RIALO_TESTNET_CHAIN: ChainDefinition;
+declare const RIALO_DEVNET_CHAIN: ChainDefinition;
+declare const RIALO_LOCALNET_CHAIN: ChainDefinition;
 /** System program ID */
 declare const SYSTEM_PROGRAM_ID: string;
 /** Base derivation path for Rialo wallets (BIP44 coin type 756) */
@@ -154,56 +241,6 @@ declare const KELVIN_PER_RLO: number;
 declare const PUBLIC_KEY_LENGTH: number;
 declare const SECRET_KEY_LENGTH: number;
 declare const SIGNATURE_LENGTH: number;
-declare const BLOCKHASH_LENGTH: number;
-
-/**
- * Represents a 32-byte blockhash used for transaction replay protection.
- *
- * @example
- * ```typescript
- * // From RPC response
- * const blockhash = Blockhash.fromString(rpcBlockhash);
- *
- * // Comparison
- * if (blockhash1.equals(blockhash2)) {
- *   console.log("Same blockhash");
- * }
- * ```
- */
-declare class Blockhash {
-    private readonly bytes;
-    private constructor();
-    /**
-     * Creates a Blockhash from raw bytes.
-     *
-     * @param bytes - 32-byte blockhash
-     * @throws {CryptoError} If bytes length is not 32
-     */
-    static fromBytes(bytes: Uint8Array): Blockhash;
-    /**
-     * Creates a Blockhash from a base58-encoded string.
-     *
-     * @param str - Base58-encoded blockhash
-     * @throws {CryptoError} If string is invalid or decodes to wrong length
-     */
-    static fromString(str: string): Blockhash;
-    /**
-     * Returns a copy of the raw bytes.
-     */
-    toBytes(): Uint8Array;
-    /**
-     * Returns the base58-encoded string representation.
-     */
-    toString(): string;
-    /**
-     * Checks equality with another blockhash using constant-time comparison.
-     */
-    equals(other: Blockhash): boolean;
-    /**
-     * JSON serialization (returns base58 string).
-     */
-    toJSON(): string;
-}
 
 /**
  * Error codes for cryptographic operations.
@@ -793,7 +830,6 @@ declare enum SystemInstruction {
  *
  * const tx = TransactionBuilder.create()
  *   .setPayer(fromPubkey)
- *   .setRecentBlockhash(blockhash)
  *   .addInstruction(instruction)
  *   .build();
  * ```
@@ -810,87 +846,440 @@ declare function transferInstruction(from: PublicKey, to: PublicKey, amount: big
  */
 declare function createAccount(from: PublicKey, newAccount: PublicKey, lamports: bigint, space: bigint, owner: PublicKey): Instruction;
 
-interface HttpTransportConfig {
-    /** Request timeout in milliseconds */
-    timeout?: number;
-    /** Maximum number of retry attempts */
-    maxRetries?: number;
-    /** Base delay for exponential backoff (ms) */
-    retryBaseDelay?: number;
-    /** Maximum retry delay (ms) */
-    retryMaxDelay?: number;
-    /** Custom headers to include in requests */
-    headers?: Record<string, string>;
-}
 /**
- * HTTP transport with built-in retry logic and timeout handling.
+ * An unsigned transaction message ready to be signed.
  *
- * Features:
- * - Automatic retries with exponential backoff
- * - Request timeouts using AbortController
- * - Network error recovery
- * - Rate limit handling
- * - Proper HTTP status code handling
+ * This is the data that gets signed by transaction signers.
+ * It's immutable to prevent accidental modification after creation.
+ *
+ * @example
+ * ```typescript
+ * const message = MessageBuilder.create()
+ *   .setPayer(payer)
+ *   .setValidFrom(validFrom)
+ *   .addInstruction(transferInstruction)
+ *   .build();
+ *
+ * // Serialize for signing
+ * const messageBytes = message.serialize();
+ * ```
  */
-declare class HttpTransport {
-    private readonly url;
-    private readonly config;
-    constructor(url: string, config?: HttpTransportConfig);
+declare class Message {
+    /** Message header with signature requirements */
+    readonly header: MessageHeader;
+    /** All account public keys referenced in the transaction */
+    readonly accountKeys: readonly PublicKey[];
+    /** Transaction valid from (milliseconds since Unix epoch) */
+    validFrom?: bigint;
+    /** Compiled instructions with account indices */
+    readonly instructions: readonly CompiledInstruction[];
+    /** Cached serialized bytes */
+    private serializedCache?;
+    constructor(header: MessageHeader, accountKeys: readonly PublicKey[], validFrom: bigint, instructions: readonly CompiledInstruction[]);
     /**
-     * Makes an HTTP request with automatic retry logic.
+     * Serialize message to bytes for signing.
+     * Result is cached for performance.
+     */
+    serialize(): Uint8Array;
+    /**
+     * Deserialize a message from wire format.
      *
-     * Retries are attempted for network errors and server errors (5xx).
-     * Uses exponential backoff between retry attempts.
+     * @param data - Serialized message bytes
+     * @returns Deserialized Message
      */
-    request(body: string, requestDetails?: Record<string, unknown>): Promise<unknown>;
+    static deserialize(data: Uint8Array): Message;
+    private serializeInternal;
+    private serializeCompactArray;
+    private serializeCompactU16;
     /**
-     * Make a single HTTP request with timeout
+     * Get all signers required for this message.
      */
-    private makeRequest;
+    getSigners(): readonly PublicKey[];
     /**
-     * Handle HTTP error responses
+     * Check if a public key is a required signer.
      */
-    private handleHttpError;
+    isSignerRequired(pubkey: PublicKey): boolean;
     /**
-     * Returns the configured RPC endpoint URL.
+     * Get the index of a signer in the signers array.
+     * Returns -1 if not a signer.
      */
-    getUrl(): string;
+    getSignerIndex(pubkey: PublicKey): number;
 }
 
 /**
- * Base client with JSON-RPC protocol handling.
+ * Interface for signing messages and transactions.
  *
- * All specific clients (QueryClient, TransactionClient) extend this.
+ * Enables multiple signing strategies:
+ * - **KeypairSigner**: Local keypair signing
+ * - **Browser Wallet**: Browser extension integration
+ * - **Hardware Wallet**: Ledger, Trezor, etc.
+ * - **Remote Signer**: API-based signing services
+ *
+ * @example
+ * ```typescript
+ * // Browser wallet implementation
+ * class BrowserWalletSigner implements Signer {
+ *   async getPublicKey(): Promise<PublicKey> {
+ *     const pubkey = await window.rialoWallet.getPublicKey();
+ *     return PublicKey.fromString(pubkey);
+ *   }
+ *
+ *   async signMessage(message: Uint8Array): Promise<Signature> {
+ *     const sig = await window.rialoWallet.signMessage(message);
+ *     return Signature.fromBytes(sig);
+ *   }
+ * }
+ *
+ * // Usage
+ * const signer = new BrowserWalletSigner();
+ * const publicKey = await signer.getPublicKey();
+ * const signature = await signer.signMessage(message);
+ * ```
  */
-declare class BaseRpcClient {
-    protected readonly transport: HttpTransport;
-    private requestId;
-    constructor(transport: HttpTransport);
+interface Signer {
     /**
-     * Makes a JSON-RPC 2.0 method call with type safety.
+     * Retrieves the signer's public key.
      *
-     * Handles request serialization, response validation, and error mapping.
-     */
-    protected call<T>(method: string, params?: unknown[]): Promise<T>;
-    /**
-     * Validate JSON-RPC response structure
+     * **Note**: May trigger wallet connection prompts for browser wallets.
      */
-    private isValidJsonRpcResponse;
+    getPublicKey(): Promise<PublicKey>;
     /**
-     * Returns the configured RPC endpoint URL.
+     * Signs arbitrary message bytes.
+     *
+     * @param message - Message bytes to sign
+     * @returns Ed25519 signature over the message
      */
-    getUrl(): string;
+    signMessage(message: Uint8Array): Promise<Signature>;
 }
 
 /**
- * RPC type definitions for the Rialo blockchain.
+ * Signer implementation using a local Ed25519 keypair.
+ *
+ * Provides synchronous signing without external dependencies.
+ * Suitable for server-side applications, CLIs, and testing.
+ *
+ * @example
+ * ```typescript
+ * import { Keypair, KeypairSigner } from '@rialo/ts-cdk';
+ *
+ * // Generate new keypair
+ * const keypair = Keypair.generate();
+ * const signer = new KeypairSigner(keypair);
+ *
+ * // Or from mnemonic
+ * const mnemonic = Mnemonic.generate();
+ * const keypair = await mnemonic.toKeypair(0);
+ * const signer = new KeypairSigner(keypair);
+ *
+ * // Sign messages
+ * const publicKey = await signer.getPublicKey();
+ * const signature = await signer.signMessage(message);
+ * ```
  */
+declare class KeypairSigner implements Signer {
+    private readonly keypair;
+    constructor(keypair: Keypair);
+    /**
+     * Returns the keypair's public key.
+     */
+    getPublicKey(): Promise<PublicKey>;
+    /**
+     * Signs a message using the keypair's private key.
+     */
+    signMessage(message: Uint8Array): Promise<Signature>;
+}
 
 /**
- * Account information response.
- */
-interface AccountInfo {
-    /** Account balance in smallest denomination */
+ * A transaction with zero or more signatures.
+ *
+ * Transactions are immutable - signing methods return new instances.
+ * This prevents accidental modification and signature tampering.
+ *
+ * @example
+ * ```typescript
+ * // Simple signing
+ * const tx = builder.build();
+ * const signed = tx.sign(keypair);
+ *
+ * // Method chaining
+ * const signed = tx
+ *   .sign(keypair1)
+ *   .sign(keypair2)
+ *   .sign(keypair3);
+ *
+ * // Multi-sig convenience
+ * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+ * ```
+ */
+declare class Transaction {
+    /** The unsigned message */
+    private readonly message;
+    /** Signatures (64 bytes each), aligned with message.header.numRequiredSignatures */
+    private readonly signatures;
+    private constructor();
+    /**
+     * Create an unsigned transaction from a message.
+     * All signature slots are initialized to zero.
+     *
+     * @internal - Users should use TransactionBuilder instead
+     */
+    static fromMessage(message: Message): Transaction;
+    /**
+     * Create transaction from message and existing signatures.
+     * @internal
+     */
+    static fromMessageAndSignatures(message: Message, signatures: readonly Uint8Array[]): Transaction;
+    /**
+     * Deserialize a transaction from wire format.
+     */
+    static deserialize(data: Uint8Array): Transaction;
+    getMessage(): Message;
+    /**
+     * Sign the transaction with a keypair.
+     * Returns a NEW Transaction instance.
+     *
+     * @param keypair - Keypair to sign with
+     * @returns New Transaction instance with signature added
+     *
+     * @example
+     * ```typescript
+     * const signedTx = tx.sign(keypair);
+     * await client.sendTransaction(signedTx.serialize());
+     * ```
+     */
+    sign(keypair: Keypair): Transaction;
+    /**
+     * Sign with multiple keypairs at once.
+     * Returns a NEW Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+     * ```
+     */
+    signAll(keypairs: Keypair[]): Transaction;
+    /**
+     * Sign the transaction with a Signer interface (async).
+     * Returns a NEW Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = await tx.signWith(browserWallet);
+     * ```
+     */
+    signWith(signer: Signer): Promise<Transaction>;
+    /**
+     * Sign with multiple signers.
+     * Returns a NEW Transaction instance.
+     */
+    signAllWith(signers: Signer[]): Promise<Transaction>;
+    /**
+     * Partially sign the transaction (for multi-sig transactions).
+     * Returns a NEW Transaction instance.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = tx
+     *   .partialSign(signer1)
+     *   .partialSign(signer2);
+     * ```
+     */
+    partialSign(keypair: Keypair): Transaction;
+    /**
+     * Partially sign with a Signer interface (async).
+     * Returns a NEW Transaction instance.
+     */
+    partialSignWith(signer: Signer): Promise<Transaction>;
+    /**
+     * Add a signature at a specific index.
+     * Returns a NEW Transaction instance.
+     *
+     * Most users should use sign() or signAll() instead.
+     */
+    addSignature(index: number, signature: Signature | Uint8Array): Transaction;
+    /**
+     * Add a signature for a specific public key.
+     * Returns a NEW Transaction instance.
+     *
+     * Most users should use sign() or signAll() instead.
+     */
+    addSignatureForPubkey(pubkey: PublicKey, signature: Signature | Uint8Array): Transaction;
+    /**
+     * Check if transaction is fully signed (all signatures present).
+     */
+    isSigned(): boolean;
+    /**
+     * Check if a specific signature slot is filled.
+     */
+    isSignaturePresent(index: number): boolean;
+    /**
+     * Get all signatures (returns copies to prevent mutation).
+     */
+    getSignatures(): readonly Uint8Array[];
+    /**
+     * Get a specific signature (returns copy).
+     */
+    getSignature(index: number): Uint8Array;
+    /**
+     * Get a specific signature for a public key.
+     */
+    getSignatureForPubkey(pubkey: PublicKey): Uint8Array;
+    /**
+     * Get required signers for this transaction.
+     */
+    getSigners(): readonly PublicKey[];
+    /**
+     * Get the number of required signatures.
+     */
+    getRequiredSignatureCount(): number;
+    /**
+     * Throw an error if the transaction is not fully signed.
+     *
+     * @throws {TransactionError} If transaction is not fully signed
+     *
+     * @example
+     * ```typescript
+     * signedTx.ensureSigned(); // Throws if not signed
+     * await client.sendTransaction(signedTx.serialize());
+     * ```
+     */
+    ensureSigned(): void;
+    /**
+     * Serialize transaction to wire format.
+     */
+    serialize(): Uint8Array;
+}
+
+/**
+ * Fluent API for building transactions.
+ * Returns Transaction directly (not Message).
+ */
+
+/**
+ * Builder for creating transactions with a fluent API.
+ *
+ * Provides an intuitive interface for constructing transactions.
+ * Call build() to get an unsigned Transaction ready for signing.
+ *
+ * @example
+ * ```typescript
+ * // Simple transfer
+ * const tx = TransactionBuilder.create()
+ *   .setPayer(payer)
+ *   .setValidFrom(validFrom)
+ *   .addInstruction(transfer(from, to, 1_000_000n))
+ *   .build();
+ *
+ * const signedTx = tx.sign(keypair);
+ * await client.transaction.sendTransaction(signedTx.serialize());
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multi-instruction transaction
+ * const tx = TransactionBuilder.create()
+ *   .setPayer(payer)
+ *   .setValidFrom(validFrom)
+ *   .addInstruction(transfer(from, to, 1_000_000n))
+ *   .addInstruction(memoInstruction("Payment for invoice #123"))
+ *   .build();
+ * ```
+ */
+declare class TransactionBuilder {
+    private payer?;
+    private validFrom?;
+    private readonly instructions;
+    private constructor();
+    /**
+     * Create a new transaction builder.
+     */
+    static create(): TransactionBuilder;
+    /**
+     * Set the fee payer for this transaction.
+     *
+     * The payer will be the first account and must sign the transaction.
+     * The payer pays for transaction fees.
+     *
+     * @param payer - Public key of the fee payer
+     */
+    setPayer(payer: PublicKey): this;
+    /**
+     * Set the Transaction valid from.
+     *
+     * This is the time the transaction is valid from, in milliseconds since Unix epoch.
+     * It can be used for additional replay protection or auditing.
+     *
+     * @param validFrom - Transaction valid from in milliseconds since Unix epoch
+     */
+    setValidFrom(validFrom: bigint): this;
+    /**
+     * Add an instruction to the transaction.
+     *
+     * @param instruction - Instruction to add
+     */
+    addInstruction(instruction: Instruction): this;
+    /**
+     * Add multiple instructions at once.
+     *
+     * @param instructions - Array of instructions to add
+     */
+    addInstructions(instructions: readonly Instruction[]): this;
+    /**
+     * Build the transaction (unsigned).
+     *
+     * Returns an unsigned Transaction that's ready to be signed.
+     *
+     * @returns Unsigned Transaction
+     * @throws {TransactionError} If payer, valid_from, or instructions are missing
+     *
+     * @example
+     * ```typescript
+     * const tx = builder.build();
+     * const signedTx = tx.sign(keypair);
+     * ```
+     */
+    build(): Transaction;
+}
+
+/**
+ * Base client with JSON-RPC protocol handling.
+ *
+ * All specific clients (QueryClient, TransactionClient) extend this.
+ */
+declare class BaseRpcClient {
+    protected readonly transport: HttpTransport;
+    private requestId;
+    constructor(transport: HttpTransport);
+    /**
+     * Makes a JSON-RPC 2.0 method call with type safety.
+     *
+     * Handles request serialization, response validation, and error mapping.
+     */
+    protected call<T>(method: string, params?: unknown[]): Promise<T>;
+    /**
+     * Validate JSON-RPC response structure
+     */
+    private isValidJsonRpcResponse;
+    /**
+     * Generates the next request ID with Overflow Protection.
+     * @returns The next request ID.
+     */
+    private nextRequestId;
+    /**
+     * Returns the configured RPC endpoint URL.
+     */
+    getUrl(): string;
+}
+
+/**
+ * RPC type definitions for the Rialo blockchain.
+ */
+
+/**
+ * Account information response.
+ */
+interface AccountInfo {
+    /** Account balance in smallest denomination */
     balance: bigint;
     /** Owner program public key */
     owner: PublicKey;
@@ -907,21 +1296,8 @@ interface AccountInfo {
 interface TransactionResponse {
     /** Transaction signature */
     signature: string;
-    /** Slot in which the transaction was processed */
-    slot: bigint;
-    /** Block time (Unix timestamp) */
-    blockTime?: bigint;
-    /** Error message if transaction failed */
-    err?: string;
-}
-/**
- * Signature status.
- */
-interface SignatureStatus {
-    /** Slot in which the transaction was processed */
-    slot: bigint;
-    /** Number of confirmations */
-    confirmations?: number;
+    /** Block height */
+    blockHeight?: bigint;
     /** Error message if transaction failed */
     err?: string;
 }
@@ -1060,673 +1436,574 @@ interface GetTransactionsResponse {
     /** Array of transaction data */
     transactions: Array<Record<string, unknown>>;
 }
-
 /**
- * Main Rialo RPC client for blockchain interactions.
+ * Signature status from the RPC.
  */
-
-/**
- * High-level Rialo RPC client for blockchain interactions.
- *
- * Provides a unified interface for querying blockchain state and
- * sending transactions. Internally delegates to specialized clients
- * (QueryRpcClient, TransactionRpcClient) for modular organization.
- *
- * @example
- * ```typescript
- * const client = createRialoClient(URL_DEVNET);
- *
- * // Query operations
- * const balance = await client.getBalance(publicKey);
- * const blockhash = await client.getLatestBlockhash();
- *
- * // Transaction operations
- * const signature = await client.sendTransaction(signedTx);
- * ```
- */
-declare class RialoClient {
-    private readonly queryClient;
-    private readonly transactionClient;
-    private readonly transport;
-    constructor(transport: HttpTransport);
-    /**
-     * Returns the configured RPC endpoint URL.
-     */
-    getUrl(): string;
-    /**
-     * Retrieves the latest blockhash from the blockchain.
-     *
-     * Required for transaction creation and replay protection.
-     */
-    getLatestBlockhash(): Promise<Blockhash>;
-    /**
-     * Retrieves the balance of an account in kelvins (smallest unit).
-     */
-    getBalance(pubkey: PublicKey): Promise<bigint>;
-    /**
-     * Retrieves detailed information about an account.
-     *
-     * @returns Account info or null if account doesn't exist
-     */
-    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
-    /**
-     * Retrieves the current block height.
-     */
-    getBlockHeight(): Promise<bigint>;
-    /**
-     * Retrieves detailed information about a transaction.
-     *
-     * @returns Transaction info or null if transaction not found
-     */
-    getTransaction(signature: string): Promise<TransactionResponse | null>;
-    /**
-     * Retrieves the total number of transactions processed since genesis.
-     */
-    getTransactionCount(): Promise<bigint>;
-    /**
-     * Retrieves the status of multiple transaction signatures.
-     */
-    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
-    /**
-     * Retrieves current epoch information.
-     */
-    getEpochInfo(): Promise<EpochInfoResponse>;
-    /**
-     * Checks the health status of the RPC node.
-     *
-     * @returns "ok" if healthy, error message otherwise
-     */
-    getHealth(): Promise<"ok" | string>;
-    /**
-     * Submits a signed transaction to the blockchain.
-     *
-     * @param transaction - Serialized signed transaction bytes
-     * @param options - Transaction submission options
-     * @returns Transaction signature
-     */
-    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
-    /**
-     * Requests an airdrop of tokens to an account.
-     *
-     * **Note**: Only available on devnet and testnet.
-     *
-     * @param pubkey - Account to receive the airdrop
-     * @param amount - Amount in kelvins (smallest unit)
-     * @returns Transaction signature
-     */
-    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
-}
-
-/**
- * Query client for read-only RPC operations.
- */
-
-/**
- * Client for querying blockchain state.
- *
- * Handles all read-only operations like getting balances, account info, etc.
- */
-declare class QueryRpcClient extends BaseRpcClient {
-    /**
-     * Get the latest blockhash from the blockchain
-     */
-    getLatestBlockhash(): Promise<Blockhash>;
-    /**
-     * Get the balance of an account
-     */
-    getBalance(pubkey: PublicKey): Promise<bigint>;
-    /**
-     * Get detailed information about an account
-     */
-    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
-    /**
-     * Get the current block height
-     */
-    getBlockHeight(): Promise<bigint>;
-    /**
-     * Get detailed information about a transaction
-     */
-    getTransaction(signature: string): Promise<TransactionResponse | null>;
-    /**
-     * Get the total number of transactions processed since genesis
-     */
-    getTransactionCount(): Promise<bigint>;
-    /**
-     * Get the status of multiple transaction signatures
-     */
-    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
-    /**
-     * Get epoch information
-     */
-    getEpochInfo(): Promise<EpochInfoResponse>;
-    /**
-     * Get the health status of the node
-     */
-    getHealth(): Promise<"ok" | string>;
-}
-
-/**
- * Query client for read-only RPC operations.
- */
-
-/**
- * Client for sending/simulating transactions and requesting airdrops.
- *
- * Handles all transaction operations like sending transactions, requesting airdrops, etc.
- */
-declare class TransactionRpcClient extends BaseRpcClient {
-    /**
-     * Submit a signed transaction to the blockchain
-     */
-    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
-    /**
-     * Request an airdrop of tokens to an account (devnet/testnet only)
-     */
-    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
+interface SignatureStatus {
+    /** Slot in which the transaction was processed */
+    slot: bigint;
+    /** Whether the transaction has been executed */
+    executed: boolean;
+    /** Error message if transaction failed */
+    err?: string;
 }
-
 /**
- * Error codes for RPC operations, categorized by type.
+ * Options for confirming a transaction.
  */
-declare enum RpcErrorCode {
-    REQUEST_TIMEOUT = "REQUEST_TIMEOUT",
-    NETWORK_ERROR = "NETWORK_ERROR",
-    CONNECTION_REFUSED = "CONNECTION_REFUSED",
-    INVALID_RESPONSE = "INVALID_RESPONSE",
-    PARSE_ERROR = "PARSE_ERROR",
-    INVALID_REQUEST = "INVALID_REQUEST",
-    METHOD_NOT_FOUND = "METHOD_NOT_FOUND",
-    INVALID_PARAMS = "INVALID_PARAMS",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    TRANSACTION_REJECTED = "TRANSACTION_REJECTED",
-    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
-    ACCOUNT_NOT_FOUND = "ACCOUNT_NOT_FOUND",
-    BLOCKHASH_NOT_FOUND = "BLOCKHASH_NOT_FOUND",
-    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
-    NODE_UNHEALTHY = "NODE_UNHEALTHY"
+interface ConfirmTransactionOptions {
+    /** Maximum number of retry attempts (default: 30) */
+    maxRetries?: number;
+    /** Delay between retries in milliseconds (default: 1000) */
+    retryDelay?: number;
 }
 /**
- * Detailed error context for debugging and error handling.
+ * Options for sending and confirming a transaction.
  */
-interface RpcErrorDetails {
-    method?: string;
-    params?: unknown;
-    requestId?: number;
-    url?: string;
-    httpStatus?: number;
-    rpcCode?: number;
-    timeout?: number;
-    attempts?: number;
-    [key: string]: unknown;
+interface SendAndConfirmOptions extends SendTransactionOptions, ConfirmTransactionOptions {
 }
 /**
- * Error class for RPC operations with structured error information.
- *
- * Provides actionable error messages and indicates whether errors are retryable.
+ * Result of a confirmed transaction.
  */
-declare class RpcError extends Error {
-    readonly code: RpcErrorCode;
-    readonly details: RpcErrorDetails;
-    readonly retryable: boolean;
-    constructor(code: RpcErrorCode, message: string, details?: RpcErrorDetails, retryable?: boolean);
-    static requestTimeout(timeoutMs: number, details: RpcErrorDetails): RpcError;
-    static networkError(message: string, details: RpcErrorDetails): RpcError;
-    static invalidResponse(details: RpcErrorDetails): RpcError;
-    static accountNotFound(pubkey: string): RpcError;
-    static rateLimitExceeded(details: RpcErrorDetails): RpcError;
-    static fromRpcCode(rpcCode: number, message: string, details: RpcErrorDetails): RpcError;
-    toJSON(): {
-        code: RpcErrorCode;
-        message: string;
-        details?: Record<string, unknown>;
-        retryable: boolean;
-    };
+interface ConfirmedTransaction {
+    /** Transaction signature */
+    signature: string;
+    /** Whether the transaction was executed */
+    executed: boolean;
+    /** Error message if transaction failed */
+    err?: string;
 }
 
 /**
- * RPC client module for communicating with Rialo blockchain nodes.
+ * Main Rialo RPC client for blockchain interactions.
+ */
+
+/**
+ * High-level Rialo RPC client for blockchain interactions.
  *
- * Provides a high-level client interface with automatic retry logic,
- * connection management, and type-safe RPC methods.
+ * Provides a unified interface for querying blockchain state and
+ * sending transactions. Internally delegates to specialized clients
+ * (QueryRpcClient, TransactionRpcClient) for modular organization.
  *
  * @example
  * ```typescript
- * import { createRialoClient, URL_DEVNET } from '@rialo/ts-cdk';
+ * import { createRialoClient, RIALO_DEVNET_CHAIN } from '@rialo/ts-cdk';
  *
- * // Create client with custom configuration
- * const client = createRialoClient(URL_DEVNET, {
- *   timeout: 30000,
- *   maxRetries: 3,
- * });
+ * const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });
  *
- * // Query blockchain state
+ * // Query operations
  * const balance = await client.getBalance(publicKey);
- * const blockHeight = await client.getBlockHeight();
+ * const chainId = client.getChainIdentifier();
  *
- * // Send transactions
+ * // Transaction operations
  * const signature = await client.sendTransaction(signedTx);
  * ```
  */
-
-/**
- * Creates an RPC client with automatic retry and timeout handling.
- *
- * @param url - RPC endpoint URL (e.g., URL_DEVNET, URL_MAINNET)
- * @param config - Transport configuration (timeout, retries, headers)
- * @returns Configured RialoClient instance
- */
-declare function createRialoClient(url: string, config?: HttpTransportConfig): RialoClient;
-
-/**
- * An unsigned transaction message ready to be signed.
- *
- * This is the data that gets signed by transaction signers.
- * It's immutable to prevent accidental modification after creation.
- *
- * @example
- * ```typescript
- * const message = MessageBuilder.create()
- *   .setPayer(payer)
- *   .setRecentBlockhash(blockhash)
- *   .setCreationTime(txCreationTime)
- *   .addInstruction(transferInstruction)
- *   .build();
- *
- * // Serialize for signing
- * const messageBytes = message.serialize();
- * ```
- */
-declare class Message {
-    /** Message header with signature requirements */
-    readonly header: MessageHeader;
-    /** All account public keys referenced in the transaction */
-    readonly accountKeys: readonly PublicKey[];
-    /** Recent blockhash for replay protection */
-    readonly recentBlockhash: Blockhash;
-    /** Transaction creation timestamp (milliseconds since Unix epoch) */
-    txCreationTime?: bigint;
-    /** Compiled instructions with account indices */
-    readonly instructions: readonly CompiledInstruction[];
-    /** Cached serialized bytes */
-    private serializedCache?;
-    constructor(header: MessageHeader, accountKeys: readonly PublicKey[], recentBlockhash: Blockhash, txCreationTime: bigint, instructions: readonly CompiledInstruction[]);
+declare class RialoClient {
+    private readonly queryClient;
+    private readonly transactionClient;
+    private readonly transport;
+    private readonly chain;
+    constructor(transport: HttpTransport, chain: ChainDefinition);
     /**
-     * Serialize message to bytes for signing.
-     * Result is cached for performance.
+     * Returns the configured RPC endpoint URL.
      */
-    serialize(): Uint8Array;
+    getUrl(): string;
     /**
-     * Deserialize a message from wire format.
+     * Returns the chain identifier.
+     */
+    getChainIdentifier(): IdentifierString;
+    /**
+     * Returns the chain configuration.
+     */
+    getChainConfig(): ChainDefinition;
+    /**
+     * Retrieves the balance of an account in kelvins (smallest unit).
+     */
+    getBalance(pubkey: PublicKey): Promise<bigint>;
+    /**
+     * Retrieves detailed information about an account.
      *
-     * @param data - Serialized message bytes
-     * @returns Deserialized Message
+     * @returns Account info or null if account doesn't exist
      */
-    static deserialize(data: Uint8Array): Message;
-    private serializeInternal;
-    private serializeCompactArray;
-    private serializeCompactU16;
+    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
     /**
-     * Get all signers required for this message.
+     * Retrieves the current block height.
      */
-    getSigners(): readonly PublicKey[];
+    getBlockHeight(): Promise<bigint>;
     /**
-     * Check if a public key is a required signer.
+     * Retrieves detailed information about a transaction.
+     *
+     * @returns Transaction info or null if transaction not found
      */
-    isSignerRequired(pubkey: PublicKey): boolean;
+    getTransaction(signature: string): Promise<TransactionResponse | null>;
     /**
-     * Get the index of a signer in the signers array.
-     * Returns -1 if not a signer.
+     * Retrieves the total number of transactions processed since genesis.
      */
-    getSignerIndex(pubkey: PublicKey): number;
-}
-
-/**
- * Interface for signing messages and transactions.
- *
- * Enables multiple signing strategies:
- * - **KeypairSigner**: Local keypair signing
- * - **Browser Wallet**: Browser extension integration
- * - **Hardware Wallet**: Ledger, Trezor, etc.
- * - **Remote Signer**: API-based signing services
- *
- * @example
- * ```typescript
- * // Browser wallet implementation
- * class BrowserWalletSigner implements Signer {
- *   async getPublicKey(): Promise<PublicKey> {
- *     const pubkey = await window.rialoWallet.getPublicKey();
- *     return PublicKey.fromString(pubkey);
- *   }
- *
- *   async signMessage(message: Uint8Array): Promise<Signature> {
- *     const sig = await window.rialoWallet.signMessage(message);
- *     return Signature.fromBytes(sig);
- *   }
- * }
- *
- * // Usage
- * const signer = new BrowserWalletSigner();
- * const publicKey = await signer.getPublicKey();
- * const signature = await signer.signMessage(message);
- * ```
- */
-interface Signer {
+    getTransactionCount(): Promise<bigint>;
     /**
-     * Retrieves the signer's public key.
+     * Retrieves the status of multiple transaction signatures.
+     */
+    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
+    /**
+     * Retrieves current epoch information.
+     */
+    getEpochInfo(): Promise<EpochInfoResponse>;
+    /**
+     * Checks the health status of the RPC node.
      *
-     * **Note**: May trigger wallet connection prompts for browser wallets.
+     * @returns "ok" if healthy, error message otherwise
      */
-    getPublicKey(): Promise<PublicKey>;
+    getHealth(): Promise<"ok" | string>;
     /**
-     * Signs arbitrary message bytes.
+     * Submits a signed transaction to the blockchain.
      *
-     * @param message - Message bytes to sign
-     * @returns Ed25519 signature over the message
+     * @param transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission options
+     * @returns Transaction signature
      */
-    signMessage(message: Uint8Array): Promise<Signature>;
-}
-
-/**
- * Signer implementation using a local Ed25519 keypair.
- *
- * Provides synchronous signing without external dependencies.
- * Suitable for server-side applications, CLIs, and testing.
- *
- * @example
- * ```typescript
- * import { Keypair, KeypairSigner } from '@rialo/ts-cdk';
- *
- * // Generate new keypair
- * const keypair = Keypair.generate();
- * const signer = new KeypairSigner(keypair);
- *
- * // Or from mnemonic
- * const mnemonic = Mnemonic.generate();
- * const keypair = await mnemonic.toKeypair(0);
- * const signer = new KeypairSigner(keypair);
- *
- * // Sign messages
- * const publicKey = await signer.getPublicKey();
- * const signature = await signer.signMessage(message);
- * ```
- */
-declare class KeypairSigner implements Signer {
-    private readonly keypair;
-    constructor(keypair: Keypair);
+    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
     /**
-     * Returns the keypair's public key.
+     * Requests an airdrop of tokens to an account.
+     *
+     * **Note**: Only available on devnet and testnet.
+     *
+     * @param pubkey - Account to receive the airdrop
+     * @param amount - Amount in kelvins (smallest unit)
+     * @returns Transaction signature
      */
-    getPublicKey(): Promise<PublicKey>;
+    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
     /**
-     * Signs a message using the keypair's private key.
+     * Submits a signed transaction and waits for confirmation.
+     *
+     * @param transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission and confirmation options
+     * @returns Confirmed transaction details
+     * @throws {TransactionFailedError} If the transaction fails on-chain
+     * @throws {TransactionConfirmationTimeoutError} If confirmation times out
+     *
+     * @example
+     * ```typescript
+     * const result = await client.sendAndConfirmTransaction(signedTx);
+     * console.log(`Confirmed in slot ${result.slot}`);
+     * ```
      */
-    signMessage(message: Uint8Array): Promise<Signature>;
+    sendAndConfirmTransaction(transaction: Uint8Array, options?: SendAndConfirmOptions): Promise<ConfirmedTransaction>;
+    /**
+     * Waits for a transaction to be confirmed.
+     *
+     * @param signature - Transaction signature to monitor
+     * @param options - Confirmation options
+     * @returns Confirmed transaction details
+     */
+    confirmTransaction(signature: string, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
+    /**
+     * Requests an airdrop and waits for confirmation.
+     *
+     * **Note**: Only available on devnet and testnet.
+     */
+    requestAirdropAndConfirm(pubkey: PublicKey, amount: bigint, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
 }
 
 /**
- * A transaction with zero or more signatures.
- *
- * Transactions are immutable - signing methods return new instances.
- * This prevents accidental modification and signature tampering.
- *
- * @example
- * ```typescript
- * // Simple signing
- * const tx = builder.build();
- * const signed = tx.sign(keypair);
- *
- * // Method chaining
- * const signed = tx
- *   .sign(keypair1)
- *   .sign(keypair2)
- *   .sign(keypair3);
+ * Query client for read-only RPC operations.
+ */
+
+/**
+ * Client for querying blockchain state.
  *
- * // Multi-sig convenience
- * const signed = tx.signAll([keypair1, keypair2, keypair3]);
- * ```
+ * Handles all read-only operations like getting balances, account info, etc.
  */
-declare class Transaction {
-    /** The unsigned message */
-    private readonly message;
-    /** Signatures (64 bytes each), aligned with message.header.numRequiredSignatures */
-    private readonly signatures;
-    private constructor();
+declare class QueryRpcClient extends BaseRpcClient {
     /**
-     * Create an unsigned transaction from a message.
-     * All signature slots are initialized to zero.
+     * Retrieve the balance of an account in kelvins (smallest unit).
      *
-     * @internal - Users should use TransactionBuilder instead
-     */
-    static fromMessage(message: Message): Transaction;
-    /**
-     * Create transaction from message and existing signatures.
-     * @internal
+     * @param pubkey - The public key of the account to query
+     * @returns The account balance in kelvins
+     *
+     * @example
+     * ```typescript
+     * const balance = await client.getBalance(publicKey);
+     * console.log(`Balance: ${balance} kelvins`);
+     * ```
      */
-    static fromMessageAndSignatures(message: Message, signatures: readonly Uint8Array[]): Transaction;
+    getBalance(pubkey: PublicKey): Promise<bigint>;
     /**
-     * Deserialize a transaction from wire format.
+     * Retrieve detailed information about an account.
+     *
+     * Returns account data including balance, owner program, stored data,
+     * executable status, and rent epoch.
+     *
+     * @param pubkey - The public key of the account to query
+     * @returns Account information, or null if the account does not exist
+     *
+     * @example
+     * ```typescript
+     * const info = await client.getAccountInfo(publicKey);
+     * if (info) {
+     *   console.log(`Owner: ${info.owner}`);
+     *   console.log(`Balance: ${info.balance} kelvins`);
+     *   console.log(`Data length: ${info.data.length} bytes`);
+     * }
+     * ```
      */
-    static deserialize(data: Uint8Array): Transaction;
-    getMessage(): Message;
+    getAccountInfo(pubkey: PublicKey): Promise<AccountInfo | null>;
     /**
-     * Sign the transaction with a keypair.
-     * Returns a NEW Transaction instance.
+     * Retrieve the current block height of the blockchain.
+     *
+     * The block height represents the number of blocks that have been
+     * confirmed on the chain since genesis.
      *
-     * @param keypair - Keypair to sign with
-     * @returns New Transaction instance with signature added
+     * @returns The current block height
      *
      * @example
      * ```typescript
-     * const signedTx = tx.sign(keypair);
-     * await client.sendTransaction(signedTx.serialize());
+     * const height = await client.getBlockHeight();
+     * console.log(`Current block height: ${height}`);
      * ```
      */
-    sign(keypair: Keypair): Transaction;
+    getBlockHeight(): Promise<bigint>;
     /**
-     * Sign with multiple keypairs at once.
-     * Returns a NEW Transaction instance.
+     * Retrieve detailed information about a confirmed transaction.
+     *
+     * Returns transaction metadata including the block height it was
+     * confirmed in and any execution errors.
+     *
+     * @param signature - The transaction signature to query
+     * @returns Transaction information, or null if the transaction is not found
      *
      * @example
      * ```typescript
-     * const signed = tx.signAll([keypair1, keypair2, keypair3]);
+     * const tx = await client.getTransaction(signature);
+     * if (tx) {
+     *   console.log(`Confirmed in block: ${tx.blockHeight}`);
+     *   if (tx.err) {
+     *     console.log(`Transaction failed: ${tx.err}`);
+     *   }
+     * }
      * ```
      */
-    signAll(keypairs: Keypair[]): Transaction;
+    getTransaction(signature: string): Promise<TransactionResponse | null>;
     /**
-     * Sign the transaction with a Signer interface (async).
-     * Returns a NEW Transaction instance.
+     * Retrieve the total number of transactions processed since genesis.
+     *
+     * @returns The total transaction count
      *
      * @example
      * ```typescript
-     * const signedTx = await tx.signWith(browserWallet);
+     * const count = await client.getTransactionCount();
+     * console.log(`Total transactions: ${count}`);
      * ```
      */
-    signWith(signer: Signer): Promise<Transaction>;
-    /**
-     * Sign with multiple signers.
-     * Returns a NEW Transaction instance.
-     */
-    signAllWith(signers: Signer[]): Promise<Transaction>;
+    getTransactionCount(): Promise<bigint>;
     /**
-     * Partially sign the transaction (for multi-sig transactions).
-     * Returns a NEW Transaction instance.
+     * Retrieve the status of multiple transaction signatures in a single request.
+     *
+     * Useful for batch-checking transaction confirmations. Returns null for
+     * signatures that are not found or have expired from the status cache.
+     *
+     * @param signatures - Array of transaction signatures to query
+     * @returns Array of signature statuses (null if signature not found)
      *
      * @example
      * ```typescript
-     * const signedTx = tx
-     *   .partialSign(signer1)
-     *   .partialSign(signer2);
+     * const statuses = await client.getSignatureStatuses([sig1, sig2, sig3]);
+     * statuses.forEach((status, i) => {
+     *   if (status) {
+     *     console.log(`${signatures[i]}: slot ${status.slot}, executed: ${status.executed}`);
+     *   } else {
+     *     console.log(`${signatures[i]}: not found`);
+     *   }
+     * });
      * ```
      */
-    partialSign(keypair: Keypair): Transaction;
-    /**
-     * Partially sign with a Signer interface (async).
-     * Returns a NEW Transaction instance.
-     */
-    partialSignWith(signer: Signer): Promise<Transaction>;
+    getSignatureStatuses(signatures: string[]): Promise<(SignatureStatus | null)[]>;
     /**
-     * Add a signature at a specific index.
-     * Returns a NEW Transaction instance.
+     * Retrieve information about the current epoch.
      *
-     * Most users should use sign() or signAll() instead.
-     */
-    addSignature(index: number, signature: Signature | Uint8Array): Transaction;
-    /**
-     * Add a signature for a specific public key.
-     * Returns a NEW Transaction instance.
+     * Returns epoch metadata including the current epoch number, slot position
+     * within the epoch, total slots per epoch, and current block height.
      *
-     * Most users should use sign() or signAll() instead.
-     */
-    addSignatureForPubkey(pubkey: PublicKey, signature: Signature | Uint8Array): Transaction;
-    /**
-     * Check if transaction is fully signed (all signatures present).
-     */
-    isSigned(): boolean;
-    /**
-     * Check if a specific signature slot is filled.
-     */
-    isSignaturePresent(index: number): boolean;
-    /**
-     * Get all signatures (returns copies to prevent mutation).
-     */
-    getSignatures(): readonly Uint8Array[];
-    /**
-     * Get a specific signature (returns copy).
-     */
-    getSignature(index: number): Uint8Array;
-    /**
-     * Get a specific signature for a public key.
-     */
-    getSignatureForPubkey(pubkey: PublicKey): Uint8Array;
-    /**
-     * Get required signers for this transaction.
-     */
-    getSigners(): readonly PublicKey[];
-    /**
-     * Get the number of required signatures.
+     * @returns Current epoch information
+     *
+     * @example
+     * ```typescript
+     * const info = await client.getEpochInfo();
+     * console.log(`Epoch: ${info.epoch}`);
+     * console.log(`Slot ${info.slotIndex} of ${info.slotsInEpoch}`);
+     * console.log(`Block height: ${info.blockHeight}`);
+     * ```
      */
-    getRequiredSignatureCount(): number;
+    getEpochInfo(): Promise<EpochInfoResponse>;
     /**
-     * Throw an error if the transaction is not fully signed.
+     * Check the health status of the RPC node.
      *
-     * @throws {TransactionError} If transaction is not fully signed
+     * Returns "ok" if the node is healthy. If the node is unhealthy,
+     * returns an error message describing the issue.
+     *
+     * @returns "ok" if healthy, otherwise an error message
      *
      * @example
      * ```typescript
-     * signedTx.ensureSigned(); // Throws if not signed
-     * await client.sendTransaction(signedTx.serialize());
+     * const health = await client.getHealth();
+     * if (health === "ok") {
+     *   console.log("Node is healthy");
+     * } else {
+     *   console.log(`Node unhealthy: ${health}`);
+     * }
      * ```
      */
-    ensureSigned(): void;
-    /**
-     * Serialize transaction to wire format.
-     */
-    serialize(): Uint8Array;
+    getHealth(): Promise<"ok" | string>;
 }
 
 /**
- * Fluent API for building transactions.
- * Returns Transaction directly (not Message).
+ * Query client for read-only RPC operations.
  */
 
 /**
- * Builder for creating transactions with a fluent API.
- *
- * Provides an intuitive interface for constructing transactions.
- * Call build() to get an unsigned Transaction ready for signing.
- *
- * @example
- * ```typescript
- * // Simple transfer
- * const tx = TransactionBuilder.create()
- *   .setPayer(payer)
- *   .setRecentBlockhash(blockhash)
- *   .setTxCreationTime(txCreationTime)
- *   .addInstruction(transfer(from, to, 1_000_000n))
- *   .build();
- *
- * const signedTx = tx.sign(keypair);
- * await client.transaction.sendTransaction(signedTx.serialize());
- * ```
+ * Client for sending/simulating transactions and requesting airdrops.
  *
- * @example
- * ```typescript
- * // Multi-instruction transaction
- * const tx = TransactionBuilder.create()
- *   .setPayer(payer)
- *   .setRecentBlockhash(blockhash)
- *   .setTxCreationTime(txCreationTime)
- *   .addInstruction(transfer(from, to, 1_000_000n))
- *   .addInstruction(memoInstruction("Payment for invoice #123"))
- *   .build();
- * ```
+ * Handles all transaction operations like sending transactions, requesting airdrops, etc.
  */
-declare class TransactionBuilder {
-    private payer?;
-    private recentBlockhash?;
-    private txCreationTime?;
-    private readonly instructions;
-    private constructor();
-    /**
-     * Create a new transaction builder.
-     */
-    static create(): TransactionBuilder;
+declare class TransactionRpcClient extends BaseRpcClient {
     /**
-     * Set the fee payer for this transaction.
+     * Submit a signed transaction to the blockchain.
      *
-     * The payer will be the first account and must sign the transaction.
-     * The payer pays for transaction fees.
+     * Sends the transaction to the network for processing. The transaction
+     * must be fully signed before submission. Returns immediately with the
+     * transaction signature - use {@link confirmTransaction} or
+     * {@link sendAndConfirmTransaction} to wait for confirmation.
      *
-     * @param payer - Public key of the fee payer
-     */
-    setPayer(payer: PublicKey): this;
-    /**
-     * Set the recent blockhash for replay protection.
+     * @param transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission options
+     * @returns Transaction signature (base58 encoded)
      *
-     * Get this from client.getLatestBlockhash().
-     * Transactions are only valid for ~60 seconds after the blockhash.
+     * @example
+     * ```typescript
+     * const signature = await client.sendTransaction(signedTx);
+     * console.log(`Submitted: ${signature}`);
      *
-     * @param blockhash - Recent blockhash from the network
+     * // With options
+     * const signature = await client.sendTransaction(signedTx, {
+     *   skipPreflight: true,
+     *   maxRetries: 3,
+     * });
+     * ```
      */
-    setRecentBlockhash(blockhash: Blockhash): this;
+    sendTransaction(transaction: Uint8Array, options?: SendTransactionOptions): Promise<string>;
     /**
-     * Set the transaction creation timestamp.
+     * Wait for a transaction to be confirmed.
      *
-     * This is the time the transaction was created, in milliseconds since Unix epoch.
-     * It can be used for additional replay protection or auditing.
+     * A transaction is considered confirmed when:
+     * - It has been processed in a block (`blockHeight > 0`)
      *
-     * @param txCreationTime - Transaction creation time in milliseconds since Unix epoch
+     * @param signature - Transaction signature to monitor
+     * @param options - Confirmation options
+     * @returns Confirmed transaction details
+     * @throws {TransactionFailedError} If the transaction fails on-chain
+     * @throws {TransactionConfirmationTimeoutError} If confirmation times out
      */
-    setTxCreationTime(txCreationTime: bigint): this;
+    confirmTransaction(signature: string, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
     /**
-     * Add an instruction to the transaction.
+     * Submit a signed transaction and wait for confirmation.
      *
-     * @param instruction - Instruction to add
+     * Polls the transaction status until it is confirmed (blockHeight > 0),
+     * or until the maximum number of retries is reached.
+     *
+     * @param transaction - Serialized signed transaction bytes
+     * @param options - Transaction submission and confirmation options
+     * @returns Confirmed transaction details
+     * @throws {TransactionFailedError} If the transaction fails on-chain
+     * @throws {TransactionConfirmationTimeoutError} If confirmation times out
+     *
+     * @example
+     * ```typescript
+     * const result = await client.sendAndConfirmTransaction(signedTx);
+     * console.log(`Confirmed in block ${result.blockHeight}, executed: ${result.executed}`);
+     *
+     * // With custom retry settings
+     * const result = await client.sendAndConfirmTransaction(signedTx, {
+     *   maxRetries: 3,
+     *   retryDelay: 500,
+     * });
+     * ```
      */
-    addInstruction(instruction: Instruction): this;
+    sendAndConfirmTransaction(transaction: Uint8Array, options?: SendAndConfirmOptions): Promise<ConfirmedTransaction>;
     /**
-     * Add multiple instructions at once.
+     * Request an airdrop of tokens to an account.
      *
-     * @param instructions - Array of instructions to add
+     * **Note**: Only available on devnet and testnet networks.
+     *
+     * Returns immediately with the airdrop transaction signature.
+     * Use {@link requestAirdropAndConfirm} to wait for the airdrop to complete.
+     *
+     * @param pubkey - The public key of the account to receive tokens
+     * @param amount - Amount to airdrop in kelvins (smallest unit)
+     * @returns Airdrop transaction signature
+     *
+     * @example
+     * ```typescript
+     * const signature = await client.requestAirdrop(publicKey, 1_000_000_000n);
+     * console.log(`Airdrop requested: ${signature}`);
+     * ```
      */
-    addInstructions(instructions: readonly Instruction[]): this;
+    requestAirdrop(pubkey: PublicKey, amount: bigint): Promise<string>;
     /**
-     * Build the transaction (unsigned).
+     * Request an airdrop of tokens and wait for confirmation.
      *
-     * Returns an unsigned Transaction that's ready to be signed.
+     * **Note**: Only available on devnet and testnet networks.
      *
-     * @returns Unsigned Transaction
-     * @throws {TransactionError} If payer, blockhash, or instructions are missing
+     * Combines {@link requestAirdrop} and {@link confirmTransaction} into
+     * a single call for convenience.
+     *
+     * @param pubkey - The public key of the account to receive tokens
+     * @param amount - Amount to airdrop in kelvins (smallest unit)
+     * @param options - Confirmation options (max retries, retry delay)
+     * @returns Confirmed transaction details
+     * @throws {RpcError} If the airdrop transaction fails or confirmation times out
      *
      * @example
      * ```typescript
-     * const tx = builder.build();
-     * const signedTx = tx.sign(keypair);
+     * const result = await client.requestAirdropAndConfirm(publicKey, 1_000_000_000n);
+     * if (result.executed) {
+     *   console.log("Airdrop confirmed!");
+     * }
      * ```
      */
-    build(): Transaction;
+    requestAirdropAndConfirm(pubkey: PublicKey, amount: bigint, options?: ConfirmTransactionOptions): Promise<ConfirmedTransaction>;
+    private getTransaction;
+    /**
+     * Sleeps for a given number of milliseconds.
+     * @param ms - The number of milliseconds to sleep.
+     * @returns A promise that resolves when the sleep is complete.
+     */
+    private sleep;
+}
+
+/**
+ * Error codes for RPC operations, categorized by type.
+ */
+declare enum RpcErrorCode {
+    REQUEST_TIMEOUT = "REQUEST_TIMEOUT",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    CONNECTION_REFUSED = "CONNECTION_REFUSED",
+    INVALID_NETWORK = "INVALID_NETWORK",
+    INVALID_RESPONSE = "INVALID_RESPONSE",
+    PARSE_ERROR = "PARSE_ERROR",
+    INVALID_REQUEST = "INVALID_REQUEST",
+    METHOD_NOT_FOUND = "METHOD_NOT_FOUND",
+    INVALID_PARAMS = "INVALID_PARAMS",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    TRANSACTION_REJECTED = "TRANSACTION_REJECTED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    TRANSACTION_CONFIRMATION_TIMEOUT = "TRANSACTION_CONFIRMATION_TIMEOUT",
+    ACCOUNT_NOT_FOUND = "ACCOUNT_NOT_FOUND",
+    RATE_LIMIT_EXCEEDED = "RATE_LIMIT_EXCEEDED",
+    NODE_UNHEALTHY = "NODE_UNHEALTHY"
+}
+/**
+ * Detailed error context for debugging and error handling.
+ */
+interface RpcErrorDetails {
+    method?: string;
+    params?: unknown;
+    requestId?: number;
+    url?: string;
+    httpStatus?: number;
+    rpcCode?: number;
+    timeout?: number;
+    attempts?: number;
+    [key: string]: unknown;
+}
+/**
+ * Error class for RPC operations with structured error information.
+ *
+ * Provides actionable error messages and indicates whether errors are retryable.
+ */
+declare class RpcError extends Error {
+    readonly code: RpcErrorCode;
+    readonly details: RpcErrorDetails;
+    readonly retryable: boolean;
+    constructor(code: RpcErrorCode, message: string, details?: RpcErrorDetails, retryable?: boolean);
+    static requestTimeout(timeoutMs: number, details: RpcErrorDetails): RpcError;
+    static networkError(message: string, details: RpcErrorDetails): RpcError;
+    static invalidResponse(details: RpcErrorDetails): RpcError;
+    static accountNotFound(pubkey: string): RpcError;
+    static rateLimitExceeded(details: RpcErrorDetails): RpcError;
+    static fromRpcCode(rpcCode: number, message: string, details: RpcErrorDetails): RpcError;
+    toJSON(): {
+        code: RpcErrorCode;
+        message: string;
+        details?: Record<string, unknown>;
+        retryable: boolean;
+    };
 }
 
+/**
+ * Creates an RPC client with automatic retry and timeout handling.
+ *
+ * @param config - Client configuration with chain definition and optional transport settings
+ * @param config.chain - Chain definition (e.g., RIALO_DEVNET_CHAIN, RIALO_MAINNET_CHAIN) or a custom chain with your own rpcUrl
+ * @param config.transport - Optional transport configuration (timeout, retries, headers)
+ * @returns Configured RialoClient instance
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with preset chain
+ * const client = createRialoClient({ chain: RIALO_DEVNET_CHAIN });
+ *
+ * // With custom transport config
+ * const client = createRialoClient({
+ *   chain: RIALO_MAINNET_CHAIN,
+ *   transport: { timeout: 30000, maxRetries: 5 }
+ * });
+ *
+ * // With custom RPC URL
+ * const client = createRialoClient({
+ *   chain: {
+ *     id: 'rialo:mainnet',
+ *     name: 'Mainnet',
+ *     rpcUrl: 'https://mainnet.custom-rpc.com:4101'
+ *   },
+ * });
+ * ```
+ */
+declare function createRialoClient(config: RialoClientConfig): RialoClient;
+/**
+ * Returns a default RialoClientConfig for a given network.
+ *
+ * Provides preset chain configurations for standard Rialo networks, making it easy
+ * to connect to mainnet, devnet, testnet, or localnet without manual configuration.
+ *
+ * @param network - Network identifier: "mainnet", "devnet", "testnet", or "localnet"
+ * @returns Default RialoClientConfig for the specified network
+ * @throws {RpcError} With code INVALID_NETWORK if an unknown network is provided
+ *
+ * @example
+ * ```typescript
+ * // Get devnet config and create client
+ * const config = getDefaultRialoClientConfig('devnet');
+ * const client = createRialoClient(config);
+ *
+ * // Customize the config with transport options
+ * const config = getDefaultRialoClientConfig('mainnet');
+ * const client = createRialoClient({
+ *   ...config,
+ *   transport: { timeout: 60000, maxRetries: 5 }
+ * });
+ *
+ * // Use custom RPC URL while preserving network identity
+ * const config = getDefaultRialoClientConfig('mainnet');
+ * const client = createRialoClient({
+ *   ...config,
+ *   chain: {
+ *     ...config.chain,
+ *     rpcUrl: 'https://mainnet.custom-rpc.com:4101'
+ *   },
+ * });
+ * ```
+ */
+declare function getDefaultRialoClientConfig(network: RialoNetwork): RialoClientConfig;
+
 /**
  * Converts bytes to base64 string.
  *
@@ -1771,4 +2048,4 @@ declare function getMainnetUrl(): string;
  */
 declare function getLocalnetUrl(): string;
 
-export { type AccountInfo, type AccountMeta, AccountMetaTable, BASE_DERIVATION_PATH, BLOCKHASH_LENGTH, BaseRpcClient, Blockhash, type CompiledInstruction, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, type EpochInfoResponse, type GetConnectedFullNodesResponse, type GetFeeForMessageResponse, type GetHealthResponse, type GetSignaturesForAddressConfig, type GetSignaturesForAddressResponse, type GetSubscriptionsResponse, type GetTransactionsConfig, type GetTransactionsResponse, type GetTriggeredTransactionsResponse, type GetValidatorHealthResponse, type GetWorkflowLineageRequest, type GetWorkflowLineageResponse, HttpTransport, type HttpTransportConfig, type Instruction, type IsBlockhashValidResponse, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, type MessageHeader, Mnemonic, type MnemonicStrength, type MultipleAccountsResponse, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, type RpcErrorDetails$1 as RpcErrorDetails, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, type SendTransactionOptions, Signature, type SignatureStatus, type Signer, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, type TransactionResponse, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_TESTNET, calculateBackoff, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, sleep, toBase64, transferInstruction };
+export { type AccountInfo, type AccountMeta, AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, type ChainDefinition, type CompiledInstruction, type ConfirmTransactionOptions, type ConfirmedTransaction, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, type EpochInfoResponse, type GetConnectedFullNodesResponse, type GetFeeForMessageResponse, type GetHealthResponse, type GetSignaturesForAddressConfig, type GetSignaturesForAddressResponse, type GetSubscriptionsResponse, type GetTransactionsConfig, type GetTransactionsResponse, type GetTriggeredTransactionsResponse, type GetValidatorHealthResponse, type GetWorkflowLineageRequest, type GetWorkflowLineageResponse, HttpTransport, type HttpTransportConfig, type IdentifierString, type Instruction, type IsBlockhashValidResponse, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, type MessageHeader, Mnemonic, type MnemonicStrength, type MultipleAccountsResponse, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_TESTNET_CHAIN, RialoClient, type RialoClientConfig, RialoError, RialoErrorType, type RialoNetwork, RpcError, RpcErrorCode, type RpcErrorDetails$1 as RpcErrorDetails, SECRET_KEY_LENGTH, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, type SendAndConfirmOptions, type SendTransactionOptions, Signature, type SignatureStatus, type Signer, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, type TransactionResponse, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_TESTNET, calculateBackoff, createAccount, createBorshInstruction, createRialoClient, encodeBorshData, fromBase64, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, sleep, toBase64, transferInstruction };